Rough prototype for architectural changes needed to introduce execution proofs

beacon_node/beacon_chain/src/beacon_chain.rs

@@ -3659,6 +3659,40 @@ impl<T: BeaconChainTypes> BeaconChain<T> {
             .await
     }
 
+    /// Checks if the provided execution proof(s) can make any cached blocks available/importable.
+    ///  Otherwise caches the proof(s) in the data availability checker.
+    ///
+    /// Note: Unlike blobs/data columns, execution proofs do not carry a signed header because
+    /// they arrive after the block has been made. So we do not perform any slashing-related checks for proofs.
+    pub async fn check_gossip_execution_proof_availability_and_import<
+        O: crate::observed_data_sidecars::ObservationStrategy,
+    >(
+        self: &Arc<Self>,
+        block_root: Hash256,
+        execution_proofs: impl IntoIterator<
+            Item = crate::execution_proof_verification::GossipVerifiedExecutionProof<T, O>,
+        >,
+    ) -> Result<AvailabilityProcessingStatus, BlockError> {
+        let availability = self
+            .data_availability_checker
+            .put_gossip_verified_execution_proofs(block_root, execution_proofs)?;
+
+        // Note: the slot is only used for logging, default to 0 for now. The proof type may change
+        // in the future making the block's slot easily available.
+        let slot = self
+            .data_availability_checker
+            .get_cached_block(&block_root)
+            .map(|b| match b {
+                BlockProcessStatus::Unknown => Slot::new(0),
+                BlockProcessStatus::NotValidated(block, _)
+                | BlockProcessStatus::ExecutionValidated(block) => block.slot(),
+            })
+            .unwrap_or(Slot::new(0));
+
+        self.process_availability(slot, availability, || Ok(()))
+            .await
+    }
+
     fn check_columns_for_slashability<'a>(
         self: &Arc<Self>,
         block_root: Hash256,

beacon_node/beacon_chain/src/builder.rs

@@ -942,6 +942,13 @@ where
         };
         debug!(?custody_context, "Loading persisted custody context");
 
+        // Extract execution proof requirements before moving chain_config
+        let min_execution_proofs_required = if self.chain_config.stateless_validation {
+            Some(self.chain_config.stateless_min_proofs_required)
+        } else {
+            None
+        };
+
         let beacon_chain = BeaconChain {
             spec: self.spec.clone(),
             config: self.chain_config,
@@ -1019,6 +1026,7 @@ where
                     store,
                     custody_context,
                     self.spec,
+                    min_execution_proofs_required,
                 )
                 .map_err(|e| format!("Error initializing DataAvailabilityChecker: {:?}", e))?,
             ),

beacon_node/beacon_chain/src/chain_config.rs

@@ -81,6 +81,34 @@ pub struct ChainConfig {
     pub prepare_payload_lookahead: Duration,
     /// Use EL-free optimistic sync for the finalized part of the chain.
     pub optimistic_finalized_sync: bool,
+    /// Enable stateless validation mode for new payloads.
+    ///
+    /// Currently this means that the node will accept blocks optimistically
+    /// and maintain metadata about which blocks have been proven and which ones have not.
+    pub stateless_validation: bool,
+    /// Generate execution proofs for all blocks received.
+    ///
+    /// Nodes that have this enabled will be used to bootstrap proofs into the subnets,
+    /// whether they are a proposer or not.
+    pub generate_execution_proofs: bool,
+    /// Maximum number of execution proof subnets this node will participate in.
+    ///
+    /// This is a per-node configuration that must not exceed the protocol maximum
+    /// (MAX_EXECUTION_PROOF_SUBNETS). Nodes may choose to participate in fewer
+    /// subnets to reduce resource usage, but this limits the number of proofs they
+    /// can generate or validate.
+    ///
+    /// TODO: We can remove the sequential allocations with a random allocation, so that lower numbered
+    /// TODO: subnets are not important. Current strategy is mostly POC.
+    ///
+    /// Note: stateless_min_proofs_required must not exceed this value, as a node
+    /// cannot require more proofs than the number of subnets it participates in.
+    pub max_execution_proof_subnets: u64,
+    /// Minimum number of proofs required to consider a block valid in stateless mode.
+    ///
+    /// Must be between 1 and max_execution_proof_subnets. Higher values provide
+    /// more security but may increase block validation latency.
+    pub stateless_min_proofs_required: usize,
     /// The size of the shuffling cache,
     pub shuffling_cache_size: usize,
     /// If using a weak-subjectivity sync, whether we should download blocks all the way back to
@@ -144,6 +172,10 @@ impl Default for ChainConfig {
             prepare_payload_lookahead: Duration::from_secs(4),
             // This value isn't actually read except in tests.
             optimistic_finalized_sync: true,
+            stateless_validation: false,
+            generate_execution_proofs: false,
+            max_execution_proof_subnets: 8,
+            stateless_min_proofs_required: 1,
             shuffling_cache_size: crate::shuffling_cache::DEFAULT_CACHE_SIZE,
             genesis_backfill: false,
             complete_blob_backfill: false,

beacon_node/beacon_chain/src/data_availability_checker.rs

@@ -22,7 +22,7 @@ use tracing::{debug, error, instrument};
 use types::blob_sidecar::{BlobIdentifier, BlobSidecar, FixedBlobSidecarList};
 use types::{
     BlobSidecarList, BlockImportSource, ChainSpec, DataColumnSidecar, DataColumnSidecarList, Epoch,
-    EthSpec, Hash256, SignedBeaconBlock, Slot,
+    EthSpec, ExecutionProof, Hash256, SignedBeaconBlock, Slot,
 };
 
 mod error;
@@ -100,8 +100,8 @@ pub enum DataColumnReconstructionResult<E: EthSpec> {
 
 /// This type is returned after adding a block / blob to the `DataAvailabilityChecker`.
 ///
-/// Indicates if the block is fully `Available` or if we need blobs or blocks
-///  to "complete" the requirements for an `AvailableBlock`.
+/// Indicates if the block is ready for import or if we need blobs, columns, or execution proofs
+/// to "complete" the requirements for an importable block.
 pub enum Availability<E: EthSpec> {
     MissingComponents(Hash256),
     Available(Box<AvailableExecutedBlock<E>>),
@@ -113,7 +113,9 @@ impl<E: EthSpec> Debug for Availability<E> {
             Self::MissingComponents(block_root) => {
                 write!(f, "MissingComponents({})", block_root)
             }
-            Self::Available(block) => write!(f, "Available({:?})", block.import_data.block_root),
+            Self::Available(block) => {
+                write!(f, "ReadyForImport({:?})", block.import_data.block_root)
+            }
         }
     }
 }
@@ -126,12 +128,14 @@ impl<T: BeaconChainTypes> DataAvailabilityChecker<T> {
         store: BeaconStore<T>,
         custody_context: Arc<CustodyContext<T::EthSpec>>,
         spec: Arc<ChainSpec>,
+        min_execution_proofs_required: Option<usize>,
     ) -> Result<Self, AvailabilityCheckError> {
         let inner = DataAvailabilityCheckerInner::new(
             OVERFLOW_LRU_CAPACITY,
             store,
             custody_context.clone(),
             spec.clone(),
+            min_execution_proofs_required,
         )?;
         Ok(Self {
             complete_blob_backfill,
@@ -210,6 +214,26 @@ impl<T: BeaconChainTypes> DataAvailabilityChecker<T> {
         self.availability_cache.peek_data_columns(block_root)
     }
 
+    /// Put gossip verified execution proofs into the availability cache.
+    ///
+    /// This allows stateless validation nodes to collect proofs for execution payloads.
+    pub fn put_gossip_verified_execution_proofs<I, O>(
+        &self,
+        block_root: Hash256,
+        execution_proofs: I,
+    ) -> Result<Availability<T::EthSpec>, AvailabilityCheckError>
+    where
+        I: IntoIterator<
+            Item = crate::execution_proof_verification::GossipVerifiedExecutionProof<T, O>,
+        >,
+        O: crate::observed_data_sidecars::ObservationStrategy,
+    {
+        self.availability_cache.put_execution_proofs(
+            block_root,
+            execution_proofs.into_iter().map(|v| v.into_inner()),
+        )
+    }
+
     /// Put a list of blobs received via RPC into the availability cache. This performs KZG
     /// verification on the blobs in the list.
     #[instrument(skip_all, level = "trace")]
@@ -386,6 +410,7 @@ impl<T: BeaconChainTypes> DataAvailabilityChecker<T> {
                     block,
                     blob_data: AvailableBlockData::Blobs(blob_list),
                     blobs_available_timestamp: None,
+                    proof_data: ImportableProofData::NoneRequired,
                     spec: self.spec.clone(),
                 }))
             } else {
@@ -411,6 +436,7 @@ impl<T: BeaconChainTypes> DataAvailabilityChecker<T> {
                             .collect(),
                     ),
                     blobs_available_timestamp: None,
+                    proof_data: ImportableProofData::NoneRequired,
                     spec: self.spec.clone(),
                 }))
             } else {
@@ -423,6 +449,7 @@ impl<T: BeaconChainTypes> DataAvailabilityChecker<T> {
             block,
             blob_data: AvailableBlockData::NoData,
             blobs_available_timestamp: None,
+            proof_data: ImportableProofData::NoneRequired,
             spec: self.spec.clone(),
         }))
     }
@@ -479,6 +506,7 @@ impl<T: BeaconChainTypes> DataAvailabilityChecker<T> {
                         block,
                         blob_data: AvailableBlockData::Blobs(blobs),
                         blobs_available_timestamp: None,
+                        proof_data: ImportableProofData::NoneRequired,
                         spec: self.spec.clone(),
                     })
                 } else {
@@ -493,6 +521,7 @@ impl<T: BeaconChainTypes> DataAvailabilityChecker<T> {
                             data_columns.into_iter().map(|d| d.into_inner()).collect(),
                         ),
                         blobs_available_timestamp: None,
+                        proof_data: ImportableProofData::NoneRequired,
                         spec: self.spec.clone(),
                     })
                 } else {
@@ -504,6 +533,7 @@ impl<T: BeaconChainTypes> DataAvailabilityChecker<T> {
                     block,
                     blob_data: AvailableBlockData::NoData,
                     blobs_available_timestamp: None,
+                    proof_data: ImportableProofData::NoneRequired,
                     spec: self.spec.clone(),
                 })
             };
@@ -527,6 +557,13 @@ impl<T: BeaconChainTypes> DataAvailabilityChecker<T> {
         self.da_check_required_for_epoch(epoch) && self.spec.is_peer_das_enabled_for_epoch(epoch)
     }
 
+    /// Determines the execution proof requirements for an epoch.
+    /// - If the epoch is from prior to the data availability boundary, no execution proofs are required.
+    /// - This allows historical blocks to sync without waiting for execution proofs.
+    pub fn execution_proofs_required_for_epoch(&self, epoch: Epoch) -> bool {
+        self.da_check_required_for_epoch(epoch) // Only for recent blocks within DA boundary
+    }
+
     /// See `Self::blobs_required_for_epoch`
     fn blobs_required_for_block(&self, block: &SignedBeaconBlock<T::EthSpec>) -> bool {
         block.num_expected_blobs() > 0 && self.blobs_required_for_epoch(block.epoch())
@@ -754,6 +791,25 @@ pub enum AvailableBlockData<E: EthSpec> {
     DataColumns(DataColumnSidecarList<E>),
 }
 
+/// Execution proof data
+///
+/// The proofs that were collected that convinced the node that the
+/// Block's execution payload was indeed valid.
+#[derive(Debug, Clone)]
+pub enum ImportableProofData {
+    /// Execution proofs that were used to validate this block.
+    /// The number of proofs is at least `min_proofs_required` because
+    /// that is needed for the block to be seen as available/importable.
+    ///
+    /// TODO: Its possible for us to provide a proof that that the
+    /// ExecutionPayload was invalid. Is this useful? This would allow
+    /// us to distinguish between the case where the prover cannot create a
+    /// proof of a valid payload.
+    Proofs(Vec<ExecutionProof>),
+    /// This is the case when the node opts to not receive proofs
+    NoneRequired,
+}
+
 /// A fully available block that is ready to be imported into fork choice.
 #[derive(Debug)]
 pub struct AvailableBlock<E: EthSpec> {
@@ -762,6 +818,8 @@ pub struct AvailableBlock<E: EthSpec> {
     blob_data: AvailableBlockData<E>,
     /// Timestamp at which this block first became available (UNIX timestamp, time since 1970).
     blobs_available_timestamp: Option<Duration>,
+    /// Execution proof data for this block
+    pub proof_data: ImportableProofData,
     pub spec: Arc<ChainSpec>,
 }
 
@@ -770,13 +828,15 @@ impl<E: EthSpec> AvailableBlock<E> {
         block_root: Hash256,
         block: Arc<SignedBeaconBlock<E>>,
         data: AvailableBlockData<E>,
+        proof_data: ImportableProofData,
         spec: Arc<ChainSpec>,
     ) -> Self {
         Self {
             block_root,
             block,
             blob_data: data,
             blobs_available_timestamp: None,
+            proof_data,
             spec,
         }
     }
@@ -828,6 +888,7 @@ impl<E: EthSpec> AvailableBlock<E> {
                 }
             },
             blobs_available_timestamp: self.blobs_available_timestamp,
+            proof_data: self.proof_data.clone(),
             spec: self.spec.clone(),
         })
     }
@@ -1112,6 +1173,7 @@ mod test {
             store,
             custody_context,
             spec,
+            None,
         )
         .expect("should initialise data availability checker")
     }