Modify ticks and hashes_per_tick check for alpenglow blocks (anza-xyz#98)

Author: carllin

core/src/consensus/progress_map.rs

@@ -140,6 +140,31 @@ impl ForkProgress {
         }
     }
 
+    fn calculate_alpenglow_ticks(
+        slot: Slot,
+        first_alpenglow_slot: Slot,
+        parent_slot: Slot,
+        ticks_per_slot: u64,
+    ) -> Option<u64> {
+        // Slots before alpenglow shouldn't have alpenglow ticks
+        if slot < first_alpenglow_slot {
+            return None;
+        }
+
+        let alpenglow_ticks = if parent_slot < first_alpenglow_slot && slot >= first_alpenglow_slot
+        {
+            // 1. All slots between the parent and the first alpenglow slot need to
+            // have `ticks_per_slot` ticks
+            // 2. One extra tick for the actual alpenglow slot
+            // 3. There are no ticks for any skipped alpenglow slots
+            (first_alpenglow_slot - parent_slot - 1) * ticks_per_slot + 1
+        } else {
+            1
+        };
+
+        Some(alpenglow_ticks)
+    }
+
     pub fn new_from_bank(
         bank: &Bank,
         validator_identity: &Pubkey,
@@ -168,6 +193,20 @@ impl ForkProgress {
             num_dropped_blocks_on_fork,
         );
 
+        if let Some(first_alpenglow_slot) = bank
+            .feature_set
+            .activated_slot(&solana_feature_set::secp256k1_program_enabled::id())
+        {
+            if let Some(num_expected_ticks) = Self::calculate_alpenglow_ticks(
+                bank.slot(),
+                first_alpenglow_slot,
+                bank.parent_slot(),
+                bank.ticks_per_slot(),
+            ) {
+                bank.set_tick_height(bank.max_tick_height() - num_expected_ticks);
+            }
+        }
+
         if bank.is_frozen() {
             new_progress.fork_stats.bank_hash = Some(bank.hash());
         }
@@ -616,4 +655,83 @@ mod test {
             .is_leader_slot = true;
         assert!(!progress_map.get_leader_propagation_slot_must_exist(10).0);
     }
+
+    #[test]
+    fn test_calculate_alpenglow_ticks() {
+        let first_alpenglow_slot = 10;
+        let ticks_per_slot = 2;
+
+        // Slots before alpenglow don't have alpenglow ticks
+        let slot = 9;
+        let parent_slot = 8;
+        assert!(ForkProgress::calculate_alpenglow_ticks(
+            slot,
+            first_alpenglow_slot,
+            parent_slot,
+            ticks_per_slot
+        )
+        .is_none());
+
+        // First alpenglow slot should only have 1 tick
+        let slot = first_alpenglow_slot;
+        let parent_slot = first_alpenglow_slot - 1;
+        assert_eq!(
+            ForkProgress::calculate_alpenglow_ticks(
+                slot,
+                first_alpenglow_slot,
+                parent_slot,
+                ticks_per_slot
+            )
+            .unwrap(),
+            1
+        );
+
+        // First alpenglow slot with skipped non-alpenglow slots
+        // need to have `ticks_per_slot` ticks per skipped slot and
+        // then one additional tick for the first alpenglow slot
+        let slot = first_alpenglow_slot;
+        let num_skipped_slots = 3;
+        let parent_slot = first_alpenglow_slot - num_skipped_slots - 1;
+        assert_eq!(
+            ForkProgress::calculate_alpenglow_ticks(
+                slot,
+                first_alpenglow_slot,
+                parent_slot,
+                ticks_per_slot
+            )
+            .unwrap(),
+            num_skipped_slots * ticks_per_slot + 1
+        );
+
+        // Skipped alpenglow slots don't need any additional ticks
+        let slot = first_alpenglow_slot + 2;
+        let parent_slot = first_alpenglow_slot;
+        assert_eq!(
+            ForkProgress::calculate_alpenglow_ticks(
+                slot,
+                first_alpenglow_slot,
+                parent_slot,
+                ticks_per_slot
+            )
+            .unwrap(),
+            1
+        );
+
+        // Skipped alpenglow slots along skipped non-alpenglow slots
+        // need to have `ticks_per_slot` ticks per skipped non-alpenglow
+        // slot only and then one additional tick for the alpenglow slot
+        let slot = first_alpenglow_slot + 2;
+        let num_skipped_non_alpenglow_slots = 4;
+        let parent_slot = first_alpenglow_slot - num_skipped_non_alpenglow_slots - 1;
+        assert_eq!(
+            ForkProgress::calculate_alpenglow_ticks(
+                slot,
+                first_alpenglow_slot,
+                parent_slot,
+                ticks_per_slot
+            )
+            .unwrap(),
+            num_skipped_non_alpenglow_slots * ticks_per_slot + 1
+        );
+    }
 }

ledger/src/blockstore_processor.rs

@@ -1089,7 +1089,7 @@ pub fn process_blockstore_from_root(
 /// Verify that a segment of entries has the correct number of ticks and hashes
 fn verify_ticks(
     bank: &Bank,
-    entries: &[Entry],
+    mut entries: &[Entry],
     slot_full: bool,
     tick_hash_count: &mut u64,
 ) -> std::result::Result<(), BlockError> {
@@ -1119,6 +1119,28 @@ fn verify_ticks(
         }
     }
 
+    if let Some(first_alpenglow_slot) = bank
+        .feature_set
+        .activated_slot(&solana_feature_set::secp256k1_program_enabled::id())
+    {
+        if bank.parent_slot() >= first_alpenglow_slot {
+            return Ok(());
+        }
+
+        if bank.slot() >= first_alpenglow_slot && next_bank_tick_height == max_bank_tick_height {
+            if entries.is_empty() {
+                // This shouldn't happen, but good to double check
+                error!("Processing empty entries in verify_ticks()");
+                return Ok(());
+            }
+            // last entry must be a tick, as verified by the `has_trailing_entry`
+            // check above. Because in Alpenglow the last tick does not have any
+            // hashing guarantees, we pass everything but that last tick to the
+            // entry verification.
+            entries = &entries[..entries.len() - 1];
+        }
+    }
+
     let hashes_per_tick = bank.hashes_per_tick().unwrap_or(0);
     if !entries.verify_tick_hash_count(tick_hash_count, hashes_per_tick) {
         warn!(