add partial Amsterdam logic (#43)

jsign · Copilot · web-flow · commit 02da61a0d721 · 2026-04-28T10:44:05.000+08:00
Co-authored-by: Copilot &lt;copilot@github.com&gt;
diff --git a/crates/stateless-validator-common/src/host.rs b/crates/stateless-validator-common/src/host.rs
@@ -9,9 +9,9 @@ use crate::{
     guest::StatelessValidatorOutput,
     new_payload_request::{
         ConsolidationRequest, DepositRequest, ExecutionPayloadV1, ExecutionPayloadV2,
-        ExecutionPayloadV3, ExecutionRequests, Hash32, NewPayloadRequest,
-        NewPayloadRequestBellatrix, NewPayloadRequestCapella, NewPayloadRequestDeneb,
-        NewPayloadRequestElectraFulu, WithdrawalRequest,
+        ExecutionPayloadV3, ExecutionPayloadV4, ExecutionRequests, Hash32, NewPayloadRequest,
+        NewPayloadRequestAmsterdam, NewPayloadRequestBellatrix, NewPayloadRequestCapella,
+        NewPayloadRequestDeneb, NewPayloadRequestElectraFulu, WithdrawalRequest,
     },
 };
 
@@ -66,6 +66,24 @@ impl NewPayloadRequest {
             },
         ))
     }
+
+    /// Constructs a new [`NewPayloadRequest`] for Amsterdam.
+    pub fn new_amsterdam(
+        execution_payload: ExecutionPayloadV4,
+        versioned_hashes: Vec<Hash32>,
+        parent_beacon_block_root: Hash32,
+        execution_requests: &[impl AsRef<[u8]>],
+    ) -> Result<Self> {
+        let versioned_hashes = bounded_list(versioned_hashes, "versioned hashes")?;
+        let execution_requests = decode_execution_requests(execution_requests)
+            .context("Decoding execution requests failed")?;
+        Ok(NewPayloadRequest::Amsterdam(NewPayloadRequestAmsterdam {
+            execution_payload,
+            versioned_hashes,
+            parent_beacon_block_root,
+            execution_requests,
+        }))
+    }
 }
 
 fn bounded_list<T, const N: usize>(values: Vec<T>, label: &str) -> Result<SszList<T, N>> {
diff --git a/crates/stateless-validator-common/src/new_payload_request.rs b/crates/stateless-validator-common/src/new_payload_request.rs
@@ -43,6 +43,7 @@ pub const MAX_WITHDRAWAL_REQUESTS_PER_PAYLOAD: usize = 16;
 pub const MAX_CONSOLIDATION_REQUESTS_PER_PAYLOAD: usize = 2;
 
 /// Composite types
+pub type BlockAccessList = SszList<u8, MAX_BYTES_PER_TRANSACTION>;
 pub type Transaction = SszList<u8, MAX_BYTES_PER_TRANSACTION>;
 pub type Transactions = SszList<Transaction, MAX_TRANSACTIONS_PER_PAYLOAD>;
 pub type Withdrawals = SszList<Withdrawal, MAX_WITHDRAWALS_PER_PAYLOAD>;
@@ -133,6 +134,7 @@ pub enum ForkName {
     Deneb,
     Electra,
     Fulu,
+    Amsterdam,
 }
 
 #[derive(Debug, Clone, HashTreeRoot, SszEncode, SszDecode)]
@@ -236,6 +238,46 @@ pub struct ExecutionPayloadV3 {
     pub excess_blob_gas: u64,
 }
 
+#[derive(Debug, Clone, HashTreeRoot, SszEncode, SszDecode)]
+#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
+#[cfg_attr(
+    feature = "rkyv",
+    derive(rkyv::Archive, rkyv::Serialize, rkyv::Deserialize)
+)]
+pub struct ExecutionPayloadV4 {
+    pub parent_hash: Hash32,
+    pub fee_recipient: Address20,
+    pub state_root: Hash32,
+    pub receipts_root: Hash32,
+    #[cfg_attr(feature = "serde", serde(with = "crate::serde_wrappers::bytes_array"))]
+    pub logs_bloom: LogsBloom,
+    pub prev_randao: Hash32,
+    pub block_number: u64,
+    pub gas_limit: u64,
+    pub gas_used: u64,
+    pub timestamp: u64,
+    #[cfg_attr(feature = "serde", serde(with = "crate::serde_wrappers::ssz_list"))]
+    #[cfg_attr(feature = "rkyv", rkyv(with = crate::rkyv_wrappers::AsSszList))]
+    pub extra_data: ExtraData,
+    pub base_fee_per_gas: Uint256Bytes,
+    pub block_hash: Hash32,
+    #[cfg_attr(
+        feature = "serde",
+        serde(with = "crate::serde_wrappers::nested_ssz_list")
+    )]
+    #[cfg_attr(feature = "rkyv", rkyv(with = crate::rkyv_wrappers::AsNestedSszList))]
+    pub transactions: Transactions,
+    #[cfg_attr(feature = "serde", serde(with = "crate::serde_wrappers::ssz_list"))]
+    #[cfg_attr(feature = "rkyv", rkyv(with = crate::rkyv_wrappers::AsSszList))]
+    pub withdrawals: Withdrawals,
+    pub blob_gas_used: u64,
+    pub excess_blob_gas: u64,
+    #[cfg_attr(feature = "serde", serde(with = "crate::serde_wrappers::ssz_list"))]
+    #[cfg_attr(feature = "rkyv", rkyv(with = crate::rkyv_wrappers::AsSszList))]
+    pub block_access_list: BlockAccessList,
+    pub slot_number: u64,
+}
+
 #[derive(Debug, Clone, HashTreeRoot, SszEncode, SszDecode)]
 #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
 #[cfg_attr(
@@ -285,6 +327,21 @@ pub struct NewPayloadRequestElectraFulu {
     pub execution_requests: ExecutionRequests,
 }
 
+#[derive(Debug, Clone, HashTreeRoot, SszEncode, SszDecode)]
+#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
+#[cfg_attr(
+    feature = "rkyv",
+    derive(rkyv::Archive, rkyv::Serialize, rkyv::Deserialize)
+)]
+pub struct NewPayloadRequestAmsterdam {
+    pub execution_payload: ExecutionPayloadV4,
+    #[cfg_attr(feature = "serde", serde(with = "crate::serde_wrappers::ssz_list"))]
+    #[cfg_attr(feature = "rkyv", rkyv(with = crate::rkyv_wrappers::AsSszList))]
+    pub versioned_hashes: VersionedHashes,
+    pub parent_beacon_block_root: Hash32,
+    pub execution_requests: ExecutionRequests,
+}
+
 #[derive(Debug, Clone)]
 #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
 #[cfg_attr(
@@ -296,6 +353,7 @@ pub enum NewPayloadRequest {
     Capella(NewPayloadRequestCapella),
     Deneb(NewPayloadRequestDeneb),
     ElectraFulu(NewPayloadRequestElectraFulu),
+    Amsterdam(NewPayloadRequestAmsterdam),
 }
 
 impl NewPayloadRequest {
@@ -305,6 +363,7 @@ impl NewPayloadRequest {
             NewPayloadRequest::Capella(req) => req.hash_tree_root(hasher),
             NewPayloadRequest::Deneb(req) => req.hash_tree_root(hasher),
             NewPayloadRequest::ElectraFulu(req) => req.hash_tree_root(hasher),
+            NewPayloadRequest::Amsterdam(req) => req.hash_tree_root(hasher),
         }
     }
 }
diff --git a/crates/stateless-validator-ethrex/src/host.rs b/crates/stateless-validator-ethrex/src/host.rs
@@ -122,7 +122,7 @@ fn from_reth_witness_to_ethrex_witness(
         bpo3_time: stateless_input.chain_config.bpo3_time,
         bpo4_time: stateless_input.chain_config.bpo4_time,
         bpo5_time: stateless_input.chain_config.bpo5_time,
-        amsterdam_time: None,
+        amsterdam_time: stateless_input.chain_config.amsterdam_time,
         enable_verkle_at_genesis: false,
     };
 
diff --git a/crates/stateless-validator-reth/src/host.rs b/crates/stateless-validator-reth/src/host.rs
@@ -4,7 +4,7 @@ use alloc::{format, vec::Vec};
 use std::sync::Arc;
 
 use alloy_consensus::Transaction;
-use alloy_eips::{Encodable2718, eip7685::Requests};
+use alloy_eips::{Encodable2718, eip7685::Requests, eip7928::BlockAccessList};
 use alloy_genesis::{ChainConfig, Genesis};
 use alloy_primitives::U256;
 use anyhow::Context;
@@ -17,8 +17,8 @@ pub use stateless::StatelessInput;
 use stateless::{UncompressedPublicKey, stateless_validation_with_trie};
 pub use stateless_validator_common::guest::StatelessValidatorOutput;
 use stateless_validator_common::new_payload_request::{
-    ExecutionPayloadV1, ExecutionPayloadV2, ExecutionPayloadV3, ExtraData, ForkName,
-    NewPayloadRequest, Transaction as Tx, Transactions, Withdrawal, Withdrawals,
+    ExecutionPayloadV1, ExecutionPayloadV2, ExecutionPayloadV3, ExecutionPayloadV4, ExtraData,
+    ForkName, NewPayloadRequest, Transaction as Tx, Transactions, Withdrawal, Withdrawals,
 };
 use tries::zeth::SparseState;
 
@@ -67,6 +67,12 @@ where
 /// Determines the fork name based on alloy chain config and block timestamp.
 pub fn determine_fork_name(chain_config: &ChainConfig, timestamp: u64) -> ForkName {
     // Check forks in reverse chronological order
+    if chain_config
+        .amsterdam_time
+        .is_some_and(|amsterdam_time| timestamp >= amsterdam_time)
+    {
+        return ForkName::Amsterdam;
+    }
     if chain_config
         .osaka_time
         .is_some_and(|osaka_time| timestamp >= osaka_time)
@@ -95,7 +101,7 @@ pub fn determine_fork_name(chain_config: &ChainConfig, timestamp: u64) -> ForkNa
 }
 
 /// Converts a [`StatelessInput`] to a [`NewPayloadRequest`].
-pub fn to_new_payload_request(
+fn to_new_payload_request(
     stateless_input: &StatelessInput,
     requests: Requests,
 ) -> anyhow::Result<NewPayloadRequest> {
@@ -272,6 +278,60 @@ pub fn to_new_payload_request(
                 &requests,
             )
         }
+        ForkName::Amsterdam => {
+            let withdrawals = build_withdrawals()?;
+            // TODO(Amsterdam): use actual BAL that should be received from parameter.
+            let block_access_list = Tx::try_from(alloy_rlp::encode(BlockAccessList::default()))
+                .map_err(|err| {
+                    anyhow::anyhow!(
+                        "default block access list length should be within bounds: {err:?}"
+                    )
+                })?;
+            let slot_number = header.slot_number.unwrap_or_default();
+
+            let payload = ExecutionPayloadV4 {
+                parent_hash: header.parent_hash.0,
+                fee_recipient: header.beneficiary.0.0,
+                state_root: header.state_root.0,
+                receipts_root: header.receipts_root.0,
+                logs_bloom,
+                prev_randao: header.mix_hash.0,
+                block_number: header.number,
+                gas_limit: header.gas_limit,
+                gas_used: header.gas_used,
+                timestamp: header.timestamp,
+                extra_data,
+                base_fee_per_gas: U256::from(header.base_fee_per_gas.unwrap_or_default())
+                    .to_le_bytes(),
+                block_hash: stateless_input.block.hash_slow().0,
+                transactions,
+                withdrawals,
+                blob_gas_used: header.blob_gas_used.unwrap_or_default(),
+                excess_blob_gas: header.excess_blob_gas.unwrap_or_default(),
+                block_access_list,
+                slot_number,
+            };
+
+            let versioned_hashes: Vec<[u8; 32]> = body
+                .transactions()
+                .filter_map(|tx| tx.blob_versioned_hashes())
+                .flatten()
+                .map(|h| h.0)
+                .collect();
+
+            let parent_beacon_block_root = stateless_input
+                .block
+                .parent_beacon_block_root
+                .unwrap_or_default()
+                .0;
+
+            NewPayloadRequest::new_amsterdam(
+                payload,
+                versioned_hashes,
+                parent_beacon_block_root,
+                &requests,
+            )
+        }
     }
 }
 
diff --git a/crates/stateless-validator-reth/src/new_payload_request.rs b/crates/stateless-validator-reth/src/new_payload_request.rs
@@ -9,15 +9,15 @@ use alloy_rpc_types_engine::{
     CancunPayloadFields, ExecutionData, ExecutionPayload as AlloyExecutionPayload,
     ExecutionPayloadSidecar, ExecutionPayloadV1 as AlloyExecutionPayloadV1,
     ExecutionPayloadV2 as AlloyExecutionPayloadV2, ExecutionPayloadV3 as AlloyExecutionPayloadV3,
-    PayloadError,
+    ExecutionPayloadV4 as AlloyExecutionPayloadV4, PayloadError,
 };
 use anyhow::{Context, Result};
 use reth_chainspec::{ChainSpec, EthereumHardforks};
 use reth_payload_validator::{cancun, prague, shanghai};
 use reth_primitives_traits::{Block as _, SealedBlock, SignedTransaction};
 use stateless_validator_common::new_payload_request::{
-    ExecutionPayloadV1, ExecutionPayloadV2, ExecutionPayloadV3, NativeSha256Hasher,
-    NewPayloadRequest, Withdrawal, compute_requests_hash,
+    ExecutionPayloadV1, ExecutionPayloadV2, ExecutionPayloadV3, ExecutionPayloadV4,
+    NativeSha256Hasher, NewPayloadRequest, Withdrawal, compute_requests_hash,
 };
 
 /// Converts a [`NewPayloadRequest`] into a validated reth [`Block`].
@@ -78,6 +78,8 @@ where
         chain_spec.is_prague_active_at_timestamp(sealed_block.timestamp),
     )?;
 
+    // TODO(Amsterdam): Add Amsterdam-specific validation.
+
     Ok(sealed_block)
 }
 
@@ -151,6 +153,42 @@ fn new_payload_request_to_execution_data(req: NewPayloadRequest) -> ExecutionDat
 
             ExecutionData::new(AlloyExecutionPayload::V3(v3), sidecar)
         }
+        NewPayloadRequest::Amsterdam(a) => {
+            let execution_payload = a.execution_payload;
+            let blob_gas_used = execution_payload.blob_gas_used;
+            let excess_blob_gas = execution_payload.excess_blob_gas;
+            let slot_number = execution_payload.slot_number;
+            let block_access_list =
+                Bytes::from(execution_payload.block_access_list.clone().into_inner());
+            let (v1, withdrawals) = convert_v2_to_alloy_from_v4(execution_payload);
+            let v4 = AlloyExecutionPayloadV4 {
+                payload_inner: AlloyExecutionPayloadV3 {
+                    payload_inner: AlloyExecutionPayloadV2 {
+                        payload_inner: v1,
+                        withdrawals,
+                    },
+                    blob_gas_used,
+                    excess_blob_gas,
+                },
+                block_access_list,
+                slot_number,
+            };
+
+            let versioned_hashes: Vec<B256> =
+                a.versioned_hashes.into_iter().map(B256::from).collect();
+            let parent_beacon_block_root = B256::from(a.parent_beacon_block_root);
+            let cancun_fields =
+                CancunPayloadFields::new(parent_beacon_block_root, versioned_hashes);
+
+            let requests_hash = B256::from(compute_requests_hash(
+                &a.execution_requests,
+                &NativeSha256Hasher,
+            ));
+            let prague_fields = alloy_rpc_types_engine::PraguePayloadFields::new(requests_hash);
+            let sidecar = ExecutionPayloadSidecar::v4(cancun_fields, prague_fields);
+
+            ExecutionData::new(AlloyExecutionPayload::V4(v4), sidecar)
+        }
     }
 }
 
@@ -243,6 +281,39 @@ fn convert_v2_to_alloy_from_v3(
     (v1, withdrawals)
 }
 
+fn convert_v2_to_alloy_from_v4(
+    payload: ExecutionPayloadV4,
+) -> (AlloyExecutionPayloadV1, Vec<AlloyWithdrawal>) {
+    let v1 = AlloyExecutionPayloadV1 {
+        parent_hash: B256::from(payload.parent_hash),
+        fee_recipient: Address::from(payload.fee_recipient),
+        state_root: B256::from(payload.state_root),
+        receipts_root: B256::from(payload.receipts_root),
+        logs_bloom: Bloom::from_slice(&payload.logs_bloom[..]),
+        prev_randao: B256::from(payload.prev_randao),
+        block_number: payload.block_number,
+        gas_limit: payload.gas_limit,
+        gas_used: payload.gas_used,
+        timestamp: payload.timestamp,
+        extra_data: Bytes::from(payload.extra_data.into_inner()),
+        base_fee_per_gas: U256::from_le_bytes(payload.base_fee_per_gas),
+        block_hash: B256::from(payload.block_hash),
+        transactions: payload
+            .transactions
+            .into_iter()
+            .map(|tx| Bytes::from(tx.into_inner()))
+            .collect(),
+    };
+
+    let withdrawals = payload
+        .withdrawals
+        .into_iter()
+        .map(convert_withdrawal)
+        .collect();
+
+    (v1, withdrawals)
+}
+
 fn convert_withdrawal(w: Withdrawal) -> AlloyWithdrawal {
     AlloyWithdrawal {
         index: w.index,
