@nomicfoundation/edr 0.12.0-next.9 → 0.12.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nomicfoundation/edr",
-  "version": "0.12.0-next.9",
+  "version": "0.12.0",
   "devDependencies": {
     "@napi-rs/cli": "^2.18.4",
     "@nomicfoundation/ethereumjs-util": "^9.0.4",
@@ -9,16 +9,16 @@
     "@types/chai-as-promised": "^7.1.8",
     "@types/mocha": ">=9.1.0",
     "@types/node": "^20.0.0",
-    "@typescript-eslint/eslint-plugin": "5.61.0",
-    "@typescript-eslint/parser": "5.61.0",
+    "@typescript-eslint/eslint-plugin": "5.62.0",
+    "@typescript-eslint/parser": "5.62.0",
     "chai": "^4.3.6",
     "chai-as-promised": "^7.1.1",
     "chalk": "^2.4.2",
     "eslint": "^8.44.0",
-    "eslint-config-prettier": "9.1.0",
-    "eslint-plugin-import": "2.27.5",
-    "eslint-plugin-mocha": "10.4.1",
-    "eslint-plugin-prettier": "5.2.1",
+    "eslint-config-prettier": "9.1.2",
+    "eslint-plugin-import": "2.32.0",
+    "eslint-plugin-mocha": "10.5.0",
+    "eslint-plugin-prettier": "5.5.5",
     "ethers": "^6.1.0",
     "json-stream-stringify": "^3.1.4",
     "mocha": "^10.0.0",
@@ -31,13 +31,13 @@
   },
   "exports": {
     ".": "./index.js",
-    "./solidity-tests": "./dist/src/ts/solidity_tests.js"
+    "./coverage": "./dist/src/ts/coverage.js"
   },
   "files": [
     "index.js",
     "index.d.ts",
-    "src/",
-    "dist/src/"
+    "dist/src/",
+    "coverage.sol"
   ],
   "license": "MIT",
   "main": "index.js",
@@ -59,28 +59,30 @@
   "repository": "NomicFoundation/edr.git",
   "types": "index.d.ts",
   "dependencies": {
-    "@nomicfoundation/edr-darwin-arm64": "0.12.0-next.9",
-    "@nomicfoundation/edr-darwin-x64": "0.12.0-next.9",
-    "@nomicfoundation/edr-linux-arm64-gnu": "0.12.0-next.9",
-    "@nomicfoundation/edr-linux-arm64-musl": "0.12.0-next.9",
-    "@nomicfoundation/edr-linux-x64-gnu": "0.12.0-next.9",
-    "@nomicfoundation/edr-linux-x64-musl": "0.12.0-next.9",
-    "@nomicfoundation/edr-win32-x64-msvc": "0.12.0-next.9"
+    "@nomicfoundation/edr-darwin-arm64": "0.12.0",
+    "@nomicfoundation/edr-darwin-x64": "0.12.0",
+    "@nomicfoundation/edr-linux-arm64-gnu": "0.12.0",
+    "@nomicfoundation/edr-linux-arm64-musl": "0.12.0",
+    "@nomicfoundation/edr-linux-x64-gnu": "0.12.0",
+    "@nomicfoundation/edr-linux-x64-musl": "0.12.0",
+    "@nomicfoundation/edr-win32-x64-msvc": "0.12.0"
   },
   "scripts": {
     "artifacts": "napi artifacts",
     "build": "pnpm run build:publish",
     "build:debug": "bash ../../scripts/build_edr_napi.sh --features op",
-    "build:dev": "bash ../../scripts/build_edr_napi.sh --release --features op,test-mock",
+    "build:dev": "bash ../../scripts/build_edr_napi.sh --release --features op",
+    "build:perf-js": "RUSTFLAGS='-Cforce-frame-pointers=yes' bash ../../scripts/build_edr_napi.sh --profile napi-publish --features op",
     "build:publish": "bash ../../scripts/build_edr_napi.sh --profile napi-publish --features op",
     "build:scenarios": "bash ../../scripts/build_edr_napi.sh --release --features op,scenarios",
+    "build:test": "bash ../../scripts/build_edr_napi.sh --release --features op,test-mock",
     "build:tracing": "bash ../../scripts/build_edr_napi.sh --release --features op,tracing",
     "build:typingFile": "bash ../../scripts/build_edr_napi.sh --features op",
     "clean": "rm -rf @nomicfoundation/edr.node",
     "eslint": "eslint 'test/**/*.ts'",
     "lint": "pnpm run prettier && pnpm run eslint",
     "lint:fix": "pnpm run prettier --write",
-    "pretest": "pnpm build:dev",
+    "pretest": "pnpm build:test",
     "prettier": "prettier --check \"test/**.ts\"",
     "test": "node --max-old-space-size=8192 node_modules/mocha/bin/_mocha --recursive \"test/**/*.ts\"",
     "testNoBuild": "node --max-old-space-size=8192 node_modules/mocha/bin/_mocha --recursive \"test/**/{,!(logs|mock)}.ts\"",

package/src/account.rs

@@ -1,124 +0,0 @@
-use derive_more::Debug;
-use edr_primitives::{hex, Address, HashMap, U256};
-use edr_solidity_tests::{backend::Predeploy, revm::state::AccountInfo};
-use edr_state_api::EvmStorageSlot;
-use napi::bindgen_prelude::{BigInt, Uint8Array};
-use napi_derive::napi;
-
-use crate::{
-    cast::TryCast,
-    serde::{
-        serialize_bigint_as_struct, serialize_optional_bigint_as_struct,
-        serialize_optional_uint8array_as_hex, serialize_uint8array_as_hex,
-    },
-};
-
-/// Specification of overrides for an account and its storage.
-#[napi(object)]
-#[derive(Clone, Debug, serde::Serialize)]
-pub struct AccountOverride {
-    /// The account's address
-    #[debug("{}", hex::encode(address))]
-    #[serde(serialize_with = "serialize_uint8array_as_hex")]
-    pub address: Uint8Array,
-    /// If present, the overwriting balance.
-    #[serde(serialize_with = "serialize_optional_bigint_as_struct")]
-    pub balance: Option<BigInt>,
-    /// If present, the overwriting nonce.
-    #[serde(serialize_with = "serialize_optional_bigint_as_struct")]
-    pub nonce: Option<BigInt>,
-    /// If present, the overwriting code.
-    #[debug("{:?}", code.as_ref().map(hex::encode))]
-    #[serde(serialize_with = "serialize_optional_uint8array_as_hex")]
-    pub code: Option<Uint8Array>,
-    /// BEWARE: This field is not supported yet. See <https://github.com/NomicFoundation/edr/issues/911>
-    ///
-    /// If present, the overwriting storage.
-    pub storage: Option<Vec<StorageSlot>>,
-}
-
-impl TryFrom<AccountOverride> for (Address, edr_provider::AccountOverride) {
-    type Error = napi::Error;
-
-    fn try_from(value: AccountOverride) -> Result<Self, Self::Error> {
-        let AccountOverride {
-            address,
-            balance,
-            nonce,
-            code,
-            storage,
-        } = value;
-        let storage = storage
-            .map(|storage| {
-                storage
-                    .into_iter()
-                    .map(|StorageSlot { index, value }| {
-                        let value = value.try_cast()?;
-                        let slot = EvmStorageSlot::new(value, 0);
-
-                        let index: U256 = index.try_cast()?;
-                        Ok((index, slot))
-                    })
-                    .collect::<napi::Result<_>>()
-            })
-            .transpose()?;
-
-        let account_override = edr_provider::AccountOverride {
-            balance: balance.map(TryCast::try_cast).transpose()?,
-            nonce: nonce.map(TryCast::try_cast).transpose()?,
-            code: code.map(TryCast::try_cast).transpose()?,
-            storage,
-        };
-
-        let address: Address = address.try_cast()?;
-
-        Ok((address, account_override))
-    }
-}
-
-impl TryFrom<AccountOverride> for Predeploy {
-    type Error = napi::Error;
-
-    fn try_from(value: AccountOverride) -> Result<Self, Self::Error> {
-        let (address, account_override) = value.try_into()?;
-
-        let storage = account_override.storage.unwrap_or_else(HashMap::new);
-        let balance = account_override.balance.unwrap_or(U256::ZERO);
-        let nonce = account_override.nonce.unwrap_or(0);
-        let code = account_override.code.ok_or_else(|| {
-            napi::Error::from_reason(format!("Predeploy with address '{address}' must have code"))
-        })?;
-
-        if code.is_empty() {
-            return Err(napi::Error::from_reason(
-                "Predeploy with address '{address}' must have non-empty code",
-            ));
-        }
-        let code_hash = code.hash_slow();
-
-        let account_info = AccountInfo {
-            balance,
-            nonce,
-            code_hash,
-            code: Some(code),
-        };
-
-        Ok(Self {
-            address,
-            account_info,
-            storage,
-        })
-    }
-}
-
-/// A description of a storage slot's state.
-#[napi(object)]
-#[derive(Clone, Debug, serde::Serialize)]
-pub struct StorageSlot {
-    /// The storage slot's index
-    #[serde(serialize_with = "serialize_bigint_as_struct")]
-    pub index: BigInt,
-    /// The storage slot's value
-    #[serde(serialize_with = "serialize_bigint_as_struct")]
-    pub value: BigInt,
-}

package/src/block.rs

@@ -1,28 +0,0 @@
-use napi::bindgen_prelude::BigInt;
-use napi_derive::napi;
-
-use crate::cast::TryCast;
-
-/// Information about the blob gas used in a block.
-#[napi(object)]
-pub struct BlobGas {
-    /// The total amount of blob gas consumed by the transactions within the
-    /// block.
-    pub gas_used: BigInt,
-    /// The running total of blob gas consumed in excess of the target, prior to
-    /// the block. Blocks with above-target blob gas consumption increase this
-    /// value, blocks with below-target blob gas consumption decrease it
-    /// (bounded at 0).
-    pub excess_gas: BigInt,
-}
-
-impl TryFrom<BlobGas> for edr_block_header::BlobGas {
-    type Error = napi::Error;
-
-    fn try_from(value: BlobGas) -> Result<Self, Self::Error> {
-        Ok(Self {
-            gas_used: BigInt::try_cast(value.gas_used)?,
-            excess_gas: BigInt::try_cast(value.excess_gas)?,
-        })
-    }
-}

package/src/call_override.rs

@@ -1,116 +0,0 @@
-use std::sync::mpsc::channel;
-
-use edr_primitives::{Address, Bytes};
-use napi::{
-    bindgen_prelude::{Promise, Uint8Array},
-    threadsafe_function::{
-        ErrorStrategy, ThreadSafeCallContext, ThreadsafeFunction, ThreadsafeFunctionCallMode,
-    },
-    tokio::runtime,
-    Env, JsFunction, Status,
-};
-use napi_derive::napi;
-
-use crate::cast::TryCast;
-
-/// The result of executing a call override.
-#[napi(object)]
-pub struct CallOverrideResult {
-    pub result: Uint8Array,
-    pub should_revert: bool,
-}
-
-impl TryCast<Option<edr_provider::CallOverrideResult>> for Option<CallOverrideResult> {
-    type Error = napi::Error;
-
-    fn try_cast(self) -> Result<Option<edr_provider::CallOverrideResult>, Self::Error> {
-        match self {
-            None => Ok(None),
-            Some(result) => Ok(Some(edr_provider::CallOverrideResult {
-                output: Bytes::copy_from_slice(&result.result),
-                should_revert: result.should_revert,
-            })),
-        }
-    }
-}
-
-struct CallOverrideCall {
-    contract_address: Address,
-    data: Bytes,
-}
-
-#[derive(Clone)]
-pub struct CallOverrideCallback {
-    call_override_callback_fn: ThreadsafeFunction<CallOverrideCall, ErrorStrategy::Fatal>,
-    runtime: runtime::Handle,
-}
-
-impl CallOverrideCallback {
-    pub fn new(
-        env: &Env,
-        call_override_callback: JsFunction,
-        runtime: runtime::Handle,
-    ) -> napi::Result<Self> {
-        let mut call_override_callback_fn = call_override_callback.create_threadsafe_function(
-            0,
-            |ctx: ThreadSafeCallContext<CallOverrideCall>| {
-                let address = ctx
-                    .env
-                    .create_arraybuffer_with_data(ctx.value.contract_address.to_vec())?
-                    .into_raw();
-
-                let data = ctx
-                    .env
-                    .create_arraybuffer_with_data(ctx.value.data.to_vec())?
-                    .into_raw();
-
-                Ok(vec![address, data])
-            },
-        )?;
-
-        // Maintain a weak reference to the function to avoid blocking the event loop
-        // from exiting.
-        call_override_callback_fn.unref(env)?;
-
-        Ok(Self {
-            call_override_callback_fn,
-            runtime,
-        })
-    }
-
-    pub fn call_override(
-        &self,
-        contract_address: Address,
-        data: Bytes,
-    ) -> Option<edr_provider::CallOverrideResult> {
-        let (sender, receiver) = channel();
-
-        let runtime = self.runtime.clone();
-        let status = self.call_override_callback_fn.call_with_return_value(
-            CallOverrideCall {
-                contract_address,
-                data,
-            },
-            ThreadsafeFunctionCallMode::Blocking,
-            move |result: Promise<Option<CallOverrideResult>>| {
-                runtime.spawn(async move {
-                    let result = result.await?.try_cast();
-                    sender.send(result).map_err(|_error| {
-                        napi::Error::new(
-                            Status::GenericFailure,
-                            "Failed to send result from call_override_callback",
-                        )
-                    })
-                });
-                Ok(())
-            },
-        );
-
-        assert_eq!(status, Status::Ok, "Call override callback failed");
-
-        receiver
-            .recv()
-            .unwrap()
-            .expect("Failed call to call_override_callback")
-    }
-}

package/src/cast.rs

@@ -1,165 +0,0 @@
-use edr_primitives::{Address, Bytecode, Bytes, B256, B64, U256};
-use napi::{
-    bindgen_prelude::{BigInt, Uint8Array},
-    Status,
-};
-
-/// An attempted conversion that consumes `self`, which may or may not be
-/// expensive. It is identical to [`TryInto`], but it allows us to implement
-/// the trait for external types.
-pub trait TryCast<T>: Sized {
-    /// The type returned in the event of a conversion error.
-    type Error;
-
-    /// Performs the conversion.
-    fn try_cast(self) -> Result<T, Self::Error>;
-}
-
-impl TryCast<Address> for Uint8Array {
-    type Error = napi::Error;
-
-    fn try_cast(self) -> std::result::Result<Address, Self::Error> {
-        if self.len() != 20 {
-            return Err(napi::Error::new(
-                Status::InvalidArg,
-                "Uint8Array was expected to be 20 bytes.".to_string(),
-            ));
-        }
-        Ok(Address::from_slice(&self))
-    }
-}
-
-impl TryCast<B64> for Uint8Array {
-    type Error = napi::Error;
-
-    fn try_cast(self) -> std::result::Result<B64, Self::Error> {
-        if self.len() != 8 {
-            return Err(napi::Error::new(
-                Status::InvalidArg,
-                "Uint8Array was expected to be 8 bytes.".to_string(),
-            ));
-        }
-        Ok(B64::from_slice(&self))
-    }
-}
-
-impl TryCast<B256> for Uint8Array {
-    type Error = napi::Error;
-
-    fn try_cast(self) -> std::result::Result<B256, Self::Error> {
-        if self.len() != 32 {
-            return Err(napi::Error::new(
-                Status::InvalidArg,
-                "Uint8Array was expected to be 32 bytes.".to_string(),
-            ));
-        }
-        Ok(B256::from_slice(&self))
-    }
-}
-
-impl TryCast<Bytecode> for Uint8Array {
-    type Error = napi::Error;
-
-    fn try_cast(self) -> std::result::Result<Bytecode, Self::Error> {
-        let bytes = Bytes::copy_from_slice(&self);
-        Bytecode::new_raw_checked(bytes).map_err(|error| {
-            napi::Error::new(
-                Status::InvalidArg,
-                format!("Uint8Array was not valid bytecode: {error}"),
-            )
-        })
-    }
-}
-
-impl TryCast<u64> for BigInt {
-    type Error = napi::Error;
-
-    fn try_cast(self) -> std::result::Result<u64, Self::Error> {
-        let (signed, value, lossless) = self.get_u64();
-
-        if signed {
-            return Err(napi::Error::new(
-                Status::InvalidArg,
-                "BigInt was expected to be unsigned.".to_string(),
-            ));
-        }
-
-        if !lossless {
-            return Err(napi::Error::new(
-                Status::InvalidArg,
-                "BigInt was expected to fit within 64 bits.".to_string(),
-            ));
-        }
-
-        Ok(value)
-    }
-}
-
-impl TryCast<u128> for BigInt {
-    type Error = napi::Error;
-
-    fn try_cast(self) -> std::result::Result<u128, Self::Error> {
-        let (signed, value, lossless) = self.get_u128();
-
-        if signed {
-            return Err(napi::Error::new(
-                Status::InvalidArg,
-                "BigInt was expected to be unsigned.".to_string(),
-            ));
-        }
-
-        if !lossless {
-            return Err(napi::Error::new(
-                Status::InvalidArg,
-                "BigInt was expected to fit within 128 bits.".to_string(),
-            ));
-        }
-
-        Ok(value)
-    }
-}
-
-impl TryCast<usize> for BigInt {
-    type Error = napi::Error;
-
-    fn try_cast(self) -> std::result::Result<usize, Self::Error> {
-        let size: u64 = BigInt::try_cast(self)?;
-        usize::try_from(size).map_err(|e| napi::Error::new(Status::InvalidArg, e.to_string()))
-    }
-}
-
-impl TryCast<U256> for BigInt {
-    type Error = napi::Error;
-
-    fn try_cast(mut self) -> std::result::Result<U256, Self::Error> {
-        let num_words = self.words.len();
-        match num_words.cmp(&4) {
-            std::cmp::Ordering::Less => self.words.append(&mut vec![0u64; 4 - num_words]),
-            std::cmp::Ordering::Equal => (),
-            std::cmp::Ordering::Greater => {
-                return Err(napi::Error::new(
-                    Status::InvalidArg,
-                    "BigInt cannot have more than 4 words.".to_owned(),
-                ));
-            }
-        }
-
-        Ok(U256::from_limbs(self.words.try_into().unwrap()))
-    }
-}
-
-impl<T> TryCast<T> for T {
-    type Error = napi::Error;
-
-    fn try_cast(self) -> std::result::Result<T, Self::Error> {
-        Ok(self)
-    }
-}
-
-impl TryCast<Option<Bytes>> for Option<Uint8Array> {
-    type Error = napi::Error;
-
-    fn try_cast(self) -> Result<Option<Bytes>, Self::Error> {
-        Ok(self.map(|buffer| Bytes::copy_from_slice(&buffer)))
-    }
-}

package/src/chains/generic.rs

@@ -1,58 +0,0 @@
-use std::sync::Arc;
-
-use edr_generic::GenericChainSpec;
-use edr_napi_core::{
-    logger::Logger,
-    provider::{SyncProvider, SyncProviderFactory},
-    subscription::subscriber_callback_for_chain_spec,
-};
-use edr_provider::time::CurrentTime;
-use edr_solidity::contract_decoder::ContractDecoder;
-use napi::tokio::runtime;
-use napi_derive::napi;
-
-use crate::provider::ProviderFactory;
-
-pub struct GenericChainProviderFactory;
-
-impl SyncProviderFactory for GenericChainProviderFactory {
-    fn create_provider(
-        &self,
-        runtime: runtime::Handle,
-        provider_config: edr_napi_core::provider::Config,
-        logger_config: edr_napi_core::logger::Config,
-        subscription_callback: edr_napi_core::subscription::Callback,
-        contract_decoder: Arc<ContractDecoder>,
-    ) -> napi::Result<Arc<dyn SyncProvider>> {
-        let logger = Logger::<GenericChainSpec, CurrentTime>::new(
-            logger_config,
-            Arc::clone(&contract_decoder),
-        )?;
-
-        let provider_config =
-            edr_provider::ProviderConfig::<edr_chain_l1::Hardfork>::try_from(provider_config)?;
-
-        let provider = edr_provider::Provider::<GenericChainSpec>::new(
-            runtime.clone(),
-            Box::new(logger),
-            subscriber_callback_for_chain_spec::<GenericChainSpec, CurrentTime>(
-                subscription_callback,
-            ),
-            provider_config,
-            contract_decoder,
-            CurrentTime,
-        )
-        .map_err(|error| napi::Error::new(napi::Status::GenericFailure, error.to_string()))?;
-
-        Ok(Arc::new(provider))
-    }
-}
-
-#[napi]
-pub const GENERIC_CHAIN_TYPE: &str = edr_generic::CHAIN_TYPE;
-
-#[napi(catch_unwind)]
-pub fn generic_chain_provider_factory() -> ProviderFactory {
-    let factory: Arc<dyn SyncProviderFactory> = Arc::new(GenericChainProviderFactory);
-    factory.into()
-}