Rough prototype for architectural changes needed to introduce execution proofs

beacon_node/beacon_chain/src/beacon_chain.rs

@@ -3673,25 +3673,22 @@ impl<T: BeaconChainTypes> BeaconChain<T> {
             Item = crate::execution_proof_verification::GossipVerifiedExecutionProof<T, O>,
         >,
     ) -> Result<AvailabilityProcessingStatus, BlockError> {
-        // Obtain the slot from the DA checker pending components. If we don't have the
-        // block pending yet, return an error.
-        //
-        // Note: This assumes that we won't ask for a proof if its in the store.
-        let slot = self
-            .data_availability_checker
-            .get_execution_valid_block(&block_root)
-            .map(|b| b.slot())
-            // TODO: This is not an InternalError, just means we've received a proof without a block
-            .ok_or_else(|| {
-                BlockError::InternalError(
-                    "missing block in DA checker for execution proof".to_string(),
-                )
-            })?;
-
         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
     }

beacon_node/beacon_chain/src/builder.rs

@@ -899,7 +899,7 @@ where
         let genesis_time = head_snapshot.beacon_state.genesis_time();
         let canonical_head = CanonicalHead::new(fork_choice, Arc::new(head_snapshot));
         let shuffling_cache_size = self.chain_config.shuffling_cache_size;
-        let max_execution_payload_proofs = self.chain_config.max_execution_payload_proofs;
+        let complete_blob_backfill = self.chain_config.complete_blob_backfill;
 
         // Calculate the weak subjectivity point in which to backfill blocks to.
         let genesis_backfill_slot = if self.chain_config.genesis_backfill {

beacon_node/beacon_chain/src/chain_config.rs

@@ -91,8 +91,6 @@ pub struct ChainConfig {
     /// 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 payload proofs to store in memory.
-    pub max_execution_payload_proofs: usize,
     /// Maximum number of execution proof subnets this node will participate in.
     ///
     /// This is a per-node configuration that must not exceed the protocol maximum
@@ -176,7 +174,6 @@ impl Default for ChainConfig {
             optimistic_finalized_sync: true,
             stateless_validation: false,
             generate_execution_proofs: false,
-            max_execution_payload_proofs: 10_000,
             max_execution_proof_subnets: 8,
             stateless_min_proofs_required: 1,
             shuffling_cache_size: crate::shuffling_cache::DEFAULT_CACHE_SIZE,

beacon_node/beacon_chain/src/data_availability_checker.rs

@@ -21,8 +21,8 @@ use task_executor::TaskExecutor;
 use tracing::{debug, error, instrument};
 use types::blob_sidecar::{BlobIdentifier, BlobSidecar, FixedBlobSidecarList};
 use types::{
-    BlobSidecarList, ChainSpec, DataColumnSidecar, DataColumnSidecarList, Epoch, EthSpec,
-    ExecutionProof, Hash256, SignedBeaconBlock, Slot,
+    BlobSidecarList, BlockImportSource, ChainSpec, DataColumnSidecar, DataColumnSidecarList, Epoch,
+    EthSpec, ExecutionProof, Hash256, SignedBeaconBlock, Slot,
 };
 
 mod error;
@@ -1165,7 +1165,16 @@ mod test {
         let kzg = get_kzg(&spec);
         let store = Arc::new(HotColdDB::open_ephemeral(<_>::default(), spec.clone()).unwrap());
         let custody_context = Arc::new(CustodyContext::new(false));
-        DataAvailabilityChecker::new(slot_clock, kzg, store, custody_context, spec, None)
-            .expect("should initialise data availability checker")
+        let complete_blob_backfill = false;
+        DataAvailabilityChecker::new(
+            complete_blob_backfill,
+            slot_clock,
+            kzg,
+            store,
+            custody_context,
+            spec,
+            None,
+        )
+        .expect("should initialise data availability checker")
     }
 }

beacon_node/beacon_chain/src/data_availability_checker/overflow_lru_cache.rs

@@ -9,6 +9,7 @@ use crate::block_verification_types::{
 use crate::data_availability_checker::{Availability, AvailabilityCheckError, ImportableProofData};
 use crate::data_column_verification::KzgVerifiedCustodyDataColumn;
 use crate::execution_proof_verification::VerifiedExecutionProof;
+use crate::{BeaconChainTypes, BlockProcessStatus};
 use lighthouse_tracing::SPAN_PENDING_COMPONENTS;
 use lru::LruCache;
 use parking_lot::{MappedRwLockReadGuard, RwLock, RwLockReadGuard, RwLockWriteGuard};
@@ -211,9 +212,9 @@ impl<E: EthSpec> PendingComponents<E> {
     ) {
         for vproof in execution_proofs {
             let subnet_id = vproof.as_proof().subnet_id;
-            if !self.verified_execution_proofs.contains_key(&subnet_id) {
-                self.verified_execution_proofs.insert(subnet_id, vproof);
-            }
+            self.verified_execution_proofs
+                .entry(subnet_id)
+                .or_insert(vproof);
         }
     }
 

beacon_node/beacon_chain/src/errors.rs

@@ -231,6 +231,23 @@ pub enum BeaconChainError {
     },
     FailedToReconstructBlobs(String),
     ExecutionProofError(String),
+    ProposerCacheIncorrectState {
+        state_decision_block_root: Hash256,
+        requested_decision_block_root: Hash256,
+    },
+    ProposerCacheAccessorFailure {
+        decision_block_root: Hash256,
+        proposal_epoch: Epoch,
+    },
+    ProposerCacheOutOfBounds {
+        slot: Slot,
+        epoch: Epoch,
+    },
+    ProposerCacheWrongEpoch {
+        request_epoch: Epoch,
+        cache_epoch: Epoch,
+    },
+    SkipProposerPreparation,
 }
 
 easy_from_to!(SlotProcessingError, BeaconChainError);

beacon_node/beacon_chain/src/execution_proof_network.rs

@@ -1,9 +1,9 @@
-use crate::{BeaconChain, BeaconChainTypes, BlockProductionError};
+use crate::{BeaconChain, BeaconChainTypes};
 use std::sync::Arc;
 use tracing::{debug, info, warn};
 use types::{
-    BeaconBlockRef, BeaconStateError, ExecPayload, ExecutionPayload, ExecutionProofSubnetId,
-    FullPayload, FullPayloadRef, Hash256,
+    BeaconBlockRef, BeaconStateError, ExecutionPayload, ExecutionProofSubnetId, FullPayload,
+    FullPayloadRef, Hash256,
 };
 
 /// Spawn a background task to generate and store execution proofs with publishing via callback

beacon_node/beacon_chain/src/execution_proof_verification.rs

@@ -11,11 +11,10 @@ use std::time::Duration;
 use crate::BeaconChainError;
 use crate::beacon_chain::{BeaconChain, BeaconChainTypes};
 use crate::execution_proof_generation;
-use crate::observed_data_sidecars::{DoNotObserve, ObservationStrategy, Observe};
+use crate::observed_data_sidecars::{ObservationStrategy, Observe};
 use slot_clock::SlotClock;
-use tracing::debug;
 use types::execution_proof_subnet_id::ExecutionProofSubnetId;
-use types::{EthSpec, ExecutionProof, Hash256, Slot};
+use types::{ExecutionProof, Hash256, Slot};
 
 /// An error occurred while validating a gossip execution proof.
 #[derive(Debug)]
@@ -37,12 +36,12 @@ pub enum GossipExecutionProofError {
     /// The execution proof is structurally invalid.
     InvalidStructure { reason: String },
     /// Some other error occurred.
-    BeaconChainError(BeaconChainError),
+    BeaconChainError(Box<BeaconChainError>),
 }
 
 impl From<BeaconChainError> for GossipExecutionProofError {
     fn from(e: BeaconChainError) -> Self {
-        Self::BeaconChainError(e)
+        Self::BeaconChainError(e.into())
     }
 }
 
@@ -161,7 +160,7 @@ impl<T: BeaconChainTypes, O: ObservationStrategy> GossipVerifiedExecutionProof<T
 fn validate_execution_proof_for_gossip<T: BeaconChainTypes, O: ObservationStrategy>(
     proof: Arc<ExecutionProof>,
     subnet_id: ExecutionProofSubnetId,
-    chain: &BeaconChain<T>,
+    _chain: &BeaconChain<T>,
 ) -> Result<(), GossipExecutionProofError> {
     // Check subnet ID matches
     if proof.subnet_id != subnet_id {
@@ -179,7 +178,9 @@ fn validate_execution_proof_for_gossip<T: BeaconChainTypes, O: ObservationStrate
     }
 
     // TODO: Add timing validation based on slot
-    // TODO: Add duplicate proof detection
+    if O::observe() {
+        // TODO: Add duplicate proof detection
+    }
     // TODO: Add block existence validation
 
     Ok(())

beacon_node/http_api/src/publish_blocks.rs

@@ -3,7 +3,7 @@ use std::future::Future;
 
 use beacon_chain::blob_verification::{GossipBlobError, GossipVerifiedBlob};
 use beacon_chain::block_verification_types::{AsBlock, RpcBlock};
-use beacon_chain::data_column_verification::{GossipDataColumnError, GossipVerifiedDataColumn};
+use beacon_chain::data_column_verification::GossipVerifiedDataColumn;
 use beacon_chain::execution_proof_network;
 use beacon_chain::validator_monitor::{get_block_delay_ms, timestamp_now};
 use beacon_chain::{
@@ -29,10 +29,9 @@ use tokio::sync::mpsc::UnboundedSender;
 use tracing::{Span, debug, debug_span, error, info, instrument, warn};
 use tree_hash::TreeHash;
 use types::{
-    AbstractExecPayload, BeaconBlockRef, BeaconStateError, BlobSidecar, BlobsList,
-    BlockImportSource, DataColumnSubnetId, EthSpec, ExecPayload, ExecutionBlockHash,
-    ExecutionPayload, ForkName, FullPayload, FullPayloadBellatrix, FullPayloadRef, Hash256,
-    KzgProofs, SignedBeaconBlock, SignedBlindedBeaconBlock,
+    AbstractExecPayload, BeaconBlockRef, BlobSidecar, BlobsList, BlockImportSource,
+    DataColumnSubnetId, EthSpec, ExecPayload, ExecutionBlockHash, ForkName, FullPayload,
+    FullPayloadBellatrix, Hash256, KzgProofs, SignedBeaconBlock, SignedBlindedBeaconBlock,
 };
 use warp::http::StatusCode;
 use warp::{Rejection, Reply, reply::Response};

beacon_node/network/src/network_beacon_processor/gossip_methods.rs

@@ -39,13 +39,10 @@ use std::path::PathBuf;
 use std::sync::Arc;
 use std::time::{Duration, Instant, SystemTime, UNIX_EPOCH};
 use store::hot_cold_store::HotColdDBError;
-use tokio::sync::mpsc::UnboundedSender;
-use tokio::sync::mpsc::error::TrySendError;
 use tracing::{Instrument, Span, debug, error, info, instrument, trace, warn};
 use types::{
-    Attestation, AttestationData, AttestationRef, AttesterSlashing, BeaconBlockRef,
-    BeaconStateError, BlobSidecar, DataColumnSidecar, DataColumnSubnetId, EthSpec, ExecPayload,
-    ExecutionPayload, ExecutionProof, ExecutionProofSubnetId, FullPayload, FullPayloadRef, Hash256,
+    Attestation, AttestationData, AttestationRef, AttesterSlashing, BlobSidecar, DataColumnSidecar,
+    DataColumnSubnetId, EthSpec, ExecPayload, ExecutionProof, ExecutionProofSubnetId, Hash256,
     IndexedAttestation, LightClientFinalityUpdate, LightClientOptimisticUpdate, ProposerSlashing,
     SignedAggregateAndProof, SignedBeaconBlock, SignedBlsToExecutionChange,
     SignedContributionAndProof, SignedVoluntaryExit, SingleAttestation, Slot, SubnetId,
@@ -3369,7 +3366,6 @@ impl<T: BeaconChainTypes> NetworkBeaconProcessor<T> {
                     "execution_proof_validation_failed",
                 );
                 self.propagate_validation_result(message_id, peer_id, MessageAcceptance::Reject);
-                return;
             }
             Ok(availability_status) => {
                 match availability_status {