From 47094d592c252363911e82ec3c68ac8f4ab05a9d Mon Sep 17 00:00:00 2001 From: Pawan Dhananjay Date: Fri, 16 Jan 2026 12:40:57 -0800 Subject: [PATCH] Add bal support, remove epbs stuff --- beacon_node/execution_layer/src/engine_api.rs | 33 +++++++ .../src/engine_api/json_structures.rs | 5 + .../test_utils/execution_block_generator.rs | 1 + .../src/test_utils/mock_builder.rs | 25 +++++ .../src/per_block_processing.rs | 6 ++ .../state_processing/src/upgrade/gloas.rs | 24 +---- consensus/types/src/block/beacon_block.rs | 33 +------ .../types/src/block/beacon_block_body.rs | 98 +++++-------------- .../types/src/block/signed_beacon_block.rs | 82 ++++++++++++---- consensus/types/src/execution/dumb_macros.rs | 19 +++- .../types/src/execution/execution_payload.rs | 4 + .../src/execution/execution_payload_header.rs | 98 ++++++++++++++++--- consensus/types/src/execution/mod.rs | 10 +- consensus/types/src/execution/payload.rs | 52 ++++++++-- consensus/types/src/state/beacon_state.rs | 54 +++------- 15 files changed, 336 insertions(+), 208 deletions(-) diff --git a/beacon_node/execution_layer/src/engine_api.rs b/beacon_node/execution_layer/src/engine_api.rs index 32090bccfc..d3ed3fc9fe 100644 --- a/beacon_node/execution_layer/src/engine_api.rs +++ b/beacon_node/execution_layer/src/engine_api.rs @@ -16,6 +16,7 @@ pub use json_structures::{JsonWithdrawal, TransitionConfigurationV1}; use pretty_reqwest_error::PrettyReqwestError; use reqwest::StatusCode; use serde::{Deserialize, Serialize}; +use ssz_types::VariableList; use strum::IntoStaticStr; use superstruct::superstruct; pub use types::{ @@ -541,6 +542,38 @@ impl ExecutionPayloadBodyV1 { )) } } + ExecutionPayloadHeader::Gloas(header) => { + if let Some(withdrawals) = self.withdrawals { + Ok(ExecutionPayload::Gloas(ExecutionPayloadGloas { + parent_hash: header.parent_hash, + fee_recipient: header.fee_recipient, + state_root: header.state_root, + receipts_root: header.receipts_root, + logs_bloom: header.logs_bloom, + prev_randao: header.prev_randao, + block_number: header.block_number, + gas_limit: header.gas_limit, + gas_used: header.gas_used, + timestamp: header.timestamp, + extra_data: header.extra_data, + base_fee_per_gas: header.base_fee_per_gas, + block_hash: header.block_hash, + transactions: self.transactions, + withdrawals, + blob_gas_used: header.blob_gas_used, + excess_blob_gas: header.excess_blob_gas, + // block_access_list is not available via getPayloadBodiesByHash/Range + // so we initialize it as empty here. The full payload with block_access_list + // should be obtained via getPayload when needed. + block_access_list: VariableList::empty(), + })) + } else { + Err(format!( + "block {} is post capella but payload body doesn't have withdrawals", + header.block_hash + )) + } + } } } } diff --git a/beacon_node/execution_layer/src/engine_api/json_structures.rs b/beacon_node/execution_layer/src/engine_api/json_structures.rs index c8488c94d6..b7cd4efbcf 100644 --- a/beacon_node/execution_layer/src/engine_api/json_structures.rs +++ b/beacon_node/execution_layer/src/engine_api/json_structures.rs @@ -107,6 +107,9 @@ pub struct JsonExecutionPayload { #[superstruct(only(Deneb, Electra, Fulu, Gloas))] #[serde(with = "serde_utils::u64_hex_be")] pub excess_blob_gas: u64, + #[superstruct(only(Gloas))] + #[serde(with = "ssz_types::serde_utils::hex_var_list")] + pub block_access_list: VariableList, } impl From> for JsonExecutionPayloadBellatrix { @@ -252,6 +255,7 @@ impl TryFrom> for JsonExecutionPayloadGloas withdrawals: withdrawals_to_json(payload.withdrawals)?, blob_gas_used: payload.blob_gas_used, excess_blob_gas: payload.excess_blob_gas, + block_access_list: payload.block_access_list, }) } } @@ -425,6 +429,7 @@ impl TryFrom> for ExecutionPayloadGloas withdrawals: withdrawals_from_json(payload.withdrawals)?, blob_gas_used: payload.blob_gas_used, excess_blob_gas: payload.excess_blob_gas, + block_access_list: payload.block_access_list, }) } } diff --git a/beacon_node/execution_layer/src/test_utils/execution_block_generator.rs b/beacon_node/execution_layer/src/test_utils/execution_block_generator.rs index 6b247a4cd4..c5f31c45fd 100644 --- a/beacon_node/execution_layer/src/test_utils/execution_block_generator.rs +++ b/beacon_node/execution_layer/src/test_utils/execution_block_generator.rs @@ -725,6 +725,7 @@ impl ExecutionBlockGenerator { withdrawals: pa.withdrawals.clone().try_into().unwrap(), blob_gas_used: 0, excess_blob_gas: 0, + block_access_list: VariableList::empty(), }), _ => unreachable!(), }, diff --git a/beacon_node/execution_layer/src/test_utils/mock_builder.rs b/beacon_node/execution_layer/src/test_utils/mock_builder.rs index 884aa9bf47..94d921c407 100644 --- a/beacon_node/execution_layer/src/test_utils/mock_builder.rs +++ b/beacon_node/execution_layer/src/test_utils/mock_builder.rs @@ -117,6 +117,9 @@ impl BidStuff for BuilderBid { ExecutionPayloadHeaderRefMut::Fulu(header) => { header.fee_recipient = fee_recipient; } + ExecutionPayloadHeaderRefMut::Gloas(header) => { + header.fee_recipient = fee_recipient; + } } } @@ -137,6 +140,9 @@ impl BidStuff for BuilderBid { ExecutionPayloadHeaderRefMut::Fulu(header) => { header.gas_limit = gas_limit; } + ExecutionPayloadHeaderRefMut::Gloas(header) => { + header.gas_limit = gas_limit; + } } } @@ -161,6 +167,9 @@ impl BidStuff for BuilderBid { ExecutionPayloadHeaderRefMut::Fulu(header) => { header.parent_hash = ExecutionBlockHash::from_root(parent_hash); } + ExecutionPayloadHeaderRefMut::Gloas(header) => { + header.parent_hash = ExecutionBlockHash::from_root(parent_hash); + } } } @@ -181,6 +190,9 @@ impl BidStuff for BuilderBid { ExecutionPayloadHeaderRefMut::Fulu(header) => { header.prev_randao = prev_randao; } + ExecutionPayloadHeaderRefMut::Gloas(header) => { + header.prev_randao = prev_randao; + } } } @@ -201,6 +213,9 @@ impl BidStuff for BuilderBid { ExecutionPayloadHeaderRefMut::Fulu(header) => { header.block_number = block_number; } + ExecutionPayloadHeaderRefMut::Gloas(header) => { + header.block_number = block_number; + } } } @@ -221,6 +236,9 @@ impl BidStuff for BuilderBid { ExecutionPayloadHeaderRefMut::Fulu(header) => { header.timestamp = timestamp; } + ExecutionPayloadHeaderRefMut::Gloas(header) => { + header.timestamp = timestamp; + } } } @@ -241,6 +259,9 @@ impl BidStuff for BuilderBid { ExecutionPayloadHeaderRefMut::Fulu(header) => { header.withdrawals_root = withdrawals_root; } + ExecutionPayloadHeaderRefMut::Gloas(header) => { + header.withdrawals_root = withdrawals_root; + } } } @@ -274,6 +295,10 @@ impl BidStuff for BuilderBid { header.extra_data = extra_data; header.block_hash = ExecutionBlockHash::from_root(header.tree_hash_root()); } + ExecutionPayloadHeaderRefMut::Gloas(header) => { + header.extra_data = extra_data; + header.block_hash = ExecutionBlockHash::from_root(header.tree_hash_root()); + } } } } diff --git a/consensus/state_processing/src/per_block_processing.rs b/consensus/state_processing/src/per_block_processing.rs index cd1c1b9849..e56225bd32 100644 --- a/consensus/state_processing/src/per_block_processing.rs +++ b/consensus/state_processing/src/per_block_processing.rs @@ -456,6 +456,12 @@ pub fn process_execution_payload>( _ => return Err(BlockProcessingError::IncorrectStateType), } } + ExecutionPayloadHeaderRefMut::Gloas(header_mut) => { + match payload.to_execution_payload_header() { + ExecutionPayloadHeader::Gloas(header) => *header_mut = header, + _ => return Err(BlockProcessingError::IncorrectStateType), + } + } } Ok(()) diff --git a/consensus/state_processing/src/upgrade/gloas.rs b/consensus/state_processing/src/upgrade/gloas.rs index 81c0fcfe63..50b78ecb05 100644 --- a/consensus/state_processing/src/upgrade/gloas.rs +++ b/consensus/state_processing/src/upgrade/gloas.rs @@ -1,11 +1,5 @@ -use bls::Hash256; -use milhouse::{List, Vector}; -use ssz_types::BitVector; use std::mem; -use types::{ - BeaconState, BeaconStateError as Error, BeaconStateGloas, BuilderPendingPayment, ChainSpec, - EthSpec, ExecutionPayloadBid, Fork, -}; +use types::{BeaconState, BeaconStateError as Error, BeaconStateGloas, ChainSpec, EthSpec, Fork}; /// Transform a `Fulu` state into a `Gloas` state. pub fn upgrade_to_gloas( @@ -69,11 +63,8 @@ pub fn upgrade_state_to_gloas( // Sync committees current_sync_committee: pre.current_sync_committee.clone(), next_sync_committee: pre.next_sync_committee.clone(), - // Execution Bid - latest_execution_payload_bid: ExecutionPayloadBid { - block_hash: pre.latest_execution_payload_header.block_hash, - ..Default::default() - }, + // Execution - upgrade header from Fulu to Gloas + latest_execution_payload_header: pre.latest_execution_payload_header.upgrade_to_gloas(), // Capella next_withdrawal_index: pre.next_withdrawal_index, next_withdrawal_validator_index: pre.next_withdrawal_validator_index, @@ -88,15 +79,6 @@ pub fn upgrade_state_to_gloas( pending_deposits: pre.pending_deposits.clone(), pending_partial_withdrawals: pre.pending_partial_withdrawals.clone(), pending_consolidations: pre.pending_consolidations.clone(), - // Gloas - execution_payload_availability: BitVector::default(), // All bits set to false initially - builder_pending_payments: Vector::new(vec![ - BuilderPendingPayment::default(); - E::builder_pending_payments_limit() - ])?, - builder_pending_withdrawals: List::default(), // Empty list initially, - latest_block_hash: pre.latest_execution_payload_header.block_hash, - latest_withdrawals_root: Hash256::default(), // Caches total_active_balance: pre.total_active_balance, progressive_balances_cache: mem::take(&mut pre.progressive_balances_cache), diff --git a/consensus/types/src/block/beacon_block.rs b/consensus/types/src/block/beacon_block.rs index bee3cdb274..a4e7e800bc 100644 --- a/consensus/types/src/block/beacon_block.rs +++ b/consensus/types/src/block/beacon_block.rs @@ -15,7 +15,6 @@ use tree_hash_derive::TreeHash; use typenum::Unsigned; use crate::{ - SignedExecutionPayloadBid, attestation::{AttestationBase, AttestationData, IndexedAttestationBase}, block::{ BeaconBlockBodyAltair, BeaconBlockBodyBase, BeaconBlockBodyBellatrix, @@ -695,41 +694,15 @@ impl> EmptyBlock for BeaconBlockGloa deposits: VariableList::empty(), voluntary_exits: VariableList::empty(), sync_aggregate: SyncAggregate::empty(), + execution_payload: Payload::Gloas::default(), bls_to_execution_changes: VariableList::empty(), - signed_execution_payload_bid: SignedExecutionPayloadBid::empty(), - payload_attestations: VariableList::empty(), - _phantom: PhantomData, + blob_kzg_commitments: VariableList::empty(), + execution_requests: ExecutionRequests::default(), }, } } } -// TODO(EIP-7732) Mark's branch had the following implementation but not sure if it's needed so will just add header below for reference -// impl> BeaconBlockEIP7732 { - -// TODO(EIP-7732) Look into whether we can remove this in the future since no blinded blocks post-gloas -impl From>> - for BeaconBlockGloas> -{ - fn from(block: BeaconBlockGloas>) -> Self { - let BeaconBlockGloas { - slot, - proposer_index, - parent_root, - state_root, - body, - } = block; - - BeaconBlockGloas { - slot, - proposer_index, - parent_root, - state_root, - body: body.into(), - } - } -} - // We can convert pre-Bellatrix blocks without payloads into blocks "with" payloads. impl From>> for BeaconBlockBase> diff --git a/consensus/types/src/block/beacon_block_body.rs b/consensus/types/src/block/beacon_block_body.rs index a113f85fd3..1f50056d4c 100644 --- a/consensus/types/src/block/beacon_block_body.rs +++ b/consensus/types/src/block/beacon_block_body.rs @@ -14,19 +14,17 @@ use tree_hash::{BYTES_PER_CHUNK, TreeHash}; use tree_hash_derive::TreeHash; use crate::{ - SignedExecutionPayloadBid, - attestation::{ - AttestationBase, AttestationElectra, AttestationRef, AttestationRefMut, PayloadAttestation, - }, + attestation::{AttestationBase, AttestationElectra, AttestationRef, AttestationRefMut}, core::{EthSpec, Graffiti, Hash256}, deposit::Deposit, execution::{ AbstractExecPayload, BlindedPayload, BlindedPayloadBellatrix, BlindedPayloadCapella, - BlindedPayloadDeneb, BlindedPayloadElectra, BlindedPayloadFulu, Eth1Data, ExecutionPayload, - ExecutionPayloadBellatrix, ExecutionPayloadCapella, ExecutionPayloadDeneb, - ExecutionPayloadElectra, ExecutionPayloadFulu, ExecutionPayloadGloas, ExecutionRequests, - FullPayload, FullPayloadBellatrix, FullPayloadCapella, FullPayloadDeneb, - FullPayloadElectra, FullPayloadFulu, SignedBlsToExecutionChange, + BlindedPayloadDeneb, BlindedPayloadElectra, BlindedPayloadFulu, BlindedPayloadGloas, + Eth1Data, ExecutionPayload, ExecutionPayloadBellatrix, ExecutionPayloadCapella, + ExecutionPayloadDeneb, ExecutionPayloadElectra, ExecutionPayloadFulu, + ExecutionPayloadGloas, ExecutionRequests, FullPayload, FullPayloadBellatrix, + FullPayloadCapella, FullPayloadDeneb, FullPayloadElectra, FullPayloadFulu, + FullPayloadGloas, SignedBlsToExecutionChange, }, exit::SignedVoluntaryExit, fork::{ForkName, map_fork_name}, @@ -159,18 +157,17 @@ pub struct BeaconBlockBody = FullPay #[superstruct(only(Fulu), partial_getter(rename = "execution_payload_fulu"))] #[serde(flatten)] pub execution_payload: Payload::Fulu, + #[superstruct(only(Gloas), partial_getter(rename = "execution_payload_gloas"))] + #[serde(flatten)] + pub execution_payload: Payload::Gloas, #[superstruct(only(Capella, Deneb, Electra, Fulu, Gloas))] pub bls_to_execution_changes: VariableList, - #[superstruct(only(Deneb, Electra, Fulu))] + #[superstruct(only(Deneb, Electra, Fulu, Gloas))] pub blob_kzg_commitments: KzgCommitments, - #[superstruct(only(Electra, Fulu))] + #[superstruct(only(Electra, Fulu, Gloas))] pub execution_requests: ExecutionRequests, - #[superstruct(only(Gloas))] - pub signed_execution_payload_bid: SignedExecutionPayloadBid, - #[superstruct(only(Gloas))] - pub payload_attestations: VariableList, E::MaxPayloadAttestations>, - #[superstruct(only(Base, Altair, Gloas))] + #[superstruct(only(Base, Altair))] #[metastruct(exclude_from(fields))] #[ssz(skip_serializing, skip_deserializing)] #[tree_hash(skip_hashing)] @@ -199,7 +196,7 @@ impl<'a, E: EthSpec, Payload: AbstractExecPayload> BeaconBlockBodyRef<'a, E, Self::Deneb(body) => Ok(Payload::Ref::from(&body.execution_payload)), Self::Electra(body) => Ok(Payload::Ref::from(&body.execution_payload)), Self::Fulu(body) => Ok(Payload::Ref::from(&body.execution_payload)), - Self::Gloas(_) => Err(BeaconStateError::IncorrectStateVariant), + Self::Gloas(body) => Ok(Payload::Ref::from(&body.execution_payload)), } } @@ -257,19 +254,16 @@ impl<'a, E: EthSpec, Payload: AbstractExecPayload> BeaconBlockBodyRef<'a, E, /// Produces the proof of inclusion for a `KzgCommitment` in `self.blob_kzg_commitments` /// at `index` using an existing proof for the `blob_kzg_commitments` field. - /// TODO(EIP7732) Investigate calling functions since this will no longer work for glas since no block_kzg_commitments in the body anymore pub fn complete_kzg_commitment_merkle_proof( &self, index: usize, kzg_commitments_proof: &[Hash256], ) -> Result, BeaconStateError> { match self { - Self::Base(_) - | Self::Altair(_) - | Self::Bellatrix(_) - | Self::Capella(_) - | Self::Gloas(_) => Err(BeaconStateError::IncorrectStateVariant), - Self::Deneb(_) | Self::Electra(_) | Self::Fulu(_) => { + Self::Base(_) | Self::Altair(_) | Self::Bellatrix(_) | Self::Capella(_) => { + Err(BeaconStateError::IncorrectStateVariant) + } + Self::Deneb(_) | Self::Electra(_) | Self::Fulu(_) | Self::Gloas(_) => { // We compute the branches by generating 2 merkle trees: // 1. Merkle tree for the `blob_kzg_commitments` List object // 2. Merkle tree for the `BeaconBlockBody` container @@ -547,46 +541,6 @@ impl From>> } } -// Post-Fulu block bodies without payloads can be converted into block bodies with payloads -// TODO(EIP-7732) Look into whether we can remove this in the future since no blinded blocks post-gloas -impl From>> - for BeaconBlockBodyGloas> -{ - fn from(body: BeaconBlockBodyGloas>) -> Self { - let BeaconBlockBodyGloas { - randao_reveal, - eth1_data, - graffiti, - proposer_slashings, - attester_slashings, - attestations, - deposits, - voluntary_exits, - sync_aggregate, - bls_to_execution_changes, - signed_execution_payload_bid, - payload_attestations, - _phantom, - } = body; - - BeaconBlockBodyGloas { - randao_reveal, - eth1_data, - graffiti, - proposer_slashings, - attester_slashings, - attestations, - deposits, - voluntary_exits, - sync_aggregate, - bls_to_execution_changes, - signed_execution_payload_bid, - payload_attestations, - _phantom: PhantomData, - } - } -} - // Likewise bodies with payloads can be transformed into bodies without. impl From>> for ( @@ -897,10 +851,10 @@ impl From>> deposits, voluntary_exits, sync_aggregate, + execution_payload: FullPayloadGloas { execution_payload }, bls_to_execution_changes, - signed_execution_payload_bid, - payload_attestations, - _phantom, + blob_kzg_commitments, + execution_requests, } = body; ( @@ -914,12 +868,14 @@ impl From>> deposits, voluntary_exits, sync_aggregate, + execution_payload: BlindedPayloadGloas { + execution_payload_header: From::from(&execution_payload), + }, bls_to_execution_changes, - signed_execution_payload_bid, - payload_attestations, - _phantom: PhantomData, + blob_kzg_commitments: blob_kzg_commitments.clone(), + execution_requests, }, - None, + Some(execution_payload), ) } } diff --git a/consensus/types/src/block/signed_beacon_block.rs b/consensus/types/src/block/signed_beacon_block.rs index aeb3c18d95..e8927ee765 100644 --- a/consensus/types/src/block/signed_beacon_block.rs +++ b/consensus/types/src/block/signed_beacon_block.rs @@ -17,17 +17,19 @@ use crate::{ block::{ BLOB_KZG_COMMITMENTS_INDEX, BeaconBlock, BeaconBlockAltair, BeaconBlockBase, BeaconBlockBellatrix, BeaconBlockBodyBellatrix, BeaconBlockBodyCapella, - BeaconBlockBodyDeneb, BeaconBlockBodyElectra, BeaconBlockBodyFulu, BeaconBlockCapella, - BeaconBlockDeneb, BeaconBlockElectra, BeaconBlockFulu, BeaconBlockGloas, BeaconBlockHeader, - BeaconBlockRef, BeaconBlockRefMut, SignedBeaconBlockHeader, + BeaconBlockBodyDeneb, BeaconBlockBodyElectra, BeaconBlockBodyFulu, BeaconBlockBodyGloas, + BeaconBlockCapella, BeaconBlockDeneb, BeaconBlockElectra, BeaconBlockFulu, + BeaconBlockGloas, BeaconBlockHeader, BeaconBlockRef, BeaconBlockRefMut, + SignedBeaconBlockHeader, }, core::{ChainSpec, Domain, Epoch, EthSpec, Hash256, SignedRoot, SigningData, Slot}, execution::{ AbstractExecPayload, BlindedPayload, BlindedPayloadBellatrix, BlindedPayloadCapella, - BlindedPayloadDeneb, BlindedPayloadElectra, BlindedPayloadFulu, ExecutionPayload, - ExecutionPayloadBellatrix, ExecutionPayloadCapella, ExecutionPayloadDeneb, - ExecutionPayloadElectra, ExecutionPayloadFulu, FullPayload, FullPayloadBellatrix, - FullPayloadCapella, FullPayloadDeneb, FullPayloadElectra, FullPayloadFulu, + BlindedPayloadDeneb, BlindedPayloadElectra, BlindedPayloadFulu, BlindedPayloadGloas, + ExecutionPayload, ExecutionPayloadBellatrix, ExecutionPayloadCapella, + ExecutionPayloadDeneb, ExecutionPayloadElectra, ExecutionPayloadFulu, + ExecutionPayloadGloas, FullPayload, FullPayloadBellatrix, FullPayloadCapella, + FullPayloadDeneb, FullPayloadElectra, FullPayloadFulu, FullPayloadGloas, }, fork::{Fork, ForkName, ForkVersionDecode, InconsistentFork, map_fork_name}, kzg_ext::format_kzg_commitments, @@ -673,15 +675,59 @@ impl SignedBeaconBlockFulu> { } } -// We can convert gloas blocks without payloads into blocks "with" payloads. -// TODO(EIP-7732) Look into whether we can remove this in the future since no blinded blocks post-gloas -impl From>> - for SignedBeaconBlockGloas> -{ - fn from(signed_block: SignedBeaconBlockGloas>) -> Self { - let SignedBeaconBlockGloas { message, signature } = signed_block; +impl SignedBeaconBlockGloas> { + pub fn into_full_block( + self, + execution_payload: ExecutionPayloadGloas, + ) -> SignedBeaconBlockGloas> { + let SignedBeaconBlockGloas { + message: + BeaconBlockGloas { + slot, + proposer_index, + parent_root, + state_root, + body: + BeaconBlockBodyGloas { + randao_reveal, + eth1_data, + graffiti, + proposer_slashings, + attester_slashings, + attestations, + deposits, + voluntary_exits, + sync_aggregate, + execution_payload: BlindedPayloadGloas { .. }, + bls_to_execution_changes, + blob_kzg_commitments, + execution_requests, + }, + }, + signature, + } = self; SignedBeaconBlockGloas { - message: message.into(), + message: BeaconBlockGloas { + slot, + proposer_index, + parent_root, + state_root, + body: BeaconBlockBodyGloas { + randao_reveal, + eth1_data, + graffiti, + proposer_slashings, + attester_slashings, + attestations, + deposits, + voluntary_exits, + sync_aggregate, + execution_payload: FullPayloadGloas { execution_payload }, + bls_to_execution_changes, + blob_kzg_commitments, + execution_requests, + }, + }, signature, } } @@ -710,7 +756,9 @@ impl SignedBeaconBlock> { (SignedBeaconBlock::Fulu(block), Some(ExecutionPayload::Fulu(payload))) => { SignedBeaconBlock::Fulu(block.into_full_block(payload)) } - (SignedBeaconBlock::Gloas(block), _) => SignedBeaconBlock::Gloas(block.into()), + (SignedBeaconBlock::Gloas(block), Some(ExecutionPayload::Gloas(payload))) => { + SignedBeaconBlock::Gloas(block.into_full_block(payload)) + } // avoid wildcard matching forks so that compiler will // direct us here when a new fork has been added (SignedBeaconBlock::Bellatrix(_), _) => return None, @@ -718,7 +766,7 @@ impl SignedBeaconBlock> { (SignedBeaconBlock::Deneb(_), _) => return None, (SignedBeaconBlock::Electra(_), _) => return None, (SignedBeaconBlock::Fulu(_), _) => return None, - // TODO(EIP-7732) Determine if need a match arm for gloas here + (SignedBeaconBlock::Gloas(_), _) => return None, }; Some(full_block) } diff --git a/consensus/types/src/execution/dumb_macros.rs b/consensus/types/src/execution/dumb_macros.rs index 4eae416bb5..9201d54988 100644 --- a/consensus/types/src/execution/dumb_macros.rs +++ b/consensus/types/src/execution/dumb_macros.rs @@ -3,7 +3,6 @@ // - ExecutionPayloadHeader // - FullPayload // - BlindedPayload -// TODO(EIP-7732): get rid of this whole file and panics once the engine_api is refactored for ePBS #[macro_export] macro_rules! map_execution_payload_into_full_payload { @@ -29,7 +28,10 @@ macro_rules! map_execution_payload_into_full_payload { let f: fn(ExecutionPayloadFulu<_>, fn(_) -> _) -> _ = $f; f(inner, FullPayload::Fulu) } - ExecutionPayload::Gloas(_) => panic!("FullPayload::Gloas does not exist!"), + ExecutionPayload::Gloas(inner) => { + let f: fn(ExecutionPayloadGloas<_>, fn(_) -> _) -> _ = $f; + f(inner, FullPayload::Gloas) + } } }; } @@ -58,7 +60,10 @@ macro_rules! map_execution_payload_into_blinded_payload { let f: fn(ExecutionPayloadFulu<_>, fn(_) -> _) -> _ = $f; f(inner, BlindedPayload::Fulu) } - ExecutionPayload::Gloas(_) => panic!("BlindedPayload::Gloas does not exist!"), + ExecutionPayload::Gloas(inner) => { + let f: fn(ExecutionPayloadGloas<_>, fn(_) -> _) -> _ = $f; + f(inner, BlindedPayload::Gloas) + } } }; } @@ -102,7 +107,13 @@ macro_rules! map_execution_payload_ref_into_execution_payload_header { ) -> _ = $f; f(inner, ExecutionPayloadHeader::Fulu) } - ExecutionPayloadRef::Gloas(_) => panic!("ExecutionPayloadHeader::Gloas does not exist!"), + ExecutionPayloadRef::Gloas(inner) => { + let f: fn( + &$lifetime ExecutionPayloadGloas<_>, + fn(_) -> _, + ) -> _ = $f; + f(inner, ExecutionPayloadHeader::Gloas) + } } } } diff --git a/consensus/types/src/execution/execution_payload.rs b/consensus/types/src/execution/execution_payload.rs index d99b8785fa..4749273c6f 100644 --- a/consensus/types/src/execution/execution_payload.rs +++ b/consensus/types/src/execution/execution_payload.rs @@ -109,6 +109,10 @@ pub struct ExecutionPayload { #[superstruct(only(Deneb, Electra, Fulu, Gloas), partial_getter(copy))] #[serde(with = "serde_utils::quoted_u64")] pub excess_blob_gas: u64, + /// EIP-7928: Block access list + #[superstruct(only(Gloas))] + #[serde(with = "ssz_types::serde_utils::hex_var_list")] + pub block_access_list: VariableList, } impl<'a, E: EthSpec> ExecutionPayloadRef<'a, E> { diff --git a/consensus/types/src/execution/execution_payload_header.rs b/consensus/types/src/execution/execution_payload_header.rs index 0b8556634a..4b2b820f70 100644 --- a/consensus/types/src/execution/execution_payload_header.rs +++ b/consensus/types/src/execution/execution_payload_header.rs @@ -14,7 +14,8 @@ use crate::{ core::{Address, EthSpec, ExecutionBlockHash, Hash256, Uint256}, execution::{ ExecutionPayloadBellatrix, ExecutionPayloadCapella, ExecutionPayloadDeneb, - ExecutionPayloadElectra, ExecutionPayloadFulu, ExecutionPayloadRef, Transactions, + ExecutionPayloadElectra, ExecutionPayloadFulu, ExecutionPayloadGloas, ExecutionPayloadRef, + Transactions, }, fork::ForkName, map_execution_payload_ref_into_execution_payload_header, @@ -23,7 +24,7 @@ use crate::{ }; #[superstruct( - variants(Bellatrix, Capella, Deneb, Electra, Fulu), + variants(Bellatrix, Capella, Deneb, Electra, Fulu, Gloas), variant_attributes( derive( Default, @@ -105,14 +106,17 @@ pub struct ExecutionPayloadHeader { pub block_hash: ExecutionBlockHash, #[superstruct(getter(copy))] pub transactions_root: Hash256, - #[superstruct(only(Capella, Deneb, Electra, Fulu), partial_getter(copy))] + #[superstruct(only(Capella, Deneb, Electra, Fulu, Gloas), partial_getter(copy))] pub withdrawals_root: Hash256, - #[superstruct(only(Deneb, Electra, Fulu), partial_getter(copy))] + #[superstruct(only(Deneb, Electra, Fulu, Gloas), partial_getter(copy))] #[serde(with = "serde_utils::quoted_u64")] pub blob_gas_used: u64, - #[superstruct(only(Deneb, Electra, Fulu), partial_getter(copy))] + #[superstruct(only(Deneb, Electra, Fulu, Gloas), partial_getter(copy))] #[serde(with = "serde_utils::quoted_u64")] pub excess_blob_gas: u64, + /// EIP-7928: Block access list root + #[superstruct(only(Gloas), partial_getter(copy))] + pub block_access_list_root: Hash256, } impl ExecutionPayloadHeader { @@ -136,19 +140,14 @@ impl ExecutionPayloadHeader { ExecutionPayloadHeaderElectra::from_ssz_bytes(bytes).map(Self::Electra) } ForkName::Fulu => ExecutionPayloadHeaderFulu::from_ssz_bytes(bytes).map(Self::Fulu), - ForkName::Gloas => Err(ssz::DecodeError::BytesInvalid(format!( - "unsupported fork for ExecutionPayloadHeader: {fork_name}", - ))), + ForkName::Gloas => ExecutionPayloadHeaderGloas::from_ssz_bytes(bytes).map(Self::Gloas), } } #[allow(clippy::arithmetic_side_effects)] pub fn ssz_max_var_len_for_fork(fork_name: ForkName) -> usize { // TODO(newfork): Add a new case here if there are new variable fields - if fork_name.gloas_enabled() { - // TODO(EIP7732): check this - 0 - } else if fork_name.bellatrix_enabled() { + if fork_name.bellatrix_enabled() { // Max size of variable length `extra_data` field E::max_extra_data_bytes() * ::ssz_fixed_len() } else { @@ -163,6 +162,7 @@ impl ExecutionPayloadHeader { ExecutionPayloadHeader::Deneb(_) => ForkName::Deneb, ExecutionPayloadHeader::Electra(_) => ForkName::Electra, ExecutionPayloadHeader::Fulu(_) => ForkName::Fulu, + ExecutionPayloadHeader::Gloas(_) => ForkName::Gloas, } } } @@ -270,6 +270,31 @@ impl ExecutionPayloadHeaderElectra { } } +impl ExecutionPayloadHeaderFulu { + pub fn upgrade_to_gloas(&self) -> ExecutionPayloadHeaderGloas { + ExecutionPayloadHeaderGloas { + parent_hash: self.parent_hash, + fee_recipient: self.fee_recipient, + state_root: self.state_root, + receipts_root: self.receipts_root, + logs_bloom: self.logs_bloom.clone(), + prev_randao: self.prev_randao, + block_number: self.block_number, + gas_limit: self.gas_limit, + gas_used: self.gas_used, + timestamp: self.timestamp, + extra_data: self.extra_data.clone(), + base_fee_per_gas: self.base_fee_per_gas, + block_hash: self.block_hash, + transactions_root: self.transactions_root, + withdrawals_root: self.withdrawals_root, + blob_gas_used: self.blob_gas_used, + excess_blob_gas: self.excess_blob_gas, + block_access_list_root: Hash256::zero(), + } + } +} + impl<'a, E: EthSpec> From<&'a ExecutionPayloadBellatrix> for ExecutionPayloadHeaderBellatrix { fn from(payload: &'a ExecutionPayloadBellatrix) -> Self { Self { @@ -385,6 +410,31 @@ impl<'a, E: EthSpec> From<&'a ExecutionPayloadFulu> for ExecutionPayloadHeade } } +impl<'a, E: EthSpec> From<&'a ExecutionPayloadGloas> for ExecutionPayloadHeaderGloas { + fn from(payload: &'a ExecutionPayloadGloas) -> Self { + Self { + parent_hash: payload.parent_hash, + fee_recipient: payload.fee_recipient, + state_root: payload.state_root, + receipts_root: payload.receipts_root, + logs_bloom: payload.logs_bloom.clone(), + prev_randao: payload.prev_randao, + block_number: payload.block_number, + gas_limit: payload.gas_limit, + gas_used: payload.gas_used, + timestamp: payload.timestamp, + extra_data: payload.extra_data.clone(), + base_fee_per_gas: payload.base_fee_per_gas, + block_hash: payload.block_hash, + transactions_root: payload.transactions.tree_hash_root(), + withdrawals_root: payload.withdrawals.tree_hash_root(), + blob_gas_used: payload.blob_gas_used, + excess_blob_gas: payload.excess_blob_gas, + block_access_list_root: payload.block_access_list.tree_hash_root(), + } + } +} + // These impls are required to work around an inelegance in `to_execution_payload_header`. // They only clone headers so they should be relatively cheap. impl<'a, E: EthSpec> From<&'a Self> for ExecutionPayloadHeaderBellatrix { @@ -417,6 +467,12 @@ impl<'a, E: EthSpec> From<&'a Self> for ExecutionPayloadHeaderFulu { } } +impl<'a, E: EthSpec> From<&'a Self> for ExecutionPayloadHeaderGloas { + fn from(payload: &'a Self) -> Self { + payload.clone() + } +} + impl<'a, E: EthSpec> From> for ExecutionPayloadHeader { fn from(payload: ExecutionPayloadRef<'a, E>) -> Self { map_execution_payload_ref_into_execution_payload_header!( @@ -478,6 +534,9 @@ impl ExecutionPayloadHeaderRefMut<'_, E> { ExecutionPayloadHeaderRefMut::Fulu(mut_ref) => { *mut_ref = header.try_into()?; } + ExecutionPayloadHeaderRefMut::Gloas(mut_ref) => { + *mut_ref = header.try_into()?; + } } Ok(()) } @@ -505,6 +564,16 @@ impl TryFrom> for ExecutionPayloadHeaderFu } } +impl TryFrom> for ExecutionPayloadHeaderGloas { + type Error = BeaconStateError; + fn try_from(header: ExecutionPayloadHeader) -> Result { + match header { + ExecutionPayloadHeader::Gloas(execution_payload_header) => Ok(execution_payload_header), + _ => Err(BeaconStateError::IncorrectStateVariant), + } + } +} + impl<'de, E: EthSpec> ContextDeserialize<'de, ForkName> for ExecutionPayloadHeader { fn context_deserialize(deserializer: D, context: ForkName) -> Result where @@ -532,8 +601,11 @@ impl<'de, E: EthSpec> ContextDeserialize<'de, ForkName> for ExecutionPayloadHead ForkName::Fulu => { Self::Fulu(Deserialize::deserialize(deserializer).map_err(convert_err)?) } + ForkName::Gloas => { + Self::Gloas(Deserialize::deserialize(deserializer).map_err(convert_err)?) + } - ForkName::Base | ForkName::Altair | ForkName::Gloas => { + ForkName::Base | ForkName::Altair => { return Err(serde::de::Error::custom(format!( "ExecutionPayloadHeader failed to deserialize: unsupported fork '{}'", context diff --git a/consensus/types/src/execution/mod.rs b/consensus/types/src/execution/mod.rs index a3d4ed8730..bbb0b5fcd5 100644 --- a/consensus/types/src/execution/mod.rs +++ b/consensus/types/src/execution/mod.rs @@ -26,17 +26,17 @@ pub use execution_payload_envelope::ExecutionPayloadEnvelope; pub use execution_payload_header::{ ExecutionPayloadHeader, ExecutionPayloadHeaderBellatrix, ExecutionPayloadHeaderCapella, ExecutionPayloadHeaderDeneb, ExecutionPayloadHeaderElectra, ExecutionPayloadHeaderFulu, - ExecutionPayloadHeaderRef, ExecutionPayloadHeaderRefMut, + ExecutionPayloadHeaderGloas, ExecutionPayloadHeaderRef, ExecutionPayloadHeaderRefMut, }; pub use execution_requests::{ ConsolidationRequests, DepositRequests, ExecutionRequests, RequestType, WithdrawalRequests, }; pub use payload::{ AbstractExecPayload, BlindedPayload, BlindedPayloadBellatrix, BlindedPayloadCapella, - BlindedPayloadDeneb, BlindedPayloadElectra, BlindedPayloadFulu, BlindedPayloadRef, - BlockProductionVersion, BlockType, ExecPayload, FullPayload, FullPayloadBellatrix, - FullPayloadCapella, FullPayloadDeneb, FullPayloadElectra, FullPayloadFulu, FullPayloadRef, - OwnedExecPayload, + BlindedPayloadDeneb, BlindedPayloadElectra, BlindedPayloadFulu, BlindedPayloadGloas, + BlindedPayloadRef, BlockProductionVersion, BlockType, ExecPayload, FullPayload, + FullPayloadBellatrix, FullPayloadCapella, FullPayloadDeneb, FullPayloadElectra, + FullPayloadFulu, FullPayloadGloas, FullPayloadRef, OwnedExecPayload, }; pub use signed_bls_to_execution_change::SignedBlsToExecutionChange; pub use signed_execution_payload_bid::SignedExecutionPayloadBid; diff --git a/consensus/types/src/execution/payload.rs b/consensus/types/src/execution/payload.rs index c51369034c..3df966f74b 100644 --- a/consensus/types/src/execution/payload.rs +++ b/consensus/types/src/execution/payload.rs @@ -15,9 +15,9 @@ use crate::{ execution::{ ExecutionPayload, ExecutionPayloadBellatrix, ExecutionPayloadCapella, ExecutionPayloadDeneb, ExecutionPayloadElectra, ExecutionPayloadFulu, - ExecutionPayloadHeader, ExecutionPayloadHeaderBellatrix, ExecutionPayloadHeaderCapella, - ExecutionPayloadHeaderDeneb, ExecutionPayloadHeaderElectra, ExecutionPayloadHeaderFulu, - ExecutionPayloadRef, Transactions, + ExecutionPayloadGloas, ExecutionPayloadHeader, ExecutionPayloadHeaderBellatrix, + ExecutionPayloadHeaderCapella, ExecutionPayloadHeaderDeneb, ExecutionPayloadHeaderElectra, + ExecutionPayloadHeaderFulu, ExecutionPayloadHeaderGloas, ExecutionPayloadRef, Transactions, }, fork::ForkName, map_execution_payload_into_blinded_payload, map_execution_payload_into_full_payload, @@ -119,6 +119,7 @@ pub trait AbstractExecPayload: + TryInto + TryInto + TryInto + + TryInto + Sync { type Ref<'a>: ExecPayload @@ -127,7 +128,8 @@ pub trait AbstractExecPayload: + From<&'a Self::Capella> + From<&'a Self::Deneb> + From<&'a Self::Electra> - + From<&'a Self::Fulu>; + + From<&'a Self::Fulu> + + From<&'a Self::Gloas>; type Bellatrix: OwnedExecPayload + Into @@ -154,10 +156,15 @@ pub trait AbstractExecPayload: + for<'a> From>> + TryFrom> + Sync; + type Gloas: OwnedExecPayload + + Into + + for<'a> From>> + + TryFrom> + + Sync; } #[superstruct( - variants(Bellatrix, Capella, Deneb, Electra, Fulu), + variants(Bellatrix, Capella, Deneb, Electra, Fulu, Gloas), variant_attributes( derive( Debug, @@ -218,6 +225,8 @@ pub struct FullPayload { pub execution_payload: ExecutionPayloadElectra, #[superstruct(only(Fulu), partial_getter(rename = "execution_payload_fulu"))] pub execution_payload: ExecutionPayloadFulu, + #[superstruct(only(Gloas), partial_getter(rename = "execution_payload_gloas"))] + pub execution_payload: ExecutionPayloadGloas, } impl From> for ExecutionPayload { @@ -329,6 +338,7 @@ impl ExecPayload for FullPayload { FullPayload::Deneb(inner) => Ok(inner.execution_payload.withdrawals.tree_hash_root()), FullPayload::Electra(inner) => Ok(inner.execution_payload.withdrawals.tree_hash_root()), FullPayload::Fulu(inner) => Ok(inner.execution_payload.withdrawals.tree_hash_root()), + FullPayload::Gloas(inner) => Ok(inner.execution_payload.withdrawals.tree_hash_root()), } } @@ -340,6 +350,7 @@ impl ExecPayload for FullPayload { FullPayload::Deneb(inner) => Ok(inner.execution_payload.blob_gas_used), FullPayload::Electra(inner) => Ok(inner.execution_payload.blob_gas_used), FullPayload::Fulu(inner) => Ok(inner.execution_payload.blob_gas_used), + FullPayload::Gloas(inner) => Ok(inner.execution_payload.blob_gas_used), } } @@ -371,7 +382,7 @@ impl FullPayload { ForkName::Deneb => Ok(FullPayloadDeneb::default().into()), ForkName::Electra => Ok(FullPayloadElectra::default().into()), ForkName::Fulu => Ok(FullPayloadFulu::default().into()), - ForkName::Gloas => Err(BeaconStateError::IncorrectStateVariant), + ForkName::Gloas => Ok(FullPayloadGloas::default().into()), } } } @@ -472,6 +483,9 @@ impl ExecPayload for FullPayloadRef<'_, E> { Ok(inner.execution_payload.withdrawals.tree_hash_root()) } FullPayloadRef::Fulu(inner) => Ok(inner.execution_payload.withdrawals.tree_hash_root()), + FullPayloadRef::Gloas(inner) => { + Ok(inner.execution_payload.withdrawals.tree_hash_root()) + } } } @@ -483,6 +497,7 @@ impl ExecPayload for FullPayloadRef<'_, E> { FullPayloadRef::Deneb(inner) => Ok(inner.execution_payload.blob_gas_used), FullPayloadRef::Electra(inner) => Ok(inner.execution_payload.blob_gas_used), FullPayloadRef::Fulu(inner) => Ok(inner.execution_payload.blob_gas_used), + FullPayloadRef::Gloas(inner) => Ok(inner.execution_payload.blob_gas_used), } } @@ -506,6 +521,7 @@ impl AbstractExecPayload for FullPayload { type Deneb = FullPayloadDeneb; type Electra = FullPayloadElectra; type Fulu = FullPayloadFulu; + type Gloas = FullPayloadGloas; } impl From> for FullPayload { @@ -524,7 +540,7 @@ impl TryFrom> for FullPayload { } #[superstruct( - variants(Bellatrix, Capella, Deneb, Electra, Fulu), + variants(Bellatrix, Capella, Deneb, Electra, Fulu, Gloas), variant_attributes( derive( Debug, @@ -584,6 +600,8 @@ pub struct BlindedPayload { pub execution_payload_header: ExecutionPayloadHeaderElectra, #[superstruct(only(Fulu), partial_getter(rename = "execution_payload_fulu"))] pub execution_payload_header: ExecutionPayloadHeaderFulu, + #[superstruct(only(Gloas), partial_getter(rename = "execution_payload_gloas"))] + pub execution_payload_header: ExecutionPayloadHeaderGloas, } impl<'a, E: EthSpec> From> for BlindedPayload { @@ -673,6 +691,7 @@ impl ExecPayload for BlindedPayload { BlindedPayload::Deneb(inner) => Ok(inner.execution_payload_header.withdrawals_root), BlindedPayload::Electra(inner) => Ok(inner.execution_payload_header.withdrawals_root), BlindedPayload::Fulu(inner) => Ok(inner.execution_payload_header.withdrawals_root), + BlindedPayload::Gloas(inner) => Ok(inner.execution_payload_header.withdrawals_root), } } @@ -684,6 +703,7 @@ impl ExecPayload for BlindedPayload { BlindedPayload::Deneb(inner) => Ok(inner.execution_payload_header.blob_gas_used), BlindedPayload::Electra(inner) => Ok(inner.execution_payload_header.blob_gas_used), BlindedPayload::Fulu(inner) => Ok(inner.execution_payload_header.blob_gas_used), + BlindedPayload::Gloas(inner) => Ok(inner.execution_payload_header.blob_gas_used), } } @@ -783,6 +803,7 @@ impl<'b, E: EthSpec> ExecPayload for BlindedPayloadRef<'b, E> { Ok(inner.execution_payload_header.withdrawals_root) } BlindedPayloadRef::Fulu(inner) => Ok(inner.execution_payload_header.withdrawals_root), + BlindedPayloadRef::Gloas(inner) => Ok(inner.execution_payload_header.withdrawals_root), } } @@ -794,6 +815,7 @@ impl<'b, E: EthSpec> ExecPayload for BlindedPayloadRef<'b, E> { BlindedPayloadRef::Deneb(inner) => Ok(inner.execution_payload_header.blob_gas_used), BlindedPayloadRef::Electra(inner) => Ok(inner.execution_payload_header.blob_gas_used), BlindedPayloadRef::Fulu(inner) => Ok(inner.execution_payload_header.blob_gas_used), + BlindedPayloadRef::Gloas(inner) => Ok(inner.execution_payload_header.blob_gas_used), } } @@ -1105,6 +1127,13 @@ impl_exec_payload_for_fork!( ExecutionPayloadFulu, Fulu ); +impl_exec_payload_for_fork!( + BlindedPayloadGloas, + FullPayloadGloas, + ExecutionPayloadHeaderGloas, + ExecutionPayloadGloas, + Gloas +); impl AbstractExecPayload for BlindedPayload { type Ref<'a> = BlindedPayloadRef<'a, E>; @@ -1113,6 +1142,7 @@ impl AbstractExecPayload for BlindedPayload { type Deneb = BlindedPayloadDeneb; type Electra = BlindedPayloadElectra; type Fulu = BlindedPayloadFulu; + type Gloas = BlindedPayloadGloas; } impl From> for BlindedPayload { @@ -1154,6 +1184,11 @@ impl From> for BlindedPayload { execution_payload_header, }) } + ExecutionPayloadHeader::Gloas(execution_payload_header) => { + Self::Gloas(BlindedPayloadGloas { + execution_payload_header, + }) + } } } } @@ -1176,6 +1211,9 @@ impl From> for ExecutionPayloadHeader { BlindedPayload::Fulu(blinded_payload) => { ExecutionPayloadHeader::Fulu(blinded_payload.execution_payload_header) } + BlindedPayload::Gloas(blinded_payload) => { + ExecutionPayloadHeader::Gloas(blinded_payload.execution_payload_header) + } } } } diff --git a/consensus/types/src/state/beacon_state.rs b/consensus/types/src/state/beacon_state.rs index f3e5ae411b..932e9d89b4 100644 --- a/consensus/types/src/state/beacon_state.rs +++ b/consensus/types/src/state/beacon_state.rs @@ -23,7 +23,6 @@ use tree_hash_derive::TreeHash; use typenum::Unsigned; use crate::{ - BuilderPendingPayment, BuilderPendingWithdrawal, ExecutionBlockHash, ExecutionPayloadBid, attestation::{ AttestationDuty, BeaconCommittee, Checkpoint, CommitteeIndex, ParticipationFlags, PendingAttestation, @@ -35,7 +34,7 @@ use crate::{ execution::{ Eth1Data, ExecutionPayloadHeaderBellatrix, ExecutionPayloadHeaderCapella, ExecutionPayloadHeaderDeneb, ExecutionPayloadHeaderElectra, ExecutionPayloadHeaderFulu, - ExecutionPayloadHeaderRef, ExecutionPayloadHeaderRefMut, + ExecutionPayloadHeaderGloas, ExecutionPayloadHeaderRef, ExecutionPayloadHeaderRefMut, }, fork::{Fork, ForkName, ForkVersionDecode, InconsistentFork, map_fork_name}, light_client::consts::{ @@ -543,9 +542,12 @@ where )] #[metastruct(exclude_from(tree_lists))] pub latest_execution_payload_header: ExecutionPayloadHeaderFulu, - #[superstruct(only(Gloas))] + #[superstruct( + only(Gloas), + partial_getter(rename = "latest_execution_payload_header_gloas") + )] #[metastruct(exclude_from(tree_lists))] - pub latest_execution_payload_bid: ExecutionPayloadBid, + pub latest_execution_payload_header: ExecutionPayloadHeaderGloas, #[superstruct(only(Capella, Deneb, Electra, Fulu, Gloas), partial_getter(copy))] #[serde(with = "serde_utils::quoted_u64")] #[metastruct(exclude_from(tree_lists))] @@ -603,33 +605,6 @@ where #[serde(with = "ssz_types::serde_utils::quoted_u64_fixed_vec")] pub proposer_lookahead: Vector, - // Gloas - #[test_random(default)] - #[superstruct(only(Gloas))] - #[metastruct(exclude_from(tree_lists))] - pub execution_payload_availability: BitVector, - - #[compare_fields(as_iter)] - #[test_random(default)] - #[superstruct(only(Gloas))] - pub builder_pending_payments: Vector, - - #[compare_fields(as_iter)] - #[test_random(default)] - #[superstruct(only(Gloas))] - pub builder_pending_withdrawals: - List, - - #[test_random(default)] - #[superstruct(only(Gloas))] - #[metastruct(exclude_from(tree_lists))] - pub latest_block_hash: ExecutionBlockHash, - - #[test_random(default)] - #[superstruct(only(Gloas))] - #[metastruct(exclude_from(tree_lists))] - pub latest_withdrawals_root: Hash256, - // Caching (not in the spec) #[serde(skip_serializing, skip_deserializing)] #[ssz(skip_serializing, skip_deserializing)] @@ -1190,8 +1165,9 @@ impl BeaconState { BeaconState::Fulu(state) => Ok(ExecutionPayloadHeaderRef::Fulu( &state.latest_execution_payload_header, )), - // TODO(EIP-7732): investigate calling functions - BeaconState::Gloas(_) => Err(BeaconStateError::IncorrectStateVariant), + BeaconState::Gloas(state) => Ok(ExecutionPayloadHeaderRef::Gloas( + &state.latest_execution_payload_header, + )), } } @@ -1217,8 +1193,9 @@ impl BeaconState { BeaconState::Fulu(state) => Ok(ExecutionPayloadHeaderRefMut::Fulu( &mut state.latest_execution_payload_header, )), - // TODO(EIP-7732): investigate calling functions - BeaconState::Gloas(_) => Err(BeaconStateError::IncorrectStateVariant), + BeaconState::Gloas(state) => Ok(ExecutionPayloadHeaderRefMut::Gloas( + &mut state.latest_execution_payload_header, + )), } } @@ -2295,15 +2272,12 @@ impl BeaconState { pub fn is_parent_block_full(&self) -> bool { match self { BeaconState::Base(_) | BeaconState::Altair(_) => false, - // TODO(EIP-7732): check the implications of this when we get to forkchoice modifications BeaconState::Bellatrix(_) | BeaconState::Capella(_) | BeaconState::Deneb(_) | BeaconState::Electra(_) - | BeaconState::Fulu(_) => true, - BeaconState::Gloas(state) => { - state.latest_execution_payload_bid.block_hash == state.latest_block_hash - } + | BeaconState::Fulu(_) + | BeaconState::Gloas(_) => true, } }