@nomicfoundation/edr 0.12.0-next.4 → 0.12.0-next.5

package/index.d.ts

@@ -405,8 +405,7 @@ export enum SuccessReason {
   /** The opcode `RETURN` was called */
   Return = 1,
   /** The opcode `SELFDESTRUCT` was called */
-  SelfDestruct = 2,
-  EofReturnContract = 3
+  SelfDestruct = 2
 }
 export interface CallOutput {
   /** Return value */
@@ -459,15 +458,7 @@ export enum ExceptionalHalt {
   /** Error on created contract that begins with EF */
   CreateContractStartingWithEF = 12,
   /** EIP-3860: Limit and meter initcode. Initcode size limit exceeded. */
-  CreateInitCodeSizeLimit = 13,
-  /** Aux data overflow, new aux data is larger tha u16 max size. */
-  EofAuxDataOverflow = 14,
-  /** Aud data is smaller then already present data size. */
-  EofAuxDataTooSmall = 15,
-  /** EOF Subroutine stack overflow */
-  SubRoutineStackOverflow = 16,
-  /** Check for target address validity is only done inside subcall. */
-  InvalidEXTCALLTarget = 17
+  CreateInitCodeSizeLimit = 13
 }
 /** The result when the EVM terminates due to an exceptional halt. */
 export interface HaltResult {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nomicfoundation/edr",
-  "version": "0.12.0-next.4",
+  "version": "0.12.0-next.5",
   "devDependencies": {
     "@napi-rs/cli": "^2.18.4",
     "@nomicfoundation/ethereumjs-util": "^9.0.4",
@@ -59,13 +59,13 @@
   "repository": "NomicFoundation/edr.git",
   "types": "index.d.ts",
   "optionalDependencies": {
-    "@nomicfoundation/edr-darwin-arm64": "0.12.0-next.4",
-    "@nomicfoundation/edr-darwin-x64": "0.12.0-next.4",
-    "@nomicfoundation/edr-linux-arm64-gnu": "0.12.0-next.4",
-    "@nomicfoundation/edr-linux-arm64-musl": "0.12.0-next.4",
-    "@nomicfoundation/edr-linux-x64-gnu": "0.12.0-next.4",
-    "@nomicfoundation/edr-linux-x64-musl": "0.12.0-next.4",
-    "@nomicfoundation/edr-win32-x64-msvc": "0.12.0-next.4"
+    "@nomicfoundation/edr-darwin-arm64": "0.12.0-next.5",
+    "@nomicfoundation/edr-darwin-x64": "0.12.0-next.5",
+    "@nomicfoundation/edr-linux-arm64-gnu": "0.12.0-next.5",
+    "@nomicfoundation/edr-linux-arm64-musl": "0.12.0-next.5",
+    "@nomicfoundation/edr-linux-x64-gnu": "0.12.0-next.5",
+    "@nomicfoundation/edr-linux-x64-musl": "0.12.0-next.5",
+    "@nomicfoundation/edr-win32-x64-msvc": "0.12.0-next.5"
   },
   "scripts": {
     "artifacts": "napi artifacts",

package/src/account.rs

@@ -53,7 +53,7 @@ impl TryFrom<AccountOverride> for (edr_eth::Address, edr_provider::AccountOverri
                     .into_iter()
                     .map(|StorageSlot { index, value }| {
                         let value = value.try_cast()?;
-                        let slot = edr_evm::state::EvmStorageSlot::new(value);
+                        let slot = edr_evm::state::EvmStorageSlot::new(value, 0);
 
                         let index: edr_eth::U256 = index.try_cast()?;
                         Ok((index, slot))

package/src/chains/generic.rs

@@ -3,12 +3,13 @@ use std::sync::Arc;
 use edr_eth::l1;
 use edr_generic::GenericChainSpec;
 use edr_napi_core::{
-    logger::{self, Logger},
-    provider::{self, ProviderBuilder, SyncProviderFactory},
-    subscription,
+    logger::Logger,
+    provider::{SyncProvider, SyncProviderFactory},
+    subscription::subscriber_callback_for_chain_spec,
 };
 use edr_provider::time::CurrentTime;
 use edr_solidity::contract_decoder::ContractDecoder;
+use napi::tokio::runtime;
 use napi_derive::napi;
 
 use crate::provider::ProviderFactory;
@@ -16,14 +17,14 @@ use crate::provider::ProviderFactory;
 pub struct GenericChainProviderFactory;
 
 impl SyncProviderFactory for GenericChainProviderFactory {
-    fn create_provider_builder(
+    fn create_provider(
         &self,
-        env: &napi::Env,
+        runtime: runtime::Handle,
         provider_config: edr_napi_core::provider::Config,
-        logger_config: logger::Config,
-        subscription_config: subscription::Config,
+        logger_config: edr_napi_core::logger::Config,
+        subscription_callback: edr_napi_core::subscription::Callback,
         contract_decoder: Arc<ContractDecoder>,
-    ) -> napi::Result<Box<dyn provider::Builder>> {
+    ) -> napi::Result<Arc<dyn SyncProvider>> {
         let logger = Logger::<GenericChainSpec, CurrentTime>::new(
             logger_config,
             Arc::clone(&contract_decoder),
@@ -32,15 +33,19 @@ impl SyncProviderFactory for GenericChainProviderFactory {
         let provider_config =
             edr_provider::ProviderConfig::<l1::SpecId>::try_from(provider_config)?;
 
-        let subscription_callback =
-            subscription::Callback::new(env, subscription_config.subscription_callback)?;
-
-        Ok(Box::new(ProviderBuilder::new(
-            contract_decoder,
+        let provider = edr_provider::Provider::<GenericChainSpec>::new(
+            runtime.clone(),
             Box::new(logger),
+            subscriber_callback_for_chain_spec::<GenericChainSpec, CurrentTime>(
+                subscription_callback,
+            ),
             provider_config,
-            subscription_callback,
-        )))
+            contract_decoder,
+            CurrentTime,
+        )
+        .map_err(|error| napi::Error::new(napi::Status::GenericFailure, error.to_string()))?;
+
+        Ok(Arc::new(provider))
     }
 }
 

package/src/chains/l1.rs

@@ -7,12 +7,15 @@ use edr_evm::eips::{
 };
 use edr_napi_core::{
     logger::Logger,
-    provider::{self, ProviderBuilder, SyncProviderFactory},
-    subscription,
+    provider::{SyncProvider, SyncProviderFactory},
+    subscription::subscriber_callback_for_chain_spec,
 };
 use edr_provider::time::CurrentTime;
 use edr_solidity::contract_decoder::ContractDecoder;
-use napi::bindgen_prelude::{BigInt, Uint8Array};
+use napi::{
+    bindgen_prelude::{BigInt, Uint8Array},
+    tokio::runtime,
+};
 use napi_derive::napi;
 
 use crate::{account::AccountOverride, provider::ProviderFactory};
@@ -20,29 +23,31 @@ use crate::{account::AccountOverride, provider::ProviderFactory};
 pub struct L1ProviderFactory;
 
 impl SyncProviderFactory for L1ProviderFactory {
-    fn create_provider_builder(
+    fn create_provider(
         &self,
-        env: &napi::Env,
+        runtime: runtime::Handle,
         provider_config: edr_napi_core::provider::Config,
         logger_config: edr_napi_core::logger::Config,
-        subscription_config: edr_napi_core::subscription::Config,
+        subscription_callback: edr_napi_core::subscription::Callback,
         contract_decoder: Arc<ContractDecoder>,
-    ) -> napi::Result<Box<dyn provider::Builder>> {
+    ) -> napi::Result<Arc<dyn SyncProvider>> {
         let logger =
             Logger::<L1ChainSpec, CurrentTime>::new(logger_config, Arc::clone(&contract_decoder))?;
 
         let provider_config =
             edr_provider::ProviderConfig::<l1::SpecId>::try_from(provider_config)?;
 
-        let subscription_callback =
-            subscription::Callback::new(env, subscription_config.subscription_callback)?;
-
-        Ok(Box::new(ProviderBuilder::new(
-            contract_decoder,
+        let provider = edr_provider::Provider::<L1ChainSpec>::new(
+            runtime.clone(),
             Box::new(logger),
+            subscriber_callback_for_chain_spec::<L1ChainSpec, CurrentTime>(subscription_callback),
             provider_config,
-            subscription_callback,
-        )))
+            contract_decoder,
+            CurrentTime,
+        )
+        .map_err(|error| napi::Error::new(napi::Status::GenericFailure, error.to_string()))?;
+
+        Ok(Arc::new(provider))
     }
 }
 

package/src/chains/op.rs

@@ -2,14 +2,17 @@ use std::{str::FromStr, sync::Arc};
 
 use edr_eth::hex;
 use edr_napi_core::{
-    logger::{self, Logger},
-    provider::{self, ProviderBuilder, SyncProviderFactory},
-    subscription,
+    logger::Logger,
+    provider::{SyncProvider, SyncProviderFactory},
+    subscription::subscriber_callback_for_chain_spec,
 };
 use edr_op::{predeploys::GAS_PRICE_ORACLE_ADDRESS, OpChainSpec, OpSpecId};
 use edr_provider::time::CurrentTime;
 use edr_solidity::contract_decoder::ContractDecoder;
-use napi::bindgen_prelude::{BigInt, Uint8Array};
+use napi::{
+    bindgen_prelude::{BigInt, Uint8Array},
+    tokio::runtime,
+};
 use napi_derive::napi;
 
 use crate::{
@@ -20,28 +23,30 @@ use crate::{
 pub struct OpProviderFactory;
 
 impl SyncProviderFactory for OpProviderFactory {
-    fn create_provider_builder(
+    fn create_provider(
         &self,
-        env: &napi::Env,
-        provider_config: provider::Config,
-        logger_config: logger::Config,
-        subscription_config: subscription::Config,
+        runtime: runtime::Handle,
+        provider_config: edr_napi_core::provider::Config,
+        logger_config: edr_napi_core::logger::Config,
+        subscription_callback: edr_napi_core::subscription::Callback,
         contract_decoder: Arc<ContractDecoder>,
-    ) -> napi::Result<Box<dyn provider::Builder>> {
+    ) -> napi::Result<Arc<dyn SyncProvider>> {
         let logger =
             Logger::<OpChainSpec, CurrentTime>::new(logger_config, Arc::clone(&contract_decoder))?;
 
         let provider_config = edr_provider::ProviderConfig::<OpSpecId>::try_from(provider_config)?;
 
-        let subscription_callback =
-            subscription::Callback::new(env, subscription_config.subscription_callback)?;
-
-        Ok(Box::new(ProviderBuilder::new(
-            contract_decoder,
+        let provider = edr_provider::Provider::<OpChainSpec>::new(
+            runtime.clone(),
             Box::new(logger),
+            subscriber_callback_for_chain_spec::<OpChainSpec, CurrentTime>(subscription_callback),
             provider_config,
-            subscription_callback,
-        )))
+            contract_decoder,
+            CurrentTime,
+        )
+        .map_err(|error| napi::Error::new(napi::Status::GenericFailure, error.to_string()))?;
+
+        Ok(Arc::new(provider))
     }
 }
 

package/src/config.rs

@@ -2,6 +2,7 @@ use core::fmt::{Debug, Display};
 use std::{
     num::NonZeroU64,
     path::PathBuf,
+    sync::Arc,
     time::{Duration, SystemTime},
 };
 
@@ -10,6 +11,7 @@ use edr_eth::{
     signature::{secret_key_from_str, SecretKey},
     Bytes, HashMap, HashSet,
 };
+use edr_solidity::contract_decoder::ContractDecoder;
 use napi::{
     bindgen_prelude::{BigInt, Promise, Reference, Uint8Array},
     threadsafe_function::{
@@ -20,7 +22,10 @@ use napi::{
 };
 use napi_derive::napi;
 
-use crate::{account::AccountOverride, block::BlobGas, cast::TryCast, precompile::Precompile};
+use crate::{
+    account::AccountOverride, block::BlobGas, cast::TryCast, logger::LoggerConfig,
+    precompile::Precompile, subscription::SubscriptionConfig,
+};
 
 /// Specification of a chain with possible overrides.
 #[napi(object)]
@@ -541,3 +546,46 @@ impl From<BuildInfoAndOutput> for edr_napi_core::solidity::config::BuildInfoAndO
         }
     }
 }
+
+/// Result of [`resolve_configs`].
+pub struct ConfigResolution {
+    pub contract_decoder: Arc<ContractDecoder>,
+    pub logger_config: edr_napi_core::logger::Config,
+    pub provider_config: edr_napi_core::provider::Config,
+    pub subscription_callback: edr_napi_core::subscription::Callback,
+}
+
+/// Helper function for resolving the provided N-API configs.
+pub fn resolve_configs(
+    env: &napi::Env,
+    runtime: runtime::Handle,
+    provider_config: ProviderConfig,
+    logger_config: LoggerConfig,
+    subscription_config: SubscriptionConfig,
+    tracing_config: TracingConfigWithBuffers,
+) -> napi::Result<ConfigResolution> {
+    let provider_config = provider_config.resolve(env, runtime)?;
+    let logger_config = logger_config.resolve(env)?;
+
+    // TODO: https://github.com/NomicFoundation/edr/issues/760
+    let build_info_config = edr_solidity::artifacts::BuildInfoConfig::parse_from_buffers(
+        (&edr_napi_core::solidity::config::TracingConfigWithBuffers::from(tracing_config)).into(),
+    )
+    .map_err(|error| napi::Error::from_reason(error.to_string()))?;
+
+    let contract_decoder = ContractDecoder::new(&build_info_config).map_or_else(
+        |error| Err(napi::Error::from_reason(error.to_string())),
+        |contract_decoder| Ok(Arc::new(contract_decoder)),
+    )?;
+
+    let subscription_config = edr_napi_core::subscription::Config::from(subscription_config);
+    let subscription_callback =
+        edr_napi_core::subscription::Callback::new(env, subscription_config.subscription_callback)?;
+
+    Ok(ConfigResolution {
+        contract_decoder,
+        logger_config,
+        provider_config,
+        subscription_callback,
+    })
+}

package/src/context.rs

@@ -1,11 +1,7 @@
 use std::sync::Arc;
 
 use edr_eth::HashMap;
-use edr_napi_core::{
-    provider::{self, SyncProviderFactory},
-    solidity,
-};
-use edr_solidity::contract_decoder::ContractDecoder;
+use edr_napi_core::{provider::SyncProviderFactory, solidity};
 use edr_solidity_tests::{
     decode::RevertDecoder,
     multi_runner::{SuiteResultAndArtifactId, TestContract, TestContracts},
@@ -22,7 +18,7 @@ use napi_derive::napi;
 use tracing_subscriber::{prelude::*, EnvFilter, Registry};
 
 use crate::{
-    config::{ProviderConfig, TracingConfigWithBuffers},
+    config::{resolve_configs, ConfigResolution, ProviderConfig, TracingConfigWithBuffers},
     logger::LoggerConfig,
     provider::{Provider, ProviderFactory},
     solidity_tests::{
@@ -78,25 +74,20 @@ impl EdrContext {
         }
 
         let runtime = runtime::Handle::current();
-        let provider_config =
-            try_or_reject_promise!(provider_config.resolve(&env, runtime.clone()));
-
-        let logger_config = try_or_reject_promise!(logger_config.resolve(&env));
-
-        // TODO: https://github.com/NomicFoundation/edr/issues/760
-        let build_info_config = try_or_reject_promise!(
-            edr_solidity::artifacts::BuildInfoConfig::parse_from_buffers(
-                (&edr_napi_core::solidity::config::TracingConfigWithBuffers::from(tracing_config))
-                    .into(),
-            )
-            .map_err(|error| napi::Error::from_reason(error.to_string()))
-        );
-
-        let contract_decoder = try_or_reject_promise!(ContractDecoder::new(&build_info_config)
-            .map_or_else(
-                |error| Err(napi::Error::from_reason(error.to_string())),
-                |contract_decoder| Ok(Arc::new(contract_decoder))
-            ));
+
+        let ConfigResolution {
+            contract_decoder,
+            logger_config,
+            provider_config,
+            subscription_callback,
+        } = try_or_reject_promise!(resolve_configs(
+            &env,
+            runtime.clone(),
+            provider_config,
+            logger_config,
+            subscription_config,
+            tracing_config
+        ));
 
         #[cfg(feature = "scenarios")]
         let scenario_file =
@@ -106,31 +97,32 @@ impl EdrContext {
                 logger_config.enable,
             )));
 
-        let builder = {
+        let factory = {
             // TODO: https://github.com/NomicFoundation/edr/issues/760
             // TODO: Don't block the JS event loop
             let context = runtime.block_on(async { self.inner.lock().await });
 
-            try_or_reject_promise!(context.create_provider_builder(
-                &env,
-                &chain_type,
-                provider_config,
-                logger_config,
-                subscription_config.into(),
-                &contract_decoder,
-            ))
+            try_or_reject_promise!(context.get_provider_factory(&chain_type))
         };
 
         runtime.clone().spawn_blocking(move || {
-            let result = builder.build(runtime.clone()).map(|provider| {
-                Provider::new(
-                    provider,
-                    runtime,
-                    contract_decoder,
-                    #[cfg(feature = "scenarios")]
-                    scenario_file,
+            let result = factory
+                .create_provider(
+                    runtime.clone(),
+                    provider_config,
+                    logger_config,
+                    subscription_callback,
+                    Arc::clone(&contract_decoder),
                 )
-            });
+                .map(|provider| {
+                    Provider::new(
+                        provider,
+                        runtime,
+                        contract_decoder,
+                        #[cfg(feature = "scenarios")]
+                        scenario_file,
+                    )
+                });
 
             deferred.resolve(|_env| result);
         });
@@ -410,23 +402,12 @@ impl Context {
 
     /// Tries to create a new provider for the provided chain type and
     /// configuration.
-    pub fn create_provider_builder(
+    pub fn get_provider_factory(
         &self,
-        env: &napi::Env,
         chain_type: &str,
-        provider_config: edr_napi_core::provider::Config,
-        logger_config: edr_napi_core::logger::Config,
-        subscription_config: edr_napi_core::subscription::Config,
-        contract_decoder: &Arc<ContractDecoder>,
-    ) -> napi::Result<Box<dyn provider::Builder>> {
+    ) -> napi::Result<Arc<dyn SyncProviderFactory>> {
         if let Some(factory) = self.provider_factories.get(chain_type) {
-            factory.create_provider_builder(
-                env,
-                provider_config,
-                logger_config,
-                subscription_config,
-                contract_decoder.clone(),
-            )
+            Ok(Arc::clone(factory))
         } else {
             Err(napi::Error::new(
                 napi::Status::GenericFailure,

package/src/mock/time.rs

@@ -5,13 +5,12 @@ use edr_evm::spec::RuntimeSpec;
 use edr_generic::GenericChainSpec;
 use edr_napi_core::logger::Logger;
 use edr_rpc_eth::RpcSpec;
-use edr_solidity::contract_decoder::ContractDecoder;
 use napi::{bindgen_prelude::BigInt, tokio::runtime, Env, JsObject};
 use napi_derive::napi;
 
 use crate::{
     cast::TryCast as _,
-    config::{ProviderConfig, TracingConfigWithBuffers},
+    config::{resolve_configs, ConfigResolution, ProviderConfig, TracingConfigWithBuffers},
     logger::LoggerConfig,
     provider::Provider,
     subscription::SubscriptionConfig,
@@ -68,73 +67,65 @@ pub fn create_provider_with_mock_timer(
     }
 
     let runtime = runtime::Handle::current();
-    let provider_config = try_or_reject_promise!(provider_config.resolve(&env, runtime.clone()));
-
-    let logger_config = try_or_reject_promise!(logger_config.resolve(&env));
-
-    // TODO: https://github.com/NomicFoundation/edr/issues/760
-    let build_info_config = try_or_reject_promise!(
-        edr_solidity::artifacts::BuildInfoConfig::parse_from_buffers(
-            (&edr_napi_core::solidity::config::TracingConfigWithBuffers::from(tracing_config))
-                .into(),
-        )
-        .map_err(|error| napi::Error::from_reason(error.to_string()))
-    );
-
-    let contract_decoder = try_or_reject_promise!(ContractDecoder::new(&build_info_config)
-        .map_or_else(
-            |error| Err(napi::Error::from_reason(error.to_string())),
-            |contract_decoder| Ok(Arc::new(contract_decoder))
-        ));
-
-    let subscription_config = edr_napi_core::subscription::Config::from(subscription_config);
-    let subscription_callback = try_or_reject_promise!(edr_napi_core::subscription::Callback::new(
+
+    let ConfigResolution {
+        contract_decoder,
+        logger_config,
+        provider_config,
+        subscription_callback,
+    } = try_or_reject_promise!(resolve_configs(
         &env,
-        subscription_config.subscription_callback,
+        runtime.clone(),
+        provider_config,
+        logger_config,
+        subscription_config,
+        tracing_config,
     ));
 
-    let logger = try_or_reject_promise!(Logger::<
-        GenericChainSpec,
-        Arc<edr_provider::time::MockTime>,
-    >::new(logger_config, Arc::clone(&contract_decoder),));
-
-    let provider_config = try_or_reject_promise!(
-        edr_provider::ProviderConfig::<edr_eth::l1::SpecId>::try_from(provider_config)
-    );
-
     let timer = Arc::clone(&time.inner);
 
     runtime.clone().spawn_blocking(move || {
-        let result =
-            edr_provider::Provider::<GenericChainSpec, Arc<edr_provider::time::MockTime>>::new(
-                runtime.clone(),
-                Box::new(logger),
-                Box::new(move |event| {
-                    let event = edr_napi_core::subscription::SubscriptionEvent::new::<
-                        <GenericChainSpec as RuntimeSpec>::Block,
-                        <GenericChainSpec as RpcSpec>::RpcBlock<B256>,
-                        <GenericChainSpec as ChainSpec>::SignedTransaction,
-                    >(event);
-
-                    subscription_callback.call(event);
-                }),
-                provider_config,
-                contract_decoder.clone(),
-                timer,
-            )
-            .map_or_else(
-                |error| Err(napi::Error::from_reason(error.to_string())),
-                |provider| {
-                    Ok(Provider::new(
-                        Arc::new(provider),
-                        runtime,
-                        contract_decoder,
-                        #[cfg(feature = "scenarios")]
-                        None,
-                    ))
-                },
-            );
+        // Using a closure to limit the scope, allowing us to use `?` for error
+        // handling. This is necessary because the result of the closure is used
+        // to resolve the deferred promise.
+        let create_provider = move || -> napi::Result<Provider> {
+            let logger = Logger::<GenericChainSpec, Arc<edr_provider::time::MockTime>>::new(
+                logger_config,
+                Arc::clone(&contract_decoder),
+            )?;
+
+            let provider_config =
+                edr_provider::ProviderConfig::<edr_eth::l1::SpecId>::try_from(provider_config)?;
+
+            let provider =
+                edr_provider::Provider::<GenericChainSpec, Arc<edr_provider::time::MockTime>>::new(
+                    runtime.clone(),
+                    Box::new(logger),
+                    Box::new(move |event| {
+                        let event = edr_napi_core::subscription::SubscriptionEvent::new::<
+                            <GenericChainSpec as RuntimeSpec>::Block,
+                            <GenericChainSpec as RpcSpec>::RpcBlock<B256>,
+                            <GenericChainSpec as ChainSpec>::SignedTransaction,
+                        >(event);
+
+                        subscription_callback.call(event);
+                    }),
+                    provider_config,
+                    contract_decoder.clone(),
+                    timer,
+                )
+                .map_err(|error| napi::Error::from_reason(error.to_string()))?;
+
+            Ok(Provider::new(
+                Arc::new(provider),
+                runtime,
+                contract_decoder,
+                #[cfg(feature = "scenarios")]
+                None,
+            ))
+        };
 
+        let result = create_provider();
         deferred.resolve(|_env| result);
     });
 

package/src/result.rs

@@ -16,7 +16,6 @@ pub enum SuccessReason {
     Return,
     /// The opcode `SELFDESTRUCT` was called
     SelfDestruct,
-    EofReturnContract,
 }
 
 impl From<edr_eth::result::SuccessReason> for SuccessReason {
@@ -25,7 +24,6 @@ impl From<edr_eth::result::SuccessReason> for SuccessReason {
             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,
         }
     }
 }
@@ -36,7 +34,6 @@ impl From<SuccessReason> for edr_eth::result::SuccessReason {
             SuccessReason::Stop => Self::Stop,
             SuccessReason::Return => Self::Return,
             SuccessReason::SelfDestruct => Self::SelfDestruct,
-            SuccessReason::EofReturnContract => Self::EofReturnContract,
         }
     }
 }
@@ -100,14 +97,6 @@ pub enum ExceptionalHalt {
     CreateContractStartingWithEF,
     /// EIP-3860: Limit and meter initcode. Initcode size limit exceeded.
     CreateInitCodeSizeLimit,
-    /// Aux data overflow, new aux data is larger tha u16 max size.
-    EofAuxDataOverflow,
-    /// Aud data is smaller then already present data size.
-    EofAuxDataTooSmall,
-    /// EOF Subroutine stack overflow
-    SubRoutineStackOverflow,
-    /// Check for target address validity is only done inside subcall.
-    InvalidEXTCALLTarget,
 }
 
 impl From<edr_eth::l1::HaltReason> for ExceptionalHalt {
@@ -133,12 +122,6 @@ impl From<edr_eth::l1::HaltReason> for ExceptionalHalt {
             edr_eth::l1::HaltReason::CreateInitCodeSizeLimit => {
                 ExceptionalHalt::CreateInitCodeSizeLimit
             }
-            edr_eth::l1::HaltReason::EofAuxDataOverflow => ExceptionalHalt::EofAuxDataOverflow,
-            edr_eth::l1::HaltReason::EofAuxDataTooSmall => ExceptionalHalt::EofAuxDataTooSmall,
-            edr_eth::l1::HaltReason::SubRoutineStackOverflow => {
-                ExceptionalHalt::SubRoutineStackOverflow
-            }
-            edr_eth::l1::HaltReason::InvalidEXTCALLTarget => ExceptionalHalt::InvalidEXTCALLTarget,
             edr_eth::l1::HaltReason::OverflowPayment
             | edr_eth::l1::HaltReason::StateChangeDuringStaticCall
             | edr_eth::l1::HaltReason::CallNotAllowedInsideStatic
@@ -167,10 +150,6 @@ impl From<ExceptionalHalt> for edr_eth::l1::HaltReason {
             ExceptionalHalt::CreateContractSizeLimit => Self::CreateContractSizeLimit,
             ExceptionalHalt::CreateContractStartingWithEF => Self::CreateContractStartingWithEF,
             ExceptionalHalt::CreateInitCodeSizeLimit => Self::CreateInitCodeSizeLimit,
-            ExceptionalHalt::EofAuxDataOverflow => Self::EofAuxDataOverflow,
-            ExceptionalHalt::EofAuxDataTooSmall => Self::EofAuxDataTooSmall,
-            ExceptionalHalt::SubRoutineStackOverflow => Self::SubRoutineStackOverflow,
-            ExceptionalHalt::InvalidEXTCALLTarget => Self::InvalidEXTCALLTarget,
         }
     }
 }

package/src/trace/return_data.rs

@@ -57,10 +57,17 @@ impl ReturnData {
             return Ok(String::new());
         }
 
+        if !self.is_error_return_data() {
+            return Err(napi::Error::new(
+                napi::Status::InvalidArg,
+                "VM Exception while processing transaction: Expected return data to be a Error(string)",
+            ));
+        }
+
         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",
+                "VM Exception while processing transaction: Expected return data to contain a valid string",
             )
         })?;
 
@@ -69,10 +76,17 @@ impl ReturnData {
 
     #[napi(catch_unwind)]
     pub fn decode_panic(&self) -> napi::Result<BigInt> {
+        if !self.is_panic_return_data() {
+            return Err(napi::Error::new(
+                napi::Status::InvalidArg,
+                "VM Exception while processing transaction: Expected return data to be a Panic(uint256)",
+            ));
+        }
+
         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",
+                "VM Exception while processing transaction: Expected return data to contain a valid uint256",
             )
         })?;