@nomicfoundation/edr 0.12.0-next.9 → 0.12.0

package/src/solidity_tests/factory.rs

@@ -1,22 +0,0 @@
-use std::sync::Arc;
-
-use edr_napi_core::solidity::SyncTestRunnerFactory;
-use napi_derive::napi;
-
-#[napi]
-pub struct SolidityTestRunnerFactory {
-    inner: Arc<dyn SyncTestRunnerFactory>,
-}
-
-impl SolidityTestRunnerFactory {
-    /// Returns a reference to the inner test runner factory.
-    pub fn as_inner(&self) -> &Arc<dyn SyncTestRunnerFactory> {
-        &self.inner
-    }
-}
-
-impl From<Arc<dyn SyncTestRunnerFactory>> for SolidityTestRunnerFactory {
-    fn from(inner: Arc<dyn SyncTestRunnerFactory>) -> Self {
-        Self { inner }
-    }
-}

package/src/solidity_tests/l1.rs

@@ -1,68 +0,0 @@
-use std::{collections::BTreeMap, sync::Arc};
-
-use edr_napi_core::solidity::{
-    config::{TestRunnerConfig, TracingConfigWithBuffers},
-    SyncTestRunner, SyncTestRunnerFactory,
-};
-use edr_primitives::Bytes;
-use edr_solidity::artifacts::ArtifactId;
-use edr_solidity_tests::{
-    contracts::ContractsByArtifact, decode::RevertDecoder, evm_context::L1EvmBuilder,
-    multi_runner::TestContract, MultiContractRunner,
-};
-use napi::tokio;
-use napi_derive::napi;
-
-use crate::solidity_tests::{factory::SolidityTestRunnerFactory, runner::LazyContractDecoder};
-
-struct L1TestRunnerFactory;
-
-impl SyncTestRunnerFactory for L1TestRunnerFactory {
-    fn create_test_runner(
-        &self,
-        runtime: tokio::runtime::Handle,
-        config: TestRunnerConfig,
-        contracts: BTreeMap<ArtifactId, TestContract>,
-        known_contracts: ContractsByArtifact,
-        libs_to_deploy: Vec<Bytes>,
-        revert_decoder: RevertDecoder,
-        tracing_config: TracingConfigWithBuffers,
-    ) -> napi::Result<Box<dyn SyncTestRunner>> {
-        let contract_decoder = LazyContractDecoder::new(tracing_config);
-
-        let runner = tokio::task::block_in_place(|| {
-            runtime
-                .block_on(MultiContractRunner::<
-                    edr_chain_l1::BlockEnv,
-                    (),
-                    L1EvmBuilder,
-                    edr_chain_l1::HaltReason,
-                    edr_chain_l1::Hardfork,
-                    _,
-                    edr_chain_l1::InvalidTransaction,
-                    edr_chain_l1::TxEnv,
-                >::new(
-                    config.try_into()?,
-                    contracts,
-                    known_contracts,
-                    libs_to_deploy,
-                    contract_decoder,
-                    revert_decoder,
-                ))
-                .map_err(|err| {
-                    napi::Error::new(
-                        napi::Status::GenericFailure,
-                        format!("Failed to create multi contract runner: {err}"),
-                    )
-                })
-        })?;
-
-        Ok(Box::new(runner))
-    }
-}
-
-#[napi(catch_unwind)]
-pub fn l1_solidity_test_runner_factory() -> SolidityTestRunnerFactory {
-    let factory: Arc<dyn SyncTestRunnerFactory> = Arc::new(L1TestRunnerFactory);
-    factory.into()
-}

package/src/solidity_tests/op.rs

@@ -1,69 +0,0 @@
-use std::{collections::BTreeMap, sync::Arc};
-
-use edr_napi_core::solidity::{
-    config::{TestRunnerConfig, TracingConfigWithBuffers},
-    SyncTestRunner, SyncTestRunnerFactory,
-};
-use edr_op::solidity_tests::OpEvmBuilder;
-use edr_primitives::Bytes;
-use edr_solidity::artifacts::ArtifactId;
-use edr_solidity_tests::{
-    contracts::ContractsByArtifact, decode::RevertDecoder, multi_runner::TestContract,
-    MultiContractRunner,
-};
-use napi::tokio;
-use napi_derive::napi;
-
-use crate::solidity_tests::{factory::SolidityTestRunnerFactory, runner::LazyContractDecoder};
-
-struct OpTestRunnerFactory;
-
-impl SyncTestRunnerFactory for OpTestRunnerFactory {
-    fn create_test_runner(
-        &self,
-        runtime: tokio::runtime::Handle,
-        config: TestRunnerConfig,
-        contracts: BTreeMap<ArtifactId, TestContract>,
-        known_contracts: ContractsByArtifact,
-        libs_to_deploy: Vec<Bytes>,
-        revert_decoder: RevertDecoder,
-        tracing_config: TracingConfigWithBuffers,
-    ) -> napi::Result<Box<dyn SyncTestRunner>> {
-        let contract_decoder = LazyContractDecoder::new(tracing_config);
-
-        let runner = tokio::task::block_in_place(|| {
-            runtime
-                .block_on(MultiContractRunner::<
-                    edr_op::BlockEnv,
-                    _,
-                    OpEvmBuilder,
-                    edr_op::HaltReason,
-                    edr_op::Hardfork,
-                    _,
-                    edr_op::transaction::InvalidTransaction,
-                    edr_op::transaction::OpTxEnv<edr_chain_l1::TxEnv>,
-                >::new(
-                    config.try_into()?,
-                    contracts,
-                    known_contracts,
-                    libs_to_deploy,
-                    contract_decoder,
-                    revert_decoder,
-                ))
-                .map_err(|err| {
-                    napi::Error::new(
-                        napi::Status::GenericFailure,
-                        format!("Failed to create multi contract runner: {err}"),
-                    )
-                })
-        })?;
-
-        Ok(Box::new(runner))
-    }
-}
-
-#[napi(catch_unwind)]
-pub fn op_solidity_test_runner_factory() -> SolidityTestRunnerFactory {
-    let factory: Arc<dyn SyncTestRunnerFactory> = Arc::new(OpTestRunnerFactory);
-    factory.into()
-}

package/src/solidity_tests/runner.rs

@@ -1,51 +0,0 @@
-use std::sync::{Mutex, OnceLock};
-
-use edr_evm_spec::HaltReasonTrait;
-use edr_napi_core::solidity::config::TracingConfigWithBuffers;
-use edr_solidity::{
-    artifacts::BuildInfoConfigWithBuffers,
-    contract_decoder::{ContractDecoder, ContractDecoderError, NestedTraceDecoder},
-    nested_trace::NestedTrace,
-};
-
-/// Only parses the tracing config which is very expensive if the contract
-/// decoder is used.
-#[derive(Debug)]
-pub(crate) struct LazyContractDecoder {
-    // We need the `Mutex`, because `Uint8Array` is not `Sync`
-    tracing_config: Mutex<TracingConfigWithBuffers>,
-    // Storing the result so that we can propagate the error
-    contract_decoder: OnceLock<Result<ContractDecoder, ContractDecoderError>>,
-}
-
-impl LazyContractDecoder {
-    pub fn new(tracing_config: TracingConfigWithBuffers) -> Self {
-        Self {
-            tracing_config: Mutex::new(tracing_config),
-            contract_decoder: OnceLock::new(),
-        }
-    }
-}
-
-impl<HaltReasonT: HaltReasonTrait> NestedTraceDecoder<HaltReasonT> for LazyContractDecoder {
-    fn try_to_decode_nested_trace(
-        &self,
-        nested_trace: NestedTrace<HaltReasonT>,
-    ) -> Result<NestedTrace<HaltReasonT>, ContractDecoderError> {
-        self.contract_decoder
-            .get_or_init(|| {
-                let tracing_config = self
-                    .tracing_config
-                    .lock()
-                    .expect("Can't get poisoned, because only called once");
-                edr_solidity::artifacts::BuildInfoConfig::parse_from_buffers(
-                    BuildInfoConfigWithBuffers::from(&*tracing_config),
-                )
-                .map_err(|err| ContractDecoderError::Initialization(err.to_string()))
-                .and_then(|config| ContractDecoder::new(&config))
-            })
-            .as_ref()
-            .map_err(Clone::clone)
-            .and_then(|decoder| decoder.try_to_decode_nested_trace(nested_trace))
-    }
-}