@nomicfoundation/edr 0.12.0-alpha.0 → 0.12.0-next.0

package/src/config.rs

@@ -1,40 +1,66 @@
+use core::fmt::{Debug, Display};
 use std::{
     num::NonZeroU64,
+    path::PathBuf,
     time::{Duration, SystemTime},
 };
 
-use edr_eth::KECCAK_EMPTY;
+use edr_coverage::reporter::SyncOnCollectedCoverageCallback;
+use edr_eth::{
+    signature::{secret_key_from_str, SecretKey},
+    Bytes, HashMap, HashSet,
+};
 use napi::{
-    Either,
-    bindgen_prelude::{BigInt, Buffer, Uint8Array},
+    bindgen_prelude::{BigInt, Promise, Reference, Uint8Array},
+    threadsafe_function::{
+        ErrorStrategy, ThreadSafeCallContext, ThreadsafeFunction, ThreadsafeFunctionCallMode,
+    },
+    tokio::runtime,
+    Either, JsFunction, JsString, JsStringUtf8,
 };
 use napi_derive::napi;
 
-use crate::{
-    account::{Account, OwnedAccount, StorageSlot},
-    block::BlobGas,
-    cast::TryCast,
-};
+use crate::{account::AccountOverride, block::BlobGas, cast::TryCast, precompile::Precompile};
 
-/// Configuration for a chain
+/// Specification of a chain with possible overrides.
 #[napi(object)]
-pub struct ChainConfig {
+pub struct ChainOverride {
     /// The chain ID
     pub chain_id: BigInt,
-    /// The chain's supported hardforks
-    pub hardforks: Vec<HardforkActivation>,
+    /// The chain's name
+    pub name: String,
+    /// If present, overrides for the chain's supported hardforks
+    pub hardfork_activation_overrides: Option<Vec<HardforkActivation>>,
+}
+
+/// Configuration for a code coverage reporter.
+#[napi(object)]
+pub struct CodeCoverageConfig {
+    /// The callback to be called when coverage has been collected.
+    ///
+    /// The callback receives an array of unique coverage hit markers (i.e. no
+    /// repetition) per transaction.
+    ///
+    /// Exceptions thrown in the callback will be propagated to the original
+    /// caller.
+    #[napi(ts_type = "(coverageHits: Uint8Array[]) => Promise<void>")]
+    pub on_collected_coverage_callback: JsFunction,
 }
 
 /// Configuration for forking a blockchain
 #[napi(object)]
 pub struct ForkConfig {
-    /// The URL of the JSON-RPC endpoint to fork from
-    pub json_rpc_url: String,
     /// The block number to fork from. If not provided, the latest safe block is
     /// used.
     pub block_number: Option<BigInt>,
+    /// The directory to cache remote JSON-RPC responses
+    pub cache_dir: Option<String>,
+    /// Overrides for the configuration of chains.
+    pub chain_overrides: Option<Vec<ChainOverride>>,
     /// The HTTP headers to use when making requests to the JSON-RPC endpoint
     pub http_headers: Option<Vec<HttpHeader>>,
+    /// The URL of the JSON-RPC endpoint to fork from
+    pub url: String,
 }
 
 #[napi(object)]
@@ -46,10 +72,22 @@ pub struct HttpHeader {
 /// Configuration for a hardfork activation
 #[napi(object)]
 pub struct HardforkActivation {
+    /// The condition for the hardfork activation
+    pub condition: Either<HardforkActivationByBlockNumber, HardforkActivationByTimestamp>,
+    /// The activated hardfork
+    pub hardfork: String,
+}
+
+#[napi(object)]
+pub struct HardforkActivationByBlockNumber {
     /// The block number at which the hardfork is activated
     pub block_number: BigInt,
-    /// The activated hardfork
-    pub spec_id: String,
+}
+
+#[napi(object)]
+pub struct HardforkActivationByTimestamp {
+    /// The timestamp at which the hardfork is activated
+    pub timestamp: BigInt,
 }
 
 #[napi(string_enum)]
@@ -81,6 +119,13 @@ pub struct MiningConfig {
     pub mem_pool: MemPoolConfig,
 }
 
+/// Configuration for runtime observability.
+#[napi(object)]
+pub struct ObservabilityConfig {
+    /// If present, configures runtime observability to collect code coverage.
+    pub code_coverage: Option<CodeCoverageConfig>,
+}
+
 /// Configuration for a provider
 #[napi(object)]
 pub struct ProviderConfig {
@@ -94,21 +139,15 @@ pub struct ProviderConfig {
     pub bail_on_transaction_failure: bool,
     /// The gas limit of each block
     pub block_gas_limit: BigInt,
-    /// The directory to cache remote JSON-RPC responses
-    pub cache_dir: Option<String>,
     /// The chain ID of the blockchain
     pub chain_id: BigInt,
-    /// The configuration for chains
-    pub chains: Vec<ChainConfig>,
     /// The address of the coinbase
-    pub coinbase: Buffer,
-    /// Enables RIP-7212
-    pub enable_rip_7212: bool,
+    pub coinbase: Uint8Array,
     /// The configuration for forking a blockchain. If not provided, a local
     /// blockchain will be created
     pub fork: Option<ForkConfig>,
     /// The genesis state of the blockchain
-    pub genesis_state: Vec<Account>,
+    pub genesis_state: Vec<AccountOverride>,
     /// The hardfork of the blockchain
     pub hardfork: String,
     /// The initial base fee per gas of the blockchain. Required for EIP-1559
@@ -120,22 +159,93 @@ pub struct ProviderConfig {
     pub initial_date: Option<BigInt>,
     /// The initial parent beacon block root of the blockchain. Required for
     /// EIP-4788
-    pub initial_parent_beacon_block_root: Option<Buffer>,
+    pub initial_parent_beacon_block_root: Option<Uint8Array>,
     /// The minimum gas price of the next block.
     pub min_gas_price: BigInt,
     /// The configuration for the miner
     pub mining: MiningConfig,
     /// The network ID of the blockchain
     pub network_id: BigInt,
-    /// Owned accounts, for which the secret key is known
-    pub owned_accounts: Vec<OwnedAccount>,
+    /// The configuration for the provider's observability
+    pub observability: ObservabilityConfig,
+    // Using JsString here as it doesn't have `Debug`, `Display` and `Serialize` implementation
+    // which prevents accidentally leaking the secret keys to error messages and logs.
+    /// Secret keys of owned accounts
+    pub owned_accounts: Vec<JsString>,
+    /// Overrides for precompiles
+    pub precompile_overrides: Vec<Reference<Precompile>>,
 }
 
-impl TryFrom<ForkConfig> for edr_provider::hardhat_rpc_types::ForkConfig {
+impl TryFrom<ForkConfig> for edr_provider::ForkConfig<String> {
     type Error = napi::Error;
 
     fn try_from(value: ForkConfig) -> Result<Self, Self::Error> {
         let block_number: Option<u64> = value.block_number.map(TryCast::try_cast).transpose()?;
+
+        let cache_dir = PathBuf::from(
+            value
+                .cache_dir
+                .unwrap_or(edr_defaults::CACHE_DIR.to_owned()),
+        );
+
+        let chain_overrides = value
+            .chain_overrides
+            .map(|chain_overrides| {
+                chain_overrides
+                    .into_iter()
+                    .map(
+                        |ChainOverride {
+                             chain_id,
+                             name,
+                             hardfork_activation_overrides,
+                         }| {
+                            let hardfork_activation_overrides =
+                                hardfork_activation_overrides
+                                    .map(|hardfork_activations| {
+                                        hardfork_activations
+                                .into_iter()
+                                .map(
+                                    |HardforkActivation {
+                                         condition,
+                                         hardfork,
+                                     }| {
+                                        let condition = match condition {
+                                            Either::A(HardforkActivationByBlockNumber {
+                                                block_number,
+                                            }) => edr_evm::hardfork::ForkCondition::Block(
+                                                block_number.try_cast()?,
+                                            ),
+                                            Either::B(HardforkActivationByTimestamp {
+                                                timestamp,
+                                            }) => edr_evm::hardfork::ForkCondition::Timestamp(
+                                                timestamp.try_cast()?,
+                                            ),
+                                        };
+
+                                        Ok(edr_evm::hardfork::Activation {
+                                            condition,
+                                            hardfork,
+                                        })
+                                    },
+                                )
+                                .collect::<napi::Result<Vec<_>>>()
+                                .map(edr_evm::hardfork::Activations::new)
+                                    })
+                                    .transpose()?;
+
+                            let chain_config = edr_evm::hardfork::ChainOverride {
+                                name,
+                                hardfork_activation_overrides,
+                            };
+
+                            let chain_id = chain_id.try_cast()?;
+                            Ok((chain_id, chain_config))
+                        },
+                    )
+                    .collect::<napi::Result<_>>()
+            })
+            .transpose()?;
+
         let http_headers = value.http_headers.map(|http_headers| {
             http_headers
                 .into_iter()
@@ -144,9 +254,11 @@ impl TryFrom<ForkConfig> for edr_provider::hardhat_rpc_types::ForkConfig {
         });
 
         Ok(Self {
-            json_rpc_url: value.json_rpc_url,
             block_number,
+            cache_dir,
+            chain_overrides: chain_overrides.unwrap_or_default(),
             http_headers,
+            url: value.url,
         })
     }
 }
@@ -207,133 +319,178 @@ impl TryFrom<MiningConfig> for edr_provider::MiningConfig {
     }
 }
 
-impl TryFrom<ProviderConfig> for edr_napi_core::provider::Config {
-    type Error = napi::Error;
+impl ObservabilityConfig {
+    /// Resolves the instance, converting it to a
+    /// [`edr_provider::observability::Config`].
+    pub fn resolve(
+        self,
+        env: &napi::Env,
+        runtime: runtime::Handle,
+    ) -> napi::Result<edr_provider::observability::Config> {
+        let on_collected_coverage_fn = self
+            .code_coverage
+            .map(
+                |code_coverage| -> napi::Result<Box<dyn SyncOnCollectedCoverageCallback>> {
+                    let mut on_collected_coverage_callback: ThreadsafeFunction<
+                        _,
+                        ErrorStrategy::Fatal,
+                    > = code_coverage
+                        .on_collected_coverage_callback
+                        .create_threadsafe_function(
+                            0,
+                            |ctx: ThreadSafeCallContext<HashSet<Bytes>>| {
+                                let hits = ctx
+                                    .env
+                                    .create_array_with_length(ctx.value.len())
+                                    .and_then(|mut hits| {
+                                        for (idx, hit) in ctx.value.into_iter().enumerate() {
+                                            ctx.env
+                                                .create_buffer_with_data(hit.to_vec())
+                                                .and_then(|hit| {
+                                                    let idx = u32::try_from(idx).unwrap_or_else(|_| panic!("Number of hits should not exceed '{}'",
+                                                        u32::MAX));
+
+                                                    hits.set_element(idx, hit.into_raw())
+                                                })?;
+                                        }
+                                        Ok(hits)
+                                    })?;
+
+                                Ok(vec![hits])
+                            },
+                        )?;
+
+                    // Maintain a weak reference to the function to avoid blocking the event loop
+                    // from exiting.
+                    on_collected_coverage_callback.unref(env)?;
+
+                    let on_collected_coverage_fn: Box<dyn SyncOnCollectedCoverageCallback> =
+                        Box::new(move |hits| {
+                            let runtime = runtime.clone();
+
+                            let (sender, receiver) = std::sync::mpsc::channel();
+
+                            let status = on_collected_coverage_callback
+                                .call_with_return_value(hits, ThreadsafeFunctionCallMode::Blocking, move |result: Promise<()>| {
+                                    // We spawn a background task to handle the async callback
+                                    runtime.spawn(async move {
+                                        let result = result.await;
+                                        sender.send(result).map_err(|_error| {
+                                            napi::Error::new(
+                                                napi::Status::GenericFailure,
+                                                "Failed to send result from on_collected_coverage_callback",
+                                            )
+                                        })
+                                    });
+                                    Ok(())
+                                });
+
+                            let () = receiver.recv().expect("Receive can only fail if the channel is closed")?;
+
+                            assert_eq!(status, napi::Status::Ok);
+
+                            Ok(())
+                        });
+
+                    Ok(on_collected_coverage_fn)
+                },
+            )
+            .transpose()?;
+
+        Ok(edr_provider::observability::Config {
+            on_collected_coverage_fn,
+            ..edr_provider::observability::Config::default()
+        })
+    }
+}
 
-    fn try_from(value: ProviderConfig) -> Result<Self, Self::Error> {
-        let accounts = value
+impl ProviderConfig {
+    /// Resolves the instance to a [`edr_napi_core::provider::Config`].
+    pub fn resolve(
+        self,
+        env: &napi::Env,
+        runtime: runtime::Handle,
+    ) -> napi::Result<edr_napi_core::provider::Config> {
+        let owned_accounts = self
             .owned_accounts
             .into_iter()
-            .map(edr_provider::config::OwnedAccount::try_from)
+            .map(|secret_key| {
+                // This is the only place in production code where it's allowed to use
+                // `DangerousSecretKeyStr`.
+                #[allow(deprecated)]
+                use edr_eth::signature::DangerousSecretKeyStr;
+
+                static_assertions::assert_not_impl_all!(JsString: Debug, Display, serde::Serialize);
+                static_assertions::assert_not_impl_all!(JsStringUtf8: Debug, Display, serde::Serialize);
+                // `SecretKey` has `Debug` implementation, but it's opaque (only shows the
+                // type name)
+                static_assertions::assert_not_impl_any!(SecretKey: Display, serde::Serialize);
+
+                let secret_key = secret_key.into_utf8()?;
+                // This is the only place in production code where it's allowed to use
+                // `DangerousSecretKeyStr`.
+                #[allow(deprecated)]
+                let secret_key_str = DangerousSecretKeyStr(secret_key.as_str()?);
+                let secret_key: SecretKey = secret_key_from_str(secret_key_str)
+                    .map_err(|error| napi::Error::new(napi::Status::InvalidArg, error))?;
+
+                Ok(secret_key)
+            })
             .collect::<napi::Result<Vec<_>>>()?;
 
         let block_gas_limit =
-            NonZeroU64::new(value.block_gas_limit.try_cast()?).ok_or_else(|| {
+            NonZeroU64::new(self.block_gas_limit.try_cast()?).ok_or_else(|| {
                 napi::Error::new(
                     napi::Status::GenericFailure,
                     "Block gas limit must be greater than 0",
                 )
             })?;
 
-        let chains = value
-            .chains
-            .into_iter()
-            .map(
-                |ChainConfig {
-                     chain_id,
-                     hardforks,
-                 }| {
-                    let hardforks = hardforks
-                        .into_iter()
-                        .map(
-                            |HardforkActivation {
-                                 block_number,
-                                 spec_id: hardfork,
-                             }| {
-                                let block_number = block_number.try_cast()?;
-
-                                Ok(edr_napi_core::provider::HardforkActivation {
-                                    block_number,
-                                    hardfork,
-                                })
-                            },
-                        )
-                        .collect::<napi::Result<Vec<_>>>()?;
-
-                    let chain_id = chain_id.try_cast()?;
-                    Ok((chain_id, hardforks))
-                },
-            )
-            .collect::<napi::Result<_>>()?;
-
-        let genesis_state = value
+        let genesis_state = self
             .genesis_state
             .into_iter()
-            .map(
-                |Account {
-                     address,
-                     balance,
-                     nonce,
-                     code,
-                     storage,
-                 }| {
-                    let code: Option<edr_eth::Bytecode> =
-                        code.map(TryCast::try_cast).transpose()?;
-
-                    let code_hash = code
-                        .as_ref()
-                        .map_or(KECCAK_EMPTY, edr_eth::Bytecode::hash_slow);
-
-                    let info = edr_eth::account::AccountInfo {
-                        balance: balance.try_cast()?,
-                        nonce: nonce.try_cast()?,
-                        code_hash,
-                        code,
-                    };
-
-                    let storage = storage
-                        .into_iter()
-                        .map(|StorageSlot { index, value }| {
-                            let value = value.try_cast()?;
-                            let slot = edr_evm::state::EvmStorageSlot::new(value);
-
-                            let index: edr_eth::U256 = index.try_cast()?;
-                            Ok((index, slot))
-                        })
-                        .collect::<napi::Result<_>>()?;
-
-                    let address: edr_eth::Address = address.try_cast()?;
-                    let account = edr_provider::config::Account { info, storage };
+            .map(TryInto::try_into)
+            .collect::<napi::Result<HashMap<edr_eth::Address, edr_provider::AccountOverride>>>()?;
 
-                    Ok((address, account))
-                },
-            )
-            .collect::<napi::Result<_>>()?;
-
-        Ok(Self {
-            accounts,
-            allow_blocks_with_same_timestamp: value.allow_blocks_with_same_timestamp,
-            allow_unlimited_contract_size: value.allow_unlimited_contract_size,
-            bail_on_call_failure: value.bail_on_call_failure,
-            bail_on_transaction_failure: value.bail_on_transaction_failure,
+        let precompile_overrides = self
+            .precompile_overrides
+            .into_iter()
+            .map(|precompile| precompile.to_tuple())
+            .collect();
+
+        Ok(edr_napi_core::provider::Config {
+            allow_blocks_with_same_timestamp: self.allow_blocks_with_same_timestamp,
+            allow_unlimited_contract_size: self.allow_unlimited_contract_size,
+            bail_on_call_failure: self.bail_on_call_failure,
+            bail_on_transaction_failure: self.bail_on_transaction_failure,
             block_gas_limit,
-            cache_dir: value.cache_dir,
-            chain_id: value.chain_id.try_cast()?,
-            chains,
-            coinbase: value.coinbase.try_cast()?,
-            enable_rip_7212: value.enable_rip_7212,
-            fork: value.fork.map(TryInto::try_into).transpose()?,
+            chain_id: self.chain_id.try_cast()?,
+            coinbase: self.coinbase.try_cast()?,
+            fork: self.fork.map(TryInto::try_into).transpose()?,
             genesis_state,
-            hardfork: value.hardfork,
-            initial_base_fee_per_gas: value
+            hardfork: self.hardfork,
+            initial_base_fee_per_gas: self
                 .initial_base_fee_per_gas
                 .map(TryCast::try_cast)
                 .transpose()?,
-            initial_blob_gas: value.initial_blob_gas.map(TryInto::try_into).transpose()?,
-            initial_date: value
+            initial_blob_gas: self.initial_blob_gas.map(TryInto::try_into).transpose()?,
+            initial_date: self
                 .initial_date
                 .map(|date| {
                     let elapsed_since_epoch = Duration::from_secs(date.try_cast()?);
                     napi::Result::Ok(SystemTime::UNIX_EPOCH + elapsed_since_epoch)
                 })
                 .transpose()?,
-            initial_parent_beacon_block_root: value
+            initial_parent_beacon_block_root: self
                 .initial_parent_beacon_block_root
                 .map(TryCast::try_cast)
                 .transpose()?,
-            mining: value.mining.try_into()?,
-            min_gas_price: value.min_gas_price.try_cast()?,
-            network_id: value.network_id.try_cast()?,
+            mining: self.mining.try_into()?,
+            min_gas_price: self.min_gas_price.try_cast()?,
+            network_id: self.network_id.try_cast()?,
+            observability: self.observability.resolve(env, runtime)?,
+            owned_accounts,
+            precompile_overrides,
         })
     }
 }
@@ -349,6 +506,23 @@ pub struct TracingConfigWithBuffers {
     pub ignore_contracts: Option<bool>,
 }
 
+impl From<TracingConfigWithBuffers> for edr_napi_core::solidity::config::TracingConfigWithBuffers {
+    fn from(value: TracingConfigWithBuffers) -> Self {
+        edr_napi_core::solidity::config::TracingConfigWithBuffers {
+            build_infos: value.build_infos.map(|infos| match infos {
+                Either::A(with_output) => Either::A(with_output),
+                Either::B(separate_output) => Either::B(
+                    separate_output
+                        .into_iter()
+                        .map(edr_napi_core::solidity::config::BuildInfoAndOutput::from)
+                        .collect(),
+                ),
+            }),
+            ignore_contracts: value.ignore_contracts,
+        }
+    }
+}
+
 /// Hardhat V3 build info where the compiler output is not part of the build
 /// info file.
 #[napi(object)]
@@ -359,41 +533,11 @@ pub struct BuildInfoAndOutput {
     pub output: Uint8Array,
 }
 
-impl<'a> From<&'a BuildInfoAndOutput>
-    for edr_solidity::artifacts::BuildInfoBufferSeparateOutput<'a>
-{
-    fn from(value: &'a BuildInfoAndOutput) -> Self {
+impl From<BuildInfoAndOutput> for edr_napi_core::solidity::config::BuildInfoAndOutput {
+    fn from(value: BuildInfoAndOutput) -> Self {
         Self {
-            build_info: value.build_info.as_ref(),
-            output: value.output.as_ref(),
-        }
-    }
-}
-
-impl<'a> From<&'a TracingConfigWithBuffers>
-    for edr_solidity::artifacts::BuildInfoConfigWithBuffers<'a>
-{
-    fn from(value: &'a TracingConfigWithBuffers) -> Self {
-        use edr_solidity::artifacts::{BuildInfoBufferSeparateOutput, BuildInfoBuffers};
-
-        let build_infos = value.build_infos.as_ref().map(|infos| match infos {
-            Either::A(with_output) => BuildInfoBuffers::WithOutput(
-                with_output
-                    .iter()
-                    .map(std::convert::AsRef::as_ref)
-                    .collect(),
-            ),
-            Either::B(separate_output) => BuildInfoBuffers::SeparateInputOutput(
-                separate_output
-                    .iter()
-                    .map(BuildInfoBufferSeparateOutput::from)
-                    .collect(),
-            ),
-        });
-
-        Self {
-            build_infos,
-            ignore_contracts: value.ignore_contracts,
+            build_info: value.build_info,
+            output: value.output,
         }
     }
 }