feat(l1): implement EIP-7843 (Amsterdam) (#5973)

**Motivation**

This PR implement [EIP-7843](https://eips.ethereum.org/EIPS/eip-7843).

**Description**

This PR implements the `SLOTNUM` opcode.

<!-- Link to issues: Resolves #111, Resolves #222 -->

**Checklist**

- [ ] Updated `STORE_SCHEMA_VERSION` (crates/storage/lib.rs) if the PR
includes breaking changes to the `Store` requiring a re-sync.

---------

Co-authored-by: Edgar <git@edgl.dev>

Author: azteca1998

benches/benches/build_block_benchmark.rs

@@ -146,6 +146,7 @@ fn create_payload_block(genesis_block: &Block, store: &Store) -> (Block, u64) {
         random: genesis_block.header.prev_randao,
         withdrawals: None,
         beacon_root: genesis_block.header.parent_beacon_block_root,
+        slot_number: None,
         version: 3,
         elasticity_multiplier: 1,
         gas_ceil: DEFAULT_BUILDER_GAS_CEIL,

crates/blockchain/payload.rs

@@ -84,6 +84,7 @@ pub struct BuildPayloadArgs {
     pub random: H256,
     pub withdrawals: Option<Vec<Withdrawal>>,
     pub beacon_root: Option<H256>,
+    pub slot_number: Option<u64>,
     pub version: u8,
     pub elasticity_multiplier: u64,
     pub gas_ceil: u64,
@@ -170,6 +171,7 @@ pub fn create_payload(
         requests_hash: chain_config
             .is_prague_activated(args.timestamp)
             .then_some(*DEFAULT_REQUESTS_HASH),
+        slot_number: args.slot_number,
         ..Default::default()
     };
 

crates/l2/sequencer/block_producer.rs

@@ -183,6 +183,7 @@ impl BlockProducer {
             random: H256::zero(),
             withdrawals: Default::default(),
             beacon_root: Some(head_beacon_block_root),
+            slot_number: None,
             version,
             elasticity_multiplier: self.elasticity_multiplier,
             gas_ceil: self.block_gas_limit,

crates/networking/rpc/engine/fork_choice.rs

@@ -11,7 +11,9 @@ use tracing::{debug, info, warn};
 use crate::{
     rpc::{RpcApiContext, RpcHandler},
     types::{
-        fork_choice::{ForkChoiceResponse, ForkChoiceState, PayloadAttributesV3},
+        fork_choice::{
+            ForkChoiceResponse, ForkChoiceState, PayloadAttributesV3, PayloadAttributesV4,
+        },
         payload::PayloadStatus,
     },
     utils::RpcErr,
@@ -128,6 +130,46 @@ impl RpcHandler for ForkChoiceUpdatedV3 {
     }
 }
 
+#[derive(Debug)]
+pub struct ForkChoiceUpdatedV4 {
+    pub fork_choice_state: ForkChoiceState,
+    pub payload_attributes: Option<PayloadAttributesV4>,
+}
+
+impl From<ForkChoiceUpdatedV4> for RpcRequest {
+    fn from(val: ForkChoiceUpdatedV4) -> Self {
+        RpcRequest {
+            method: "engine_forkchoiceUpdatedV4".to_string(),
+            params: Some(vec![
+                serde_json::json!(val.fork_choice_state),
+                serde_json::json!(val.payload_attributes),
+            ]),
+            ..Default::default()
+        }
+    }
+}
+
+impl RpcHandler for ForkChoiceUpdatedV4 {
+    fn parse(params: &Option<Vec<Value>>) -> Result<Self, RpcErr> {
+        let (fork_choice_state, payload_attributes) = parse_v4(params)?;
+        Ok(ForkChoiceUpdatedV4 {
+            fork_choice_state,
+            payload_attributes,
+        })
+    }
+
+    async fn handle(&self, context: RpcApiContext) -> Result<Value, RpcErr> {
+        let (head_block_opt, mut response) =
+            handle_forkchoice(&self.fork_choice_state, context.clone(), 4).await?;
+        if let (Some(head_block), Some(attributes)) = (head_block_opt, &self.payload_attributes) {
+            validate_attributes_v4(attributes, &head_block, &context)?;
+            let payload_id = build_payload_v4(attributes, context, &self.fork_choice_state).await?;
+            response.set_id(payload_id);
+        }
+        serde_json::to_value(response).map_err(|error| RpcErr::Internal(error.to_string()))
+    }
+}
+
 fn parse(
     params: &Option<Vec<Value>>,
     is_v3: bool,
@@ -386,6 +428,7 @@ async fn build_payload(
         random: attributes.prev_randao,
         withdrawals: attributes.withdrawals.clone(),
         beacon_root: attributes.parent_beacon_block_root,
+        slot_number: None,
         version,
         elasticity_multiplier: ELASTICITY_MULTIPLIER,
         gas_ceil: context.gas_ceil,
@@ -411,3 +454,104 @@ async fn build_payload(
         .await;
     Ok(payload_id)
 }
+
+fn parse_v4(
+    params: &Option<Vec<Value>>,
+) -> Result<(ForkChoiceState, Option<PayloadAttributesV4>), RpcErr> {
+    let params = params
+        .as_ref()
+        .ok_or(RpcErr::BadParams("No params provided".to_owned()))?;
+
+    if params.len() != 2 && params.len() != 1 {
+        return Err(RpcErr::BadParams("Expected 2 or 1 params".to_owned()));
+    }
+
+    let forkchoice_state: ForkChoiceState = serde_json::from_value(params[0].clone())?;
+    let mut payload_attributes: Option<PayloadAttributesV4> = None;
+    if params.len() == 2 {
+        payload_attributes =
+            match serde_json::from_value::<Option<PayloadAttributesV4>>(params[1].clone()) {
+                Ok(attributes) => attributes,
+                Err(error) => {
+                    warn!("Could not parse payload attributes {}", error);
+                    None
+                }
+            };
+    }
+    Ok((forkchoice_state, payload_attributes))
+}
+
+fn validate_attributes_v4(
+    attributes: &PayloadAttributesV4,
+    head_block: &BlockHeader,
+    context: &RpcApiContext,
+) -> Result<(), RpcErr> {
+    // Similar validation to V3
+    let chain_config = context.storage.get_chain_config();
+    if !chain_config.is_amsterdam_activated(attributes.timestamp) {
+        return Err(RpcErr::InvalidPayloadAttributes(
+            "V4 payload attributes used for pre-Amsterdam timestamp".to_string(),
+        ));
+    }
+    if attributes.withdrawals.is_none() {
+        return Err(RpcErr::InvalidPayloadAttributes(
+            "V4 payload attributes missing withdrawals".to_string(),
+        ));
+    }
+    if attributes.parent_beacon_block_root.is_none() {
+        return Err(RpcErr::InvalidPayloadAttributes(
+            "V4 payload attributes missing parent_beacon_block_root".to_string(),
+        ));
+    }
+    validate_timestamp_v4(attributes, head_block)
+}
+
+fn validate_timestamp_v4(
+    attributes: &PayloadAttributesV4,
+    head_block: &BlockHeader,
+) -> Result<(), RpcErr> {
+    if attributes.timestamp <= head_block.timestamp {
+        return Err(RpcErr::InvalidPayloadAttributes(
+            "invalid timestamp".to_string(),
+        ));
+    }
+    Ok(())
+}
+
+async fn build_payload_v4(
+    attributes: &PayloadAttributesV4,
+    context: RpcApiContext,
+    fork_choice_state: &ForkChoiceState,
+) -> Result<u64, RpcErr> {
+    let args = BuildPayloadArgs {
+        parent: fork_choice_state.head_block_hash,
+        timestamp: attributes.timestamp,
+        fee_recipient: attributes.suggested_fee_recipient,
+        random: attributes.prev_randao,
+        withdrawals: attributes.withdrawals.clone(),
+        beacon_root: attributes.parent_beacon_block_root,
+        slot_number: Some(attributes.slot_number),
+        version: 4,
+        elasticity_multiplier: ELASTICITY_MULTIPLIER,
+        gas_ceil: context.gas_ceil,
+    };
+    let payload_id = args
+        .id()
+        .map_err(|error| RpcErr::Internal(error.to_string()))?;
+
+    info!(
+        id = payload_id,
+        slot = attributes.slot_number,
+        "Fork choice updated V4 includes payload attributes. Creating a new payload"
+    );
+    let payload = match create_payload(&args, &context.storage, context.node_data.extra_data) {
+        Ok(payload) => payload,
+        Err(ChainError::EvmError(error)) => return Err(error.into()),
+        Err(error) => return Err(RpcErr::Internal(error.to_string())),
+    };
+    context
+        .blockchain
+        .initiate_payload_build(payload, payload_id)
+        .await;
+    Ok(payload_id)
+}

crates/networking/rpc/engine/mod.rs

@@ -15,10 +15,11 @@ pub type ExchangeCapabilitiesRequest = Vec<String>;
 
 /// List of capabilities that the execution layer client supports. Add new capabilities here.
 /// More info: https://github.com/ethereum/execution-apis/blob/main/src/engine/common.md#engine_exchangecapabilities
-pub const CAPABILITIES: [&str; 19] = [
+pub const CAPABILITIES: [&str; 20] = [
     "engine_forkchoiceUpdatedV1",
     "engine_forkchoiceUpdatedV2",
     "engine_forkchoiceUpdatedV3",
+    "engine_forkchoiceUpdatedV4",
     "engine_newPayloadV1",
     "engine_newPayloadV2",
     "engine_newPayloadV3",

crates/networking/rpc/rpc.rs

@@ -7,7 +7,9 @@ use crate::engine::{
     ExchangeCapabilitiesRequest,
     blobs::BlobsV1Request,
     exchange_transition_config::ExchangeTransitionConfigV1Req,
-    fork_choice::{ForkChoiceUpdatedV1, ForkChoiceUpdatedV2, ForkChoiceUpdatedV3},
+    fork_choice::{
+        ForkChoiceUpdatedV1, ForkChoiceUpdatedV2, ForkChoiceUpdatedV3, ForkChoiceUpdatedV4,
+    },
     payload::{
         GetPayloadBodiesByHashV1Request, GetPayloadBodiesByRangeV1Request, GetPayloadV1Request,
         GetPayloadV2Request, GetPayloadV3Request, GetPayloadV4Request, NewPayloadV1Request,
@@ -797,6 +799,7 @@ pub async fn map_engine_requests(
         "engine_forkchoiceUpdatedV1" => ForkChoiceUpdatedV1::call(req, context).await,
         "engine_forkchoiceUpdatedV2" => ForkChoiceUpdatedV2::call(req, context).await,
         "engine_forkchoiceUpdatedV3" => ForkChoiceUpdatedV3::call(req, context).await,
+        "engine_forkchoiceUpdatedV4" => ForkChoiceUpdatedV4::call(req, context).await,
         "engine_newPayloadV5" => NewPayloadV5Request::call(req, context).await,
         "engine_newPayloadV4" => NewPayloadV4Request::call(req, context).await,
         "engine_newPayloadV3" => NewPayloadV3Request::call(req, context).await,

crates/networking/rpc/types/fork_choice.rs

@@ -23,6 +23,20 @@ pub struct PayloadAttributesV3 {
     pub parent_beacon_block_root: Option<H256>,
 }
 
+#[derive(Debug, Deserialize, Default, Serialize, Clone)]
+#[serde(rename_all = "camelCase")]
+#[allow(unused)]
+pub struct PayloadAttributesV4 {
+    #[serde(with = "serde_utils::u64::hex_str")]
+    pub timestamp: u64,
+    pub prev_randao: H256,
+    pub suggested_fee_recipient: Address,
+    pub withdrawals: Option<Vec<Withdrawal>>,
+    pub parent_beacon_block_root: Option<H256>,
+    #[serde(with = "serde_utils::u64::hex_str")]
+    pub slot_number: u64,
+}
+
 #[derive(Debug, Serialize, Deserialize)]
 #[serde(rename_all = "camelCase")]
 pub struct ForkChoiceResponse {

crates/networking/rpc/types/payload.rs

@@ -51,6 +51,13 @@ pub struct ExecutionPayload {
         default
     )]
     pub excess_blob_gas: Option<u64>,
+    // ExecutionPayloadV4 fields (EIP-7843)
+    #[serde(
+        skip_serializing_if = "Option::is_none",
+        with = "serde_utils::u64::hex_str_opt",
+        default
+    )]
+    pub slot_number: Option<u64>,
     // ExecutionPayloadV4 fields. Optional since we support previous versions.
     #[serde(
         skip_serializing_if = "Option::is_none",
@@ -141,6 +148,7 @@ impl ExecutionPayload {
             parent_beacon_block_root,
             // TODO: set the value properly
             requests_hash,
+            slot_number: self.slot_number,
             block_access_list_hash,
             ..Default::default()
         };
@@ -172,6 +180,7 @@ impl ExecutionPayload {
             withdrawals: block.body.withdrawals,
             blob_gas_used: block.header.blob_gas_used,
             excess_blob_gas: block.header.excess_blob_gas,
+            slot_number: block.header.slot_number,
             // TODO: need to finish this after we are able to get BAL from blocks
             block_access_list: None,
         }

crates/vm/backends/levm/mod.rs

@@ -334,6 +334,10 @@ impl LEVM {
             coinbase: block_header.coinbase,
             timestamp: block_header.timestamp.into(),
             prev_randao: Some(block_header.prev_randao),
+            slot_number: block_header
+                .slot_number
+                .map(U256::from)
+                .unwrap_or(U256::zero()),
             chain_id: chain_config.chain_id.into(),
             base_fee_per_gas: block_header.base_fee_per_gas.unwrap_or_default().into(),
             base_blob_fee_per_gas: get_base_fee_per_blob_gas(block_excess_blob_gas, &config)?,
@@ -404,7 +408,7 @@ impl LEVM {
         db: &mut GeneralizedDatabase,
         vm_type: VMType,
     ) -> Result<ExecutionResult, EvmError> {
-        let mut env = env_from_generic(tx, block_header, db)?;
+        let mut env = env_from_generic(tx, block_header, db, vm_type)?;
 
         env.block_gas_limit = i64::MAX as u64; // disable block gas limit
 
@@ -560,7 +564,7 @@ impl LEVM {
         db: &mut GeneralizedDatabase,
         vm_type: VMType,
     ) -> Result<(ExecutionResult, AccessList), VMError> {
-        let mut env = env_from_generic(&tx, header, db)?;
+        let mut env = env_from_generic(&tx, header, db, vm_type)?;
 
         adjust_disabled_base_fee(&mut env);
 
@@ -802,12 +806,31 @@ fn env_from_generic(
     tx: &GenericTransaction,
     header: &BlockHeader,
     db: &GeneralizedDatabase,
+    vm_type: VMType,
 ) -> Result<Environment, VMError> {
     let chain_config = db.store.get_chain_config()?;
     let gas_price =
         calculate_gas_price_for_generic(tx, header.base_fee_per_gas.unwrap_or(INITIAL_BASE_FEE));
     let block_excess_blob_gas = header.excess_blob_gas.map(U256::from);
     let config = EVMConfig::new_from_chain_config(&chain_config, header);
+
+    // Validate slot_number for Amsterdam+ blocks
+    // For L2 chains, slot_number is always 0
+    let slot_number = if let VMType::L2(_) = vm_type {
+        U256::zero()
+    } else if config.fork >= Fork::Amsterdam {
+        header
+            .slot_number
+            .map(U256::from)
+            .ok_or(VMError::Internal(InternalError::Custom(
+                "slot_number must be present in Amsterdam+ blocks".to_string(),
+            )))?
+    } else {
+        // Pre-Amsterdam: slot_number should be None, default to zero
+        // This value should never be used since SLOTNUM opcode doesn't exist pre-Amsterdam
+        header.slot_number.map(U256::from).unwrap_or(U256::zero())
+    };
+
     Ok(Environment {
         origin: tx.from.0.into(),
         gas_limit: tx
@@ -818,6 +841,7 @@ fn env_from_generic(
         coinbase: header.coinbase,
         timestamp: header.timestamp.into(),
         prev_randao: Some(header.prev_randao),
+        slot_number,
         chain_id: chain_config.chain_id.into(),
         base_fee_per_gas: header.base_fee_per_gas.unwrap_or_default().into(),
         base_blob_fee_per_gas: get_base_fee_per_blob_gas(block_excess_blob_gas, &config)?,

crates/vm/levm/src/environment.rs

@@ -26,6 +26,7 @@ pub struct Environment {
     pub timestamp: U256,
     pub prev_randao: Option<H256>,
     pub difficulty: U256,
+    pub slot_number: U256,
     pub chain_id: U256,
     pub base_fee_per_gas: U256,
     pub base_blob_fee_per_gas: U256,