Epbs devnet 1

beacon_node/beacon_chain/src/beacon_chain.rs

@@ -941,6 +941,28 @@ impl<T: BeaconChainTypes> BeaconChain<T> {
         )?
     }
 
+    /// Returns the Pending (pre-payload) state root at the given slot in the canonical chain.
+    ///
+    /// In ePBS (Gloas+), if the canonical state at `slot` is Full (post-payload), this resolves
+    /// to the same-slot Pending state root. For skipped slots or pre-Gloas, returns the canonical
+    /// state root unchanged.
+    pub fn pending_state_root_at_slot(&self, request_slot: Slot) -> Result<Option<Hash256>, Error> {
+        let Some(root) = self.state_root_at_slot(request_slot)? else {
+            return Ok(None);
+        };
+
+        // Pre-Gloas: all states are inherently Pending.
+        if !self
+            .spec
+            .fork_name_at_slot::<T::EthSpec>(request_slot)
+            .gloas_enabled()
+        {
+            return Ok(Some(root));
+        }
+
+        Ok(Some(self.store.resolve_pending_state_root(&root)?))
+    }
+
     /// Returns the block root at the given slot, if any. Only returns roots in the canonical chain.
     ///
     /// ## Notes
@@ -2820,7 +2842,15 @@ impl<T: BeaconChainTypes> BeaconChain<T> {
                 //
                 // Note that `check_block_relevancy` is incapable of returning
                 // `DuplicateImportStatusUnknown` so we don't need to handle that case here.
-                Err(BlockError::DuplicateFullyImported(_)) => continue,
+                //
+                // Gloas: keep duplicate blocks so their envelopes can still be processed
+                // in `process_chain_segment`. This handles the case where a node restarts
+                // before an envelope was persisted to the DB.
+                Err(BlockError::DuplicateFullyImported(_)) => {
+                    if block.as_block().fork_name_unchecked().gloas_enabled() {
+                        filtered_chain_segment.push((block_root, block));
+                    }
+                }
                 // If the block is the genesis block, simply ignore this block.
                 Err(BlockError::GenesisBlock) => continue,
                 // If the block is is for a finalized slot, simply ignore this block.
@@ -2836,7 +2866,15 @@ impl<T: BeaconChainTypes> BeaconChain<T> {
                 // In the case of (2), skipping the block is valid since we should never import it.
                 // However, we will potentially get a `ParentUnknown` on a later block. The sync
                 // protocol will need to ensure this is handled gracefully.
-                Err(BlockError::WouldRevertFinalizedSlot { .. }) => continue,
+                Err(BlockError::WouldRevertFinalizedSlot { .. }) => {
+                    // Gloas: keep blocks at finalized slots so their envelopes can
+                    // still be processed. This handles the checkpoint sync case where
+                    // the checkpoint block is already finalized but its envelope hasn't
+                    // been stored yet.
+                    if block.as_block().fork_name_unchecked().gloas_enabled() {
+                        filtered_chain_segment.push((block_root, block));
+                    }
+                }
                 // The block has a known parent that does not descend from the finalized block.
                 // There is no need to process this block or any children.
                 Err(BlockError::NotFinalizedDescendant { block_parent_root }) => {
@@ -2905,6 +2943,39 @@ impl<T: BeaconChainTypes> BeaconChain<T> {
             }
         };
 
+        // Strip already-known blocks (e.g. the checkpoint sync anchor) from the
+        // front of the segment and process only their envelopes. These blocks
+        // can't go through signature_verify_chain_segment because their parents
+        // may not be available.
+        while let Some((root, _)) = filtered_chain_segment.first() {
+            if !self
+                .canonical_head
+                .fork_choice_read_lock()
+                .contains_block(root)
+            {
+                break;
+            }
+            let (block_root, block) = filtered_chain_segment.remove(0);
+            let maybe_envelope = match block {
+                RangeSyncBlock::Gloas { envelope, .. } => envelope,
+                _ => None,
+            };
+            if let Some(envelope) = maybe_envelope
+                && let Err(error) = self
+                    .process_range_sync_envelope(
+                        block_root,
+                        envelope,
+                        notify_execution_layer,
+                    )
+                    .await
+            {
+                return ChainSegmentResult::Failed {
+                    imported_blocks,
+                    error: BlockError::EnvelopeError(Box::new(error)),
+                };
+            }
+        }
+
         while let Some((_root, block)) = filtered_chain_segment.first() {
             // Determine the epoch of the first block in the remaining segment.
             let start_epoch = block.epoch();
@@ -2944,12 +3015,14 @@ impl<T: BeaconChainTypes> BeaconChain<T> {
                 }
             };
 
-            // Import the blocks into the chain.
-            for signature_verified_block in signature_verified_blocks {
+            // Import the blocks (and envelopes for Gloas) into the chain.
+            for (signature_verified_block, maybe_envelope) in signature_verified_blocks {
+                let block_root = signature_verified_block.block_root();
                 let block_slot = signature_verified_block.slot();
+
                 match self
                     .process_block(
-                        signature_verified_block.block_root(),
+                        block_root,
                         signature_verified_block,
                         notify_execution_layer,
                         BlockImportSource::RangeSync,
@@ -2962,6 +3035,22 @@ impl<T: BeaconChainTypes> BeaconChain<T> {
                             AvailabilityProcessingStatus::Imported(block_root) => {
                                 // The block was imported successfully.
                                 imported_blocks.push((block_root, block_slot));
+
+                                // Gloas: process the envelope now that the block is in fork choice.
+                                if let Some(envelope) = maybe_envelope
+                                    && let Err(error) = self
+                                        .process_range_sync_envelope(
+                                            block_root,
+                                            envelope,
+                                            notify_execution_layer,
+                                        )
+                                        .await
+                                {
+                                    return ChainSegmentResult::Failed {
+                                        imported_blocks,
+                                        error: BlockError::EnvelopeError(Box::new(error)),
+                                    };
+                                }
                             }
                             AvailabilityProcessingStatus::MissingComponents(slot, block_root) => {
                                 warn!(
@@ -2978,11 +3067,29 @@ impl<T: BeaconChainTypes> BeaconChain<T> {
                             }
                         }
                     }
-                    Err(BlockError::DuplicateFullyImported(block_root)) => {
+                    Err(BlockError::DuplicateFullyImported(_))
+                    | Err(BlockError::WouldRevertFinalizedSlot { .. }) => {
                         debug!(
                             ?block_root,
-                            "Ignoring already known blocks while processing chain segment"
+                            "Ignoring already known block while processing chain segment"
                         );
+                        // Gloas: still process the envelope for duplicate blocks. The envelope
+                        // may not have been persisted before a restart, or the block may be the
+                        // checkpoint sync anchor whose envelope was never stored.
+                        if let Some(envelope) = maybe_envelope
+                            && let Err(error) = self
+                                .process_range_sync_envelope(
+                                    block_root,
+                                    envelope,
+                                    notify_execution_layer,
+                                )
+                                .await
+                        {
+                            return ChainSegmentResult::Failed {
+                                imported_blocks,
+                                error: BlockError::EnvelopeError(Box::new(error)),
+                            };
+                        }
                         continue;
                     }
                     Err(error) => {
@@ -7185,7 +7292,7 @@ impl<T: BeaconChainTypes> BeaconChain<T> {
         block_data: AvailableBlockData<T::EthSpec>,
     ) -> Option<StoreOp<'_, T::EthSpec>> {
         match block_data {
-            AvailableBlockData::NoData => None,
+            AvailableBlockData::NoData | AvailableBlockData::DataInEnvelope => None,
             AvailableBlockData::Blobs(blobs) => {
                 debug!(
                     %block_root,

beacon_node/beacon_chain/src/beacon_fork_choice_store.rs

@@ -172,11 +172,13 @@ where
         let mut anchor_state = anchor.beacon_state;
         let mut anchor_block_header = anchor_state.latest_block_header().clone();
 
-        // The anchor state MUST be on an epoch boundary (it should be advanced by the caller).
-        if !anchor_state
-            .slot()
-            .as_u64()
-            .is_multiple_of(E::slots_per_epoch())
+        // Pre-gloas the anchor state MUST be on an epoch boundary (it should be advanced by the caller).
+        // Post-gloas this requirement is relaxed.
+        if !anchor_state.fork_name_unchecked().gloas_enabled()
+            && !anchor_state
+                .slot()
+                .as_u64()
+                .is_multiple_of(E::slots_per_epoch())
         {
             return Err(Error::UnalignedCheckpoint {
                 block_slot: anchor_block_header.slot,

beacon_node/beacon_chain/src/block_verification.rs

@@ -60,6 +60,7 @@ use crate::execution_payload::{
 };
 use crate::kzg_utils::blobs_to_data_column_sidecars;
 use crate::observed_block_producers::SeenBlock;
+use crate::payload_envelope_verification::{AvailableEnvelope, EnvelopeError};
 use crate::validator_monitor::HISTORIC_EPOCHS as VALIDATOR_MONITOR_HISTORIC_EPOCHS;
 use crate::validator_pubkey_cache::ValidatorPubkeyCache;
 use crate::{
@@ -321,6 +322,20 @@ pub enum BlockError {
         bid_parent_root: Hash256,
         block_parent_root: Hash256,
     },
+    /// The child block is known but its parent execution payload envelope has not been received yet.
+    ///
+    /// ## Peer scoring
+    ///
+    /// It's unclear if this block is valid, but it cannot be fully verified without the parent's
+    /// execution payload envelope.
+    ParentEnvelopeUnknown { parent_root: Hash256 },
+    /// An error occurred while processing the execution payload envelope during range sync.
+    EnvelopeError(Box<EnvelopeError>),
+
+    PayloadEnvelopeError {
+        e: Box<EnvelopeError>,
+        penalize_peer: bool,
+    },
 }
 
 /// Which specific signature(s) are invalid in a SignedBeaconBlock
@@ -487,6 +502,36 @@ impl From<ArithError> for BlockError {
     }
 }
 
+impl From<EnvelopeError> for BlockError {
+    fn from(e: EnvelopeError) -> Self {
+        let penalize_peer = match &e {
+            // REJECT per spec: peer sent invalid envelope data
+            EnvelopeError::BadSignature
+            | EnvelopeError::BuilderIndexMismatch { .. }
+            | EnvelopeError::BlockHashMismatch { .. }
+            | EnvelopeError::SlotMismatch { .. }
+            | EnvelopeError::IncorrectBlockProposer { .. } => true,
+            // IGNORE per spec: not the peer's fault
+            EnvelopeError::BlockRootUnknown { .. }
+            | EnvelopeError::PriorToFinalization { .. }
+            | EnvelopeError::UnknownValidator { .. } => false,
+            // Internal errors: not the peer's fault
+            EnvelopeError::BeaconChainError(_)
+            | EnvelopeError::BeaconStateError(_)
+            | EnvelopeError::BlockProcessingError(_)
+            | EnvelopeError::EnvelopeProcessingError(_)
+            | EnvelopeError::ExecutionPayloadError(_)
+            | EnvelopeError::BlockError(_)
+            | EnvelopeError::InternalError(_)
+            | EnvelopeError::OptimisticSyncNotSupported { .. } => false,
+        };
+        BlockError::PayloadEnvelopeError {
+            e: Box::new(e),
+            penalize_peer,
+        }
+    }
+}
+
 /// Stores information about verifying a payload against an execution engine.
 #[derive(Debug, PartialEq, Clone, Encode, Decode)]
 pub struct PayloadVerificationOutcome {
@@ -584,10 +629,17 @@ pub(crate) fn process_block_slash_info<T: BeaconChainTypes, TErr: BlockBlobError
 /// The given `chain_segment` must contain only blocks from the same epoch, otherwise an error
 /// will be returned.
 #[instrument(skip_all)]
+#[allow(clippy::type_complexity)]
 pub fn signature_verify_chain_segment<T: BeaconChainTypes>(
     mut chain_segment: Vec<(Hash256, RangeSyncBlock<T::EthSpec>)>,
     chain: &BeaconChain<T>,
-) -> Result<Vec<SignatureVerifiedBlock<T>>, BlockError> {
+) -> Result<
+    Vec<(
+        SignatureVerifiedBlock<T>,
+        Option<Box<AvailableEnvelope<T::EthSpec>>>,
+    )>,
+    BlockError,
+> {
     if chain_segment.is_empty() {
         return Ok(vec![]);
     }
@@ -616,14 +668,30 @@ pub fn signature_verify_chain_segment<T: BeaconChainTypes>(
         let consensus_context =
             ConsensusContext::new(block.slot()).set_current_block_root(block_root);
 
-        let available_block = block.into_available_block();
+        let (available_block, envelope) = match block {
+            RangeSyncBlock::Base(ab) => (ab, None),
+            RangeSyncBlock::Gloas { block, envelope } => {
+                let ab = AvailableBlock::new(
+                    block,
+                    AvailableBlockData::DataInEnvelope,
+                    &chain.data_availability_checker,
+                    chain.spec.clone(),
+                )
+                .map_err(BlockError::AvailabilityCheck)?;
+                (ab, envelope)
+            }
+        };
+
         available_blocks.push(available_block.clone());
-        signature_verified_blocks.push(SignatureVerifiedBlock {
-            block: MaybeAvailableBlock::Available(available_block),
-            block_root,
-            parent: None,
-            consensus_context,
-        });
+        signature_verified_blocks.push((
+            SignatureVerifiedBlock {
+                block: MaybeAvailableBlock::Available(available_block),
+                block_root,
+                parent: None,
+                consensus_context,
+            },
+            envelope,
+        ));
     }
 
     chain
@@ -633,7 +701,7 @@ pub fn signature_verify_chain_segment<T: BeaconChainTypes>(
     // verify signatures
     let pubkey_cache = get_validator_pubkey_cache(chain)?;
     let mut signature_verifier = get_signature_verifier(&state, &pubkey_cache, &chain.spec);
-    for svb in &mut signature_verified_blocks {
+    for (svb, _) in &mut signature_verified_blocks {
         signature_verifier
             .include_all_signatures(svb.block.as_block(), &mut svb.consensus_context)?;
     }
@@ -644,7 +712,7 @@ pub fn signature_verify_chain_segment<T: BeaconChainTypes>(
 
     drop(pubkey_cache);
 
-    if let Some(signature_verified_block) = signature_verified_blocks.first_mut() {
+    if let Some((signature_verified_block, _)) = signature_verified_blocks.first_mut() {
         signature_verified_block.parent = Some(parent);
     }
 
@@ -1192,7 +1260,7 @@ impl<T: BeaconChainTypes> SignatureVerifiedBlock<T> {
         let result = info_span!("signature_verify").in_scope(|| signature_verifier.verify());
         match result {
             Ok(_) => {
-                // gloas blocks are always available.
+                // Gloas blocks are always available — data arrives via the envelope.
                 let maybe_available = if chain
                     .spec
                     .fork_name_at_slot::<T::EthSpec>(block.slot())
@@ -1201,7 +1269,7 @@ impl<T: BeaconChainTypes> SignatureVerifiedBlock<T> {
                     MaybeAvailableBlock::Available(
                         AvailableBlock::new(
                             block,
-                            AvailableBlockData::NoData,
+                            AvailableBlockData::DataInEnvelope,
                             &chain.data_availability_checker,
                             chain.spec.clone(),
                         )
@@ -1971,14 +2039,13 @@ fn load_parent<T: BeaconChainTypes, B: AsBlock<T::EthSpec>>(
         } else if let Ok(parent_bid_block_hash) = parent_block.payload_bid_block_hash()
             && block.as_block().is_parent_block_full(parent_bid_block_hash)
         {
-            // Post-Gloas Full block case.
-            // TODO(gloas): loading the envelope here is not very efficient
-            let Some(envelope) = chain.store.get_payload_envelope(&root)? else {
-                return Err(BeaconChainError::DBInconsistent(format!(
-                    "Missing envelope for parent block {root:?}",
-                ))
-                .into());
-            };
+            // If the parent's execution payload envelope hasn't arrived yet,
+            // return an unknown parent error so the block gets sent to the
+            // reprocess queue.
+            let envelope = chain
+                .store
+                .get_payload_envelope(&root)?
+                .ok_or(BlockError::ParentEnvelopeUnknown { parent_root: root })?;
             let state_root = envelope.message.state_root;
             (StatePayloadStatus::Full, state_root)
         } else {