@nomicfoundation/edr 0.11.3 → 0.12.0-next.0

package/src/result.rs

@@ -1,7 +1,7 @@
 use edr_evm::trace::AfterMessage;
 use napi::{
-    bindgen_prelude::{BigInt, Buffer, Either3},
-    Either, Env, JsBuffer, JsBufferValue,
+    bindgen_prelude::{BigInt, Either3, Uint8Array},
+    Either,
 };
 use napi_derive::napi;
 
@@ -19,18 +19,18 @@ pub enum SuccessReason {
     EofReturnContract,
 }
 
-impl From<edr_evm::SuccessReason> for SuccessReason {
-    fn from(eval: edr_evm::SuccessReason) -> Self {
+impl From<edr_eth::result::SuccessReason> for SuccessReason {
+    fn from(eval: edr_eth::result::SuccessReason) -> Self {
         match eval {
-            edr_evm::SuccessReason::Stop => Self::Stop,
-            edr_evm::SuccessReason::Return => Self::Return,
-            edr_evm::SuccessReason::SelfDestruct => Self::SelfDestruct,
-            edr_evm::SuccessReason::EofReturnContract => Self::EofReturnContract,
+            edr_eth::result::SuccessReason::Stop => Self::Stop,
+            edr_eth::result::SuccessReason::Return => Self::Return,
+            edr_eth::result::SuccessReason::SelfDestruct => Self::SelfDestruct,
+            edr_eth::result::SuccessReason::EofReturnContract => Self::EofReturnContract,
         }
     }
 }
 
-impl From<SuccessReason> for edr_evm::SuccessReason {
+impl From<SuccessReason> for edr_eth::result::SuccessReason {
     fn from(value: SuccessReason) -> Self {
         match value {
             SuccessReason::Stop => Self::Stop,
@@ -44,15 +44,15 @@ impl From<SuccessReason> for edr_evm::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
@@ -105,55 +105,55 @@ pub enum ExceptionalHalt {
     /// Aud data is smaller then already present data size.
     EofAuxDataTooSmall,
     /// EOF Subroutine stack overflow
-    EOFFunctionStackOverflow,
+    SubRoutineStackOverflow,
     /// Check for target address validity is only done inside subcall.
     InvalidEXTCALLTarget,
 }
 
-impl From<edr_evm::HaltReason> for ExceptionalHalt {
-    fn from(halt: edr_evm::HaltReason) -> Self {
+impl From<edr_eth::l1::HaltReason> for ExceptionalHalt {
+    fn from(halt: edr_eth::l1::HaltReason) -> Self {
         match halt {
-            edr_evm::HaltReason::OutOfGas(..) => ExceptionalHalt::OutOfGas,
-            edr_evm::HaltReason::OpcodeNotFound => ExceptionalHalt::OpcodeNotFound,
-            edr_evm::HaltReason::InvalidFEOpcode => ExceptionalHalt::InvalidFEOpcode,
-            edr_evm::HaltReason::InvalidJump => ExceptionalHalt::InvalidJump,
-            edr_evm::HaltReason::NotActivated => ExceptionalHalt::NotActivated,
-            edr_evm::HaltReason::StackUnderflow => ExceptionalHalt::StackUnderflow,
-            edr_evm::HaltReason::StackOverflow => ExceptionalHalt::StackOverflow,
-            edr_evm::HaltReason::OutOfOffset => ExceptionalHalt::OutOfOffset,
-            edr_evm::HaltReason::CreateCollision => ExceptionalHalt::CreateCollision,
-            edr_evm::HaltReason::PrecompileError => ExceptionalHalt::PrecompileError,
-            edr_evm::HaltReason::NonceOverflow => ExceptionalHalt::NonceOverflow,
-            edr_evm::HaltReason::CreateContractSizeLimit => {
+            edr_eth::l1::HaltReason::OutOfGas(..) => ExceptionalHalt::OutOfGas,
+            edr_eth::l1::HaltReason::OpcodeNotFound => ExceptionalHalt::OpcodeNotFound,
+            edr_eth::l1::HaltReason::InvalidFEOpcode => ExceptionalHalt::InvalidFEOpcode,
+            edr_eth::l1::HaltReason::InvalidJump => ExceptionalHalt::InvalidJump,
+            edr_eth::l1::HaltReason::NotActivated => ExceptionalHalt::NotActivated,
+            edr_eth::l1::HaltReason::StackUnderflow => ExceptionalHalt::StackUnderflow,
+            edr_eth::l1::HaltReason::StackOverflow => ExceptionalHalt::StackOverflow,
+            edr_eth::l1::HaltReason::OutOfOffset => ExceptionalHalt::OutOfOffset,
+            edr_eth::l1::HaltReason::CreateCollision => ExceptionalHalt::CreateCollision,
+            edr_eth::l1::HaltReason::PrecompileError => ExceptionalHalt::PrecompileError,
+            edr_eth::l1::HaltReason::NonceOverflow => ExceptionalHalt::NonceOverflow,
+            edr_eth::l1::HaltReason::CreateContractSizeLimit => {
                 ExceptionalHalt::CreateContractSizeLimit
             }
-            edr_evm::HaltReason::CreateContractStartingWithEF => {
+            edr_eth::l1::HaltReason::CreateContractStartingWithEF => {
                 ExceptionalHalt::CreateContractStartingWithEF
             }
-            edr_evm::HaltReason::CreateInitCodeSizeLimit => {
+            edr_eth::l1::HaltReason::CreateInitCodeSizeLimit => {
                 ExceptionalHalt::CreateInitCodeSizeLimit
             }
-            edr_evm::HaltReason::EofAuxDataOverflow => ExceptionalHalt::EofAuxDataOverflow,
-            edr_evm::HaltReason::EofAuxDataTooSmall => ExceptionalHalt::EofAuxDataTooSmall,
-            edr_evm::HaltReason::EOFFunctionStackOverflow => {
-                ExceptionalHalt::EOFFunctionStackOverflow
+            edr_eth::l1::HaltReason::EofAuxDataOverflow => ExceptionalHalt::EofAuxDataOverflow,
+            edr_eth::l1::HaltReason::EofAuxDataTooSmall => ExceptionalHalt::EofAuxDataTooSmall,
+            edr_eth::l1::HaltReason::SubRoutineStackOverflow => {
+                ExceptionalHalt::SubRoutineStackOverflow
             }
-            edr_evm::HaltReason::InvalidEXTCALLTarget => ExceptionalHalt::InvalidEXTCALLTarget,
-            edr_evm::HaltReason::OverflowPayment
-            | edr_evm::HaltReason::StateChangeDuringStaticCall
-            | edr_evm::HaltReason::CallNotAllowedInsideStatic
-            | edr_evm::HaltReason::OutOfFunds
-            | edr_evm::HaltReason::CallTooDeep => {
+            edr_eth::l1::HaltReason::InvalidEXTCALLTarget => ExceptionalHalt::InvalidEXTCALLTarget,
+            edr_eth::l1::HaltReason::OverflowPayment
+            | edr_eth::l1::HaltReason::StateChangeDuringStaticCall
+            | edr_eth::l1::HaltReason::CallNotAllowedInsideStatic
+            | edr_eth::l1::HaltReason::OutOfFunds
+            | edr_eth::l1::HaltReason::CallTooDeep => {
                 unreachable!("Internal halts that can be only found inside Inspector: {halt:?}")
             }
         }
     }
 }
 
-impl From<ExceptionalHalt> for edr_evm::HaltReason {
+impl From<ExceptionalHalt> for edr_eth::l1::HaltReason {
     fn from(value: ExceptionalHalt) -> Self {
         match value {
-            ExceptionalHalt::OutOfGas => Self::OutOfGas(edr_evm::OutOfGasError::Basic),
+            ExceptionalHalt::OutOfGas => Self::OutOfGas(edr_eth::l1::OutOfGasError::Basic),
             ExceptionalHalt::OpcodeNotFound => Self::OpcodeNotFound,
             ExceptionalHalt::InvalidFEOpcode => Self::InvalidFEOpcode,
             ExceptionalHalt::InvalidJump => Self::InvalidJump,
@@ -169,7 +169,7 @@ impl From<ExceptionalHalt> for edr_evm::HaltReason {
             ExceptionalHalt::CreateInitCodeSizeLimit => Self::CreateInitCodeSizeLimit,
             ExceptionalHalt::EofAuxDataOverflow => Self::EofAuxDataOverflow,
             ExceptionalHalt::EofAuxDataTooSmall => Self::EofAuxDataTooSmall,
-            ExceptionalHalt::EOFFunctionStackOverflow => Self::EOFFunctionStackOverflow,
+            ExceptionalHalt::SubRoutineStackOverflow => Self::SubRoutineStackOverflow,
             ExceptionalHalt::InvalidEXTCALLTarget => Self::InvalidEXTCALLTarget,
         }
     }
@@ -191,28 +191,25 @@ 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) -> 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_evm::ExecutionResult::Success {
+            edr_eth::result::ExecutionResult::Success {
                 reason,
                 gas_used,
                 gas_refunded,
                 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),
@@ -220,47 +217,41 @@ impl ExecutionResult {
                     gas_refunded: BigInt::from(*gas_refunded),
                     logs,
                     output: match output {
-                        edr_evm::Output::Call(return_value) => {
-                            let return_value = env
-                                .create_buffer_with_data(return_value.to_vec())
-                                .map(JsBufferValue::into_raw)?;
+                        edr_eth::result::Output::Call(return_value) => {
+                            let return_value = Uint8Array::with_data_copied(return_value);
 
                             Either::A(CallOutput { return_value })
                         }
-                        edr_evm::Output::Create(return_value, address) => {
-                            let return_value = env
-                                .create_buffer_with_data(return_value.to_vec())
-                                .map(JsBufferValue::into_raw)?;
+                        edr_eth::result::Output::Create(return_value, address) => {
+                            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_evm::ExecutionResult::Revert { gas_used, output } => {
-                let output = env
-                    .create_buffer_with_data(output.to_vec())
-                    .map(JsBufferValue::into_raw)?;
+            edr_eth::result::ExecutionResult::Revert { gas_used, output } => {
+                let output = Uint8Array::with_data_copied(output);
 
                 Either3::B(RevertResult {
                     gas_used: BigInt::from(*gas_used),
                     output,
                 })
             }
-            edr_evm::ExecutionResult::Halt { reason, gas_used } => Either3::C(HaltResult {
+            edr_eth::result::ExecutionResult::Halt { reason, gas_used } => Either3::C(HaltResult {
                 reason: ExceptionalHalt::from(*reason),
                 gas_used: BigInt::from(*gas_used),
             }),
         };
 
-        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

@@ -1,22 +1,17 @@
 use std::time::{SystemTime, UNIX_EPOCH};
 
-use edr_provider::ProviderRequest;
+use edr_scenarios::ScenarioConfig;
 use napi::tokio::{fs::File, io::AsyncWriteExt, sync::Mutex};
 use rand::{distributions::Alphanumeric, Rng};
-use serde::Serialize;
 
 const SCENARIO_FILE_PREFIX: &str = "EDR_SCENARIO_PREFIX";
 
-#[derive(Clone, Debug, Serialize)]
-struct ScenarioConfig {
-    provider_config: edr_scenarios::ScenarioProviderConfig,
+/// Creates a scenario file with the provided configuration.
+pub async fn scenario_file(
+    chain_type: String,
+    provider_config: edr_napi_core::provider::Config,
     logger_enabled: bool,
-}
-
-pub(crate) async fn scenario_file(
-    provider_config: &edr_provider::ProviderConfig,
-    logger_enabled: bool,
-) -> Result<Option<Mutex<File>>, napi::Error> {
+) -> napi::Result<Option<Mutex<File>>> {
     if let Ok(scenario_prefix) = std::env::var(SCENARIO_FILE_PREFIX) {
         let timestamp = SystemTime::now()
             .duration_since(UNIX_EPOCH)
@@ -32,8 +27,9 @@ pub(crate) async fn scenario_file(
             File::create(format!("{scenario_prefix}_{timestamp}_{suffix}.json")).await?;
 
         let config = ScenarioConfig {
-            provider_config: provider_config.clone().into(),
+            chain_type: Some(chain_type),
             logger_enabled,
+            provider_config: provider_config.try_into()?,
         };
         let mut line = serde_json::to_string(&config)?;
         line.push('\n');
@@ -45,11 +41,9 @@ pub(crate) async fn scenario_file(
     }
 }
 
-pub(crate) async fn write_request(
-    scenario_file: &Mutex<File>,
-    request: &ProviderRequest,
-) -> napi::Result<()> {
-    let mut line = serde_json::to_string(request)?;
+/// Writes a JSON-RPC request to the scenario file.
+pub async fn write_request(scenario_file: &Mutex<File>, request: &str) -> napi::Result<()> {
+    let mut line = request.to_string();
     line.push('\n');
     {
         let mut scenario_file = scenario_file.lock().await;

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,
+        }
+    }
+}