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

package/src/mock.rs

@@ -0,0 +1,68 @@
+use std::sync::Arc;
+
+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<edr_eth::l1::HaltReason>> {
+        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

@@ -0,0 +1,50 @@
+use edr_eth::Address;
+use edr_evm::precompile::{self, PrecompileFn, PrecompileWithAddress};
+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/response.rs

@@ -1,11 +1,12 @@
 use edr_eth::l1;
 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::{RawTrace, solidity_stack_trace::SolidityStackTrace},
+    trace::{solidity_stack_trace::SolidityStackTrace, RawTrace},
 };
 
 #[napi]
@@ -22,14 +23,14 @@ impl From<edr_napi_core::spec::Response<l1::HaltReason>> for Response {
 #[napi]
 impl Response {
     #[doc = "Returns the response data as a JSON string or a JSON object."]
-    #[napi(getter)]
+    #[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]
+    #[napi(catch_unwind)]
     pub fn stack_trace(&self) -> napi::Result<Option<SolidityStackTrace>> {
         let Some(SolidityTraceData {
             trace,
@@ -44,7 +45,9 @@ impl Response {
         .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_message_trace(vm_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
@@ -59,7 +62,7 @@ impl Response {
     }
 
     #[doc = "Returns the raw traces of executed contracts. This maybe contain zero or more traces."]
-    #[napi(getter)]
+    #[napi(catch_unwind, getter)]
     pub fn traces(&self) -> Vec<RawTrace> {
         self.inner
             .traces

package/src/provider.rs

@@ -6,7 +6,7 @@ use std::sync::Arc;
 
 use edr_napi_core::provider::SyncProvider;
 use edr_solidity::contract_decoder::ContractDecoder;
-use napi::{Env, JsFunction, JsObject, Status, tokio::runtime};
+use napi::{tokio::runtime, Env, JsFunction, JsObject, Status};
 use napi_derive::napi;
 
 pub use self::factory::ProviderFactory;
@@ -46,7 +46,7 @@ impl Provider {
 #[napi]
 impl Provider {
     #[doc = "Handles a JSON-RPC request and returns a JSON-RPC response."]
-    #[napi]
+    #[napi(catch_unwind)]
     pub async fn handle_request(&self, request: String) -> napi::Result<Response> {
         let provider = self.provider.clone();
 
@@ -64,24 +64,30 @@ impl Provider {
             .map(Response::from)
     }
 
-    #[napi(ts_return_type = "Promise<void>")]
+    #[napi(catch_unwind, ts_return_type = "Promise<void>")]
     pub fn set_call_override_callback(
         &self,
         env: Env,
         #[napi(
-            ts_arg_type = "(contract_address: Buffer, data: Buffer) => Promise<CallOverrideResult | undefined>"
+            ts_arg_type = "(contract_address: ArrayBuffer, data: ArrayBuffer) => Promise<CallOverrideResult | undefined>"
         )]
         call_override_callback: JsFunction,
     ) -> napi::Result<JsObject> {
+        let (deferred, promise) = env.create_deferred()?;
+
         let call_override_callback =
-            CallOverrideCallback::new(&env, call_override_callback, self.runtime.clone())?;
+            match CallOverrideCallback::new(&env, call_override_callback, self.runtime.clone()) {
+                Ok(callback) => callback,
+                Err(error) => {
+                    deferred.reject(error);
+                    return Ok(promise);
+                }
+            };
 
         let call_override_callback =
             Arc::new(move |address, data| call_override_callback.call_override(address, data));
 
         let provider = self.provider.clone();
-
-        let (deferred, promise) = env.create_deferred()?;
         self.runtime.spawn_blocking(move || {
             provider.set_call_override_callback(call_override_callback);
 
@@ -95,7 +101,7 @@ impl Provider {
     /// `eth_estimateGas`, `eth_sendRawTransaction`, `eth_sendTransaction`,
     /// `evm_mine`, `hardhat_mine` include the full stack and memory. Set to
     /// `false` to disable this.
-    #[napi]
+    #[napi(catch_unwind)]
     pub async fn set_verbose_tracing(&self, verbose_tracing: bool) -> napi::Result<()> {
         let provider = self.provider.clone();
 

package/src/result.rs

@@ -1,7 +1,7 @@
 use edr_evm::trace::AfterMessage;
 use napi::{
-    Either, Env, JsBuffer, JsBufferValue,
-    bindgen_prelude::{BigInt, Buffer, Either3},
+    bindgen_prelude::{BigInt, Either3, Uint8Array},
+    Either,
 };
 use napi_derive::napi;
 
@@ -44,15 +44,15 @@ impl From<SuccessReason> for edr_eth::result::SuccessReason {
 #[napi(object)]
 pub struct CallOutput {
     /// Return value
-    pub return_value: JsBuffer,
+    pub return_value: Uint8Array,
 }
 
 #[napi(object)]
 pub struct CreateOutput {
     /// Return value
-    pub return_value: JsBuffer,
+    pub return_value: Uint8Array,
     /// Optionally, a 160-bit address
-    pub address: Option<Buffer>,
+    pub address: Option<Uint8Array>,
 }
 
 /// The result when the EVM terminates successfully.
@@ -76,7 +76,7 @@ pub struct RevertResult {
     /// The amount of gas used
     pub gas_used: BigInt,
     /// The transaction output
-    pub output: JsBuffer,
+    pub output: Uint8Array,
 }
 
 /// Indicates that the EVM has experienced an exceptional halt. This causes
@@ -191,15 +191,15 @@ pub struct ExecutionResult {
     /// The transaction result
     pub result: Either3<SuccessResult, RevertResult, HaltResult>,
     /// Optional contract address if the transaction created a new contract.
-    pub contract_address: Option<Buffer>,
+    pub contract_address: Option<Uint8Array>,
 }
 
-impl ExecutionResult {
-    pub fn new(env: &Env, message: &AfterMessage<edr_eth::l1::HaltReason>) -> napi::Result<Self> {
+impl From<&AfterMessage<edr_eth::l1::HaltReason>> for ExecutionResult {
+    fn from(value: &AfterMessage<edr_eth::l1::HaltReason>) -> Self {
         let AfterMessage {
             execution_result,
             contract_address,
-        } = message;
+        } = value;
 
         let result = match execution_result {
             edr_eth::result::ExecutionResult::Success {
@@ -209,10 +209,7 @@ impl ExecutionResult {
                 logs,
                 output,
             } => {
-                let logs = logs
-                    .iter()
-                    .map(|log| ExecutionLog::new(env, log))
-                    .collect::<napi::Result<_>>()?;
+                let logs = logs.iter().map(ExecutionLog::from).collect();
 
                 Either3::A(SuccessResult {
                     reason: SuccessReason::from(*reason),
@@ -221,29 +218,23 @@ impl ExecutionResult {
                     logs,
                     output: match output {
                         edr_eth::result::Output::Call(return_value) => {
-                            let return_value = env
-                                .create_buffer_with_data(return_value.to_vec())
-                                .map(JsBufferValue::into_raw)?;
+                            let return_value = Uint8Array::with_data_copied(return_value);
 
                             Either::A(CallOutput { return_value })
                         }
                         edr_eth::result::Output::Create(return_value, address) => {
-                            let return_value = env
-                                .create_buffer_with_data(return_value.to_vec())
-                                .map(JsBufferValue::into_raw)?;
+                            let return_value = Uint8Array::with_data_copied(return_value);
 
                             Either::B(CreateOutput {
                                 return_value,
-                                address: address.map(|address| Buffer::from(address.as_slice())),
+                                address: address.as_ref().map(Uint8Array::with_data_copied),
                             })
                         }
                     },
                 })
             }
             edr_eth::result::ExecutionResult::Revert { gas_used, output } => {
-                let output = env
-                    .create_buffer_with_data(output.to_vec())
-                    .map(JsBufferValue::into_raw)?;
+                let output = Uint8Array::with_data_copied(output);
 
                 Either3::B(RevertResult {
                     gas_used: BigInt::from(*gas_used),
@@ -256,11 +247,11 @@ impl ExecutionResult {
             }),
         };
 
-        let contract_address = contract_address.map(|address| Buffer::from(address.as_slice()));
+        let contract_address = contract_address.as_ref().map(Uint8Array::with_data_copied);
 
-        Ok(Self {
+        Self {
             result,
             contract_address,
-        })
+        }
     }
 }

package/src/scenarios.rs

@@ -2,7 +2,7 @@ use std::time::{SystemTime, UNIX_EPOCH};
 
 use edr_scenarios::ScenarioConfig;
 use napi::tokio::{fs::File, io::AsyncWriteExt, sync::Mutex};
-use rand::{Rng, distributions::Alphanumeric};
+use rand::{distributions::Alphanumeric, Rng};
 
 const SCENARIO_FILE_PREFIX: &str = "EDR_SCENARIO_PREFIX";
 
@@ -29,7 +29,7 @@ pub async fn scenario_file(
         let config = ScenarioConfig {
             chain_type: Some(chain_type),
             logger_enabled,
-            provider_config: provider_config.into(),
+            provider_config: provider_config.try_into()?,
         };
         let mut line = serde_json::to_string(&config)?;
         line.push('\n');

package/src/serde.rs

@@ -0,0 +1,57 @@
+use edr_eth::hex;
+use napi::bindgen_prelude::{BigInt, Uint8Array};
+use serde::Serializer;
+
+/// Serialize a `Uint8Array` as a 0x-prefixed hex string
+pub fn serialize_uint8array_as_hex<S>(buffer: &Uint8Array, serializer: S) -> Result<S::Ok, S::Error>
+where
+    S: Serializer,
+{
+    let hex_string = format!("0x{}", hex::encode(buffer));
+    serializer.serialize_str(&hex_string)
+}
+
+/// Serialize an Option<Uint8Array> as a 0x-prefixed hex string or None
+pub fn serialize_optional_uint8array_as_hex<S>(
+    buffer: &Option<Uint8Array>,
+    serializer: S,
+) -> Result<S::Ok, S::Error>
+where
+    S: Serializer,
+{
+    match buffer {
+        Some(buf) => {
+            let hex_string = format!("0x{}", hex::encode(buf));
+            serializer.serialize_str(&hex_string)
+        }
+        None => serializer.serialize_none(),
+    }
+}
+
+/// Serialize a `BigInt` as a struct with `sign_bit` and `words` fields
+pub fn serialize_bigint_as_struct<S>(value: &BigInt, serializer: S) -> Result<S::Ok, S::Error>
+where
+    S: Serializer,
+{
+    use serde::ser::SerializeStruct;
+
+    let mut state = serializer.serialize_struct("BigInt", 2)?;
+    state.serialize_field("sign_bit", &value.sign_bit)?;
+    state.serialize_field("words", &value.words)?;
+    state.end()
+}
+
+/// Serialize an Option<BigInt> as a struct with `sign_bit` and `words` fields
+/// or None
+pub fn serialize_optional_bigint_as_struct<S>(
+    value: &Option<BigInt>,
+    serializer: S,
+) -> Result<S::Ok, S::Error>
+where
+    S: Serializer,
+{
+    match value {
+        Some(val) => serialize_bigint_as_struct(val, serializer),
+        None => serializer.serialize_none(),
+    }
+}

package/src/solidity_tests/artifact.rs

@@ -0,0 +1,184 @@
+use std::{
+    borrow::Cow,
+    collections::{BTreeMap, HashMap},
+};
+
+use napi_derive::napi;
+
+/// A compilation artifact.
+#[derive(Clone, Debug)]
+#[napi(object)]
+pub struct Artifact {
+    /// The identifier of the artifact.
+    pub id: ArtifactId,
+    /// The test contract.
+    pub contract: ContractData,
+}
+
+/// The identifier of a Solidity contract.
+#[derive(Clone, Debug)]
+#[napi(object)]
+pub struct ArtifactId {
+    /// The name of the contract.
+    pub name: String,
+    /// Original source file path.
+    pub source: String,
+    /// The solc semver string.
+    pub solc_version: String,
+}
+
+impl From<edr_solidity::artifacts::ArtifactId> for ArtifactId {
+    fn from(value: edr_solidity::artifacts::ArtifactId) -> Self {
+        Self {
+            name: value.name,
+            source: value.source.to_string_lossy().to_string(),
+            solc_version: value.version.to_string(),
+        }
+    }
+}
+
+impl TryFrom<ArtifactId> for edr_solidity::artifacts::ArtifactId {
+    type Error = napi::Error;
+
+    fn try_from(value: ArtifactId) -> napi::Result<Self> {
+        Ok(edr_solidity::artifacts::ArtifactId {
+            name: value.name,
+            source: value.source.parse().map_err(|_err| {
+                napi::Error::new(napi::Status::GenericFailure, "Invalid source path")
+            })?,
+            version: value.solc_version.parse().map_err(|_err| {
+                napi::Error::new(napi::Status::GenericFailure, "Invalid solc semver string")
+            })?,
+        })
+    }
+}
+
+/// A test contract to execute.
+#[derive(Clone, Debug)]
+#[napi(object)]
+pub struct ContractData {
+    /// Contract ABI as json string.
+    pub abi: String,
+    /// Contract creation code as hex string. It can be missing if the contract
+    /// is ABI only.
+    pub bytecode: Option<String>,
+    /// The link references of the deployment bytecode.
+    pub link_references: Option<HashMap<String, HashMap<String, Vec<LinkReference>>>>,
+    /// Contract runtime code as hex string. It can be missing if the contract
+    /// is ABI only.
+    pub deployed_bytecode: Option<String>,
+    /// The link references of the deployed bytecode.
+    pub deployed_link_references: Option<HashMap<String, HashMap<String, Vec<LinkReference>>>>,
+}
+
+impl TryFrom<ContractData> for foundry_compilers::artifacts::CompactContractBytecode {
+    type Error = napi::Error;
+
+    fn try_from(contract: ContractData) -> napi::Result<Self> {
+        Ok(foundry_compilers::artifacts::CompactContractBytecode {
+            abi: Some(serde_json::from_str(&contract.abi).map_err(|_err| {
+                napi::Error::new(napi::Status::GenericFailure, "Invalid JSON ABI")
+            })?),
+            bytecode: contract
+                .bytecode
+                .map(|bytecode| {
+                    let link_references =
+                        convert_link_references(contract.link_references.unwrap_or_default());
+                    let object = convert_bytecode(bytecode, !link_references.is_empty())?;
+                    Ok::<_, napi::Error>(foundry_compilers::artifacts::CompactBytecode {
+                        object,
+                        source_map: None,
+                        link_references,
+                    })
+                })
+                .transpose()?,
+            deployed_bytecode: contract
+                .deployed_bytecode
+                .map(|deployed_bytecode| {
+                    let link_references = convert_link_references(
+                        contract.deployed_link_references.unwrap_or_default(),
+                    );
+                    let object = convert_bytecode(deployed_bytecode, !link_references.is_empty())?;
+                    let compact_bytecode = foundry_compilers::artifacts::CompactBytecode {
+                        object,
+                        source_map: None,
+                        link_references,
+                    };
+                    Ok::<_, napi::Error>(foundry_compilers::artifacts::CompactDeployedBytecode {
+                        bytecode: Some(compact_bytecode),
+                        immutable_references: BTreeMap::default(),
+                    })
+                })
+                .transpose()?,
+        })
+    }
+}
+
+impl TryFrom<ContractData> for foundry_compilers::artifacts::CompactContractBytecodeCow<'static> {
+    type Error = napi::Error;
+
+    fn try_from(contract: ContractData) -> napi::Result<Self> {
+        let c: foundry_compilers::artifacts::CompactContractBytecode = contract.try_into()?;
+        Ok(foundry_compilers::artifacts::CompactContractBytecodeCow {
+            abi: c.abi.map(Cow::Owned),
+            bytecode: c.bytecode.map(Cow::Owned),
+            deployed_bytecode: c.deployed_bytecode.map(Cow::Owned),
+        })
+    }
+}
+
+// The order of link references as supplied through the NAPI interface doesn't
+// matter, but the order can matter downstream for deterministic address
+// generation.
+fn convert_link_references(
+    link_references: HashMap<String, HashMap<String, Vec<LinkReference>>>,
+) -> BTreeMap<String, BTreeMap<String, Vec<foundry_compilers::artifacts::Offsets>>> {
+    link_references
+        .into_iter()
+        .map(|(file, libraries)| {
+            let lib_map = libraries
+                .into_iter()
+                .map(|(library_name, references)| {
+                    let offsets = references.into_iter().map(Into::into).collect();
+                    (library_name, offsets)
+                })
+                .collect();
+            (file, lib_map)
+        })
+        .collect()
+}
+
+fn convert_bytecode(
+    bytecode: String,
+    needs_linking: bool,
+) -> napi::Result<foundry_compilers::artifacts::BytecodeObject> {
+    if needs_linking {
+        Ok(foundry_compilers::artifacts::BytecodeObject::Unlinked(
+            bytecode,
+        ))
+    } else {
+        let bytes = bytecode.parse().map_err(|err| {
+            let message = format!("Hex decoding error while parsing bytecode: '{err}'. Maybe forgot to pass link references for a contract that needs linking?");
+            napi::Error::from_reason(message)
+        })?;
+        Ok(foundry_compilers::artifacts::BytecodeObject::Bytecode(
+            bytes,
+        ))
+    }
+}
+
+#[derive(Clone, Debug)]
+#[napi(object)]
+pub struct LinkReference {
+    pub start: u32,
+    pub length: u32,
+}
+
+impl From<LinkReference> for foundry_compilers::artifacts::Offsets {
+    fn from(value: LinkReference) -> Self {
+        Self {
+            start: value.start,
+            length: value.length,
+        }
+    }
+}