@nomicfoundation/edr 0.12.0-next.8 → 0.12.0

package/src/instrument.rs

@@ -1,109 +0,0 @@
-use edr_instrument::coverage::{self, Version};
-use napi::bindgen_prelude::Uint8Array;
-use napi_derive::napi;
-
-#[napi(object)]
-pub struct InstrumentationResult {
-    /// The generated source code with coverage instrumentation.
-    #[napi(readonly)]
-    pub source: String,
-    /// The metadata for each instrumented code segment.
-    #[napi(readonly)]
-    pub metadata: Vec<InstrumentationMetadata>,
-}
-
-impl TryFrom<edr_instrument::coverage::InstrumentationResult> for InstrumentationResult {
-    type Error = usize;
-
-    fn try_from(
-        value: edr_instrument::coverage::InstrumentationResult,
-    ) -> Result<Self, Self::Error> {
-        let metadata = value
-            .metadata
-            .into_iter()
-            .map(InstrumentationMetadata::try_from)
-            .collect::<Result<Vec<_>, _>>()?;
-
-        Ok(InstrumentationResult {
-            source: value.source,
-            metadata,
-        })
-    }
-}
-
-#[napi(object)]
-pub struct InstrumentationMetadata {
-    /// The tag that identifies the instrumented code. Tags are
-    /// deterministically generated from the source code, source id, and
-    /// Solidity version.
-    #[napi(readonly)]
-    pub tag: Uint8Array,
-    /// The kind of instrumented code. Currently, the only supported kind
-    /// is "statement".
-    #[napi(readonly)]
-    pub kind: String,
-    /// The starting position of the instrumented code - including trivia such
-    /// as whitespace - in the source code, in UTF-16 code units.
-    #[napi(readonly)]
-    pub start_utf16: i64,
-    /// The ending position of the instrumented code - including trivia such as
-    /// whitespace - in the source code, in UTF-16 code units.
-    #[napi(readonly)]
-    pub end_utf16: i64,
-}
-
-impl TryFrom<edr_instrument::coverage::InstrumentationMetadata> for InstrumentationMetadata {
-    type Error = usize;
-
-    fn try_from(
-        value: edr_instrument::coverage::InstrumentationMetadata,
-    ) -> Result<Self, Self::Error> {
-        let start_utf16 = value
-            .start_utf16
-            .try_into()
-            .map_err(|_error| value.start_utf16)?;
-        let end_utf16 = value
-            .end_utf16
-            .try_into()
-            .map_err(|_error| value.end_utf16)?;
-
-        Ok(InstrumentationMetadata {
-            tag: Uint8Array::with_data_copied(value.tag),
-            kind: value.kind.to_owned(),
-            start_utf16,
-            end_utf16,
-        })
-    }
-}
-
-/// Adds per-statement coverage instrumentation to the given Solidity source
-/// code.
-#[napi(catch_unwind)]
-pub fn add_statement_coverage_instrumentation(
-    source_code: String,
-    source_id: String,
-    solidity_version: String,
-    coverage_library_path: String,
-) -> napi::Result<InstrumentationResult> {
-    let solidity_version = Version::parse(&solidity_version).map_err(|error| {
-        napi::Error::new(
-            napi::Status::InvalidArg,
-            format!("Invalid Solidity version: {error}"),
-        )
-    })?;
-
-    let instrumented = coverage::instrument_code(
-        &source_code,
-        &source_id,
-        solidity_version,
-        &coverage_library_path,
-    )
-    .map_err(|error| napi::Error::new(napi::Status::GenericFailure, error))?;
-
-    instrumented.try_into().map_err(|location| {
-        napi::Error::new(
-            napi::Status::GenericFailure,
-            format!("Cannot represent source locations in JavaScript: {location}."),
-        )
-    })
-}

package/src/lib.rs

@@ -1,50 +0,0 @@
-// #![warn(missing_docs)]
-
-//! NAPI bindings for EDR's core types.
-
-#[global_allocator]
-static ALLOC: mimalloc::MiMalloc = mimalloc::MiMalloc;
-
-mod account;
-mod block;
-/// Types for overriding a call.
-pub mod call_override;
-/// Types for casting N-API types to Rust types.
-pub mod cast;
-/// Supported chain types.
-pub mod chains;
-/// Types for configuration.
-pub mod config;
-/// Types related to an EDR N-API context.
-pub mod context;
-/// Types for decoding smart contract data.
-pub mod contract_decoder;
-mod debug_trace;
-pub mod gas_report;
-/// Types and functions related to code coverage instrumentation.
-pub mod instrument;
-/// Types for EVM execution logs.
-pub mod log;
-/// Types for an RPC request logger.
-pub mod logger;
-/// Types for mocking provider behavior.
-#[cfg(feature = "test-mock")]
-pub mod mock;
-/// Types for precompiles.
-pub mod precompile;
-/// Types for Ethereum RPC providers.
-pub mod provider;
-/// Types for EVM execution results.
-pub mod result;
-/// Types relating to benchmark scenarios.
-#[cfg(feature = "scenarios")]
-pub mod scenarios;
-mod serde;
-/// Solidity test runner.
-pub mod solidity_tests;
-/// Types for subscribing to events.
-pub mod subscription;
-/// Types for EVM traces.
-pub mod trace;
-/// Types related to Ethereum withdrawals.
-pub mod withdrawal;

package/src/log.rs

@@ -1,28 +0,0 @@
-use napi::bindgen_prelude::Uint8Array;
-use napi_derive::napi;
-
-/// Ethereum execution log.
-#[napi(object)]
-pub struct ExecutionLog {
-    pub address: Uint8Array,
-    pub topics: Vec<Uint8Array>,
-    pub data: Uint8Array,
-}
-
-impl From<&edr_receipt::log::ExecutionLog> for ExecutionLog {
-    fn from(value: &edr_receipt::log::ExecutionLog) -> Self {
-        let topics = value
-            .topics()
-            .iter()
-            .map(Uint8Array::with_data_copied)
-            .collect();
-
-        let data = Uint8Array::with_data_copied(&value.data.data);
-
-        Self {
-            address: Uint8Array::with_data_copied(value.address),
-            topics,
-            data,
-        }
-    }
-}

package/src/logger.rs

@@ -1,120 +0,0 @@
-use std::sync::{mpsc::channel, Arc};
-
-use edr_napi_core::logger::LoggerError;
-use edr_primitives::Bytes;
-use napi::{
-    threadsafe_function::{
-        ErrorStrategy, ThreadSafeCallContext, ThreadsafeFunction, ThreadsafeFunctionCallMode,
-    },
-    JsFunction, Status,
-};
-use napi_derive::napi;
-
-#[napi(object)]
-pub struct LoggerConfig {
-    /// Whether to enable the logger.
-    pub enable: bool,
-    #[napi(ts_type = "(inputs: ArrayBuffer[]) => string[]")]
-    pub decode_console_log_inputs_callback: JsFunction,
-    #[napi(ts_type = "(message: string, replace: boolean) => void")]
-    pub print_line_callback: JsFunction,
-}
-
-impl LoggerConfig {
-    /// Resolves the logger config, converting it to a
-    /// `edr_napi_core::logger::Config`.
-    pub fn resolve(self, env: &napi::Env) -> napi::Result<edr_napi_core::logger::Config> {
-        let mut decode_console_log_inputs_callback: ThreadsafeFunction<_, ErrorStrategy::Fatal> =
-            self.decode_console_log_inputs_callback
-                .create_threadsafe_function(0, |ctx: ThreadSafeCallContext<Vec<Bytes>>| {
-                    let inputs = ctx.env.create_array_with_length(ctx.value.len()).and_then(
-                        |mut inputs| {
-                            for (idx, input) in ctx.value.into_iter().enumerate() {
-                                ctx.env
-                                    .create_arraybuffer_with_data(input.to_vec())
-                                    .and_then(|input| {
-                                        inputs.set_element(idx as u32, input.into_raw())
-                                    })?;
-                            }
-
-                            Ok(inputs)
-                        },
-                    )?;
-
-                    Ok(vec![inputs])
-                })?;
-
-        // Maintain a weak reference to the function to avoid blocking the event loop
-        // from exiting.
-        decode_console_log_inputs_callback.unref(env)?;
-
-        let decode_console_log_inputs_fn = Arc::new(move |console_log_inputs| {
-            let (sender, receiver) = channel();
-
-            let status = decode_console_log_inputs_callback.call_with_return_value(
-                console_log_inputs,
-                ThreadsafeFunctionCallMode::Blocking,
-                move |decoded_inputs: Vec<String>| {
-                    sender.send(decoded_inputs).map_err(|_error| {
-                        napi::Error::new(
-                            Status::GenericFailure,
-                            "Failed to send result from decode_console_log_inputs",
-                        )
-                    })
-                },
-            );
-            assert_eq!(status, Status::Ok);
-
-            receiver
-                .recv()
-                .expect("Receive can only fail if the channel is closed")
-        });
-
-        let mut print_line_callback: ThreadsafeFunction<_, ErrorStrategy::Fatal> = self
-            .print_line_callback
-            .create_threadsafe_function(0, |ctx: ThreadSafeCallContext<(String, bool)>| {
-                // String
-                let message = ctx.env.create_string_from_std(ctx.value.0)?;
-
-                // bool
-                let replace = ctx.env.get_boolean(ctx.value.1)?;
-
-                Ok(vec![message.into_unknown(), replace.into_unknown()])
-            })?;
-
-        // Maintain a weak reference to the function to avoid blocking the event loop
-        // from exiting.
-        print_line_callback.unref(env)?;
-
-        let print_line_fn = Arc::new(move |message, replace| {
-            let (sender, receiver) = channel();
-
-            let status = print_line_callback.call_with_return_value(
-                (message, replace),
-                ThreadsafeFunctionCallMode::Blocking,
-                move |()| {
-                    sender.send(()).map_err(|_error| {
-                        napi::Error::new(
-                            Status::GenericFailure,
-                            "Failed to send result from decode_console_log_inputs",
-                        )
-                    })
-                },
-            );
-
-            let () = receiver.recv().unwrap();
-
-            if status == napi::Status::Ok {
-                Ok(())
-            } else {
-                Err(LoggerError::PrintLine)
-            }
-        });
-
-        Ok(edr_napi_core::logger::Config {
-            enable: self.enable,
-            decode_console_log_inputs_fn,
-            print_line_fn,
-        })
-    }
-}

package/src/mock/time.rs

@@ -1,134 +0,0 @@
-use std::sync::Arc;
-
-use edr_evm::spec::RuntimeSpec;
-use edr_evm_spec::ChainSpec;
-use edr_generic::GenericChainSpec;
-use edr_napi_core::logger::Logger;
-use edr_primitives::B256;
-use edr_rpc_spec::RpcSpec;
-use napi::{bindgen_prelude::BigInt, tokio::runtime, Env, JsObject};
-use napi_derive::napi;
-
-use crate::{
-    cast::TryCast as _,
-    config::{resolve_configs, ConfigResolution, ProviderConfig},
-    contract_decoder::ContractDecoder,
-    logger::LoggerConfig,
-    provider::Provider,
-    subscription::SubscriptionConfig,
-};
-
-#[napi]
-pub struct MockTime {
-    inner: Arc<edr_provider::time::MockTime>,
-}
-
-#[napi]
-impl MockTime {
-    #[doc = "Creates a new instance of `MockTime` with the current time."]
-    #[napi(factory, catch_unwind)]
-    pub fn now() -> Self {
-        Self {
-            inner: Arc::new(edr_provider::time::MockTime::now()),
-        }
-    }
-
-    #[doc = "Adds the specified number of seconds to the current time."]
-    #[napi(catch_unwind)]
-    pub fn add_seconds(&self, seconds: BigInt) -> napi::Result<()> {
-        let seconds = seconds.try_cast()?;
-
-        self.inner.add_seconds(seconds);
-        Ok(())
-    }
-}
-
-#[doc = "Creates a provider with a mock timer."]
-#[doc = "For testing purposes."]
-#[napi(catch_unwind, ts_return_type = "Promise<Provider>")]
-pub fn create_provider_with_mock_timer(
-    env: Env,
-    provider_config: ProviderConfig,
-    logger_config: LoggerConfig,
-    subscription_config: SubscriptionConfig,
-    contract_decoder: &ContractDecoder,
-    time: &MockTime,
-) -> napi::Result<JsObject> {
-    let (deferred, promise) = env.create_deferred()?;
-
-    macro_rules! try_or_reject_promise {
-        ($expr:expr) => {
-            match $expr {
-                Ok(value) => value,
-                Err(error) => {
-                    deferred.reject(error);
-                    return Ok(promise);
-                }
-            }
-        };
-    }
-
-    let runtime = runtime::Handle::current();
-
-    let ConfigResolution {
-        logger_config,
-        provider_config,
-        subscription_callback,
-    } = try_or_reject_promise!(resolve_configs(
-        &env,
-        runtime.clone(),
-        provider_config,
-        logger_config,
-        subscription_config,
-    ));
-
-    let contract_decoder = Arc::clone(contract_decoder.as_inner());
-    let timer = Arc::clone(&time.inner);
-
-    runtime.clone().spawn_blocking(move || {
-        // 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_chain_l1::Hardfork>::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,
-                    Arc::clone(&contract_decoder),
-                    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);
-    });
-
-    Ok(promise)
-}

package/src/mock.rs

@@ -1,71 +0,0 @@
-pub mod time;
-
-use std::sync::Arc;
-
-use edr_evm_spec::EvmHaltReason;
-use edr_napi_core::provider::SyncProvider;
-use edr_rpc_client::jsonrpc;
-use edr_solidity::contract_decoder::ContractDecoder;
-use napi::tokio::runtime;
-use napi_derive::napi;
-
-use crate::{context::EdrContext, provider::Provider};
-
-/// A mock provider that always returns the given mocked response.
-pub struct MockProvider {
-    mocked_response: serde_json::Value,
-}
-
-impl MockProvider {
-    pub fn new(mocked_response: serde_json::Value) -> Self {
-        Self { mocked_response }
-    }
-}
-
-impl SyncProvider for MockProvider {
-    fn handle_request(
-        &self,
-        _request: String,
-        _contract_decoder: Arc<ContractDecoder>,
-    ) -> napi::Result<edr_napi_core::spec::Response<EvmHaltReason>> {
-        let response = jsonrpc::ResponseData::Success {
-            result: self.mocked_response.clone(),
-        };
-        edr_napi_core::spec::marshal_response_data(response)
-            .map(|data| edr_napi_core::spec::Response {
-                solidity_trace: None,
-                data,
-                traces: Vec::new(),
-            })
-            .map_err(|error| napi::Error::new(napi::Status::GenericFailure, error.to_string()))
-    }
-
-    fn set_call_override_callback(
-        &self,
-        _call_override_callback: Arc<dyn edr_provider::SyncCallOverride>,
-    ) {
-    }
-
-    fn set_verbose_tracing(&self, _enabled: bool) {}
-}
-
-#[napi]
-impl EdrContext {
-    #[doc = "Creates a mock provider, which always returns the given response."]
-    #[doc = "For testing purposes."]
-    #[napi]
-    pub fn create_mock_provider(
-        &self,
-        mocked_response: serde_json::Value,
-    ) -> napi::Result<Provider> {
-        let provider = Provider::new(
-            Arc::new(MockProvider::new(mocked_response)),
-            runtime::Handle::current(),
-            Arc::new(ContractDecoder::default()),
-            #[cfg(feature = "scenarios")]
-            None,
-        );
-
-        Ok(provider)
-    }
-}

package/src/precompile.rs

@@ -1,50 +0,0 @@
-use edr_evm::precompile::{self, PrecompileFn, PrecompileWithAddress};
-use edr_primitives::Address;
-use napi::bindgen_prelude::Uint8Array;
-use napi_derive::napi;
-
-#[napi]
-#[derive(Clone)]
-pub struct Precompile {
-    address: Address,
-    precompile_fn: PrecompileFn,
-}
-
-impl Precompile {
-    pub fn new(address: Address, precompile_fn: PrecompileFn) -> Self {
-        Self {
-            address,
-            precompile_fn,
-        }
-    }
-
-    /// Returns the address and precompile function as a tuple.
-    pub fn to_tuple(&self) -> (Address, PrecompileFn) {
-        (self.address, self.precompile_fn)
-    }
-}
-
-impl From<PrecompileWithAddress> for Precompile {
-    fn from(value: PrecompileWithAddress) -> Self {
-        Self {
-            address: value.0,
-            precompile_fn: value.1,
-        }
-    }
-}
-
-#[napi]
-impl Precompile {
-    /// Returns the address of the precompile.
-    #[napi(catch_unwind, getter)]
-    pub fn address(&self) -> Uint8Array {
-        Uint8Array::with_data_copied(self.address)
-    }
-}
-
-/// [RIP-7212](https://github.com/ethereum/RIPs/blob/master/RIPS/rip-7212.md#specification)
-/// secp256r1 precompile.
-#[napi(catch_unwind)]
-pub fn precompile_p256_verify() -> Precompile {
-    Precompile::from(precompile::secp256r1::P256VERIFY)
-}

package/src/provider/factory.rs

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

package/src/provider/response.rs

@@ -1,73 +0,0 @@
-use edr_evm_spec::EvmHaltReason;
-use edr_napi_core::spec::SolidityTraceData;
-use edr_solidity::contract_decoder::NestedTraceDecoder as _;
-use napi::Either;
-use napi_derive::napi;
-
-use crate::{
-    cast::TryCast,
-    trace::{solidity_stack_trace::SolidityStackTrace, RawTrace},
-};
-
-#[napi]
-pub struct Response {
-    inner: edr_napi_core::spec::Response<EvmHaltReason>,
-}
-
-impl From<edr_napi_core::spec::Response<EvmHaltReason>> for Response {
-    fn from(value: edr_napi_core::spec::Response<EvmHaltReason>) -> Self {
-        Self { inner: value }
-    }
-}
-
-#[napi]
-impl Response {
-    #[doc = "Returns the response data as a JSON string or a JSON object."]
-    #[napi(catch_unwind, getter)]
-    pub fn data(&self) -> Either<String, serde_json::Value> {
-        self.inner.data.clone()
-    }
-
-    // Rust port of https://github.com/NomicFoundation/hardhat/blob/c20bf195a6efdc2d74e778b7a4a7799aac224841/packages/hardhat-core/src/internal/hardhat-network/provider/provider.ts#L590
-    #[doc = "Compute the error stack trace. Return the stack trace if it can be decoded, otherwise returns none. Throws if there was an error computing the stack trace."]
-    #[napi(catch_unwind)]
-    pub fn stack_trace(&self) -> napi::Result<Option<SolidityStackTrace>> {
-        let Some(SolidityTraceData {
-            trace,
-            contract_decoder,
-        }) = &self.inner.solidity_trace
-        else {
-            return Ok(None);
-        };
-        let nested_trace = edr_solidity::nested_tracer::convert_trace_messages_to_nested_trace(
-            trace.as_ref().clone(),
-        )
-        .map_err(|err| napi::Error::from_reason(err.to_string()))?;
-
-        if let Some(vm_trace) = nested_trace {
-            let decoded_trace = contract_decoder
-                .try_to_decode_nested_trace(vm_trace)
-                .map_err(|err| napi::Error::from_reason(err.to_string()))?;
-            let stack_trace = edr_solidity::solidity_tracer::get_stack_trace(decoded_trace)
-                .map_err(|err| napi::Error::from_reason(err.to_string()))?;
-            let stack_trace = stack_trace
-                .into_iter()
-                .map(TryCast::try_cast)
-                .collect::<Result<Vec<_>, _>>()?;
-
-            Ok(Some(stack_trace))
-        } else {
-            Ok(None)
-        }
-    }
-
-    #[doc = "Returns the raw traces of executed contracts. This maybe contain zero or more traces."]
-    #[napi(catch_unwind, getter)]
-    pub fn traces(&self) -> Vec<RawTrace> {
-        self.inner
-            .traces
-            .iter()
-            .map(|trace| RawTrace::from(trace.clone()))
-            .collect()
-    }
-}