@nomicfoundation/edr 0.10.0 → 0.12.0-alpha.0

package/src/result.rs

@@ -1,7 +1,7 @@
 use edr_evm::trace::AfterMessage;
 use napi::{
-    bindgen_prelude::{BigInt, Buffer, Either3},
     Either, Env, JsBuffer, JsBufferValue,
+    bindgen_prelude::{BigInt, Buffer, Either3},
 };
 use napi_derive::napi;
 
@@ -19,18 +19,18 @@ pub enum SuccessReason {
     EofReturnContract,
 }
 
-impl From<edr_evm::SuccessReason> for SuccessReason {
-    fn from(eval: edr_evm::SuccessReason) -> Self {
+impl From<edr_eth::result::SuccessReason> for SuccessReason {
+    fn from(eval: edr_eth::result::SuccessReason) -> Self {
         match eval {
-            edr_evm::SuccessReason::Stop => Self::Stop,
-            edr_evm::SuccessReason::Return => Self::Return,
-            edr_evm::SuccessReason::SelfDestruct => Self::SelfDestruct,
-            edr_evm::SuccessReason::EofReturnContract => Self::EofReturnContract,
+            edr_eth::result::SuccessReason::Stop => Self::Stop,
+            edr_eth::result::SuccessReason::Return => Self::Return,
+            edr_eth::result::SuccessReason::SelfDestruct => Self::SelfDestruct,
+            edr_eth::result::SuccessReason::EofReturnContract => Self::EofReturnContract,
         }
     }
 }
 
-impl From<SuccessReason> for edr_evm::SuccessReason {
+impl From<SuccessReason> for edr_eth::result::SuccessReason {
     fn from(value: SuccessReason) -> Self {
         match value {
             SuccessReason::Stop => Self::Stop,
@@ -105,55 +105,55 @@ pub enum ExceptionalHalt {
     /// Aud data is smaller then already present data size.
     EofAuxDataTooSmall,
     /// EOF Subroutine stack overflow
-    EOFFunctionStackOverflow,
+    SubRoutineStackOverflow,
     /// Check for target address validity is only done inside subcall.
     InvalidEXTCALLTarget,
 }
 
-impl From<edr_evm::HaltReason> for ExceptionalHalt {
-    fn from(halt: edr_evm::HaltReason) -> Self {
+impl From<edr_eth::l1::HaltReason> for ExceptionalHalt {
+    fn from(halt: edr_eth::l1::HaltReason) -> Self {
         match halt {
-            edr_evm::HaltReason::OutOfGas(..) => ExceptionalHalt::OutOfGas,
-            edr_evm::HaltReason::OpcodeNotFound => ExceptionalHalt::OpcodeNotFound,
-            edr_evm::HaltReason::InvalidFEOpcode => ExceptionalHalt::InvalidFEOpcode,
-            edr_evm::HaltReason::InvalidJump => ExceptionalHalt::InvalidJump,
-            edr_evm::HaltReason::NotActivated => ExceptionalHalt::NotActivated,
-            edr_evm::HaltReason::StackUnderflow => ExceptionalHalt::StackUnderflow,
-            edr_evm::HaltReason::StackOverflow => ExceptionalHalt::StackOverflow,
-            edr_evm::HaltReason::OutOfOffset => ExceptionalHalt::OutOfOffset,
-            edr_evm::HaltReason::CreateCollision => ExceptionalHalt::CreateCollision,
-            edr_evm::HaltReason::PrecompileError => ExceptionalHalt::PrecompileError,
-            edr_evm::HaltReason::NonceOverflow => ExceptionalHalt::NonceOverflow,
-            edr_evm::HaltReason::CreateContractSizeLimit => {
+            edr_eth::l1::HaltReason::OutOfGas(..) => ExceptionalHalt::OutOfGas,
+            edr_eth::l1::HaltReason::OpcodeNotFound => ExceptionalHalt::OpcodeNotFound,
+            edr_eth::l1::HaltReason::InvalidFEOpcode => ExceptionalHalt::InvalidFEOpcode,
+            edr_eth::l1::HaltReason::InvalidJump => ExceptionalHalt::InvalidJump,
+            edr_eth::l1::HaltReason::NotActivated => ExceptionalHalt::NotActivated,
+            edr_eth::l1::HaltReason::StackUnderflow => ExceptionalHalt::StackUnderflow,
+            edr_eth::l1::HaltReason::StackOverflow => ExceptionalHalt::StackOverflow,
+            edr_eth::l1::HaltReason::OutOfOffset => ExceptionalHalt::OutOfOffset,
+            edr_eth::l1::HaltReason::CreateCollision => ExceptionalHalt::CreateCollision,
+            edr_eth::l1::HaltReason::PrecompileError => ExceptionalHalt::PrecompileError,
+            edr_eth::l1::HaltReason::NonceOverflow => ExceptionalHalt::NonceOverflow,
+            edr_eth::l1::HaltReason::CreateContractSizeLimit => {
                 ExceptionalHalt::CreateContractSizeLimit
             }
-            edr_evm::HaltReason::CreateContractStartingWithEF => {
+            edr_eth::l1::HaltReason::CreateContractStartingWithEF => {
                 ExceptionalHalt::CreateContractStartingWithEF
             }
-            edr_evm::HaltReason::CreateInitCodeSizeLimit => {
+            edr_eth::l1::HaltReason::CreateInitCodeSizeLimit => {
                 ExceptionalHalt::CreateInitCodeSizeLimit
             }
-            edr_evm::HaltReason::EofAuxDataOverflow => ExceptionalHalt::EofAuxDataOverflow,
-            edr_evm::HaltReason::EofAuxDataTooSmall => ExceptionalHalt::EofAuxDataTooSmall,
-            edr_evm::HaltReason::EOFFunctionStackOverflow => {
-                ExceptionalHalt::EOFFunctionStackOverflow
+            edr_eth::l1::HaltReason::EofAuxDataOverflow => ExceptionalHalt::EofAuxDataOverflow,
+            edr_eth::l1::HaltReason::EofAuxDataTooSmall => ExceptionalHalt::EofAuxDataTooSmall,
+            edr_eth::l1::HaltReason::SubRoutineStackOverflow => {
+                ExceptionalHalt::SubRoutineStackOverflow
             }
-            edr_evm::HaltReason::InvalidEXTCALLTarget => ExceptionalHalt::InvalidEXTCALLTarget,
-            edr_evm::HaltReason::OverflowPayment
-            | edr_evm::HaltReason::StateChangeDuringStaticCall
-            | edr_evm::HaltReason::CallNotAllowedInsideStatic
-            | edr_evm::HaltReason::OutOfFunds
-            | edr_evm::HaltReason::CallTooDeep => {
+            edr_eth::l1::HaltReason::InvalidEXTCALLTarget => ExceptionalHalt::InvalidEXTCALLTarget,
+            edr_eth::l1::HaltReason::OverflowPayment
+            | edr_eth::l1::HaltReason::StateChangeDuringStaticCall
+            | edr_eth::l1::HaltReason::CallNotAllowedInsideStatic
+            | edr_eth::l1::HaltReason::OutOfFunds
+            | edr_eth::l1::HaltReason::CallTooDeep => {
                 unreachable!("Internal halts that can be only found inside Inspector: {halt:?}")
             }
         }
     }
 }
 
-impl From<ExceptionalHalt> for edr_evm::HaltReason {
+impl From<ExceptionalHalt> for edr_eth::l1::HaltReason {
     fn from(value: ExceptionalHalt) -> Self {
         match value {
-            ExceptionalHalt::OutOfGas => Self::OutOfGas(edr_evm::OutOfGasError::Basic),
+            ExceptionalHalt::OutOfGas => Self::OutOfGas(edr_eth::l1::OutOfGasError::Basic),
             ExceptionalHalt::OpcodeNotFound => Self::OpcodeNotFound,
             ExceptionalHalt::InvalidFEOpcode => Self::InvalidFEOpcode,
             ExceptionalHalt::InvalidJump => Self::InvalidJump,
@@ -169,7 +169,7 @@ impl From<ExceptionalHalt> for edr_evm::HaltReason {
             ExceptionalHalt::CreateInitCodeSizeLimit => Self::CreateInitCodeSizeLimit,
             ExceptionalHalt::EofAuxDataOverflow => Self::EofAuxDataOverflow,
             ExceptionalHalt::EofAuxDataTooSmall => Self::EofAuxDataTooSmall,
-            ExceptionalHalt::EOFFunctionStackOverflow => Self::EOFFunctionStackOverflow,
+            ExceptionalHalt::SubRoutineStackOverflow => Self::SubRoutineStackOverflow,
             ExceptionalHalt::InvalidEXTCALLTarget => Self::InvalidEXTCALLTarget,
         }
     }
@@ -195,14 +195,14 @@ pub struct ExecutionResult {
 }
 
 impl ExecutionResult {
-    pub fn new(env: &Env, message: &AfterMessage) -> napi::Result<Self> {
+    pub fn new(env: &Env, message: &AfterMessage<edr_eth::l1::HaltReason>) -> napi::Result<Self> {
         let AfterMessage {
             execution_result,
             contract_address,
         } = message;
 
         let result = match execution_result {
-            edr_evm::ExecutionResult::Success {
+            edr_eth::result::ExecutionResult::Success {
                 reason,
                 gas_used,
                 gas_refunded,
@@ -220,14 +220,14 @@ impl ExecutionResult {
                     gas_refunded: BigInt::from(*gas_refunded),
                     logs,
                     output: match output {
-                        edr_evm::Output::Call(return_value) => {
+                        edr_eth::result::Output::Call(return_value) => {
                             let return_value = env
                                 .create_buffer_with_data(return_value.to_vec())
                                 .map(JsBufferValue::into_raw)?;
 
                             Either::A(CallOutput { return_value })
                         }
-                        edr_evm::Output::Create(return_value, address) => {
+                        edr_eth::result::Output::Create(return_value, address) => {
                             let return_value = env
                                 .create_buffer_with_data(return_value.to_vec())
                                 .map(JsBufferValue::into_raw)?;
@@ -240,7 +240,7 @@ impl ExecutionResult {
                     },
                 })
             }
-            edr_evm::ExecutionResult::Revert { gas_used, output } => {
+            edr_eth::result::ExecutionResult::Revert { gas_used, output } => {
                 let output = env
                     .create_buffer_with_data(output.to_vec())
                     .map(JsBufferValue::into_raw)?;
@@ -250,7 +250,7 @@ impl ExecutionResult {
                     output,
                 })
             }
-            edr_evm::ExecutionResult::Halt { reason, gas_used } => Either3::C(HaltResult {
+            edr_eth::result::ExecutionResult::Halt { reason, gas_used } => Either3::C(HaltResult {
                 reason: ExceptionalHalt::from(*reason),
                 gas_used: BigInt::from(*gas_used),
             }),

package/src/scenarios.rs

@@ -1,22 +1,17 @@
 use std::time::{SystemTime, UNIX_EPOCH};
 
-use edr_provider::ProviderRequest;
+use edr_scenarios::ScenarioConfig;
 use napi::tokio::{fs::File, io::AsyncWriteExt, sync::Mutex};
-use rand::{distributions::Alphanumeric, Rng};
-use serde::Serialize;
+use rand::{Rng, distributions::Alphanumeric};
 
 const SCENARIO_FILE_PREFIX: &str = "EDR_SCENARIO_PREFIX";
 
-#[derive(Clone, Debug, Serialize)]
-struct ScenarioConfig {
-    provider_config: edr_scenarios::ScenarioProviderConfig,
+/// Creates a scenario file with the provided configuration.
+pub async fn scenario_file(
+    chain_type: String,
+    provider_config: edr_napi_core::provider::Config,
     logger_enabled: bool,
-}
-
-pub(crate) async fn scenario_file(
-    provider_config: &edr_provider::ProviderConfig,
-    logger_enabled: bool,
-) -> Result<Option<Mutex<File>>, napi::Error> {
+) -> napi::Result<Option<Mutex<File>>> {
     if let Ok(scenario_prefix) = std::env::var(SCENARIO_FILE_PREFIX) {
         let timestamp = SystemTime::now()
             .duration_since(UNIX_EPOCH)
@@ -32,8 +27,9 @@ pub(crate) async fn scenario_file(
             File::create(format!("{scenario_prefix}_{timestamp}_{suffix}.json")).await?;
 
         let config = ScenarioConfig {
-            provider_config: provider_config.clone().into(),
+            chain_type: Some(chain_type),
             logger_enabled,
+            provider_config: provider_config.into(),
         };
         let mut line = serde_json::to_string(&config)?;
         line.push('\n');
@@ -45,11 +41,9 @@ pub(crate) async fn scenario_file(
     }
 }
 
-pub(crate) async fn write_request(
-    scenario_file: &Mutex<File>,
-    request: &ProviderRequest,
-) -> napi::Result<()> {
-    let mut line = serde_json::to_string(request)?;
+/// Writes a JSON-RPC request to the scenario file.
+pub async fn write_request(scenario_file: &Mutex<File>, request: &str) -> napi::Result<()> {
+    let mut line = request.to_string();
     line.push('\n');
     {
         let mut scenario_file = scenario_file.lock().await;

package/src/subscription.rs

@@ -0,0 +1,32 @@
+use napi::{JsFunction, bindgen_prelude::BigInt};
+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/exit.rs

@@ -3,7 +3,6 @@
 
 use std::fmt;
 
-use edr_evm::HaltReason;
 use napi_derive::napi;
 
 #[napi]
@@ -51,20 +50,20 @@ 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,
+              | 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,
             ExitCode::Halt(_) => Self::UNKNOWN_HALT_REASON,
         }
     }

package/src/trace/return_data.rs

@@ -38,7 +38,7 @@ impl ReturnData {
 
     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]

package/src/trace/solidity_stack_trace.rs

@@ -1,8 +1,7 @@
 //! Naive rewrite of `hardhat-network/stack-traces/solidity-stack-traces.ts`
 //! from Hardhat.
 
-use edr_eth::U256;
-use edr_evm::hex;
+use edr_eth::{U256, hex};
 use napi::bindgen_prelude::{BigInt, Either24, FromNapiValue, ToNapiValue, Uint8Array, Undefined};
 use napi_derive::napi;
 use serde::{Serialize, Serializer};
@@ -107,7 +106,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 +124,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) }
     }
 }
 

package/src/trace.rs

@@ -7,10 +7,11 @@
 
 use std::sync::Arc;
 
-use edr_evm::{interpreter::OpCode, trace::BeforeMessage};
+use edr_eth::{bytecode::opcode::OpCode, l1};
+use edr_evm::trace::BeforeMessage;
 use napi::{
-    bindgen_prelude::{BigInt, Buffer, Either3},
     Env, JsBuffer, JsBufferValue,
+    bindgen_prelude::{BigInt, Buffer, Either3},
 };
 use napi_derive::napi;
 
@@ -150,7 +151,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,13 +166,14 @@ 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 }
     }
 }
 

package/src/withdrawal.rs

@@ -2,7 +2,7 @@ use edr_eth::Address;
 use napi::bindgen_prelude::{BigInt, Buffer};
 use napi_derive::napi;
 
-use crate::cast::TryCast;
+use crate::cast::TryCast as _;
 
 #[napi(object)]
 pub struct Withdrawal {