Merge branch 'main' into advise-random

Author: MegaRedHand

.github/workflows/main_prover.yaml

@@ -99,6 +99,7 @@ jobs:
           ETHREX_PROPOSER_BLOCK_TIME=12000 \
           ETHREX_COMMITTER_COMMIT_TIME=30000 \
           ETHREX_WATCHER_WATCH_INTERVAL=1000 \
+          ETHREX_COMMITTER_FIRST_WAKE_UP_TIME=60000 \
           ETHREX_BLOCK_PRODUCER_BASE_FEE_VAULT_ADDRESS=0x000c0d6b7c4516a5b274c51ea331a9410fe69127 \
           ETHREX_BLOCK_PRODUCER_OPERATOR_FEE_VAULT_ADDRESS=0xd5d2a85751b6F158e5b9B8cD509206A865672362 \
           ETHREX_BLOCK_PRODUCER_OPERATOR_FEE_PER_GAS=1000000000 \

.github/workflows/tag_release.yaml

@@ -293,6 +293,9 @@ jobs:
       - name: Checkout code
         uses: actions/checkout@v4
 
+      - name: Free Disk Space
+        uses: ./.github/actions/free-disk
+
       - name: Format name
         run: |
           # For branch builds (main) we want docker images tagged as 'main'. For tag pushes

CHANGELOG.md

@@ -4,6 +4,7 @@
 
 ### 2025-11-13
 
+- Use specialized DUP implementation [#5324](https://github.com/lambdaclass/ethrex/pull/5324)
 - Avoid recalculating blob base fee while preparing transactions [#5328](https://github.com/lambdaclass/ethrex/pull/5328)
 - Use BlobDB for account_codes column family [#5300](https://github.com/lambdaclass/ethrex/pull/5300)
 

README.md

@@ -16,10 +16,8 @@ For instructions on how to get started using ethrex L1 and/or L2, please refer t
 
 This client supports running in two different modes:
 
-- As a regular Ethereum execution client
-- As a multi-prover ZK-Rollup (supporting SP1, RISC Zero and TEEs), where block execution is proven and the proof sent to an L1 network for verification, thus inheriting the L1's security. Support for based sequencing is currently in the works.
-
-We call the first one ethrex L1 and the second one ethrex L2.
+* **ethrex L1** - As a regular Ethereum execution client
+* **ethrex L2** - As a multi-prover ZK-Rollup (supporting SP1, RISC Zero and TEEs), where block execution is proven and the proof sent to an L1 network for verification, thus inheriting the L1's security. Support for based sequencing is currently in the works.
 
 ## Philosophy
 

crates/common/types/tx_fields.rs

@@ -36,6 +36,10 @@ pub struct AuthorizationTuple {
     pub chain_id: U256,
     #[rkyv(with = crate::rkyv_utils::H160Wrapper)]
     pub address: Address,
+    #[serde(
+        default,
+        deserialize_with = "crate::serde_utils::u64::deser_hex_or_dec_str"
+    )]
     pub nonce: u64,
     #[rkyv(with = crate::rkyv_utils::U256Wrapper)]
     pub y_parity: U256,

crates/vm/levm/src/call_frame.rs

@@ -11,6 +11,9 @@ use ethrex_common::{Address, U256};
 use ethrex_common::{H256, types::Code};
 use std::{collections::HashMap, fmt};
 
+/// [`u64`]s that make up a [`U256`]
+const U64_PER_U256: usize = U256::MAX.0.len();
+
 #[derive(Clone, PartialEq, Eq)]
 /// The EVM uses a stack-based architecture and does not use registers like some other VMs.
 ///
@@ -85,7 +88,7 @@ impl Stack {
             std::ptr::copy_nonoverlapping(
                 value.0.as_ptr(),
                 self.values.get_unchecked_mut(next_offset).0.as_mut_ptr(),
-                4,
+                U64_PER_U256,
             );
         }
         self.offset = next_offset;
@@ -111,7 +114,7 @@ impl Stack {
                 .get_unchecked_mut(next_offset)
                 .0
                 .as_mut_ptr()
-                .cast() = [0u64; 4];
+                .cast() = [0u64; U64_PER_U256];
         }
         self.offset = next_offset;
 
@@ -131,18 +134,6 @@ impl Stack {
         self.offset == self.values.len()
     }
 
-    pub fn get(&self, index: usize) -> Result<&U256, ExceptionalHalt> {
-        // The following index cannot fail because `self.offset` is known to be within
-        // `STACK_LIMIT`.
-        #[expect(unsafe_code)]
-        unsafe {
-            self.values
-                .get_unchecked(self.offset..)
-                .get(index)
-                .ok_or(ExceptionalHalt::StackUnderflow)
-        }
-    }
-
     #[inline(always)]
     pub fn swap<const N: usize>(&mut self) -> Result<(), ExceptionalHalt> {
         // Compile-time check that ensures `self.offset + N` is safe,
@@ -164,6 +155,36 @@ impl Stack {
     pub fn clear(&mut self) {
         self.offset = STACK_LIMIT;
     }
+
+    /// Pushes a copy of the value at depth N
+    #[inline]
+    pub fn dup<const N: usize>(&mut self) -> Result<(), ExceptionalHalt> {
+        // Compile-time check that ensures `self.offset + N` is safe,
+        // since self.offset is bounded by STACK_LIMIT
+        const {
+            assert!(STACK_LIMIT.checked_add(N).is_some());
+        }
+        #[expect(clippy::arithmetic_side_effects)]
+        let index = self.offset + N;
+        if index >= self.values.len() {
+            return Err(ExceptionalHalt::StackUnderflow);
+        }
+
+        self.offset = self
+            .offset
+            .checked_sub(1)
+            .ok_or(ExceptionalHalt::StackOverflow)?;
+
+        #[expect(unsafe_code, reason = "index < size, offset-1 >= 0")]
+        unsafe {
+            std::ptr::copy_nonoverlapping(
+                self.values.get_unchecked_mut(index).0.as_mut_ptr(),
+                self.values.get_unchecked_mut(self.offset).0.as_mut_ptr(),
+                U64_PER_U256,
+            );
+        }
+        Ok(())
+    }
 }
 
 impl Default for Stack {

crates/vm/levm/src/opcode_handlers/dup.rs

@@ -10,15 +10,12 @@ use crate::{
 impl<'a> VM<'a> {
     // DUP operation
     pub fn op_dup<const N: usize>(&mut self) -> Result<OpcodeResult, VMError> {
-        let current_call_frame = &mut self.current_call_frame;
         // Increase the consumed gas
-        current_call_frame.increase_consumed_gas(gas_cost::DUPN)?;
+        self.current_call_frame
+            .increase_consumed_gas(gas_cost::DUPN)?;
 
-        // Get the value at the specified depth
-        let value_at_depth = *current_call_frame.stack.get(N)?;
-
-        // Push the duplicated value onto the stack
-        current_call_frame.stack.push(value_at_depth)?;
+        // Duplicate the value at the specified depth
+        self.current_call_frame.stack.dup::<N>()?;
 
         Ok(OpcodeResult::Continue)
     }

docs/SUMMARY.md

@@ -3,7 +3,7 @@
 # Introduction
 
 - [Getting started](./getting-started/README.md)
-  - [Hardware requirements]()
+  - [Hardware requirements](./getting-started/hardware_requirements.md)
   - [Installation](./getting-started/installation/README.md)
     - [Binary distribution](./getting-started/installation/binary_distribution.md)
     - [Package manager](./getting-started/installation/package_manager.md)

docs/getting-started/README.md

@@ -3,10 +3,8 @@
 Ethrex is a minimalist, stable, modular and fast implementation of the Ethereum protocol in [Rust](https://www.rust-lang.org/).
 The client supports running in two different modes:
 
-- As a regular Ethereum execution client
-- As a multi-prover ZK-Rollup (supporting SP1, RISC Zero and TEEs), where block execution is proven and the proof sent to an L1 network for verification, thus inheriting the L1's security. Support for based sequencing is currently in the works.
-
-We call the first one "ethrex L1" and the second one "ethrex L2".
+* **ethrex L1** - As a regular Ethereum execution client
+* **ethrex L2** - As a multi-prover ZK-Rollup (supporting SP1, RISC Zero and TEEs), where block execution is proven and the proof sent to an L1 network for verification, thus inheriting the L1's security. Support for based sequencing is currently in the works.
 
 ## Quickstart L1
 
@@ -17,14 +15,14 @@ Follow these steps to sync an ethrex node on the Hoodi testnet.
 Install ethrex and lighthouse:
 
 ```sh
-# install lightouse and ethrex
-brew install lambdaclass/tap/ethrex
-brew install lighthouse
-
 # create secrets directory and jwt secret
 mkdir -p ethereum/secrets/
 cd ethereum/
 openssl rand -hex 32 | tr -d "\n" | tee ./secrets/jwt.hex
+
+# install lightouse and ethrex
+brew install lambdaclass/tap/ethrex
+brew install lighthouse
 ```
 
 On one terminal:
@@ -43,6 +41,9 @@ lighthouse bn --network hoodi --execution-endpoint http://localhost:8551 --execu
 
 Install ethrex and lighthouse:
 
+> [!NOTE]
+> Go to https://github.com/sigp/lighthouse/releases/ and use the latest package there and replace that in the below commands
+
 ```sh
 # create secrets directory and jwt secret
 mkdir -p ethereum/secrets/
@@ -52,10 +53,11 @@ openssl rand -hex 32 | tr -d "\n" | tee ./secrets/jwt.hex
 # install lightouse and ethrex
 curl -L https://github.com/lambdaclass/ethrex/releases/latest/download/ethrex-linux-x86_64 -o ethrex
 chmod +x ethrex
-curl -LO https://github.com/sigp/lighthouse/releases/download/v7.1.0/lighthouse-v7.1.0-x86_64-unknown-linux-gnu.tar.gz
-tar -xvf lighthouse-v7.1.0-x86_64-unknown-linux-gnu.tar.gz
+curl -LO https://github.com/sigp/lighthouse/releases/download/v8.0.0/lighthouse-v8.0.0-x86_64-unknown-linux-gnu.tar.gz
+tar -xvf lighthouse-v8.0.0-x86_64-unknown-linux-gnu.tar.gz
 ```
 
+
 On one terminal:
 
 ```sh

docs/getting-started/hardware_requirements.md

@@ -0,0 +1,34 @@
+# Hardware Requirements
+
+> NOTE: The guidance in this document applies to running an L1 (Ethereum) node. L2 deployments (sequencers, provers and related infra) have different hardware profiles and operational requirements — see the "L2" section below for details.
+
+Hardware requirements depend primarily on the **network** you’re running — for example, **Hoodi**, **Sepolia**, or **Mainnet**.
+
+## General Recommendations
+
+Across all networks, the following apply:
+
+- **Disk Type:** Use **high-performance NVMe SSDs**. For multi-disk setups, **software RAID 0** is recommended to maximize speed and capacity. **Avoid hardware RAID**, which can limit NVMe performance.
+- **RAM:** Sufficient memory minimizes sync bottlenecks and improves stability under load.
+- **CPU:** 4-8 Cores. 
+  - x86-64 bit Processors must be compatible with the instruction set AVX2.
+
+
+---
+
+## Disk and Memory Requirements by Network
+
+
+
+| Network | Disk (Minimum) | Disk (Recommended) | RAM (Minimum) | RAM (Recommended) |
+|------|------------------|--------------------|----------------|-------------------|
+| **Ethereum Mainnet** | 500 GB | 1 TB | 32 GB | 64 GB |
+| **Ethereum Sepolia** | 200 GB | 400 GB| 32 GB | 64 GB |
+| **Ethereum Hoodi** | 50 GB | 100 GB | 32 GB | 64 GB |
+
+---
+
+## L2
+
+TBD
+