@nomicfoundation/edr 0.12.0-next.15 → 0.12.0-next.17

package/index.d.ts

@@ -336,6 +336,14 @@ export interface ProviderConfig {
   ownedAccounts: Array<string>
   /** Overrides for precompiles */
   precompileOverrides: Array<Precompile>
+  /**
+   * Transaction gas cap, introduced in [EIP-7825].
+   *
+   * When not set, will default to value defined by the used hardfork
+   *
+   * [EIP-7825]: https://eips.ethereum.org/EIPS/eip-7825
+   */
+  transactionGasCap?: bigint
 }
 /** Tracing config for Solidity stack trace generation. */
 export interface TracingConfigWithBuffers {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nomicfoundation/edr",
-  "version": "0.12.0-next.15",
+  "version": "0.12.0-next.17",
   "devDependencies": {
     "@napi-rs/cli": "^2.18.4",
     "@nomicfoundation/ethereumjs-util": "^9.0.4",
@@ -58,13 +58,13 @@
   "repository": "NomicFoundation/edr.git",
   "types": "index.d.ts",
   "dependencies": {
-    "@nomicfoundation/edr-darwin-arm64": "0.12.0-next.15",
-    "@nomicfoundation/edr-darwin-x64": "0.12.0-next.15",
-    "@nomicfoundation/edr-linux-arm64-gnu": "0.12.0-next.15",
-    "@nomicfoundation/edr-linux-arm64-musl": "0.12.0-next.15",
-    "@nomicfoundation/edr-linux-x64-gnu": "0.12.0-next.15",
-    "@nomicfoundation/edr-linux-x64-musl": "0.12.0-next.15",
-    "@nomicfoundation/edr-win32-x64-msvc": "0.12.0-next.15"
+    "@nomicfoundation/edr-darwin-arm64": "0.12.0-next.17",
+    "@nomicfoundation/edr-darwin-x64": "0.12.0-next.17",
+    "@nomicfoundation/edr-linux-arm64-gnu": "0.12.0-next.17",
+    "@nomicfoundation/edr-linux-arm64-musl": "0.12.0-next.17",
+    "@nomicfoundation/edr-linux-x64-gnu": "0.12.0-next.17",
+    "@nomicfoundation/edr-linux-x64-musl": "0.12.0-next.17",
+    "@nomicfoundation/edr-win32-x64-msvc": "0.12.0-next.17"
   },
   "scripts": {
     "artifacts": "napi artifacts",

package/src/chains/l1.rs

@@ -238,7 +238,7 @@ pub fn l1_hardfork_to_string(harfork: SpecId) -> &'static str {
 /// The returned value will be updated after each network upgrade.
 #[napi]
 pub fn l1_hardfork_latest() -> SpecId {
-    SpecId::Prague
+    SpecId::Osaka
 }
 
 macro_rules! export_spec_id {

package/src/chains/op.rs

@@ -8,7 +8,8 @@ use edr_napi_core::{
 use edr_op::{
     predeploys::{
         gas_price_oracle_code_ecotone, gas_price_oracle_code_fjord, gas_price_oracle_code_isthmus,
-        GAS_PRICE_ORACLE_ADDRESS,
+        l1_block_code_bedrock, l1_block_code_ecotone, l1_block_code_isthmus,
+        GAS_PRICE_ORACLE_ADDRESS, L1_BLOCK_PREDEPLOY_ADDRESS,
     },
     OpChainSpec,
 };
@@ -135,7 +136,7 @@ pub fn op_hardfork_to_string(hardfork: OpHardfork) -> &'static str {
 /// The returned value will be updated after each network upgrade.
 #[napi(catch_unwind)]
 pub fn op_latest_hardfork() -> OpHardfork {
-    OpHardfork::Holocene
+    OpHardfork::Isthmus
 }
 
 #[napi]
@@ -143,72 +144,13 @@ pub const OP_CHAIN_TYPE: &str = edr_op::CHAIN_TYPE;
 
 #[napi(catch_unwind)]
 pub fn op_genesis_state(hardfork: OpHardfork) -> Vec<AccountOverride> {
-    let l1_block_code = hex::decode(include_str!("../../data/op/predeploys/l1_block.txt"))
-        .expect("The bytecode for the L1Block predeploy should be a valid hex string");
+    let l1_block_code = l1_block_code(hardfork.into());
     let l1_block = AccountOverride {
-        address: hex!("4200000000000000000000000000000000000015").into(),
+        address: Uint8Array::with_data_copied(L1_BLOCK_PREDEPLOY_ADDRESS),
         balance: Some(BigInt::from(0u64)),
         nonce: Some(BigInt::from(0u64)),
-        code: Some(l1_block_code.into()),
-        storage: Some(vec![
-            StorageSlot {
-                index: BigInt::from(0u64),
-                // uint64 public number = 1
-                // uint64 public timestamp = 1
-                value: BigInt {
-                    words: vec![
-                        0x0000000000000001_u64, // least significative
-                        0x0000000000000001_u64,
-                    ],
-                    sign_bit: false,
-                },
-            },
-            StorageSlot {
-                index: BigInt::from(1u64),
-                // uint256 baseFee = 10 gwei
-                value: BigInt::from(0x00000002540be400_u64),
-            },
-            StorageSlot {
-                index: BigInt::from(2u64),
-                // bytes32 hash = 0
-                value: BigInt::from(0u64),
-            },
-            StorageSlot {
-                index: BigInt::from(3u64),
-                // uint64 sequenceNumber = 0
-                // uint32 blobBaseFeeScalar = 1014213
-                // uint32 baseFeeScalar = 5227
-                value: BigInt {
-                    words: vec![
-                        0x0000000000000000_u64, // least significative
-                        0x0000000000000000_u64,
-                        0x00000000000f79c5_u64,
-                        0x000000000000146b_u64,
-                    ],
-                    sign_bit: false,
-                },
-            },
-            StorageSlot {
-                index: BigInt::from(4u64),
-                // bytes32 batcherHash = 0
-                value: BigInt::from(0u64),
-            },
-            StorageSlot {
-                index: BigInt::from(5u64),
-                // uint256 l1FeeOverhead = 0
-                value: BigInt::from(0u64),
-            },
-            StorageSlot {
-                index: BigInt::from(6u64),
-                // uint256 l1FeeScalar = 0
-                value: BigInt::from(0u64),
-            },
-            StorageSlot {
-                index: BigInt::from(7u64),
-                // uint256 blobBaseFee = 10 gwei
-                value: BigInt::from(0x00000002540be400_u64),
-            },
-        ]),
+        code: Some(l1_block_code),
+        storage: Some(l1_block_storage(hardfork.into())),
     };
 
     /* The rest of the predeploys use a stubbed bytecode that reverts with a
@@ -315,6 +257,11 @@ pub fn op_genesis_state(hardfork: OpHardfork) -> Vec<AccountOverride> {
             hex!("4200000000000000000000000000000000000021"),
             "0x60806040526040517f08c379a0000000000000000000000000000000000000000000000000000000008152600401603490607b565b60405180910390fd5b60006048601f836099565b91507f5072656465706c6f7920454153206973206e6f7420737570706f727465642e006000830152602082019050919050565b60006020820190508181036000830152609281603d565b9050919050565b60008282526020820190509291505056fea2646970667358221220afa6c1aa54a8b3f4f979e1297db5838a94353f3b77b5ecc164da19db26ea89f564736f6c63430008000033",
         ),
+        (
+            "OperatorFeeVault",
+            hex!("0x420000000000000000000000000000000000001b"),
+            "0x60806040526040517f08c379a000000000000000000000000000000000000000000000000000000000815260040160349060b9565b60405180910390fd5b5f82825260208201905092915050565b7f5072656465706c6f79204f70657261746f724665655661756c74206973206e6f5f8201527f7420737570706f727465642e0000000000000000000000000000000000000000602082015250565b5f60a5602c83603d565b915060ae82604d565b604082019050919050565b5f6020820190508181035f83015260ce81609b565b905091905056fea2646970667358221220dc3131d0ea77326c36012aee5dd9a870b6f07d76e6f55c8029da9d70a83f50c364736f6c634300081e0033",
+        ),
     ];
 
     let stubbed_predeploys = stubbed_predeploys_data
@@ -402,6 +349,85 @@ fn gas_price_oracle_isthmus() -> AccountOverride {
         }]),
     }
 }
+fn l1_block_storage(hardfork: edr_op::Hardfork) -> Vec<StorageSlot> {
+    let mut base_storage = vec![
+        StorageSlot {
+            index: BigInt::from(0u64),
+            // uint64 public number = 1
+            // uint64 public timestamp = 1
+            value: BigInt {
+                words: vec![
+                    0x0000000000000001_u64, // least significative
+                    0x0000000000000001_u64,
+                ],
+                sign_bit: false,
+            },
+        },
+        StorageSlot {
+            index: BigInt::from(1u64),
+            // uint256 baseFee = 10 gwei
+            value: BigInt::from(0x00000002540be400_u64),
+        },
+        StorageSlot {
+            index: BigInt::from(2u64),
+            // bytes32 hash = 0
+            value: BigInt::from(0u64),
+        },
+        StorageSlot {
+            index: BigInt::from(3u64),
+            // uint64 sequenceNumber = 0
+            // uint32 blobBaseFeeScalar = 1014213
+            // uint32 baseFeeScalar = 5227
+            value: BigInt {
+                words: vec![
+                    0x0000000000000000_u64, // least significative
+                    0x0000000000000000_u64,
+                    0x00000000000f79c5_u64,
+                    0x000000000000146b_u64,
+                ],
+                sign_bit: false,
+            },
+        },
+        StorageSlot {
+            index: BigInt::from(4u64),
+            // bytes32 batcherHash = 0
+            value: BigInt::from(0u64),
+        },
+        StorageSlot {
+            index: BigInt::from(5u64),
+            // uint256 l1FeeOverhead = 0
+            value: BigInt::from(0u64),
+        },
+        StorageSlot {
+            index: BigInt::from(6u64),
+            // uint256 l1FeeScalar = 0
+            value: BigInt::from(0u64),
+        },
+        StorageSlot {
+            index: BigInt::from(7u64),
+            // uint256 blobBaseFee = 10 gwei
+            value: BigInt::from(0x00000002540be400_u64),
+        },
+    ];
+    if hardfork >= edr_op::Hardfork::ISTHMUS {
+        base_storage.push(StorageSlot {
+            // Operator fee parameters
+            index: BigInt::from(8u64),
+            value: BigInt::from(0u64),
+        });
+    }
+    base_storage
+}
+
+fn l1_block_code(hardfork: edr_op::Hardfork) -> Uint8Array {
+    if hardfork >= edr_op::Hardfork::ISTHMUS {
+        l1_block_code_isthmus().into()
+    } else if hardfork >= edr_op::Hardfork::ECOTONE {
+        l1_block_code_ecotone().into()
+    } else {
+        l1_block_code_bedrock().into()
+    }
+}
 
 macro_rules! export_spec_id {
     ($($variant:ident,)*) => {

package/src/config.rs

@@ -242,6 +242,12 @@ pub struct ProviderConfig {
     pub owned_accounts: Vec<JsString>,
     /// Overrides for precompiles
     pub precompile_overrides: Vec<Reference<Precompile>>,
+    /// Transaction gas cap, introduced in [EIP-7825].
+    ///
+    /// When not set, will default to value defined by the used hardfork
+    ///
+    /// [EIP-7825]: https://eips.ethereum.org/EIPS/eip-7825
+    pub transaction_gas_cap: Option<BigInt>,
 }
 
 impl TryFrom<ForkConfig> for edr_provider::ForkConfig<String> {
@@ -339,7 +345,7 @@ impl From<MemPoolConfig> for edr_provider::MemPoolConfig {
     }
 }
 
-impl From<MineOrdering> for edr_runtime::MineOrdering {
+impl From<MineOrdering> for edr_block_miner::MineOrdering {
     fn from(value: MineOrdering) -> Self {
         match value {
             MineOrdering::Fifo => Self::Fifo,
@@ -619,6 +625,10 @@ impl ProviderConfig {
             observability: self.observability.resolve(env, runtime)?,
             owned_accounts,
             precompile_overrides,
+            transaction_gas_cap: self
+                .transaction_gas_cap
+                .map(TryCast::try_cast)
+                .transpose()?,
         })
     }
 }

package/src/mock/time.rs

@@ -2,10 +2,10 @@ use std::sync::Arc;
 
 use edr_chain_spec::ChainSpec;
 use edr_chain_spec_block::BlockChainSpec;
+use edr_chain_spec_rpc::RpcBlockChainSpec;
 use edr_generic::GenericChainSpec;
 use edr_napi_core::logger::Logger;
 use edr_primitives::B256;
-use edr_rpc_spec::RpcBlockChainSpec;
 use napi::{bindgen_prelude::BigInt, tokio::runtime, Env, JsObject};
 use napi_derive::napi;
 

package/src/result.rs

@@ -1,5 +1,5 @@
 use edr_chain_spec::EvmHaltReason;
-use edr_runtime::trace::AfterMessage;
+use edr_tracing::AfterMessage;
 use napi::{
     bindgen_prelude::{BigInt, Either3, Uint8Array},
     Either,
@@ -19,17 +19,17 @@ pub enum SuccessReason {
     SelfDestruct,
 }
 
-impl From<edr_evm_spec::result::SuccessReason> for SuccessReason {
-    fn from(eval: edr_evm_spec::result::SuccessReason) -> Self {
+impl From<edr_chain_spec_evm::result::SuccessReason> for SuccessReason {
+    fn from(eval: edr_chain_spec_evm::result::SuccessReason) -> Self {
         match eval {
-            edr_evm_spec::result::SuccessReason::Stop => Self::Stop,
-            edr_evm_spec::result::SuccessReason::Return => Self::Return,
-            edr_evm_spec::result::SuccessReason::SelfDestruct => Self::SelfDestruct,
+            edr_chain_spec_evm::result::SuccessReason::Stop => Self::Stop,
+            edr_chain_spec_evm::result::SuccessReason::Return => Self::Return,
+            edr_chain_spec_evm::result::SuccessReason::SelfDestruct => Self::SelfDestruct,
         }
     }
 }
 
-impl From<SuccessReason> for edr_evm_spec::result::SuccessReason {
+impl From<SuccessReason> for edr_chain_spec_evm::result::SuccessReason {
     fn from(value: SuccessReason) -> Self {
         match value {
             SuccessReason::Stop => Self::Stop,
@@ -159,7 +159,7 @@ impl From<&AfterMessage<EvmHaltReason>> for ExecutionResult {
         } = value;
 
         let result = match execution_result {
-            edr_evm_spec::result::ExecutionResult::Success {
+            edr_chain_spec_evm::result::ExecutionResult::Success {
                 reason,
                 gas_used,
                 gas_refunded,
@@ -174,12 +174,12 @@ impl From<&AfterMessage<EvmHaltReason>> for ExecutionResult {
                     gas_refunded: BigInt::from(*gas_refunded),
                     logs,
                     output: match output {
-                        edr_evm_spec::result::Output::Call(return_value) => {
+                        edr_chain_spec_evm::result::Output::Call(return_value) => {
                             let return_value = Uint8Array::with_data_copied(return_value);
 
                             Either::A(CallOutput { return_value })
                         }
-                        edr_evm_spec::result::Output::Create(return_value, address) => {
+                        edr_chain_spec_evm::result::Output::Create(return_value, address) => {
                             let return_value = Uint8Array::with_data_copied(return_value);
 
                             Either::B(CreateOutput {
@@ -190,7 +190,7 @@ impl From<&AfterMessage<EvmHaltReason>> for ExecutionResult {
                     },
                 })
             }
-            edr_evm_spec::result::ExecutionResult::Revert { gas_used, output } => {
+            edr_chain_spec_evm::result::ExecutionResult::Revert { gas_used, output } => {
                 let output = Uint8Array::with_data_copied(output);
 
                 Either3::B(RevertResult {
@@ -198,7 +198,7 @@ impl From<&AfterMessage<EvmHaltReason>> for ExecutionResult {
                     output,
                 })
             }
-            edr_evm_spec::result::ExecutionResult::Halt { reason, gas_used } => {
+            edr_chain_spec_evm::result::ExecutionResult::Halt { reason, gas_used } => {
                 Either3::C(HaltResult {
                     reason: ExceptionalHalt::from(reason.clone()),
                     gas_used: BigInt::from(*gas_used),

package/src/trace.rs

@@ -9,7 +9,7 @@ use std::sync::Arc;
 
 use edr_chain_spec::EvmHaltReason;
 use edr_primitives::bytecode::opcode::OpCode;
-use edr_runtime::trace::BeforeMessage;
+use edr_tracing::BeforeMessage;
 use napi::bindgen_prelude::{BigInt, Either3, Uint8Array};
 use napi_derive::napi;
 
@@ -123,7 +123,7 @@ pub struct TracingStep {
 }
 
 impl TracingStep {
-    pub fn new(step: &edr_runtime::trace::Step) -> Self {
+    pub fn new(step: &edr_tracing::Step) -> Self {
         let stack = step.stack.full().map_or_else(
             || {
                 step.stack
@@ -162,11 +162,11 @@ pub struct TracingMessageResult {
 #[napi]
 #[derive(Clone)]
 pub struct RawTrace {
-    inner: Arc<edr_runtime::trace::Trace<EvmHaltReason>>,
+    inner: Arc<edr_tracing::Trace<EvmHaltReason>>,
 }
 
-impl From<Arc<edr_runtime::trace::Trace<EvmHaltReason>>> for RawTrace {
-    fn from(value: Arc<edr_runtime::trace::Trace<EvmHaltReason>>) -> Self {
+impl From<Arc<edr_tracing::Trace<EvmHaltReason>>> for RawTrace {
+    fn from(value: Arc<edr_tracing::Trace<EvmHaltReason>>) -> Self {
         Self { inner: value }
     }
 }
@@ -179,15 +179,13 @@ impl RawTrace {
             .messages
             .iter()
             .map(|message| match message {
-                edr_runtime::trace::TraceMessage::Before(message) => {
+                edr_tracing::TraceMessage::Before(message) => {
                     Either3::A(TracingMessage::from(message))
                 }
-                edr_runtime::trace::TraceMessage::Step(step) => Either3::B(TracingStep::new(step)),
-                edr_runtime::trace::TraceMessage::After(message) => {
-                    Either3::C(TracingMessageResult {
-                        execution_result: ExecutionResult::from(message),
-                    })
-                }
+                edr_tracing::TraceMessage::Step(step) => Either3::B(TracingStep::new(step)),
+                edr_tracing::TraceMessage::After(message) => Either3::C(TracingMessageResult {
+                    execution_result: ExecutionResult::from(message),
+                }),
             })
             .collect()
     }