Fix tests by using correct max_blobs_per_block for epoch

Author: michaelsproul

beacon_node/beacon_chain/src/data_column_verification.rs

@@ -850,6 +850,20 @@ mod test {
             .build();
         harness.advance_slot();
 
+        // Check block generator timestamp conversion sanity.
+        let exec_block_generator = harness.execution_block_generator();
+        assert_eq!(
+            exec_block_generator
+                .timestamp_to_slot_post_capella(exec_block_generator.osaka_time.unwrap()),
+            0
+        );
+        assert_eq!(
+            exec_block_generator.timestamp_to_slot_post_capella(
+                exec_block_generator.osaka_time.unwrap() + harness.spec.seconds_per_slot
+            ),
+            1
+        );
+
         let verify_fn = |column_sidecar: DataColumnSidecar<E>| {
             GossipVerifiedDataColumn::<_>::new_for_block_publishing(
                 column_sidecar.into(),

beacon_node/execution_layer/src/test_utils/execution_block_generator.rs

@@ -21,7 +21,7 @@ use types::{
     Blob, ChainSpec, EthSpec, ExecutionBlockHash, ExecutionPayload, ExecutionPayloadBellatrix,
     ExecutionPayloadCapella, ExecutionPayloadDeneb, ExecutionPayloadElectra, ExecutionPayloadFulu,
     ExecutionPayloadGloas, ExecutionPayloadHeader, FixedBytesExtended, ForkName, Hash256,
-    KzgProofs, Transaction, Transactions, Uint256,
+    KzgProofs, Slot, Transaction, Transactions, Uint256,
 };
 
 use super::DEFAULT_TERMINAL_BLOCK;
@@ -265,6 +265,37 @@ impl<E: EthSpec> ExecutionBlockGenerator<E> {
         ForkName::Bellatrix
     }
 
+    /// Get the timestamp at which `fork` activates.
+    ///
+    /// This function will panic if the `fork` is not enabled or is `<= ForkName::Bellatrix`.
+    pub fn get_fork_timestamp_post_capella(&self, fork: ForkName) -> u64 {
+        match fork {
+            ForkName::Gloas => self.amsterdam_time,
+            ForkName::Fulu => self.osaka_time,
+            ForkName::Electra => self.prague_time,
+            ForkName::Deneb => self.cancun_time,
+            ForkName::Capella => self.shanghai_time,
+            _ => panic!("only the Capella fork or later is supported"),
+        }
+        .unwrap_or_else(|| panic!("fork is {fork} but no corresponding timestamp is set"))
+    }
+
+    /// This is a slightly nasty method for converting timestamps to slots, but it will suffice
+    /// until we can plumb through a slot clock.
+    pub fn timestamp_to_slot_post_capella(&self, timestamp: u64) -> Slot {
+        let fork = self.get_fork_at_timestamp(timestamp);
+        let fork_epoch = self.spec.fork_epoch(fork).unwrap();
+        let fork_timestamp = self.get_fork_timestamp_post_capella(fork);
+
+        // Number of slots since fork.
+        let slot_offset = timestamp
+            .checked_sub(fork_timestamp)
+            .expect("timestamp should be >= fork timestamp")
+            / self.spec.seconds_per_slot;
+
+        fork_epoch.start_slot(E::slots_per_epoch()) + Slot::new(slot_offset)
+    }
+
     pub fn execution_block_by_number(&self, number: u64) -> Option<ExecutionBlock> {
         self.block_by_number(number)
             .map(|block| block.as_execution_block(self.terminal_total_difficulty))
@@ -734,9 +765,10 @@ impl<E: EthSpec> ExecutionBlockGenerator<E> {
         if fork_name.deneb_enabled() {
             // get random number between 0 and Max Blobs
             let mut rng = self.rng.lock();
-            // TODO(EIP-7892): see FIXME below
-            // FIXME: this will break with BPO forks. This function needs to calculate the epoch based on block timestamp..
-            let max_blobs = self.spec.max_blobs_per_block_within_fork(fork_name) as usize;
+            let epoch = self
+                .timestamp_to_slot_post_capella(execution_payload.timestamp())
+                .epoch(E::slots_per_epoch());
+            let max_blobs = self.spec.max_blobs_per_block(epoch) as usize;
             let num_blobs = rng.random_range(self.min_blobs_count..=max_blobs);
             let (bundle, transactions) = generate_blobs(num_blobs, fork_name)?;
             for tx in Vec::from(transactions) {