move certain custody checks to custody context

Author: eserilev

beacon_node/beacon_chain/src/beacon_chain.rs

@@ -7300,12 +7300,15 @@ impl<T: BeaconChainTypes> BeaconChain<T> {
     /// 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> {
-        self.data_availability_checker.data_availability_boundary()
+        self.data_availability_checker
+            .custody_context()
+            .data_availability_boundary()
     }
 
     /// Returns true if epoch is within the data availability boundary
     pub fn da_check_required_for_epoch(&self, epoch: Epoch) -> bool {
         self.data_availability_checker
+            .custody_context()
             .da_check_required_for_epoch(epoch)
     }
 

beacon_node/beacon_chain/src/block_verification_types.rs

@@ -1,8 +1,8 @@
-use crate::data_availability_checker::{AvailabilityCheckError, DataAvailabilityChecker};
+use crate::data_availability_checker::AvailabilityCheckError;
 pub use crate::data_availability_checker::{
     AvailableBlock, AvailableBlockData, MaybeAvailableBlock,
 };
-use crate::{BeaconChainTypes, PayloadVerificationOutcome};
+use crate::{BeaconChainTypes, CustodyContext, PayloadVerificationOutcome};
 use educe::Educe;
 use state_processing::ConsensusContext;
 use std::fmt::{Debug, Formatter};
@@ -93,15 +93,18 @@ impl<E: EthSpec> RpcBlock<E> {
     pub fn new<T>(
         block: Arc<SignedBeaconBlock<E>>,
         block_data: Option<AvailableBlockData<E>>,
-        da_checker: &DataAvailabilityChecker<T>,
+        custody_context: &CustodyContext<T>,
         spec: Arc<ChainSpec>,
     ) -> Result<Self, AvailabilityCheckError>
     where
         T: BeaconChainTypes<EthSpec = E>,
     {
         match block_data {
             Some(block_data) => Ok(RpcBlock::FullyAvailable(AvailableBlock::new(
-                block, block_data, da_checker, spec,
+                block,
+                block_data,
+                custody_context,
+                spec,
             )?)),
             None => Ok(RpcBlock::BlockOnly {
                 block_root: block.canonical_root(),

beacon_node/beacon_chain/src/builder.rs

@@ -918,7 +918,6 @@ 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 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 {
@@ -961,14 +960,18 @@ where
                 self.node_custody_type,
                 head_epoch,
                 ordered_custody_column_indices,
-                &self.spec,
+                slot_clock.clone(),
+                self.chain_config.complete_blob_backfill,
+                self.spec.clone(),
             )
         } else {
             (
                 CustodyContext::new(
                     self.node_custody_type,
+                    slot_clock.clone(),
                     ordered_custody_column_indices,
-                    &self.spec,
+                    self.chain_config.complete_blob_backfill,
+                    self.spec.clone(),
                 ),
                 None,
             )
@@ -1045,7 +1048,6 @@ where
             genesis_backfill_slot,
             data_availability_checker: Arc::new(
                 DataAvailabilityChecker::new(
-                    complete_blob_backfill,
                     slot_clock,
                     self.kzg.clone(),
                     store,