@nomicfoundation/edr 0.2.0-alpha.2

package/src/provider/config.rs

@@ -0,0 +1,271 @@
+use std::{
+    path::PathBuf,
+    time::{Duration, SystemTime},
+};
+
+use edr_eth::HashMap;
+use edr_provider::AccountConfig;
+use napi::{
+    bindgen_prelude::{BigInt, Buffer},
+    Either,
+};
+use napi_derive::napi;
+
+use crate::{account::GenesisAccount, block::BlobGas, cast::TryCast, config::SpecId};
+
+/// Configuration for a chain
+#[napi(object)]
+pub struct ChainConfig {
+    /// The chain ID
+    pub chain_id: BigInt,
+    /// The chain's supported hardforks
+    pub hardforks: Vec<HardforkActivation>,
+}
+
+/// 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 HTTP headers to use when making requests to the JSON-RPC endpoint
+    pub http_headers: Option<Vec<HttpHeader>>,
+}
+
+#[napi(object)]
+pub struct HttpHeader {
+    pub name: String,
+    pub value: String,
+}
+
+/// Configuration for a hardfork activation
+#[napi(object)]
+pub struct HardforkActivation {
+    /// The block number at which the hardfork is activated
+    pub block_number: BigInt,
+    /// The activated hardfork
+    pub spec_id: SpecId,
+}
+
+#[napi(string_enum)]
+#[doc = "The type of ordering to use when selecting blocks to mine."]
+pub enum MineOrdering {
+    #[doc = "Insertion order"]
+    Fifo,
+    #[doc = "Effective miner fee"]
+    Priority,
+}
+
+/// Configuration for the provider's mempool.
+#[napi(object)]
+pub struct MemPoolConfig {
+    pub order: MineOrdering,
+}
+
+#[napi(object)]
+pub struct IntervalRange {
+    pub min: BigInt,
+    pub max: BigInt,
+}
+
+/// Configuration for the provider's miner.
+#[napi(object)]
+pub struct MiningConfig {
+    pub auto_mine: bool,
+    pub interval: Option<Either<BigInt, IntervalRange>>,
+    pub mem_pool: MemPoolConfig,
+}
+
+/// Configuration for a provider
+#[napi(object)]
+pub struct ProviderConfig {
+    /// Whether to allow blocks with the same timestamp
+    pub allow_blocks_with_same_timestamp: bool,
+    /// Whether to allow unlimited contract size
+    pub allow_unlimited_contract_size: bool,
+    /// Whether to return an `Err` when `eth_call` fails
+    pub bail_on_call_failure: bool,
+    /// Whether to return an `Err` when a `eth_sendTransaction` fails
+    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,
+    /// The configuration for forking a blockchain. If not provided, a local
+    /// blockchain will be created
+    pub fork: Option<ForkConfig>,
+    /// The genesis accounts of the blockchain
+    pub genesis_accounts: Vec<GenesisAccount>,
+    /// The hardfork of the blockchain
+    pub hardfork: SpecId,
+    /// The initial base fee per gas of the blockchain. Required for EIP-1559
+    /// transactions and later
+    pub initial_base_fee_per_gas: Option<BigInt>,
+    /// The initial blob gas of the blockchain. Required for EIP-4844
+    pub initial_blob_gas: Option<BlobGas>,
+    /// The initial date of the blockchain, in seconds since the Unix epoch
+    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>,
+    /// 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,
+}
+
+impl TryFrom<ForkConfig> for edr_provider::hardhat_rpc_types::ForkConfig {
+    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 http_headers = value.http_headers.map(|http_headers| {
+            http_headers
+                .into_iter()
+                .map(|HttpHeader { name, value }| (name, value))
+                .collect()
+        });
+
+        Ok(Self {
+            json_rpc_url: value.json_rpc_url,
+            block_number,
+            http_headers,
+        })
+    }
+}
+
+impl From<MemPoolConfig> for edr_provider::MemPoolConfig {
+    fn from(value: MemPoolConfig) -> Self {
+        Self {
+            order: value.order.into(),
+        }
+    }
+}
+
+impl From<MineOrdering> for edr_evm::MineOrdering {
+    fn from(value: MineOrdering) -> Self {
+        match value {
+            MineOrdering::Fifo => Self::Fifo,
+            MineOrdering::Priority => Self::Priority,
+        }
+    }
+}
+
+impl TryFrom<MiningConfig> for edr_provider::MiningConfig {
+    type Error = napi::Error;
+
+    fn try_from(value: MiningConfig) -> Result<Self, Self::Error> {
+        let mem_pool = value.mem_pool.into();
+
+        let interval = value
+            .interval
+            .map(|interval| {
+                let interval = match interval {
+                    Either::A(interval) => {
+                        edr_provider::IntervalConfig::Fixed(interval.try_cast()?)
+                    }
+                    Either::B(IntervalRange { min, max }) => edr_provider::IntervalConfig::Range {
+                        min: min.try_cast()?,
+                        max: max.try_cast()?,
+                    },
+                };
+
+                napi::Result::Ok(interval)
+            })
+            .transpose()?;
+
+        Ok(Self {
+            auto_mine: value.auto_mine,
+            interval,
+            mem_pool,
+        })
+    }
+}
+
+impl TryFrom<ProviderConfig> for edr_provider::ProviderConfig {
+    type Error = napi::Error;
+
+    fn try_from(value: ProviderConfig) -> Result<Self, Self::Error> {
+        let chains = value
+            .chains
+            .into_iter()
+            .map(
+                |ChainConfig {
+                     chain_id,
+                     hardforks,
+                 }| {
+                    let hardforks = hardforks
+                        .into_iter()
+                        .map(
+                            |HardforkActivation {
+                                 block_number,
+                                 spec_id,
+                             }| {
+                                let block_number = block_number.try_cast()?;
+                                let spec_id = spec_id.try_into()?;
+
+                                Ok((block_number, spec_id))
+                            },
+                        )
+                        .collect::<napi::Result<Vec<_>>>()?;
+
+                    let chain_id = chain_id.try_cast()?;
+                    Ok((chain_id, edr_eth::spec::HardforkActivations::new(hardforks)))
+                },
+            )
+            .collect::<napi::Result<_>>()?;
+
+        Ok(Self {
+            accounts: value
+                .genesis_accounts
+                .into_iter()
+                .map(AccountConfig::try_from)
+                .collect::<napi::Result<Vec<_>>>()?,
+            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,
+            block_gas_limit: value.block_gas_limit.try_cast()?,
+            cache_dir: PathBuf::from(
+                value
+                    .cache_dir
+                    .unwrap_or(String::from(edr_defaults::CACHE_DIR)),
+            ),
+            chain_id: value.chain_id.try_cast()?,
+            chains,
+            coinbase: value.coinbase.try_cast()?,
+            fork: value.fork.map(TryInto::try_into).transpose()?,
+            genesis_accounts: HashMap::new(),
+            hardfork: value.hardfork.try_into()?,
+            initial_base_fee_per_gas: value
+                .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_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
+                .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()?,
+        })
+    }
+}

package/src/provider.rs

@@ -0,0 +1,185 @@
+mod config;
+
+use std::sync::Arc;
+
+use edr_eth::remote::jsonrpc;
+use edr_provider::InvalidRequestReason;
+use napi::{tokio::runtime, Env, JsFunction, JsObject, Status};
+use napi_derive::napi;
+
+use self::config::ProviderConfig;
+use crate::{
+    context::EdrContext,
+    logger::{Logger, LoggerConfig, LoggerError},
+    subscribe::SubscriberCallback,
+    trace::RawTrace,
+};
+
+/// A JSON-RPC provider for Ethereum.
+#[napi]
+pub struct Provider {
+    provider: Arc<edr_provider::Provider<LoggerError>>,
+}
+
+#[napi]
+impl Provider {
+    #[doc = "Constructs a new provider with the provided configuration."]
+    #[napi(ts_return_type = "Promise<Provider>")]
+    pub fn with_config(
+        env: Env,
+        // We take the context as argument to ensure that tracing is initialized properly.
+        _context: &EdrContext,
+        config: ProviderConfig,
+        logger_config: LoggerConfig,
+        #[napi(ts_arg_type = "(event: SubscriptionEvent) => void")] subscriber_callback: JsFunction,
+    ) -> napi::Result<JsObject> {
+        let config = edr_provider::ProviderConfig::try_from(config)?;
+        let runtime = runtime::Handle::current();
+
+        let logger = Box::new(Logger::new(&env, logger_config)?);
+        let subscriber_callback = SubscriberCallback::new(&env, subscriber_callback)?;
+        let subscriber_callback = Box::new(move |event| subscriber_callback.call(event));
+
+        let (deferred, promise) = env.create_deferred()?;
+        runtime.clone().spawn_blocking(move || {
+            let result = edr_provider::Provider::new(runtime, logger, subscriber_callback, config)
+                .map_or_else(
+                    |error| Err(napi::Error::new(Status::GenericFailure, error.to_string())),
+                    |provider| {
+                        Ok(Provider {
+                            provider: Arc::new(provider),
+                        })
+                    },
+                );
+
+            deferred.resolve(|_env| result);
+        });
+
+        Ok(promise)
+    }
+
+    #[doc = "Handles a JSON-RPC request and returns a JSON-RPC response."]
+    #[napi]
+    pub async fn handle_request(&self, json_request: String) -> napi::Result<Response> {
+        let provider = self.provider.clone();
+        let request = match serde_json::from_str(&json_request) {
+            Ok(request) => request,
+            Err(error) => {
+                let message = error.to_string();
+                let reason = InvalidRequestReason::new(&json_request, &message);
+
+                // HACK: We need to log failed deserialization attempts when they concern input
+                // validation.
+                if let Some((method_name, provider_error)) = reason.provider_error() {
+                    // Ignore potential failure of logging, as returning the original error is more
+                    // important
+                    let _result = runtime::Handle::current()
+                        .spawn_blocking(move || {
+                            provider.log_failed_deserialization(&method_name, &provider_error)
+                        })
+                        .await
+                        .map_err(|error| {
+                            napi::Error::new(Status::GenericFailure, error.to_string())
+                        })?;
+                }
+
+                let data = serde_json::from_str(&json_request).ok();
+                let response = jsonrpc::ResponseData::<()>::Error {
+                    error: jsonrpc::Error {
+                        code: reason.error_code(),
+                        message: reason.error_message(),
+                        data,
+                    },
+                };
+
+                return serde_json::to_string(&response)
+                    .map_err(|error| {
+                        napi::Error::new(
+                            Status::InvalidArg,
+                            format!("Invalid JSON `{json_request}` due to: {error}"),
+                        )
+                    })
+                    .map(|json_response| Response {
+                        solidity_trace: None,
+                        json: json_response,
+                        traces: Vec::new(),
+                    });
+            }
+        };
+
+        let mut response = runtime::Handle::current()
+            .spawn_blocking(move || provider.handle_request(request))
+            .await
+            .map_err(|e| napi::Error::new(Status::GenericFailure, e.to_string()))?;
+
+        // We can take the solidity trace as it won't be used for anything else
+        let solidity_trace = response.as_mut().err().and_then(|error| {
+            if let edr_provider::ProviderError::TransactionFailed(failure) = error {
+                if matches!(
+                    failure.failure.reason,
+                    edr_provider::TransactionFailureReason::OutOfGas(_)
+                ) {
+                    None
+                } else {
+                    Some(Arc::new(std::mem::take(
+                        &mut failure.failure.solidity_trace,
+                    )))
+                }
+            } else {
+                None
+            }
+        });
+
+        // We can take the traces as they won't be used for anything else
+        let traces = match &mut response {
+            Ok(response) => std::mem::take(&mut response.traces),
+            Err(edr_provider::ProviderError::TransactionFailed(failure)) => {
+                std::mem::take(&mut failure.traces)
+            }
+            Err(_) => Vec::new(),
+        };
+
+        let response = jsonrpc::ResponseData::from(response.map(|response| response.result));
+
+        serde_json::to_string(&response)
+            .map_err(|e| napi::Error::new(Status::GenericFailure, e.to_string()))
+            .map(|json_response| Response {
+                solidity_trace,
+                json: json_response,
+                traces: traces.into_iter().map(Arc::new).collect(),
+            })
+    }
+}
+
+#[napi]
+pub struct Response {
+    json: String,
+    /// When a transaction fails to execute, the provider returns a trace of the
+    /// transaction.
+    solidity_trace: Option<Arc<edr_evm::trace::Trace>>,
+    /// This may contain zero or more traces, depending on the (batch) request
+    traces: Vec<Arc<edr_evm::trace::Trace>>,
+}
+
+#[napi]
+impl Response {
+    #[napi(getter)]
+    pub fn json(&self) -> String {
+        self.json.clone()
+    }
+
+    #[napi(getter)]
+    pub fn solidity_trace(&self) -> Option<RawTrace> {
+        self.solidity_trace
+            .as_ref()
+            .map(|trace| RawTrace::new(trace.clone()))
+    }
+
+    #[napi(getter)]
+    pub fn traces(&self) -> Vec<RawTrace> {
+        self.traces
+            .iter()
+            .map(|trace| RawTrace::new(trace.clone()))
+            .collect()
+    }
+}