Builder flow for Deneb & Blobs

beacon_node/beacon_chain/src/beacon_chain.rs

@@ -7,7 +7,6 @@ use crate::attester_cache::{AttesterCache, AttesterCacheKey};
 use crate::beacon_block_streamer::{BeaconBlockStreamer, CheckEarlyAttesterCache};
 use crate::beacon_proposer_cache::compute_proposer_duties_from_head;
 use crate::beacon_proposer_cache::BeaconProposerCache;
-use crate::blob_cache::BlobCache;
 use crate::blob_verification::{self, BlobError, GossipVerifiedBlob};
 use crate::block_times_cache::BlockTimesCache;
 use crate::block_verification::POS_PANDA_BANNER;
@@ -117,8 +116,8 @@ use store::{
 use task_executor::{ShutdownReason, TaskExecutor};
 use tokio_stream::Stream;
 use tree_hash::TreeHash;
+use types::beacon_block_body::KzgCommitments;
 use types::beacon_state::CloneConfig;
-use types::blob_sidecar::BlobSidecarList;
 use types::consts::deneb::MIN_EPOCHS_FOR_BLOB_SIDECARS_REQUESTS;
 use types::*;
 
@@ -477,12 +476,15 @@ pub struct BeaconChain<T: BeaconChainTypes> {
     pub validator_monitor: RwLock<ValidatorMonitor<T::EthSpec>>,
     /// The slot at which blocks are downloaded back to.
     pub genesis_backfill_slot: Slot,
-    pub proposal_blob_cache: BlobCache<T::EthSpec>,
     pub data_availability_checker: Arc<DataAvailabilityChecker<T>>,
     pub kzg: Option<Arc<Kzg<<T::EthSpec as EthSpec>::Kzg>>>,
 }
 
-type BeaconBlockAndState<T, Payload> = (BeaconBlock<T, Payload>, BeaconState<T>);
+type BeaconBlockAndState<T, Payload> = (
+    BeaconBlock<T, Payload>,
+    BeaconState<T>,
+    Option<SidecarListVariant<T>>,
+);
 
 impl FinalizationAndCanonicity {
     pub fn is_finalized(self) -> bool {
@@ -4950,67 +4952,45 @@ impl<T: BeaconChainTypes> BeaconChain<T> {
 
         //FIXME(sean)
         // - add a new timer for processing here
-        if let (Some(blobs), Some(proofs)) = (blobs_opt, proofs_opt) {
-            let kzg = self
-                .kzg
-                .as_ref()
-                .ok_or(BlockProductionError::TrustedSetupNotInitialized)?;
-            let beacon_block_root = block.canonical_root();
-            let expected_kzg_commitments = block.body().blob_kzg_commitments().map_err(|_| {
-                BlockProductionError::InvalidBlockVariant(
-                    "DENEB block does not contain kzg commitments".to_string(),
-                )
-            })?;
-
-            if expected_kzg_commitments.len() != blobs.len() {
-                return Err(BlockProductionError::MissingKzgCommitment(format!(
-                    "Missing KZG commitment for slot {}. Expected {}, got: {}",
-                    slot,
-                    blobs.len(),
-                    expected_kzg_commitments.len()
-                )));
-            }
-
-            let kzg_proofs = Vec::from(proofs);
-
-            kzg_utils::validate_blobs::<T::EthSpec>(
-                kzg.as_ref(),
-                expected_kzg_commitments,
-                &blobs,
-                &kzg_proofs,
-            )
-            .map_err(BlockProductionError::KzgError)?;
-
-            let blob_sidecars = BlobSidecarList::from(
-                blobs
-                    .into_iter()
-                    .enumerate()
-                    .map(|(blob_index, blob)| {
-                        let kzg_commitment = expected_kzg_commitments
-                            .get(blob_index)
-                            .expect("KZG commitment should exist for blob");
+        let maybe_sidecar_list = match (blobs_opt, proofs_opt) {
+            (Some(blobs_or_blobs_roots), Some(proofs)) => {
+                let expected_kzg_commitments =
+                    block.body().blob_kzg_commitments().map_err(|_| {
+                        BlockProductionError::InvalidBlockVariant(
+                            "DENEB block does not contain kzg commitments".to_string(),
+                        )
+                    })?;
 
-                        let kzg_proof = kzg_proofs
-                            .get(blob_index)
-                            .expect("KZG proof should exist for blob");
-
-                        Ok(Arc::new(BlobSidecar {
-                            block_root: beacon_block_root,
-                            index: blob_index as u64,
-                            slot,
-                            block_parent_root: block.parent_root(),
-                            proposer_index,
-                            blob,
-                            kzg_commitment: *kzg_commitment,
-                            kzg_proof: *kzg_proof,
-                        }))
-                    })
-                    .collect::<Result<Vec<_>, BlockProductionError>>()?,
-            );
+                if expected_kzg_commitments.len() != blobs_or_blobs_roots.len() {
+                    return Err(BlockProductionError::MissingKzgCommitment(format!(
+                        "Missing KZG commitment for slot {}. Expected {}, got: {}",
+                        block.slot(),
+                        blobs_or_blobs_roots.len(),
+                        expected_kzg_commitments.len()
+                    )));
+                }
 
-            self.proposal_blob_cache
-                .put(beacon_block_root, blob_sidecars);
-        }
+                let kzg_proofs = Vec::from(proofs);
+
+                match blobs_or_blobs_roots {
+                    BlobsOrBlobRoots::Blobs(blobs) => Some(self.build_blob_sidecars(
+                        &block,
+                        blobs,
+                        expected_kzg_commitments,
+                        kzg_proofs,
+                    )?),
+                    BlobsOrBlobRoots::BlobRoots(blob_roots) => {
+                        Some(self.build_blinded_blob_sidecars(
+                            &block,
+                            blob_roots,
+                            expected_kzg_commitments,
+                            kzg_proofs,
+                        )?)
+                    }
+                }
+            }
+            _ => None,
+        };
 
         metrics::inc_counter(&metrics::BLOCK_PRODUCTION_SUCCESSES);
 
@@ -5022,7 +5002,7 @@ impl<T: BeaconChainTypes> BeaconChain<T> {
             "slot" => block.slot()
         );
 
-        Ok((block, state))
+        Ok((block, state, maybe_sidecar_list))
     }
 
     /// This method must be called whenever an execution engine indicates that a payload is
@@ -6278,6 +6258,97 @@ impl<T: BeaconChainTypes> BeaconChain<T> {
             .map(|fork_epoch| fork_epoch <= current_epoch)
             .unwrap_or(false))
     }
+
+    fn build_blob_sidecars<Payload: AbstractExecPayload<T::EthSpec>>(
+        &self,
+        block: &BeaconBlock<T::EthSpec, Payload>,
+        blobs: Blobs<T::EthSpec>,
+        expected_kzg_commitments: &KzgCommitments<T::EthSpec>,
+        kzg_proofs: Vec<KzgProof>,
+    ) -> Result<SidecarListVariant<T::EthSpec>, BlockProductionError> {
+        let kzg = self
+            .kzg
+            .as_ref()
+            .ok_or(BlockProductionError::TrustedSetupNotInitialized)?;
+        let beacon_block_root = block.canonical_root();
+        let slot = block.slot();
+
+        kzg_utils::validate_blobs::<T::EthSpec>(kzg, expected_kzg_commitments, &blobs, &kzg_proofs)
+            .map_err(BlockProductionError::KzgError)?;
+
+        let blob_sidecars = BlobSidecarList::from(
+            blobs
+                .into_iter()
+                .enumerate()
+                .map(|(blob_index, blob)| {
+                    let kzg_commitment = expected_kzg_commitments
+                        .get(blob_index)
+                        .expect("KZG commitment should exist for blob");
+
+                    let kzg_proof = kzg_proofs
+                        .get(blob_index)
+                        .expect("KZG proof should exist for blob");
+
+                    Ok(Arc::new(BlobSidecar {
+                        block_root: beacon_block_root,
+                        index: blob_index as u64,
+                        slot,
+                        block_parent_root: block.parent_root(),
+                        proposer_index: block.proposer_index(),
+                        blob,
+                        kzg_commitment: *kzg_commitment,
+                        kzg_proof: *kzg_proof,
+                    }))
+                })
+                .collect::<Result<Vec<_>, BlockProductionError>>()?,
+        );
+
+        Ok(SidecarListVariant::Full(blob_sidecars))
+    }
+
+    fn build_blinded_blob_sidecars<Payload: AbstractExecPayload<T::EthSpec>>(
+        &self,
+        block: &BeaconBlock<T::EthSpec, Payload>,
+        blob_roots: BlobRoots<T::EthSpec>,
+        expected_kzg_commitments: &KzgCommitments<T::EthSpec>,
+        kzg_proofs: Vec<KzgProof>,
+    ) -> Result<SidecarListVariant<T::EthSpec>, BlockProductionError> {
+        let beacon_block_root = block.canonical_root();
+        let slot = block.slot();
+
+        let blob_sidecars = BlindedBlobSidecarList::<T::EthSpec>::from(
+            blob_roots
+                .into_iter()
+                .enumerate()
+                .map(|(blob_index, blob_root)| {
+                    let kzg_commitment = expected_kzg_commitments
+                        .get(blob_index)
+                        .expect("KZG commitment should exist for blob");
+
+                    let kzg_proof =
+                        kzg_proofs
+                            .get(blob_index)
+                            .ok_or(BlockProductionError::MissingKzgProof(format!(
+                                "Missing KZG proof for slot {} blob index: {}",
+                                slot, blob_index
+                            )))?;
+
+                    Ok(Arc::new(BlindedBlobSidecar {
+                        block_root: beacon_block_root,
+                        index: blob_index as u64,
+                        slot,
+                        block_parent_root: block.parent_root(),
+                        proposer_index: block.proposer_index(),
+                        blob_root,
+                        kzg_commitment: *kzg_commitment,
+                        kzg_proof: *kzg_proof,
+                    }))
+                })
+                .collect::<Result<Vec<_>, BlockProductionError>>()?,
+        );
+
+        Ok(SidecarListVariant::Blinded(blob_sidecars))
+    }
 }
 
 impl<T: BeaconChainTypes> Drop for BeaconChain<T> {

beacon_node/beacon_chain/src/builder.rs

@@ -1,5 +1,4 @@
 use crate::beacon_chain::{CanonicalHead, BEACON_CHAIN_DB_KEY, ETH1_CACHE_DB_KEY, OP_POOL_DB_KEY};
-use crate::blob_cache::BlobCache;
 use crate::data_availability_checker::DataAvailabilityChecker;
 use crate::eth1_chain::{CachingEth1Backend, SszEth1};
 use crate::eth1_finalization_cache::Eth1FinalizationCache;
@@ -889,7 +888,6 @@ where
                 DataAvailabilityChecker::new(slot_clock, kzg.clone(), store, self.spec)
                     .map_err(|e| format!("Error initializing DataAvailabiltyChecker: {:?}", e))?,
             ),
-            proposal_blob_cache: BlobCache::default(),
             kzg,
         };
 

beacon_node/beacon_chain/src/errors.rs

@@ -275,14 +275,15 @@ pub enum BlockProductionError {
         blob_block_hash: ExecutionBlockHash,
         payload_block_hash: ExecutionBlockHash,
     },
-    NoBlobsCached,
     FailedToReadFinalizedBlock(store::Error),
     MissingFinalizedBlock(Hash256),
     BlockTooLarge(usize),
     ShuttingDown,
+    MissingBlobs,
     MissingSyncAggregate,
     MissingExecutionPayload,
     MissingKzgCommitment(String),
+    MissingKzgProof(String),
     TokioJoin(tokio::task::JoinError),
     BeaconChain(BeaconChainError),
     InvalidPayloadFork,

beacon_node/beacon_chain/src/lib.rs

@@ -7,7 +7,6 @@ mod beacon_chain;
 mod beacon_fork_choice_store;
 pub mod beacon_proposer_cache;
 mod beacon_snapshot;
-pub mod blob_cache;
 pub mod blob_verification;
 pub mod block_reward;
 mod block_times_cache;