@nomicfoundation/edr 0.12.0-next.8 → 0.12.0

package/src/solidity_tests.rs

@@ -1,56 +0,0 @@
-pub mod artifact;
-pub mod config;
-pub mod factory;
-pub mod l1;
-#[cfg(feature = "op")]
-pub mod op;
-pub mod runner;
-pub mod test_results;
-
-use std::path::Path;
-
-use edr_primitives::Bytes;
-use edr_solidity::linker::{LinkOutput, Linker};
-use edr_solidity_tests::{constants::LIBRARY_DEPLOYER, contracts::ContractsByArtifact};
-use foundry_compilers::artifacts::Libraries;
-
-use crate::solidity_tests::artifact::Artifact;
-
-pub(crate) struct LinkingOutput {
-    pub libs_to_deploy: Vec<Bytes>,
-    pub known_contracts: ContractsByArtifact,
-}
-
-impl LinkingOutput {
-    pub fn link(project_root: &Path, artifacts: Vec<Artifact>) -> napi::Result<Self> {
-        let artifact_contracts = artifacts
-            .into_iter()
-            .map(|artifact| Ok((artifact.id.try_into()?, artifact.contract.try_into()?)))
-            .collect::<napi::Result<Vec<_>>>()?;
-
-        let linker = Linker::new(project_root, artifact_contracts);
-
-        let LinkOutput {
-            libraries,
-            libs_to_deploy,
-        } = linker
-            .link_with_nonce_or_address(
-                Libraries::default(),
-                LIBRARY_DEPLOYER,
-                0,
-                linker.contracts.keys(),
-            )
-            .map_err(|error| napi::Error::from_reason(error.to_string()))?;
-
-        let linked_contracts = linker
-            .get_linked_artifacts(&libraries)
-            .map_err(|error| napi::Error::from_reason(error.to_string()))?;
-
-        let known_contracts = ContractsByArtifact::new(linked_contracts);
-
-        Ok(LinkingOutput {
-            libs_to_deploy,
-            known_contracts,
-        })
-    }
-}

package/src/subscription.rs

@@ -1,32 +0,0 @@
-use napi::{bindgen_prelude::BigInt, JsFunction};
-use napi_derive::napi;
-
-/// Configuration for subscriptions.
-#[napi(object)]
-pub struct SubscriptionConfig {
-    /// Callback to be called when a new event is received.
-    #[napi(ts_type = "(event: SubscriptionEvent) => void")]
-    pub subscription_callback: JsFunction,
-}
-
-impl From<edr_napi_core::subscription::Config> for SubscriptionConfig {
-    fn from(config: edr_napi_core::subscription::Config) -> Self {
-        Self {
-            subscription_callback: config.subscription_callback,
-        }
-    }
-}
-
-impl From<SubscriptionConfig> for edr_napi_core::subscription::Config {
-    fn from(config: SubscriptionConfig) -> Self {
-        Self {
-            subscription_callback: config.subscription_callback,
-        }
-    }
-}
-
-#[napi(object)]
-pub struct SubscriptionEvent {
-    pub filter_id: BigInt,
-    pub result: serde_json::Value,
-}

package/src/trace/debug.rs

@@ -1,61 +0,0 @@
-//! Port of `hardhat-network/stack-traces/debug.ts` from Hardhat.
-
-use napi::bindgen_prelude::Either25;
-use napi_derive::napi;
-
-use super::solidity_stack_trace::{RevertErrorStackTraceEntry, SolidityStackTrace};
-use crate::trace::return_data::ReturnData;
-
-#[napi(catch_unwind)]
-fn print_stack_trace(trace: SolidityStackTrace) -> napi::Result<()> {
-    let entry_values = trace
-        .into_iter()
-        .map(|entry| match entry {
-            Either25::A(entry) => serde_json::to_value(entry),
-            Either25::B(entry) => serde_json::to_value(entry),
-            Either25::C(entry) => serde_json::to_value(entry),
-            Either25::D(entry) => serde_json::to_value(entry),
-            Either25::F(entry) => serde_json::to_value(entry),
-            Either25::G(entry) => serde_json::to_value(entry),
-            Either25::H(entry) => serde_json::to_value(entry),
-            Either25::I(entry) => serde_json::to_value(entry),
-            Either25::J(entry) => serde_json::to_value(entry),
-            Either25::K(entry) => serde_json::to_value(entry),
-            Either25::L(entry) => serde_json::to_value(entry),
-            Either25::M(entry) => serde_json::to_value(entry),
-            Either25::N(entry) => serde_json::to_value(entry),
-            Either25::O(entry) => serde_json::to_value(entry),
-            Either25::P(entry) => serde_json::to_value(entry),
-            Either25::Q(entry) => serde_json::to_value(entry),
-            Either25::R(entry) => serde_json::to_value(entry),
-            Either25::S(entry) => serde_json::to_value(entry),
-            Either25::T(entry) => serde_json::to_value(entry),
-            Either25::U(entry) => serde_json::to_value(entry),
-            Either25::V(entry) => serde_json::to_value(entry),
-            Either25::W(entry) => serde_json::to_value(entry),
-            Either25::X(entry) => serde_json::to_value(entry),
-            Either25::Y(entry) => serde_json::to_value(entry),
-            // Decode the error message from the return data
-            Either25::E(entry @ RevertErrorStackTraceEntry { .. }) => {
-                use serde::de::Error;
-
-                let decoded_error_msg = ReturnData::new(entry.return_data.clone())
-                    .decode_error()
-                    .map_err(|e| {
-                    serde_json::Error::custom(format_args!("Error decoding return data: {e}"))
-                })?;
-
-                let mut value = serde_json::to_value(entry)?;
-                if let Some(obj) = value.as_object_mut() {
-                    obj.insert("message".to_string(), decoded_error_msg.into());
-                }
-                Ok(value)
-            }
-        })
-        .collect::<Result<Vec<_>, _>>()
-        .map_err(|e| napi::Error::from_reason(format!("Error converting to JSON: {e}")))?;
-
-    println!("{}", serde_json::to_string_pretty(&entry_values)?);
-
-    Ok(())
-}

package/src/trace/exit.rs

@@ -1,89 +0,0 @@
-//! Naive rewrite of `hardhat-network/provider/vm/exit.ts` from Hardhat.
-//! Used together with `VmTracer`.
-
-use std::fmt;
-
-use edr_evm_spec::EvmHaltReason;
-use napi_derive::napi;
-
-#[napi]
-pub struct Exit(pub(crate) ExitCode);
-
-#[napi]
-/// Represents the exit code of the EVM.
-#[derive(Debug, PartialEq, Eq)]
-#[allow(clippy::upper_case_acronyms, non_camel_case_types)] // These are exported and mapped 1:1 to existing JS enum
-pub enum ExitCode {
-    /// Execution was successful.
-    SUCCESS = 0,
-    /// Execution was reverted.
-    REVERT,
-    /// Execution ran out of gas.
-    OUT_OF_GAS,
-    /// Execution encountered an internal error.
-    INTERNAL_ERROR,
-    /// Execution encountered an invalid opcode.
-    INVALID_OPCODE,
-    /// Execution encountered a stack underflow.
-    STACK_UNDERFLOW,
-    /// Create init code size exceeds limit (runtime).
-    CODESIZE_EXCEEDS_MAXIMUM,
-    /// Create collision.
-    CREATE_COLLISION,
-    /// Unknown halt reason.
-    UNKNOWN_HALT_REASON,
-}
-
-impl fmt::Display for ExitCode {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        match self {
-            ExitCode::SUCCESS => write!(f, "Success"),
-            ExitCode::REVERT => write!(f, "Reverted"),
-            ExitCode::OUT_OF_GAS => write!(f, "Out of gas"),
-            ExitCode::INTERNAL_ERROR => write!(f, "Internal error"),
-            ExitCode::INVALID_OPCODE => write!(f, "Invalid opcode"),
-            ExitCode::STACK_UNDERFLOW => write!(f, "Stack underflow"),
-            ExitCode::CODESIZE_EXCEEDS_MAXIMUM => write!(f, "Codesize exceeds maximum"),
-            ExitCode::CREATE_COLLISION => write!(f, "Create collision"),
-            ExitCode::UNKNOWN_HALT_REASON => write!(f, "Unknown halt reason"),
-        }
-    }
-}
-
-#[allow(clippy::fallible_impl_from)] // naively ported for now
-impl From<edr_solidity::exit_code::ExitCode<EvmHaltReason>> for ExitCode {
-    fn from(code: edr_solidity::exit_code::ExitCode<EvmHaltReason>) -> Self {
-        use edr_solidity::exit_code::ExitCode;
-
-        match code {
-            ExitCode::Success => Self::SUCCESS,
-            ExitCode::Revert => Self::REVERT,
-            ExitCode::Halt(EvmHaltReason::OutOfGas(_)) => Self::OUT_OF_GAS,
-            ExitCode::Halt(EvmHaltReason::OpcodeNotFound | EvmHaltReason::InvalidFEOpcode
-              // Returned when an opcode is not implemented for the hardfork
-              | EvmHaltReason::NotActivated) => Self::INVALID_OPCODE,
-            ExitCode::Halt(EvmHaltReason::StackUnderflow) => Self::STACK_UNDERFLOW,
-            ExitCode::Halt(EvmHaltReason::CreateContractSizeLimit) => Self::CODESIZE_EXCEEDS_MAXIMUM,
-            ExitCode::Halt(EvmHaltReason::CreateCollision) => Self::CREATE_COLLISION,
-            _ => Self::UNKNOWN_HALT_REASON,
-        }
-    }
-}
-
-#[napi]
-impl Exit {
-    #[napi(catch_unwind, getter)]
-    pub fn kind(&self) -> ExitCode {
-        self.0
-    }
-
-    #[napi(catch_unwind)]
-    pub fn is_error(&self) -> bool {
-        !matches!(self.0, ExitCode::SUCCESS)
-    }
-
-    #[napi(catch_unwind)]
-    pub fn get_reason(&self) -> String {
-        self.0.to_string()
-    }
-}

package/src/trace/library_utils.rs

@@ -1,11 +0,0 @@
-use napi_derive::napi;
-
-#[napi(catch_unwind)]
-pub fn link_hex_string_bytecode(
-    code: String,
-    address: String,
-    position: u32,
-) -> napi::Result<String> {
-    edr_solidity::library_utils::link_hex_string_bytecode(code, &address, position)
-        .map_err(|err| napi::Error::from_reason(err.to_string()))
-}

package/src/trace/model.rs

@@ -1,59 +0,0 @@
-use std::rc::Rc;
-
-use edr_solidity::build_model::ContractMetadata;
-use napi_derive::napi;
-use serde::Serialize;
-
-/// Opaque handle to the `Bytecode` struct.
-/// Only used on the JS side by the `VmTraceDecoder` class.
-// NOTE: Needed, because we store the resolved `Bytecode` in the MessageTrace
-// JS plain objects and those need a dedicated (class) type.
-#[napi]
-pub struct BytecodeWrapper(pub(crate) Rc<ContractMetadata>);
-
-impl BytecodeWrapper {
-    pub fn new(bytecode: Rc<ContractMetadata>) -> Self {
-        Self(bytecode)
-    }
-
-    pub fn inner(&self) -> &Rc<ContractMetadata> {
-        &self.0
-    }
-}
-
-impl std::ops::Deref for BytecodeWrapper {
-    type Target = ContractMetadata;
-
-    fn deref(&self) -> &Self::Target {
-        &self.0
-    }
-}
-
-#[derive(Debug, PartialEq, Eq, Serialize)]
-#[allow(non_camel_case_types)] // intentionally mimicks the original case in TS
-#[allow(clippy::upper_case_acronyms)]
-#[napi]
-// Mimicks [`edr_solidity::build_model::ContractFunctionType`].
-pub enum ContractFunctionType {
-    CONSTRUCTOR,
-    FUNCTION,
-    FALLBACK,
-    RECEIVE,
-    GETTER,
-    MODIFIER,
-    FREE_FUNCTION,
-}
-
-impl From<edr_solidity::build_model::ContractFunctionType> for ContractFunctionType {
-    fn from(value: edr_solidity::build_model::ContractFunctionType) -> Self {
-        match value {
-            edr_solidity::build_model::ContractFunctionType::Constructor => Self::CONSTRUCTOR,
-            edr_solidity::build_model::ContractFunctionType::Function => Self::FUNCTION,
-            edr_solidity::build_model::ContractFunctionType::Fallback => Self::FALLBACK,
-            edr_solidity::build_model::ContractFunctionType::Receive => Self::RECEIVE,
-            edr_solidity::build_model::ContractFunctionType::Getter => Self::GETTER,
-            edr_solidity::build_model::ContractFunctionType::Modifier => Self::MODIFIER,
-            edr_solidity::build_model::ContractFunctionType::FreeFunction => Self::FREE_FUNCTION,
-        }
-    }
-}

package/src/trace/return_data.rs

@@ -1,96 +0,0 @@
-//! Rewrite of `hardhat-network/provider/return-data.ts` from Hardhat.
-
-use alloy_sol_types::SolError;
-use napi::bindgen_prelude::{BigInt, Uint8Array};
-use napi_derive::napi;
-
-// Built-in error types
-// See <https://docs.soliditylang.org/en/v0.8.26/control-structures.html#error-handling-assert-require-revert-and-exceptions>
-alloy_sol_types::sol! {
-  error Error(string);
-  error Panic(uint256);
-}
-
-#[napi]
-pub struct ReturnData {
-    #[napi(readonly)]
-    pub value: Uint8Array,
-    selector: Option<[u8; 4]>,
-}
-
-#[napi]
-impl ReturnData {
-    #[napi(catch_unwind, constructor)]
-    pub fn new(value: Uint8Array) -> Self {
-        let selector = value
-            .get(0..4)
-            .map(|selector| selector.try_into().expect("selector is 4 bytes"));
-
-        Self { value, selector }
-    }
-
-    #[napi(catch_unwind)]
-    pub fn is_empty(&self) -> bool {
-        self.value.is_empty()
-    }
-
-    pub fn matches_selector(&self, selector: impl AsRef<[u8]>) -> bool {
-        self.selector
-            .is_some_and(|value| value == selector.as_ref())
-    }
-
-    #[napi(catch_unwind)]
-    pub fn is_error_return_data(&self) -> bool {
-        self.selector == Some(Error::SELECTOR)
-    }
-
-    #[napi(catch_unwind)]
-    pub fn is_panic_return_data(&self) -> bool {
-        self.selector == Some(Panic::SELECTOR)
-    }
-
-    #[napi(catch_unwind)]
-    pub fn decode_error(&self) -> napi::Result<String> {
-        if self.is_empty() {
-            return Ok(String::new());
-        }
-
-        if !self.is_error_return_data() {
-            return Err(napi::Error::new(
-                napi::Status::InvalidArg,
-                "VM Exception while processing transaction: Expected return data to be a Error(string)",
-            ));
-        }
-
-        let result = Error::abi_decode(&self.value[..]).map_err(|_err| {
-            napi::Error::new(
-                napi::Status::InvalidArg,
-                "VM Exception while processing transaction: Expected return data to contain a valid string",
-            )
-        })?;
-
-        Ok(result.0)
-    }
-
-    #[napi(catch_unwind)]
-    pub fn decode_panic(&self) -> napi::Result<BigInt> {
-        if !self.is_panic_return_data() {
-            return Err(napi::Error::new(
-                napi::Status::InvalidArg,
-                "VM Exception while processing transaction: Expected return data to be a Panic(uint256)",
-            ));
-        }
-
-        let result = Panic::abi_decode(&self.value[..]).map_err(|_err| {
-            napi::Error::new(
-                napi::Status::InvalidArg,
-                "VM Exception while processing transaction: Expected return data to contain a valid uint256",
-            )
-        })?;
-
-        Ok(BigInt {
-            sign_bit: false,
-            words: result.0.as_limbs().to_vec(),
-        })
-    }
-}