@nomicfoundation/edr 0.12.0-next.8 → 0.12.0

package/src/provider.rs

@@ -1,162 +0,0 @@
-/// Types related to provider factories.
-pub mod factory;
-mod response;
-
-use std::sync::Arc;
-
-use edr_napi_core::provider::SyncProvider;
-use edr_solidity::compiler::create_models_and_decode_bytecodes;
-use napi::{tokio::runtime, Env, JsFunction, JsObject, Status};
-use napi_derive::napi;
-
-pub use self::factory::ProviderFactory;
-use self::response::Response;
-use crate::{call_override::CallOverrideCallback, contract_decoder::ContractDecoder};
-
-/// A JSON-RPC provider for Ethereum.
-#[napi]
-pub struct Provider {
-    contract_decoder: Arc<edr_solidity::contract_decoder::ContractDecoder>,
-    provider: Arc<dyn SyncProvider>,
-    runtime: runtime::Handle,
-    #[cfg(feature = "scenarios")]
-    scenario_file: Option<napi::tokio::sync::Mutex<napi::tokio::fs::File>>,
-}
-
-impl Provider {
-    /// Constructs a new instance.
-    pub fn new(
-        provider: Arc<dyn SyncProvider>,
-        runtime: runtime::Handle,
-        contract_decoder: Arc<edr_solidity::contract_decoder::ContractDecoder>,
-        #[cfg(feature = "scenarios")] scenario_file: Option<
-            napi::tokio::sync::Mutex<napi::tokio::fs::File>,
-        >,
-    ) -> Self {
-        Self {
-            contract_decoder,
-            provider,
-            runtime,
-            #[cfg(feature = "scenarios")]
-            scenario_file,
-        }
-    }
-}
-
-#[napi]
-impl Provider {
-    #[doc = "Adds a compilation result to the instance."]
-    #[doc = ""]
-    #[doc = "For internal use only. Support for this method may be removed in the future."]
-    #[napi(catch_unwind)]
-    pub async fn add_compilation_result(
-        &self,
-        solc_version: String,
-        compiler_input: serde_json::Value,
-        compiler_output: serde_json::Value,
-    ) -> napi::Result<()> {
-        let contract_decoder = self.contract_decoder.clone();
-
-        self.runtime
-            .spawn_blocking(move || {
-                let compiler_input = serde_json::from_value(compiler_input)
-                    .map_err(|error| napi::Error::from_reason(error.to_string()))?;
-
-                let compiler_output = serde_json::from_value(compiler_output)
-                    .map_err(|error| napi::Error::from_reason(error.to_string()))?;
-
-                let contracts = match create_models_and_decode_bytecodes(
-                    solc_version,
-                    &compiler_input,
-                    &compiler_output,
-                ) {
-                    Ok(contracts) => contracts,
-                    Err(error) => {
-                        return Err(napi::Error::from_reason(format!("Contract decoder failed to be updated. Please report this to help us improve Hardhat.\n{error}")));
-                    }
-                };
-
-                for contract in contracts {
-                    contract_decoder.add_contract_metadata(contract);
-                }
-
-                Ok(())
-            })
-            .await
-            .map_err(|error| napi::Error::new(Status::GenericFailure, error.to_string()))?
-    }
-
-    #[doc = "Retrieves the instance's contract decoder."]
-    #[napi(catch_unwind)]
-    pub fn contract_decoder(&self) -> ContractDecoder {
-        ContractDecoder::from(Arc::clone(&self.contract_decoder))
-    }
-
-    #[doc = "Handles a JSON-RPC request and returns a JSON-RPC response."]
-    #[napi(catch_unwind)]
-    pub async fn handle_request(&self, request: String) -> napi::Result<Response> {
-        let provider = self.provider.clone();
-
-        #[cfg(feature = "scenarios")]
-        if let Some(scenario_file) = &self.scenario_file {
-            crate::scenarios::write_request(scenario_file, &request).await?;
-        }
-
-        let contract_decoder = Arc::clone(&self.contract_decoder);
-
-        self.runtime
-            .spawn_blocking(move || provider.handle_request(request, contract_decoder))
-            .await
-            .map_err(|error| napi::Error::new(Status::GenericFailure, error.to_string()))?
-            .map(Response::from)
-    }
-
-    #[napi(catch_unwind, ts_return_type = "Promise<void>")]
-    pub fn set_call_override_callback(
-        &self,
-        env: Env,
-        #[napi(
-            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 =
-            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();
-        self.runtime.spawn_blocking(move || {
-            provider.set_call_override_callback(call_override_callback);
-
-            deferred.resolve(|_env| Ok(()));
-        });
-
-        Ok(promise)
-    }
-
-    /// Set to `true` to make the traces returned with `eth_call`,
-    /// `eth_estimateGas`, `eth_sendRawTransaction`, `eth_sendTransaction`,
-    /// `evm_mine`, `hardhat_mine` include the full stack and memory. Set to
-    /// `false` to disable this.
-    #[napi(catch_unwind)]
-    pub async fn set_verbose_tracing(&self, verbose_tracing: bool) -> napi::Result<()> {
-        let provider = self.provider.clone();
-
-        self.runtime
-            .spawn_blocking(move || {
-                provider.set_verbose_tracing(verbose_tracing);
-            })
-            .await
-            .map_err(|error| napi::Error::new(Status::GenericFailure, error.to_string()))
-    }
-}

package/src/result.rs

@@ -1,212 +0,0 @@
-use edr_evm::trace::AfterMessage;
-use edr_evm_spec::EvmHaltReason;
-use napi::{
-    bindgen_prelude::{BigInt, Either3, Uint8Array},
-    Either,
-};
-use napi_derive::napi;
-
-use crate::log::ExecutionLog;
-
-/// The possible reasons for successful termination of the EVM.
-#[napi]
-pub enum SuccessReason {
-    /// The opcode `STOP` was called
-    Stop,
-    /// The opcode `RETURN` was called
-    Return,
-    /// The opcode `SELFDESTRUCT` was called
-    SelfDestruct,
-}
-
-impl From<edr_evm::result::SuccessReason> for SuccessReason {
-    fn from(eval: edr_evm::result::SuccessReason) -> Self {
-        match eval {
-            edr_evm::result::SuccessReason::Stop => Self::Stop,
-            edr_evm::result::SuccessReason::Return => Self::Return,
-            edr_evm::result::SuccessReason::SelfDestruct => Self::SelfDestruct,
-        }
-    }
-}
-
-impl From<SuccessReason> for edr_evm::result::SuccessReason {
-    fn from(value: SuccessReason) -> Self {
-        match value {
-            SuccessReason::Stop => Self::Stop,
-            SuccessReason::Return => Self::Return,
-            SuccessReason::SelfDestruct => Self::SelfDestruct,
-        }
-    }
-}
-
-#[napi(object)]
-pub struct CallOutput {
-    /// Return value
-    pub return_value: Uint8Array,
-}
-
-#[napi(object)]
-pub struct CreateOutput {
-    /// Return value
-    pub return_value: Uint8Array,
-    /// Optionally, a 160-bit address
-    pub address: Option<Uint8Array>,
-}
-
-/// The result when the EVM terminates successfully.
-#[napi(object)]
-pub struct SuccessResult {
-    /// The reason for termination
-    pub reason: SuccessReason,
-    /// The amount of gas used
-    pub gas_used: BigInt,
-    /// The amount of gas refunded
-    pub gas_refunded: BigInt,
-    /// The logs
-    pub logs: Vec<ExecutionLog>,
-    /// The transaction output
-    pub output: Either<CallOutput, CreateOutput>,
-}
-
-/// The result when the EVM terminates due to a revert.
-#[napi(object)]
-pub struct RevertResult {
-    /// The amount of gas used
-    pub gas_used: BigInt,
-    /// The transaction output
-    pub output: Uint8Array,
-}
-
-/// Indicates that the EVM has experienced an exceptional halt. This causes
-/// execution to immediately end with all gas being consumed.
-#[napi]
-pub enum ExceptionalHalt {
-    OutOfGas,
-    OpcodeNotFound,
-    InvalidFEOpcode,
-    InvalidJump,
-    NotActivated,
-    StackUnderflow,
-    StackOverflow,
-    OutOfOffset,
-    CreateCollision,
-    PrecompileError,
-    NonceOverflow,
-    /// Create init code size exceeds limit (runtime).
-    CreateContractSizeLimit,
-    /// Error on created contract that begins with EF
-    CreateContractStartingWithEF,
-    /// EIP-3860: Limit and meter initcode. Initcode size limit exceeded.
-    CreateInitCodeSizeLimit,
-}
-
-impl From<EvmHaltReason> for ExceptionalHalt {
-    fn from(halt: EvmHaltReason) -> Self {
-        match halt {
-            EvmHaltReason::OutOfGas(..) => ExceptionalHalt::OutOfGas,
-            EvmHaltReason::OpcodeNotFound => ExceptionalHalt::OpcodeNotFound,
-            EvmHaltReason::InvalidFEOpcode => ExceptionalHalt::InvalidFEOpcode,
-            EvmHaltReason::InvalidJump => ExceptionalHalt::InvalidJump,
-            EvmHaltReason::NotActivated => ExceptionalHalt::NotActivated,
-            EvmHaltReason::StackUnderflow => ExceptionalHalt::StackUnderflow,
-            EvmHaltReason::StackOverflow => ExceptionalHalt::StackOverflow,
-            EvmHaltReason::OutOfOffset => ExceptionalHalt::OutOfOffset,
-            EvmHaltReason::CreateCollision => ExceptionalHalt::CreateCollision,
-            EvmHaltReason::PrecompileError => ExceptionalHalt::PrecompileError,
-            EvmHaltReason::NonceOverflow => ExceptionalHalt::NonceOverflow,
-            EvmHaltReason::CreateContractSizeLimit => ExceptionalHalt::CreateContractSizeLimit,
-            EvmHaltReason::CreateContractStartingWithEF => {
-                ExceptionalHalt::CreateContractStartingWithEF
-            }
-            EvmHaltReason::CreateInitCodeSizeLimit => ExceptionalHalt::CreateInitCodeSizeLimit,
-            EvmHaltReason::OverflowPayment
-            | EvmHaltReason::StateChangeDuringStaticCall
-            | EvmHaltReason::CallNotAllowedInsideStatic
-            | EvmHaltReason::OutOfFunds
-            | EvmHaltReason::CallTooDeep => {
-                unreachable!("Internal halts that can be only found inside Inspector: {halt:?}")
-            }
-        }
-    }
-}
-
-/// The result when the EVM terminates due to an exceptional halt.
-#[napi(object)]
-pub struct HaltResult {
-    /// The exceptional halt that occurred
-    pub reason: ExceptionalHalt,
-    /// Halting will spend all the gas and will thus be equal to the specified
-    /// gas limit
-    pub gas_used: BigInt,
-}
-
-/// The result of executing a transaction.
-#[napi(object)]
-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<Uint8Array>,
-}
-
-impl From<&AfterMessage<EvmHaltReason>> for ExecutionResult {
-    fn from(value: &AfterMessage<EvmHaltReason>) -> Self {
-        let AfterMessage {
-            execution_result,
-            contract_address,
-        } = value;
-
-        let result = match execution_result {
-            edr_evm::result::ExecutionResult::Success {
-                reason,
-                gas_used,
-                gas_refunded,
-                logs,
-                output,
-            } => {
-                let logs = logs.iter().map(ExecutionLog::from).collect();
-
-                Either3::A(SuccessResult {
-                    reason: SuccessReason::from(*reason),
-                    gas_used: BigInt::from(*gas_used),
-                    gas_refunded: BigInt::from(*gas_refunded),
-                    logs,
-                    output: match output {
-                        edr_evm::result::Output::Call(return_value) => {
-                            let return_value = Uint8Array::with_data_copied(return_value);
-
-                            Either::A(CallOutput { return_value })
-                        }
-                        edr_evm::result::Output::Create(return_value, address) => {
-                            let return_value = Uint8Array::with_data_copied(return_value);
-
-                            Either::B(CreateOutput {
-                                return_value,
-                                address: address.as_ref().map(Uint8Array::with_data_copied),
-                            })
-                        }
-                    },
-                })
-            }
-            edr_evm::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::result::ExecutionResult::Halt { reason, gas_used } => Either3::C(HaltResult {
-                reason: ExceptionalHalt::from(*reason),
-                gas_used: BigInt::from(*gas_used),
-            }),
-        };
-
-        let contract_address = contract_address.as_ref().map(Uint8Array::with_data_copied);
-
-        Self {
-            result,
-            contract_address,
-        }
-    }
-}

package/src/scenarios.rs

@@ -1,53 +0,0 @@
-use std::time::{SystemTime, UNIX_EPOCH};
-
-use edr_scenarios::ScenarioConfig;
-use napi::tokio::{fs::File, io::AsyncWriteExt, sync::Mutex};
-use rand::{distributions::Alphanumeric, Rng};
-
-const SCENARIO_FILE_PREFIX: &str = "EDR_SCENARIO_PREFIX";
-
-/// 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,
-) -> napi::Result<Option<Mutex<File>>> {
-    if let Ok(scenario_prefix) = std::env::var(SCENARIO_FILE_PREFIX) {
-        let timestamp = SystemTime::now()
-            .duration_since(UNIX_EPOCH)
-            .expect("Time went backwards")
-            .as_secs();
-        let suffix = rand::thread_rng()
-            .sample_iter(&Alphanumeric)
-            .take(4)
-            .map(char::from)
-            .collect::<String>();
-
-        let mut scenario_file =
-            File::create(format!("{scenario_prefix}_{timestamp}_{suffix}.json")).await?;
-
-        let config = ScenarioConfig {
-            chain_type: Some(chain_type),
-            logger_enabled,
-            provider_config: provider_config.try_into()?,
-        };
-        let mut line = serde_json::to_string(&config)?;
-        line.push('\n');
-        scenario_file.write_all(line.as_bytes()).await?;
-
-        Ok(Some(Mutex::new(scenario_file)))
-    } else {
-        Ok(None)
-    }
-}
-
-/// 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;
-        scenario_file.write_all(line.as_bytes()).await?;
-    }
-    Ok(())
-}

package/src/serde.rs

@@ -1,57 +0,0 @@
-use edr_primitives::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

@@ -1,184 +0,0 @@
-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,
-        }
-    }
-}