@nomicfoundation/edr 0.2.0-alpha.2

package/src/block.rs

@@ -0,0 +1,110 @@
+use edr_eth::{Address, Bytes, B256, B64};
+use napi::bindgen_prelude::{BigInt, Buffer};
+use napi_derive::napi;
+
+use crate::cast::TryCast;
+
+#[napi(object)]
+pub struct BlockOptions {
+    /// The parent block's hash
+    pub parent_hash: Option<Buffer>,
+    /// The block's beneficiary
+    pub beneficiary: Option<Buffer>,
+    /// The state's root hash
+    pub state_root: Option<Buffer>,
+    /// The block's difficulty
+    pub difficulty: Option<BigInt>,
+    /// The block's number
+    pub number: Option<BigInt>,
+    /// The block's gas limit
+    pub gas_limit: Option<BigInt>,
+    /// The block's timestamp
+    pub timestamp: Option<BigInt>,
+    /// The block's extra data
+    pub extra_data: Option<Buffer>,
+    /// The block's mix hash (or prevrandao)
+    pub mix_hash: Option<Buffer>,
+    /// The block's nonce
+    pub nonce: Option<Buffer>,
+    /// The block's base gas fee
+    pub base_fee: Option<BigInt>,
+    /// The block's withdrawals root
+    pub withdrawals_root: Option<Buffer>,
+    /// The hash tree root of the parent beacon block for the given execution
+    /// block (EIP-4788).
+    pub parent_beacon_block_root: Option<Buffer>,
+}
+
+impl TryFrom<BlockOptions> for edr_eth::block::BlockOptions {
+    type Error = napi::Error;
+
+    #[cfg_attr(feature = "tracing", tracing::instrument(skip_all))]
+    fn try_from(value: BlockOptions) -> Result<Self, Self::Error> {
+        Ok(Self {
+            parent_hash: value
+                .parent_hash
+                .map(TryCast::<B256>::try_cast)
+                .transpose()?,
+            beneficiary: value
+                .beneficiary
+                .map(TryCast::<Address>::try_cast)
+                .transpose()?,
+            state_root: value
+                .state_root
+                .map(TryCast::<B256>::try_cast)
+                .transpose()?,
+            difficulty: value
+                .difficulty
+                .map_or(Ok(None), |difficulty| difficulty.try_cast().map(Some))?,
+            number: value
+                .number
+                .map_or(Ok(None), |number| number.try_cast().map(Some))?,
+            gas_limit: value
+                .gas_limit
+                .map_or(Ok(None), |gas_limit| gas_limit.try_cast().map(Some))?,
+            timestamp: value
+                .timestamp
+                .map_or(Ok(None), |timestamp| timestamp.try_cast().map(Some))?,
+            extra_data: value
+                .extra_data
+                .map(|extra_data| Bytes::copy_from_slice(&extra_data)),
+            mix_hash: value.mix_hash.map(TryCast::<B256>::try_cast).transpose()?,
+            nonce: value.nonce.map(TryCast::<B64>::try_cast).transpose()?,
+            base_fee: value
+                .base_fee
+                .map_or(Ok(None), |basefee| basefee.try_cast().map(Some))?,
+            withdrawals_root: value
+                .withdrawals_root
+                .map(TryCast::<B256>::try_cast)
+                .transpose()?,
+            parent_beacon_block_root: value
+                .parent_beacon_block_root
+                .map(TryCast::<B256>::try_cast)
+                .transpose()?,
+        })
+    }
+}
+
+/// 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_eth::block::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/cast.rs

@@ -0,0 +1,119 @@
+use edr_eth::{Address, B256, B64, U256};
+use napi::{
+    bindgen_prelude::{BigInt, Buffer},
+    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 Buffer {
+    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,
+                "Buffer was expected to be 20 bytes.".to_string(),
+            ));
+        }
+        Ok(Address::from_slice(&self))
+    }
+}
+
+impl TryCast<B64> for Buffer {
+    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,
+                "Buffer was expected to be 8 bytes.".to_string(),
+            ));
+        }
+        Ok(B64::from_slice(&self))
+    }
+}
+
+impl TryCast<B256> for Buffer {
+    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,
+                "Buffer was expected to be 32 bytes.".to_string(),
+            ));
+        }
+        Ok(B256::from_slice(&self))
+    }
+}
+
+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<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)
+    }
+}

package/src/config.rs

@@ -0,0 +1,70 @@
+use napi_derive::napi;
+
+/// Identifier for the Ethereum spec.
+#[napi]
+pub enum SpecId {
+    /// Frontier
+    Frontier = 0,
+    /// Frontier Thawing
+    FrontierThawing = 1,
+    /// Homestead
+    Homestead = 2,
+    /// DAO Fork
+    DaoFork = 3,
+    /// Tangerine
+    Tangerine = 4,
+    /// Spurious Dragon
+    SpuriousDragon = 5,
+    /// Byzantium
+    Byzantium = 6,
+    /// Constantinople
+    Constantinople = 7,
+    /// Petersburg
+    Petersburg = 8,
+    /// Istanbul
+    Istanbul = 9,
+    /// Muir Glacier
+    MuirGlacier = 10,
+    /// Berlin
+    Berlin = 11,
+    /// London
+    London = 12,
+    /// Arrow Glacier
+    ArrowGlacier = 13,
+    /// Gray Glacier
+    GrayGlacier = 14,
+    /// Merge
+    Merge = 15,
+    /// Shanghai
+    Shanghai = 16,
+    /// Cancun
+    Cancun = 17,
+    /// Latest
+    Latest = 18,
+}
+
+impl From<SpecId> for edr_evm::SpecId {
+    fn from(value: SpecId) -> Self {
+        match value {
+            SpecId::Frontier => edr_evm::SpecId::FRONTIER,
+            SpecId::FrontierThawing => edr_evm::SpecId::FRONTIER_THAWING,
+            SpecId::Homestead => edr_evm::SpecId::HOMESTEAD,
+            SpecId::DaoFork => edr_evm::SpecId::DAO_FORK,
+            SpecId::Tangerine => edr_evm::SpecId::TANGERINE,
+            SpecId::SpuriousDragon => edr_evm::SpecId::SPURIOUS_DRAGON,
+            SpecId::Byzantium => edr_evm::SpecId::BYZANTIUM,
+            SpecId::Constantinople => edr_evm::SpecId::CONSTANTINOPLE,
+            SpecId::Petersburg => edr_evm::SpecId::PETERSBURG,
+            SpecId::Istanbul => edr_evm::SpecId::ISTANBUL,
+            SpecId::MuirGlacier => edr_evm::SpecId::MUIR_GLACIER,
+            SpecId::Berlin => edr_evm::SpecId::BERLIN,
+            SpecId::London => edr_evm::SpecId::LONDON,
+            SpecId::ArrowGlacier => edr_evm::SpecId::ARROW_GLACIER,
+            SpecId::GrayGlacier => edr_evm::SpecId::GRAY_GLACIER,
+            SpecId::Merge => edr_evm::SpecId::MERGE,
+            SpecId::Shanghai => edr_evm::SpecId::SHANGHAI,
+            SpecId::Cancun => edr_evm::SpecId::CANCUN,
+            SpecId::Latest => edr_evm::SpecId::LATEST,
+        }
+    }
+}

package/src/context.rs

@@ -0,0 +1,74 @@
+use std::{io, ops::Deref, sync::Arc};
+
+use napi::Status;
+use napi_derive::napi;
+use tracing_subscriber::{prelude::*, EnvFilter, Registry};
+
+#[napi]
+#[derive(Debug)]
+pub struct EdrContext {
+    inner: Arc<Context>,
+}
+
+impl Deref for EdrContext {
+    type Target = Arc<Context>;
+
+    fn deref(&self) -> &Self::Target {
+        &self.inner
+    }
+}
+
+#[napi]
+impl EdrContext {
+    #[doc = "Creates a new [`EdrContext`] instance. Should only be called once!"]
+    #[napi(constructor)]
+    pub fn new() -> napi::Result<Self> {
+        let context =
+            Context::new().map_err(|e| napi::Error::new(Status::GenericFailure, e.to_string()))?;
+
+        Ok(Self {
+            inner: Arc::new(context),
+        })
+    }
+}
+
+#[derive(Debug)]
+pub struct Context {
+    #[cfg(feature = "tracing")]
+    _tracing_write_guard: tracing_flame::FlushGuard<std::io::BufWriter<std::fs::File>>,
+}
+
+impl Context {
+    /// Creates a new [`Context`] instance. Should only be called once!
+    pub fn new() -> io::Result<Self> {
+        let fmt_layer = tracing_subscriber::fmt::layer()
+            .with_file(true)
+            .with_line_number(true)
+            .with_thread_ids(true)
+            .with_target(false)
+            .with_level(true)
+            .with_filter(EnvFilter::from_default_env());
+
+        let subscriber = Registry::default().with(fmt_layer);
+
+        #[cfg(feature = "tracing")]
+        let (flame_layer, guard) = {
+            let (flame_layer, guard) =
+                tracing_flame::FlameLayer::with_file("tracing.folded").unwrap();
+
+            let flame_layer = flame_layer.with_empty_samples(false);
+            (flame_layer, guard)
+        };
+
+        #[cfg(feature = "tracing")]
+        let subscriber = subscriber.with(flame_layer);
+
+        tracing::subscriber::set_global_default(subscriber)
+            .expect("Could not set global default tracing subscriber");
+
+        Ok(Self {
+            #[cfg(feature = "tracing")]
+            _tracing_write_guard: guard,
+        })
+    }
+}

package/src/debug_trace.rs

@@ -0,0 +1,38 @@
+use std::collections::HashMap;
+
+use napi::bindgen_prelude::{BigInt, Buffer};
+use napi_derive::napi;
+
+#[napi(object)]
+pub struct DebugTraceResult {
+    pub pass: bool,
+    pub gas_used: BigInt,
+    pub output: Option<Buffer>,
+    pub struct_logs: Vec<DebugTraceLogItem>,
+}
+
+#[napi(object)]
+pub struct DebugTraceLogItem {
+    /// Program Counter
+    pub pc: BigInt,
+    // Op code
+    pub op: u8,
+    /// Gas left before executing this operation as hex number.
+    pub gas: String,
+    /// Gas cost of this operation as hex number.
+    pub gas_cost: String,
+    /// Array of all values (hex numbers) on the stack
+    pub stack: Option<Vec<String>>,
+    /// Depth of the call stack
+    pub depth: BigInt,
+    /// Size of memory array
+    pub mem_size: BigInt,
+    /// Name of the operation
+    pub op_name: String,
+    /// Description of an error as a hex string.
+    pub error: Option<String>,
+    /// Array of all allocated values as hex strings.
+    pub memory: Option<Vec<String>>,
+    /// Map of all stored values with keys and values encoded as hex strings.
+    pub storage: Option<HashMap<String, String>>,
+}

package/src/lib.rs

@@ -0,0 +1,18 @@
+#![warn(missing_docs)]
+
+//! NAPI bindings for the EDR EVM
+
+mod account;
+mod block;
+mod cast;
+mod config;
+mod context;
+mod debug_trace;
+mod log;
+mod logger;
+mod provider;
+mod result;
+mod subscribe;
+mod sync;
+mod threadsafe_function;
+mod trace;

package/src/log.rs

@@ -0,0 +1,41 @@
+use std::mem;
+
+use napi::{bindgen_prelude::Buffer, Env, JsBuffer, JsBufferValue};
+use napi_derive::napi;
+
+/// Ethereum execution log.
+#[napi(object)]
+pub struct ExecutionLog {
+    pub address: Buffer,
+    pub topics: Vec<Buffer>,
+    pub data: JsBuffer,
+}
+
+impl ExecutionLog {
+    pub fn new(env: &Env, log: &edr_evm::Log) -> napi::Result<Self> {
+        let topics = log
+            .topics
+            .iter()
+            .map(|topic| Buffer::from(topic.as_slice()))
+            .collect();
+
+        let data = log.data.clone();
+        let data = unsafe {
+            env.create_buffer_with_borrowed_data(
+                data.as_ptr(),
+                data.len(),
+                data,
+                |data: edr_eth::Bytes, _env| {
+                    mem::drop(data);
+                },
+            )
+        }
+        .map(JsBufferValue::into_raw)?;
+
+        Ok(Self {
+            address: Buffer::from(log.address.as_slice()),
+            topics,
+            data,
+        })
+    }
+}