@nomicfoundation/edr 0.11.3 → 0.12.0-next.0

package/src/solidity_tests/factory.rs

@@ -0,0 +1,22 @@
+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

@@ -0,0 +1,68 @@
+use std::{collections::BTreeMap, sync::Arc};
+
+use edr_eth::Bytes;
+use edr_napi_core::solidity::{
+    config::{TestRunnerConfig, TracingConfigWithBuffers},
+    SyncTestRunner, SyncTestRunnerFactory,
+};
+use edr_solidity::artifacts::ArtifactId;
+use edr_solidity_tests::{
+    contracts::ContractsByArtifact, decode::RevertDecoder, evm_context::L1EvmBuilder,
+    multi_runner::TestContract, revm::context::TxEnv, 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_eth::l1::BlockEnv,
+                    (),
+                    L1EvmBuilder,
+                    edr_eth::l1::HaltReason,
+                    edr_eth::l1::SpecId,
+                    _,
+                    edr_eth::l1::InvalidTransaction,
+                    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

@@ -0,0 +1,69 @@
+use std::{collections::BTreeMap, sync::Arc};
+
+use edr_eth::Bytes;
+use edr_napi_core::solidity::{
+    config::{TestRunnerConfig, TracingConfigWithBuffers},
+    SyncTestRunner, SyncTestRunnerFactory,
+};
+use edr_op::solidity_tests::OpEvmBuilder;
+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_eth::l1::BlockEnv,
+                    _,
+                    OpEvmBuilder,
+                    edr_op::OpHaltReason,
+                    edr_op::OpSpecId,
+                    _,
+                    edr_op::transaction::InvalidTransaction,
+                    edr_op::transaction::OpTxEnv<edr_eth::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

@@ -0,0 +1,51 @@
+use std::sync::{Mutex, OnceLock};
+
+use edr_eth::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))
+    }
+}