merge queue: embarking unstable (5121d65) and [#5406 + #5397 + #4946 + #5418 + #5383 + #5174] together

beacon_node/beacon_chain/src/beacon_chain.rs

@@ -1347,11 +1347,12 @@ impl<T: BeaconChainTypes> BeaconChain<T> {
         (parent_root, slot, sync_aggregate): LightClientProducerEvent<T::EthSpec>,
     ) -> Result<(), Error> {
         self.light_client_server_cache.recompute_and_cache_updates(
-            &self.log,
             self.store.clone(),
             &parent_root,
             slot,
             &sync_aggregate,
+            &self.log,
+            &self.spec,
         )
     }
 
@@ -2566,7 +2567,7 @@ impl<T: BeaconChainTypes> BeaconChain<T> {
         &self,
         epoch: Epoch,
         validator_indices: &[u64],
-    ) -> Result<Vec<Option<SyncDuty>>, Error> {
+    ) -> Result<Vec<Result<Option<SyncDuty>, BeaconStateError>>, Error> {
         self.with_head(move |head| {
             head.beacon_state
                 .get_sync_committee_duties(epoch, validator_indices, &self.spec)
@@ -2891,7 +2892,7 @@ impl<T: BeaconChainTypes> BeaconChain<T> {
         }
 
         self.data_availability_checker
-            .notify_gossip_blob(blob.slot(), block_root, &blob);
+            .notify_gossip_blob(block_root, &blob);
         let r = self.check_gossip_blob_availability_and_import(blob).await;
         self.remove_notified(&block_root, r)
     }
@@ -2925,7 +2926,7 @@ impl<T: BeaconChainTypes> BeaconChain<T> {
         }
 
         self.data_availability_checker
-            .notify_rpc_blobs(slot, block_root, &blobs);
+            .notify_rpc_blobs(block_root, &blobs);
         let r = self
             .check_rpc_blob_availability_and_import(slot, block_root, blobs)
             .await;
@@ -6635,13 +6636,17 @@ impl<T: BeaconChainTypes> BeaconChain<T> {
         &self,
         block_root: &Hash256,
     ) -> Result<Option<(LightClientBootstrap<T::EthSpec>, ForkName)>, Error> {
-        let Some((state_root, slot)) = self
-            .get_blinded_block(block_root)?
-            .map(|block| (block.state_root(), block.slot()))
-        else {
+        let handle = self
+            .task_executor
+            .handle()
+            .ok_or(BeaconChainError::RuntimeShutdown)?;
+
+        let Some(block) = handle.block_on(async { self.get_block(block_root).await })? else {
             return Ok(None);
         };
 
+        let (state_root, slot) = (block.state_root(), block.slot());
+
         let Some(mut state) = self.get_state(&state_root, Some(slot))? else {
             return Ok(None);
         };
@@ -6651,12 +6656,12 @@ impl<T: BeaconChainTypes> BeaconChain<T> {
             .map_err(Error::InconsistentFork)?;
 
         match fork_name {
-            ForkName::Altair | ForkName::Merge => {
-                LightClientBootstrap::from_beacon_state(&mut state)
+            ForkName::Altair | ForkName::Merge | ForkName::Capella | ForkName::Deneb => {
+                LightClientBootstrap::from_beacon_state(&mut state, &block, &self.spec)
                     .map(|bootstrap| Some((bootstrap, fork_name)))
                     .map_err(Error::LightClientError)
             }
-            ForkName::Base | ForkName::Capella | ForkName::Deneb => Err(Error::UnsupportedFork),
+            ForkName::Base => Err(Error::UnsupportedFork),
         }
     }
 }

beacon_node/beacon_chain/src/data_availability_checker.rs

@@ -22,7 +22,7 @@ use std::sync::Arc;
 use task_executor::TaskExecutor;
 use types::beacon_block_body::KzgCommitmentOpts;
 use types::blob_sidecar::{BlobIdentifier, BlobSidecar, FixedBlobSidecarList};
-use types::{BlobSidecarList, ChainSpec, Epoch, EthSpec, Hash256, SignedBeaconBlock, Slot};
+use types::{BlobSidecarList, ChainSpec, Epoch, EthSpec, Hash256, SignedBeaconBlock};
 
 mod availability_view;
 mod child_components;
@@ -356,41 +356,30 @@ impl<T: BeaconChainTypes> DataAvailabilityChecker<T> {
     /// them here is useful to avoid duplicate downloads of blocks, as well as understanding
     /// our blob download requirements. We will also serve this over RPC.
     pub fn notify_block(&self, block_root: Hash256, block: Arc<SignedBeaconBlock<T::EthSpec>>) {
-        let slot = block.slot();
         self.processing_cache
             .write()
             .entry(block_root)
-            .or_insert_with(|| ProcessingComponents::new(slot))
+            .or_default()
             .merge_block(block);
     }
 
     /// Add a single blob commitment to the processing cache. This commitment is unverified but caching
     /// them here is useful to avoid duplicate downloads of blobs, as well as understanding
     /// our block and blob download requirements.
-    pub fn notify_gossip_blob(
-        &self,
-        slot: Slot,
-        block_root: Hash256,
-        blob: &GossipVerifiedBlob<T>,
-    ) {
+    pub fn notify_gossip_blob(&self, block_root: Hash256, blob: &GossipVerifiedBlob<T>) {
         let index = blob.index();
         let commitment = blob.kzg_commitment();
         self.processing_cache
             .write()
             .entry(block_root)
-            .or_insert_with(|| ProcessingComponents::new(slot))
+            .or_default()
             .merge_single_blob(index as usize, commitment);
     }
 
     /// Adds blob commitments to the processing cache. These commitments are unverified but caching
     /// them here is useful to avoid duplicate downloads of blobs, as well as understanding
     /// our block and blob download requirements.
-    pub fn notify_rpc_blobs(
-        &self,
-        slot: Slot,
-        block_root: Hash256,
-        blobs: &FixedBlobSidecarList<T::EthSpec>,
-    ) {
+    pub fn notify_rpc_blobs(&self, block_root: Hash256, blobs: &FixedBlobSidecarList<T::EthSpec>) {
         let mut commitments = KzgCommitmentOpts::<T::EthSpec>::default();
         for blob in blobs.iter().flatten() {
             if let Some(commitment) = commitments.get_mut(blob.index as usize) {
@@ -400,7 +389,7 @@ impl<T: BeaconChainTypes> DataAvailabilityChecker<T> {
         self.processing_cache
             .write()
             .entry(block_root)
-            .or_insert_with(|| ProcessingComponents::new(slot))
+            .or_default()
             .merge_blobs(commitments);
     }
 
@@ -409,14 +398,6 @@ impl<T: BeaconChainTypes> DataAvailabilityChecker<T> {
         self.processing_cache.write().remove(block_root)
     }
 
-    /// Gather all block roots for which we are not currently processing all components for the
-    /// given slot.
-    pub fn incomplete_processing_components(&self, slot: Slot) -> Vec<Hash256> {
-        self.processing_cache
-            .read()
-            .incomplete_processing_components(slot)
-    }
-
     /// The epoch at which we require a data availability check in block processing.
     /// `None` if the `Deneb` fork is disabled.
     pub fn data_availability_boundary(&self) -> Option<Epoch> {

beacon_node/beacon_chain/src/data_availability_checker/processing_cache.rs

@@ -3,7 +3,7 @@ use std::collections::hash_map::Entry;
 use std::collections::HashMap;
 use std::sync::Arc;
 use types::beacon_block_body::KzgCommitmentOpts;
-use types::{EthSpec, Hash256, SignedBeaconBlock, Slot};
+use types::{EthSpec, Hash256, SignedBeaconBlock};
 
 /// This cache is used only for gossip blocks/blobs and single block/blob lookups, to give req/resp
 /// a view of what we have and what we require. This cache serves a slightly different purpose than
@@ -29,23 +29,13 @@ impl<E: EthSpec> ProcessingCache<E> {
             .get(block_root)
             .map_or(false, |b| b.block_exists())
     }
-    pub fn incomplete_processing_components(&self, slot: Slot) -> Vec<Hash256> {
-        let mut roots_missing_components = vec![];
-        for (&block_root, info) in self.processing_cache.iter() {
-            if info.slot == slot && !info.is_available() {
-                roots_missing_components.push(block_root);
-            }
-        }
-        roots_missing_components
-    }
     pub fn len(&self) -> usize {
         self.processing_cache.len()
     }
 }
 
-#[derive(Debug, Clone)]
+#[derive(Default, Debug, Clone)]
 pub struct ProcessingComponents<E: EthSpec> {
-    slot: Slot,
     /// Blobs required for a block can only be known if we have seen the block. So `Some` here
     /// means we've seen it, a `None` means we haven't. The `kzg_commitments` value helps us figure
     /// out whether incoming blobs actually match the block.
@@ -56,12 +46,8 @@ pub struct ProcessingComponents<E: EthSpec> {
 }
 
 impl<E: EthSpec> ProcessingComponents<E> {
-    pub fn new(slot: Slot) -> Self {
-        Self {
-            slot,
-            block: None,
-            blob_commitments: KzgCommitmentOpts::<E>::default(),
-        }
+    pub fn new() -> Self {
+        Self::default()
     }
 }
 
@@ -70,7 +56,6 @@ impl<E: EthSpec> ProcessingComponents<E> {
 impl<E: EthSpec> ProcessingComponents<E> {
     pub fn empty(_block_root: Hash256) -> Self {
         Self {
-            slot: Slot::new(0),
             block: None,
             blob_commitments: KzgCommitmentOpts::<E>::default(),
         }

beacon_node/beacon_chain/src/errors.rs

@@ -250,6 +250,7 @@ easy_from_to!(StateAdvanceError, BeaconChainError);
 easy_from_to!(BlockReplayError, BeaconChainError);
 easy_from_to!(InconsistentFork, BeaconChainError);
 easy_from_to!(AvailabilityCheckError, BeaconChainError);
+easy_from_to!(LightClientError, BeaconChainError);
 
 #[derive(Debug)]
 pub enum BlockProductionError {

beacon_node/beacon_chain/src/light_client_finality_update_verification.rs

@@ -48,7 +48,7 @@ impl<T: BeaconChainTypes> VerifiedLightClientFinalityUpdate<T> {
         // verify that enough time has passed for the block to have been propagated
         let start_time = chain
             .slot_clock
-            .start_of(rcv_finality_update.signature_slot)
+            .start_of(*rcv_finality_update.signature_slot())
             .ok_or(Error::SigSlotStartIsNone)?;
         let one_third_slot_duration = Duration::new(chain.spec.seconds_per_slot / 3, 0);
         if seen_timestamp + chain.spec.maximum_gossip_clock_disparity()

beacon_node/beacon_chain/src/light_client_optimistic_update_verification.rs

@@ -52,7 +52,7 @@ impl<T: BeaconChainTypes> VerifiedLightClientOptimisticUpdate<T> {
         // verify that enough time has passed for the block to have been propagated
         let start_time = chain
             .slot_clock
-            .start_of(rcv_optimistic_update.signature_slot)
+            .start_of(*rcv_optimistic_update.signature_slot())
             .ok_or(Error::SigSlotStartIsNone)?;
         let one_third_slot_duration = Duration::new(chain.spec.seconds_per_slot / 3, 0);
         if seen_timestamp + chain.spec.maximum_gossip_clock_disparity()
@@ -65,10 +65,7 @@ impl<T: BeaconChainTypes> VerifiedLightClientOptimisticUpdate<T> {
         let head_block = &head.snapshot.beacon_block;
         // check if we can process the optimistic update immediately
         // otherwise queue
-        let canonical_root = rcv_optimistic_update
-            .attested_header
-            .beacon
-            .canonical_root();
+        let canonical_root = rcv_optimistic_update.get_canonical_root();
 
         if canonical_root != head_block.message().parent_root() {
             return Err(Error::UnknownBlockParentRoot(canonical_root));
@@ -84,7 +81,7 @@ impl<T: BeaconChainTypes> VerifiedLightClientOptimisticUpdate<T> {
             return Err(Error::InvalidLightClientOptimisticUpdate);
         }
 
-        let parent_root = rcv_optimistic_update.attested_header.beacon.parent_root;
+        let parent_root = rcv_optimistic_update.get_parent_root();
         Ok(Self {
             light_client_optimistic_update: rcv_optimistic_update,
             parent_root,

beacon_node/beacon_chain/src/light_client_server_cache.rs

@@ -8,7 +8,7 @@ use types::light_client_update::{FinalizedRootProofLen, FINALIZED_ROOT_INDEX};
 use types::non_zero_usize::new_non_zero_usize;
 use types::{
     BeaconBlockRef, BeaconState, ChainSpec, EthSpec, ForkName, Hash256, LightClientFinalityUpdate,
-    LightClientHeader, LightClientOptimisticUpdate, Slot, SyncAggregate,
+    LightClientOptimisticUpdate, Slot, SyncAggregate,
 };
 
 /// A prev block cache miss requires to re-generate the state of the post-parent block. Items in the
@@ -71,24 +71,26 @@ impl<T: BeaconChainTypes> LightClientServerCache<T> {
     /// results are cached either on disk or memory to be served via p2p and rest API
     pub fn recompute_and_cache_updates(
         &self,
-        log: &Logger,
         store: BeaconStore<T>,
         block_parent_root: &Hash256,
         block_slot: Slot,
         sync_aggregate: &SyncAggregate<T::EthSpec>,
+        log: &Logger,
+        chain_spec: &ChainSpec,
     ) -> Result<(), BeaconChainError> {
         let _timer =
             metrics::start_timer(&metrics::LIGHT_CLIENT_SERVER_CACHE_RECOMPUTE_UPDATES_TIMES);
 
         let signature_slot = block_slot;
         let attested_block_root = block_parent_root;
 
-        let attested_block = store.get_blinded_block(attested_block_root)?.ok_or(
-            BeaconChainError::DBInconsistent(format!(
-                "Block not available {:?}",
-                attested_block_root
-            )),
-        )?;
+        let attested_block =
+            store
+                .get_full_block(attested_block_root)?
+                .ok_or(BeaconChainError::DBInconsistent(format!(
+                    "Block not available {:?}",
+                    attested_block_root
+                )))?;
 
         let cached_parts = self.get_or_compute_prev_block_cache(
             store.clone(),
@@ -109,11 +111,12 @@ impl<T: BeaconChainTypes> LightClientServerCache<T> {
         };
         if is_latest_optimistic {
             // can create an optimistic update, that is more recent
-            *self.latest_optimistic_update.write() = Some(LightClientOptimisticUpdate {
-                attested_header: block_to_light_client_header(attested_block.message()),
-                sync_aggregate: sync_aggregate.clone(),
+            *self.latest_optimistic_update.write() = Some(LightClientOptimisticUpdate::new(
+                &attested_block,
+                sync_aggregate.clone(),
                 signature_slot,
-            });
+                chain_spec,
+            )?);
         };
 
         // Spec: Full nodes SHOULD provide the LightClientFinalityUpdate with the highest
@@ -127,17 +130,16 @@ impl<T: BeaconChainTypes> LightClientServerCache<T> {
         if is_latest_finality & !cached_parts.finalized_block_root.is_zero() {
             // Immediately after checkpoint sync the finalized block may not be available yet.
             if let Some(finalized_block) =
-                store.get_blinded_block(&cached_parts.finalized_block_root)?
+                store.get_full_block(&cached_parts.finalized_block_root)?
             {
-                *self.latest_finality_update.write() = Some(LightClientFinalityUpdate {
-                    // TODO: may want to cache this result from latest_optimistic_update if producing a
-                    // light_client header becomes expensive
-                    attested_header: block_to_light_client_header(attested_block.message()),
-                    finalized_header: block_to_light_client_header(finalized_block.message()),
-                    finality_branch: cached_parts.finality_branch.clone(),
-                    sync_aggregate: sync_aggregate.clone(),
+                *self.latest_finality_update.write() = Some(LightClientFinalityUpdate::new(
+                    &attested_block,
+                    &finalized_block,
+                    cached_parts.finality_branch.clone(),
+                    sync_aggregate.clone(),
                     signature_slot,
-                });
+                    chain_spec,
+                )?);
             } else {
                 debug!(
                     log,
@@ -214,7 +216,7 @@ impl LightClientCachedData {
     }
 }
 
-// Implements spec priorization rules:
+// Implements spec prioritization rules:
 // > Full nodes SHOULD provide the LightClientFinalityUpdate with the highest attested_header.beacon.slot (if multiple, highest signature_slot)
 //
 // ref: https://github.com/ethereum/consensus-specs/blob/113c58f9bf9c08867f6f5f633c4d98e0364d612a/specs/altair/light-client/full-node.md#create_light_client_finality_update
@@ -223,14 +225,15 @@ fn is_latest_finality_update<T: EthSpec>(
     attested_slot: Slot,
     signature_slot: Slot,
 ) -> bool {
-    if attested_slot > prev.attested_header.beacon.slot {
+    let prev_slot = prev.get_attested_header_slot();
+    if attested_slot > prev_slot {
         true
     } else {
-        attested_slot == prev.attested_header.beacon.slot && signature_slot > prev.signature_slot
+        attested_slot == prev_slot && signature_slot > *prev.signature_slot()
     }
 }
 
-// Implements spec priorization rules:
+// Implements spec prioritization rules:
 // > Full nodes SHOULD provide the LightClientOptimisticUpdate with the highest attested_header.beacon.slot (if multiple, highest signature_slot)
 //
 // ref: https://github.com/ethereum/consensus-specs/blob/113c58f9bf9c08867f6f5f633c4d98e0364d612a/specs/altair/light-client/full-node.md#create_light_client_optimistic_update
@@ -239,18 +242,10 @@ fn is_latest_optimistic_update<T: EthSpec>(
     attested_slot: Slot,
     signature_slot: Slot,
 ) -> bool {
-    if attested_slot > prev.attested_header.beacon.slot {
+    let prev_slot = prev.get_slot();
+    if attested_slot > prev_slot {
         true
     } else {
-        attested_slot == prev.attested_header.beacon.slot && signature_slot > prev.signature_slot
-    }
-}
-
-fn block_to_light_client_header<T: EthSpec>(
-    block: BeaconBlockRef<T, types::BlindedPayload<T>>,
-) -> LightClientHeader {
-    // TODO: make fork aware
-    LightClientHeader {
-        beacon: block.block_header(),
+        attested_slot == prev_slot && signature_slot > *prev.signature_slot()
     }
 }