feat(l1): implement engine_NewPayloadV4 (#2016)

**Motivation**

Implements endpoint `engine_newPayloadV4`. The endpoint was tested by
running the `eest` simulator.

**Description**

- Performs validation on the received `Requests` following:
https://github.com/ethereum/execution-apis/blob/c710097abda52b5a190d831eb8b1eddd3d28c603/src/engine/prague.md?plain=1#L50
- Computes the hash of the received `Requests` and adds it to the block
header for validation.
- Modifies `GenesisAccounts` to use `U256` as storage keys to be able to
parse the genesis of the `eest` simulator.
- Removes the `requests_hash` from the `Payload` structure since it is
not a payload field.

> [!NOTE]
> The `eest` suite was not added to the CI because some tests (unrelated
to this implementation) are still failing.

Author: avilagaston9

cmd/ef_tests/blockchain/types.rs

@@ -471,11 +471,7 @@ impl From<Account> for GenesisAccount {
     fn from(val: Account) -> Self {
         GenesisAccount {
             code: val.code,
-            storage: val
-                .storage
-                .into_iter()
-                .map(|(k, v)| (H256(k.to_big_endian()), v))
-                .collect(),
+            storage: val.storage,
             balance: val.balance,
             nonce: val.nonce.as_u64(),
         }

cmd/ef_tests/state/types.rs

@@ -203,11 +203,7 @@ impl From<&EFTestPreValue> for GenesisAccount {
     fn from(value: &EFTestPreValue) -> Self {
         Self {
             code: value.code.clone(),
-            storage: value
-                .storage
-                .iter()
-                .map(|(k, v)| (H256::from_slice(&k.to_big_endian()), *v))
-                .collect(),
+            storage: value.storage.clone(),
             balance: value.balance,
             nonce: value.nonce.as_u64(),
         }

crates/blockchain/blockchain.rs

@@ -7,12 +7,11 @@ mod smoke_test;
 
 use error::{ChainError, InvalidBlockError};
 use ethrex_common::constants::GAS_PER_BLOB;
-use ethrex_common::types::requests::Requests;
+use ethrex_common::types::requests::{compute_requests_hash, EncodedRequests, Requests};
 use ethrex_common::types::{
-    compute_receipts_root, compute_requests_hash, validate_block_header,
-    validate_cancun_header_fields, validate_prague_header_fields,
-    validate_pre_cancun_header_fields, Block, BlockHash, BlockHeader, BlockNumber, ChainConfig,
-    EIP4844Transaction, Receipt, Transaction,
+    compute_receipts_root, validate_block_header, validate_cancun_header_fields,
+    validate_prague_header_fields, validate_pre_cancun_header_fields, Block, BlockHash,
+    BlockHeader, BlockNumber, ChainConfig, EIP4844Transaction, Receipt, Transaction,
 };
 use ethrex_common::H256;
 
@@ -82,7 +81,8 @@ pub fn validate_requests_hash(
         return Ok(());
     }
 
-    let computed_requests_hash = compute_requests_hash(requests);
+    let encoded_requests: Vec<EncodedRequests> = requests.iter().map(|r| r.encode()).collect();
+    let computed_requests_hash = compute_requests_hash(&encoded_requests);
     let valid = header
         .requests_hash
         .map(|requests_hash| requests_hash == computed_requests_hash)

crates/blockchain/payload.rs

@@ -7,9 +7,10 @@ use ethrex_common::{
     constants::GAS_PER_BLOB,
     types::{
         calculate_base_fee_per_blob_gas, calculate_base_fee_per_gas, compute_receipts_root,
-        compute_requests_hash, compute_transactions_root, compute_withdrawals_root,
-        requests::Requests, BlobsBundle, Block, BlockBody, BlockHash, BlockHeader, BlockNumber,
-        ChainConfig, MempoolTransaction, Receipt, Transaction, Withdrawal, DEFAULT_OMMERS_HASH,
+        compute_transactions_root, compute_withdrawals_root,
+        requests::{compute_requests_hash, EncodedRequests, Requests},
+        BlobsBundle, Block, BlockBody, BlockHash, BlockHeader, BlockNumber, ChainConfig,
+        MempoolTransaction, Receipt, Transaction, Withdrawal, DEFAULT_OMMERS_HASH,
         DEFAULT_REQUESTS_HASH,
     },
     Address, Bloom, Bytes, H256, U256,
@@ -178,6 +179,7 @@ pub struct PayloadBuildContext<'a> {
     pub remaining_gas: u64,
     pub receipts: Vec<Receipt>,
     pub requests: Vec<Requests>,
+    pub requests_hash: Option<H256>,
     pub block_value: U256,
     base_fee_per_blob_gas: U256,
     pub blobs_bundle: BlobsBundle,
@@ -198,6 +200,7 @@ impl<'a> PayloadBuildContext<'a> {
             remaining_gas: payload.header.gas_limit,
             receipts: vec![],
             requests: vec![],
+            requests_hash: None,
             block_value: U256::zero(),
             base_fee_per_blob_gas: U256::from(base_fee_per_blob_gas),
             payload,
@@ -491,13 +494,23 @@ fn apply_plain_transaction(
 }
 
 pub fn extract_requests(context: &mut PayloadBuildContext) -> Result<(), EvmError> {
+    if !context
+        .chain_config()?
+        .is_prague_activated(context.payload.header.timestamp)
+    {
+        return Ok(());
+    };
+
     let requests = get_evm_backend_or_default().extract_requests(
         &context.receipts,
         context.evm_state,
         &context.payload.header,
         &mut context.block_cache,
     );
     context.requests = requests?;
+    let encoded_requests: Vec<EncodedRequests> =
+        context.requests.iter().map(|r| r.encode()).collect();
+    context.requests_hash = Some(compute_requests_hash(&encoded_requests));
 
     Ok(())
 }
@@ -517,10 +530,7 @@ fn finalize_payload(context: &mut PayloadBuildContext) -> Result<(), ChainError>
     context.payload.header.transactions_root =
         compute_transactions_root(&context.payload.body.transactions);
     context.payload.header.receipts_root = compute_receipts_root(&context.receipts);
-    context.payload.header.requests_hash = context
-        .chain_config()?
-        .is_prague_activated(context.payload.header.timestamp)
-        .then_some(compute_requests_hash(&context.requests));
+    context.payload.header.requests_hash = context.requests_hash;
     context.payload.header.gas_used = context.payload.header.gas_limit - context.remaining_gas;
     Ok(())
 }

crates/common/types/account.rs

@@ -82,7 +82,11 @@ impl From<GenesisAccount> for Account {
                 nonce: genesis.nonce,
             },
             code: genesis.code,
-            storage: genesis.storage,
+            storage: genesis
+                .storage
+                .iter()
+                .map(|(k, v)| (H256(k.to_big_endian()), *v))
+                .collect(),
         }
     }
 }
@@ -144,9 +148,12 @@ impl RLPDecode for AccountState {
     }
 }
 
-pub fn compute_storage_root(storage: &HashMap<H256, U256>) -> H256 {
+pub fn compute_storage_root(storage: &HashMap<U256, U256>) -> H256 {
     let iter = storage.iter().filter_map(|(k, v)| {
-        (!v.is_zero()).then_some((Keccak256::digest(k).to_vec(), v.encode_to_vec()))
+        (!v.is_zero()).then_some((
+            Keccak256::digest(k.to_big_endian()).to_vec(),
+            v.encode_to_vec(),
+        ))
     });
     Trie::compute_hash_from_unsorted_iter(iter)
 }

crates/common/types/block.rs

@@ -4,7 +4,7 @@ use super::{
 };
 use crate::{
     constants::MIN_BASE_FEE_PER_BLOB_GAS,
-    types::{requests::Requests, Receipt, Transaction},
+    types::{Receipt, Transaction},
     Address, H256, U256,
 };
 use bytes::Bytes;
@@ -16,7 +16,6 @@ use ethrex_rlp::{
     structs::{Decoder, Encoder},
 };
 use ethrex_trie::Trie;
-use k256::sha2::{Digest, Sha256};
 use keccak_hash::keccak;
 use serde::{Deserialize, Serialize};
 
@@ -262,18 +261,6 @@ pub fn compute_withdrawals_root(withdrawals: &[Withdrawal]) -> H256 {
     Trie::compute_hash_from_unsorted_iter(iter)
 }
 
-// See https://github.com/ethereum/EIPs/blob/2a6b6965e64787815f7fffb9a4c27660d9683846/EIPS/eip-7685.md?plain=1#L62.
-pub fn compute_requests_hash(requests: &[Requests]) -> H256 {
-    let mut hasher = Sha256::new();
-    for request in requests {
-        let request_bytes = request.to_bytes();
-        if request_bytes.len() > 1 {
-            hasher.update(Sha256::digest(request_bytes));
-        }
-    }
-    H256::from_slice(&hasher.finalize())
-}
-
 impl RLPEncode for BlockBody {
     fn encode(&self, buf: &mut dyn bytes::BufMut) {
         Encoder::new(buf)

crates/common/types/genesis.rs

@@ -296,7 +296,7 @@ pub struct GenesisAccount {
     #[serde(default, with = "crate::serde_utils::bytes")]
     pub code: Bytes,
     #[serde(default)]
-    pub storage: HashMap<H256, U256>,
+    pub storage: HashMap<U256, U256>,
     #[serde(deserialize_with = "crate::serde_utils::u256::deser_hex_or_dec_str")]
     pub balance: U256,
     #[serde(default, with = "crate::serde_utils::u64::hex_str")]
@@ -450,7 +450,7 @@ mod tests {
         let addr_b_storage = &genesis.alloc[&addr_b].storage;
         assert_eq!(
             addr_b_storage.get(
-                &H256::from_str(
+                &U256::from_str(
                     "0x0000000000000000000000000000000000000000000000000000000000000022"
                 )
                 .unwrap()
@@ -464,7 +464,7 @@ mod tests {
         );
         assert_eq!(
             addr_b_storage.get(
-                &H256::from_str(
+                &U256::from_str(
                     "0x0000000000000000000000000000000000000000000000000000000000000038"
                 )
                 .unwrap()

crates/common/types/requests.rs

@@ -1,6 +1,13 @@
+use bytes::Bytes;
 use ethereum_types::Address;
+use k256::sha2::Sha256;
+use keccak_hash::H256;
+use serde::{Deserialize, Serialize};
+use sha3::Digest;
 use tracing::error;
 
+use crate::serde_utils;
+
 use super::{Bytes48, Receipt};
 
 pub type Bytes32 = [u8; 32];
@@ -9,15 +16,38 @@ const DEPOSIT_TYPE: u8 = 0x00;
 const WITHDRAWAL_TYPE: u8 = 0x01;
 const CONSOLIDATION_TYPE: u8 = 0x02;
 
+#[derive(Clone, Debug)]
+pub struct EncodedRequests(pub Bytes);
+
+impl<'de> Deserialize<'de> for EncodedRequests {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        Ok(EncodedRequests(serde_utils::bytes::deserialize(
+            deserializer,
+        )?))
+    }
+}
+
+impl Serialize for EncodedRequests {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        serde_utils::bytes::serialize(&self.0, serializer)
+    }
+}
+
 pub enum Requests {
     Deposit(Vec<Deposit>),
     Withdrawal(Vec<u8>),
     Consolidation(Vec<u8>),
 }
 
 impl Requests {
-    pub fn to_bytes(&self) -> Vec<u8> {
-        match self {
+    pub fn encode(&self) -> EncodedRequests {
+        let bytes: Vec<u8> = match self {
             Requests::Deposit(deposits) => {
                 let deposit_data = deposits.iter().flat_map(|d| d.to_summarized_byte_array());
                 std::iter::once(DEPOSIT_TYPE).chain(deposit_data).collect()
@@ -28,8 +58,11 @@ impl Requests {
             Requests::Consolidation(data) => std::iter::once(CONSOLIDATION_TYPE)
                 .chain(data.iter().cloned())
                 .collect(),
-        }
+        };
+
+        EncodedRequests(Bytes::from(bytes))
     }
+
     pub fn from_deposit_receipts(
         deposit_contract_address: Address,
         receipts: &[Receipt],
@@ -131,3 +164,15 @@ fn fixed_bytes<const N: usize>(data: &[u8], offset: usize) -> [u8; N] {
         .try_into()
         .expect("Couldn't convert to fixed bytes")
 }
+
+// See https://github.com/ethereum/EIPs/blob/2a6b6965e64787815f7fffb9a4c27660d9683846/EIPS/eip-7685.md?plain=1#L62.
+pub fn compute_requests_hash(requests: &[EncodedRequests]) -> H256 {
+    let mut hasher = Sha256::new();
+    for request in requests {
+        let request_bytes = request.0.as_ref();
+        if request_bytes.len() > 1 {
+            hasher.update(Sha256::digest(request_bytes));
+        }
+    }
+    H256::from_slice(&hasher.finalize())
+}