Merge pull request #5072 from stacks-network/feat/pox-4-tests-nakamoto

Update pox_4_tests to run in 2.5 and 3.0

Author: jcnelson

stacks-common/src/types/mod.rs

@@ -82,6 +82,7 @@ pub enum StacksEpochId {
     Epoch30 = 0x03000,
 }
 
+#[derive(Debug)]
 pub enum MempoolCollectionBehavior {
     ByStacksHeight,
     ByReceiveTime,

stackslib/src/burnchains/burnchain.rs

@@ -549,47 +549,43 @@ impl Burnchain {
             .expect("Overflowed u64 in calculating expected sunset_burn")
     }
 
+    /// Is this the first block to receive rewards in its cycle?
+    /// This is the mod 1 block. Note: in nakamoto, the signer set for cycle N signs
+    ///  the mod 0 block.
     pub fn is_reward_cycle_start(&self, burn_height: u64) -> bool {
         self.pox_constants
             .is_reward_cycle_start(self.first_block_height, burn_height)
     }
 
+    /// Is this the first block to be signed by the signer set in cycle N?
+    /// This is the mod 0 block.
+    pub fn is_naka_signing_cycle_start(&self, burn_height: u64) -> bool {
+        self.pox_constants
+            .is_naka_signing_cycle_start(self.first_block_height, burn_height)
+    }
+
+    /// return the first burn block which receives reward in `reward_cycle`.
+    /// this is the modulo 1 block
     pub fn reward_cycle_to_block_height(&self, reward_cycle: u64) -> u64 {
         self.pox_constants
             .reward_cycle_to_block_height(self.first_block_height, reward_cycle)
     }
 
-    /// Compute the reward cycle ID of the PoX reward set which is active as of this burn_height.
-    /// The reward set is calculated at reward cycle index 1, so if this block height is at or after
-    /// reward cycle index 1, then this behaves like `block_height_to_reward_cycle()`.  However,
-    /// if it's reward cycle index is 0, then it belongs to the previous reward cycle.
-    pub fn pox_reward_cycle(&self, block_height: u64) -> Option<u64> {
-        let cycle = self.block_height_to_reward_cycle(block_height)?;
-        let effective_height = block_height.checked_sub(self.first_block_height)?;
-        if effective_height % u64::from(self.pox_constants.reward_cycle_length) == 0 {
-            Some(cycle.saturating_sub(1))
-        } else {
-            Some(cycle)
-        }
+    /// the first burn block that must be *signed* by the signer set of `reward_cycle`.
+    /// this is the modulo 0 block
+    pub fn nakamoto_first_block_of_cycle(&self, reward_cycle: u64) -> u64 {
+        self.pox_constants
+            .nakamoto_first_block_of_cycle(self.first_block_height, reward_cycle)
     }
 
+    /// What is the reward cycle for this block height?
+    /// This considers the modulo 0 block to be in reward cycle `n`, even though
+    ///  rewards for cycle `n` do not begin until modulo 1.
     pub fn block_height_to_reward_cycle(&self, block_height: u64) -> Option<u64> {
         self.pox_constants
             .block_height_to_reward_cycle(self.first_block_height, block_height)
     }
 
-    pub fn static_block_height_to_reward_cycle(
-        block_height: u64,
-        first_block_height: u64,
-        reward_cycle_length: u64,
-    ) -> Option<u64> {
-        PoxConstants::static_block_height_to_reward_cycle(
-            block_height,
-            first_block_height,
-            reward_cycle_length,
-        )
-    }
-
     /// Is this block either the first block in a reward cycle or
     ///  right before the reward phase starts? This is the mod 0 or mod 1
     ///  block. Reward cycle start events (like auto-unlocks) process *after*
@@ -607,27 +603,19 @@ impl Burnchain {
         (effective_height % reward_cycle_length) <= 1
     }
 
-    pub fn static_is_in_prepare_phase(
-        first_block_height: u64,
-        reward_cycle_length: u64,
-        prepare_length: u64,
-        block_height: u64,
-    ) -> bool {
-        PoxConstants::static_is_in_prepare_phase(
-            first_block_height,
-            reward_cycle_length,
-            prepare_length,
-            block_height,
-        )
+    /// Does this block include reward slots?
+    /// This is either in the last prepare_phase_length blocks of the cycle
+    ///  or the modulo 0 block
+    pub fn is_in_prepare_phase(&self, block_height: u64) -> bool {
+        self.pox_constants
+            .is_in_prepare_phase(self.first_block_height, block_height)
     }
 
-    pub fn is_in_prepare_phase(&self, block_height: u64) -> bool {
-        Self::static_is_in_prepare_phase(
-            self.first_block_height,
-            self.pox_constants.reward_cycle_length as u64,
-            self.pox_constants.prepare_length.into(),
-            block_height,
-        )
+    /// The prepare phase is the last prepare_phase_length blocks of the cycle
+    /// This cannot include the 0 block for nakamoto
+    pub fn is_in_naka_prepare_phase(&self, block_height: u64) -> bool {
+        self.pox_constants
+            .is_in_naka_prepare_phase(self.first_block_height, block_height)
     }
 
     pub fn regtest(working_dir: &str) -> Burnchain {

stackslib/src/burnchains/mod.rs

@@ -517,7 +517,7 @@ impl PoxConstants {
         }
     }
 
-    /// What's the first block in the prepare phase
+    /// The first block of the prepare phase during `reward_cycle`. This is the prepare phase _for the next cycle_.
     pub fn prepare_phase_start(&self, first_block_height: u64, reward_cycle: u64) -> u64 {
         let reward_cycle_start =
             self.reward_cycle_to_block_height(first_block_height, reward_cycle);
@@ -526,18 +526,37 @@ impl PoxConstants {
         prepare_phase_start
     }
 
+    /// Is this the first block to receive rewards in its cycle?
+    /// This is the mod 1 block. Note: in nakamoto, the signer set for cycle N signs
+    ///  the mod 0 block.
     pub fn is_reward_cycle_start(&self, first_block_height: u64, burn_height: u64) -> bool {
         let effective_height = burn_height - first_block_height;
         // first block of the new reward cycle
         (effective_height % u64::from(self.reward_cycle_length)) == 1
     }
 
+    /// Is this the first block to be signed by the signer set in cycle N?
+    /// This is the mod 0 block.
+    pub fn is_naka_signing_cycle_start(&self, first_block_height: u64, burn_height: u64) -> bool {
+        let effective_height = burn_height - first_block_height;
+        // first block of the new reward cycle
+        (effective_height % u64::from(self.reward_cycle_length)) == 0
+    }
+
+    /// return the first burn block which receives reward in `reward_cycle`.
+    /// this is the modulo 1 block
     pub fn reward_cycle_to_block_height(&self, first_block_height: u64, reward_cycle: u64) -> u64 {
         // NOTE: the `+ 1` is because the height of the first block of a reward cycle is mod 1, not
         // mod 0.
         first_block_height + reward_cycle * u64::from(self.reward_cycle_length) + 1
     }
 
+    /// the first burn block that must be *signed* by the signer set of `reward_cycle`.
+    /// this is the modulo 0 block
+    pub fn nakamoto_first_block_of_cycle(&self, first_block_height: u64, reward_cycle: u64) -> u64 {
+        first_block_height + reward_cycle * u64::from(self.reward_cycle_length)
+    }
+
     pub fn reward_cycle_index(&self, first_block_height: u64, burn_height: u64) -> Option<u64> {
         let effective_height = burn_height.checked_sub(first_block_height)?;
         Some(effective_height % u64::from(self.reward_cycle_length))
@@ -609,6 +628,35 @@ impl PoxConstants {
         }
     }
 
+    /// The prepare phase is the last prepare_phase_length blocks of the cycle
+    /// This cannot include the 0 block for nakamoto
+    pub fn is_in_naka_prepare_phase(&self, first_block_height: u64, block_height: u64) -> bool {
+        Self::static_is_in_naka_prepare_phase(
+            first_block_height,
+            u64::from(self.reward_cycle_length),
+            u64::from(self.prepare_length),
+            block_height,
+        )
+    }
+
+    /// The prepare phase is the last prepare_phase_length blocks of the cycle
+    /// This cannot include the 0 block for nakamoto
+    pub fn static_is_in_naka_prepare_phase(
+        first_block_height: u64,
+        reward_cycle_length: u64,
+        prepare_length: u64,
+        block_height: u64,
+    ) -> bool {
+        if block_height <= first_block_height {
+            // not a reward cycle start if we're the first block after genesis.
+            false
+        } else {
+            let effective_height = block_height - first_block_height;
+            let reward_index = effective_height % reward_cycle_length;
+            reward_index > u64::from(reward_cycle_length - prepare_length)
+        }
+    }
+
     /// Returns the active reward cycle at the given burn block height
     /// * `first_block_ht` - the first burn block height that the Stacks network monitored
     /// * `reward_cycle_len` - the length of each reward cycle in the network.

stackslib/src/chainstate/burn/db/sortdb.rs

@@ -3584,42 +3584,6 @@ impl SortitionDB {
         Ok(())
     }
 
-    /// Get the prepare phase end sortition ID of a reward cycle.  This is the last prepare
-    /// phase sortition for the prepare phase that began this reward cycle (i.e. the returned
-    /// sortition will be in the preceding reward cycle)
-    /// Wrapper around SortitionDBConn::get_prepare_phase_end_sortition_id_for_reward_ccyle()
-    pub fn get_prepare_phase_end_sortition_id_for_reward_cycle(
-        &self,
-        tip: &SortitionId,
-        reward_cycle_id: u64,
-    ) -> Result<SortitionId, db_error> {
-        self.index_conn()
-            .get_prepare_phase_end_sortition_id_for_reward_cycle(
-                &self.pox_constants,
-                self.first_block_height,
-                tip,
-                reward_cycle_id,
-            )
-    }
-
-    /// Get the prepare phase start sortition ID of a reward cycle.  This is the first prepare
-    /// phase sortition for the prepare phase that began this reward cycle (i.e. the returned
-    /// sortition will be in the preceding reward cycle)
-    /// Wrapper around SortitionDBConn::get_prepare_phase_start_sortition_id_for_reward_cycle().
-    pub fn get_prepare_phase_start_sortition_id_for_reward_cycle(
-        &self,
-        tip: &SortitionId,
-        reward_cycle_id: u64,
-    ) -> Result<SortitionId, db_error> {
-        self.index_conn()
-            .get_prepare_phase_start_sortition_id_for_reward_cycle(
-                &self.pox_constants,
-                self.first_block_height,
-                tip,
-                reward_cycle_id,
-            )
-    }
-
     /// Figure out the reward cycle for `tip` and lookup the preprocessed
     /// reward set (if it exists) for the active reward cycle during `tip`.
     /// Returns the reward cycle info on success.
@@ -3934,33 +3898,6 @@ impl<'a> SortitionDBConn<'a> {
         .and_then(|(reward_cycle_info, _anchor_sortition_id)| Ok(reward_cycle_info))
     }
 
-    /// Get the prepare phase end sortition ID of a reward cycle.  This is the last prepare
-    /// phase sortition for the prepare phase that began this reward cycle (i.e. the returned
-    /// sortition will be in the preceding reward cycle)
-    pub fn get_prepare_phase_end_sortition_id_for_reward_cycle(
-        &self,
-        pox_constants: &PoxConstants,
-        first_block_height: u64,
-        tip: &SortitionId,
-        reward_cycle_id: u64,
-    ) -> Result<SortitionId, db_error> {
-        let prepare_phase_end = pox_constants
-            .reward_cycle_to_block_height(first_block_height, reward_cycle_id)
-            .saturating_sub(1);
-
-        let last_sortition =
-            get_ancestor_sort_id(self, prepare_phase_end, tip)?.ok_or_else(|| {
-                error!(
-                    "Could not find prepare phase end ancestor while fetching reward set";
-                    "tip_sortition_id" => %tip,
-                    "reward_cycle_id" => reward_cycle_id,
-                    "prepare_phase_end_height" => prepare_phase_end
-                );
-                db_error::NotFoundError
-            })?;
-        Ok(last_sortition)
-    }
-
     /// Get the prepare phase start sortition ID of a reward cycle.  This is the first prepare
     /// phase sortition for the prepare phase that began this reward cycle (i.e. the returned
     /// sortition will be in the preceding reward cycle)
@@ -3971,9 +3908,11 @@ impl<'a> SortitionDBConn<'a> {
         tip: &SortitionId,
         reward_cycle_id: u64,
     ) -> Result<SortitionId, db_error> {
-        let prepare_phase_start = pox_constants
-            .reward_cycle_to_block_height(first_block_height, reward_cycle_id)
-            .saturating_sub(pox_constants.prepare_length.into());
+        let reward_cycle_of_prepare_phase = reward_cycle_id
+            .checked_sub(1)
+            .ok_or_else(|| db_error::Other("No prepare phase exists for cycle 0".into()))?;
+        let prepare_phase_start =
+            pox_constants.prepare_phase_start(first_block_height, reward_cycle_of_prepare_phase);
 
         let first_sortition =
             get_ancestor_sort_id(self, prepare_phase_start, tip)?.ok_or_else(|| {
@@ -5945,10 +5884,10 @@ impl<'a> SortitionHandleTx<'a> {
 
     /// Get the expected number of PoX payouts per output
     fn get_num_pox_payouts(&self, burn_block_height: u64) -> usize {
-        let op_num_outputs = if Burnchain::static_is_in_prepare_phase(
+        let op_num_outputs = if PoxConstants::static_is_in_prepare_phase(
             self.context.first_block_height,
-            self.context.pox_constants.reward_cycle_length as u64,
-            self.context.pox_constants.prepare_length.into(),
+            u64::from(self.context.pox_constants.reward_cycle_length),
+            u64::from(self.context.pox_constants.prepare_length),
             burn_block_height,
         ) {
             1
@@ -6173,7 +6112,7 @@ impl<'a> SortitionHandleTx<'a> {
                     }
                     // if there are qualifying auto-unlocks, record them
                     if !reward_set.start_cycle_state.is_empty() {
-                        let cycle_number = Burnchain::static_block_height_to_reward_cycle(
+                        let cycle_number = PoxConstants::static_block_height_to_reward_cycle(
                             snapshot.block_height,
                             self.context.first_block_height,
                             self.context.pox_constants.reward_cycle_length.into(),

stackslib/src/chainstate/coordinator/mod.rs

@@ -297,9 +297,8 @@ pub trait RewardSetProvider {
 
     fn get_reward_set_nakamoto(
         &self,
-        cycle_start_burn_height: u64,
         chainstate: &mut StacksChainState,
-        burnchain: &Burnchain,
+        cycle: u64,
         sortdb: &SortitionDB,
         block_id: &StacksBlockId,
     ) -> Result<RewardSet, Error>;
@@ -372,20 +371,12 @@ impl<'a, T: BlockEventDispatcher> RewardSetProvider for OnChainRewardSetProvider
 
     fn get_reward_set_nakamoto(
         &self,
-        cycle_start_burn_height: u64,
         chainstate: &mut StacksChainState,
-        burnchain: &Burnchain,
+        reward_cycle: u64,
         sortdb: &SortitionDB,
         block_id: &StacksBlockId,
     ) -> Result<RewardSet, Error> {
-        self.read_reward_set_nakamoto(
-            cycle_start_burn_height,
-            chainstate,
-            burnchain,
-            sortdb,
-            block_id,
-            false,
-        )
+        self.read_reward_set_nakamoto(chainstate, reward_cycle, sortdb, block_id, false)
     }
 }
 

stackslib/src/chainstate/coordinator/tests.rs

@@ -520,9 +520,8 @@ impl RewardSetProvider for StubbedRewardSetProvider {
 
     fn get_reward_set_nakamoto(
         &self,
-        cycle_start_burn_height: u64,
         chainstate: &mut StacksChainState,
-        burnchain: &Burnchain,
+        cycle: u64,
         sortdb: &SortitionDB,
         block_id: &StacksBlockId,
     ) -> Result<RewardSet, CoordError> {