Merge branch 'next' into chore/merge-2.05.0.2.0-to-next

Author: jcnelson

src/burnchains/burnchain.rs

@@ -115,7 +115,6 @@ impl BurnchainStateTransition {
         parent_snapshot: &BlockSnapshot,
         block_ops: &Vec<BlockstackOperationType>,
         missed_commits: &Vec<MissedBlockCommit>,
-        sunset_end: u64,
     ) -> Result<BurnchainStateTransition, burnchain_error> {
         // block commits and support burns discovered in this block.
         let mut block_commits: Vec<LeaderBlockCommitOp> = vec![];
@@ -167,9 +166,7 @@ impl BurnchainStateTransition {
         let mut windowed_block_commits = vec![block_commits];
         let mut windowed_missed_commits = vec![];
 
-        if !burnchain.is_in_prepare_phase(parent_snapshot.block_height + 1)
-            && parent_snapshot.block_height + 1 <= burnchain.pox_constants.sunset_end
-        {
+        if !burnchain.is_in_prepare_phase(parent_snapshot.block_height + 1) {
             // PoX reward-phase is active!
             // build a map of intended sortition -> missed commit for the missed commits
             //   discovered in this block.
@@ -212,7 +209,7 @@ impl BurnchainStateTransition {
         } else {
             // PoX reward-phase is not active
             debug!(
-                "Block {} is in a prepare phase or post-PoX sunset, so no windowing will take place",
+                "Block {} is in a prepare phase, so no windowing will take place",
                 parent_snapshot.block_height + 1
             );
 
@@ -224,18 +221,14 @@ impl BurnchainStateTransition {
         windowed_block_commits.reverse();
         windowed_missed_commits.reverse();
 
-        // figure out if the PoX sunset finished during the window,
-        // and/or which sortitions must be PoB due to them falling in a prepare phase.
+        // figure out which sortitions must be PoB due to them falling in a prepare phase.
         let window_end_height = parent_snapshot.block_height + 1;
         let window_start_height = window_end_height + 1 - (windowed_block_commits.len() as u64);
         let mut burn_blocks = vec![false; windowed_block_commits.len()];
 
-        // set burn_blocks flags to accomodate prepare phases and PoX sunset
+        // set burn_blocks flags to accomodate prepare phases
         for (i, b) in burn_blocks.iter_mut().enumerate() {
-            if sunset_end <= window_start_height + (i as u64) {
-                // past PoX sunset, so must burn
-                *b = true;
-            } else if burnchain.is_in_prepare_phase(window_start_height + (i as u64)) {
+            if burnchain.is_in_prepare_phase(window_start_height + (i as u64)) {
                 // must burn
                 *b = true;
             } else {
@@ -462,40 +455,6 @@ impl Burnchain {
         self.network_id == NETWORK_ID_MAINNET
     }
 
-    /// the expected sunset burn is:
-    ///   total_commit * (progress through sunset phase) / (sunset phase duration)
-    pub fn expected_sunset_burn(&self, burn_height: u64, total_commit: u64) -> u64 {
-        if burn_height < self.pox_constants.sunset_start
-            || burn_height >= self.pox_constants.sunset_end
-        {
-            return 0;
-        }
-
-        // no sunset burn needed in prepare phase -- it's already getting burnt
-        if self.is_in_prepare_phase(burn_height) {
-            return 0;
-        }
-
-        let reward_cycle_height = self.reward_cycle_to_block_height(
-            self.block_height_to_reward_cycle(burn_height)
-                .expect("BUG: Sunset start is less than first_block_height"),
-        );
-
-        if reward_cycle_height <= self.pox_constants.sunset_start {
-            return 0;
-        }
-
-        let sunset_duration =
-            (self.pox_constants.sunset_end - self.pox_constants.sunset_start) as u128;
-        let sunset_progress = (reward_cycle_height - self.pox_constants.sunset_start) as u128;
-
-        // use u128 to avoid any possibilities of overflowing in the calculation here.
-        let expected_u128 = (total_commit as u128) * (sunset_progress) / sunset_duration;
-        u64::try_from(expected_u128)
-            // should never be possible, because sunset_burn is <= total_commit, which is a u64
-            .expect("Overflowed u64 in calculating expected sunset_burn")
-    }
-
     pub fn is_reward_cycle_start(&self, burn_height: u64) -> bool {
         let effective_height = burn_height - self.first_block_height;
         // first block of the new reward cycle
@@ -743,20 +702,18 @@ impl Burnchain {
                     }
                 }
             }
-            x if x == Opcodes::PreStx as u8 => {
-                match PreStxOp::from_tx(block_header, burn_tx, burnchain.pox_constants.sunset_end) {
-                    Ok(op) => Some(BlockstackOperationType::PreStx(op)),
-                    Err(e) => {
-                        warn!(
-                            "Failed to parse pre stack stx tx";
-                            "txid" => %burn_tx.txid(),
-                            "data" => %to_hex(&burn_tx.data()),
-                            "error" => ?e,
-                        );
-                        None
-                    }
+            x if x == Opcodes::PreStx as u8 => match PreStxOp::from_tx(block_header, burn_tx) {
+                Ok(op) => Some(BlockstackOperationType::PreStx(op)),
+                Err(e) => {
+                    warn!(
+                        "Failed to parse pre stack stx tx";
+                        "txid" => %burn_tx.txid(),
+                        "data" => %to_hex(&burn_tx.data()),
+                        "error" => ?e,
+                    );
+                    None
                 }
-            }
+            },
             x if x == Opcodes::TransferStx as u8 => {
                 let pre_stx_txid = TransferStxOp::get_sender_txid(burn_tx).ok()?;
                 let pre_stx_tx = match pre_stx_op_map.get(&pre_stx_txid) {
@@ -794,12 +751,7 @@ impl Burnchain {
                 };
                 if let Some(BlockstackOperationType::PreStx(pre_stack_stx)) = pre_stx_tx {
                     let sender = &pre_stack_stx.output;
-                    match StackStxOp::from_tx(
-                        block_header,
-                        burn_tx,
-                        sender,
-                        burnchain.pox_constants.sunset_end,
-                    ) {
+                    match StackStxOp::from_tx(block_header, burn_tx, sender) {
                         Ok(op) => Some(BlockstackOperationType::StackStx(op)),
                         Err(e) => {
                             warn!(
@@ -1864,7 +1816,6 @@ pub mod tests {
         };
 
         let block_commit_1 = LeaderBlockCommitOp {
-            sunset_burn: 0,
             commit_outs: vec![],
             block_header_hash: BlockHeaderHash::from_bytes(
                 &hex_bytes("2222222222222222222222222222222222222222222222222222222222222222")
@@ -1905,7 +1856,6 @@ pub mod tests {
         };
 
         let block_commit_2 = LeaderBlockCommitOp {
-            sunset_burn: 0,
             commit_outs: vec![],
             block_header_hash: BlockHeaderHash::from_bytes(
                 &hex_bytes("2222222222222222222222222222222222222222222222222222222222222223")
@@ -1946,7 +1896,6 @@ pub mod tests {
         };
 
         let block_commit_3 = LeaderBlockCommitOp {
-            sunset_burn: 0,
             commit_outs: vec![],
             block_header_hash: BlockHeaderHash::from_bytes(
                 &hex_bytes("2222222222222222222222222222222222222222222222222222222222222224")
@@ -2509,7 +2458,6 @@ pub mod tests {
             // insert block commit paired to previous round's leader key, as well as a user burn
             if i > 0 {
                 let next_block_commit = LeaderBlockCommitOp {
-                    sunset_burn: 0,
                     commit_outs: vec![],
                     block_header_hash: BlockHeaderHash::from_bytes(&vec![
                         i, i, i, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,

src/burnchains/db.rs

@@ -430,8 +430,6 @@ mod tests {
 
         let mut burnchain = Burnchain::regtest(":memory:");
         burnchain.pox_constants = PoxConstants::test_default();
-        burnchain.pox_constants.sunset_start = 999;
-        burnchain.pox_constants.sunset_end = 1000;
 
         let first_block_header = burnchain_db.get_canonical_chain_tip().unwrap();
         assert_eq!(&first_block_header.block_hash, &first_bhh);
@@ -542,8 +540,6 @@ mod tests {
 
         let mut burnchain = Burnchain::regtest(":memory:");
         burnchain.pox_constants = PoxConstants::test_default();
-        burnchain.pox_constants.sunset_start = 999;
-        burnchain.pox_constants.sunset_end = 1000;
 
         let first_block_header = burnchain_db.get_canonical_chain_tip().unwrap();
         assert_eq!(&first_block_header.block_hash, &first_bhh);

src/burnchains/mod.rs

@@ -301,10 +301,6 @@ pub struct PoxConstants {
     /// percentage of liquid STX that must participate for PoX
     ///  to occur
     pub pox_participation_threshold_pct: u64,
-    /// last+1 block height of sunset phase
-    pub sunset_end: u64,
-    /// first block height of sunset phase
-    pub sunset_start: u64,
     /// The auto unlock height for PoX v1 lockups before transition to PoX v2. This
     /// also defines the burn height at which PoX reward sets are calculated using
     /// PoX v2 rather than v1
@@ -319,30 +315,25 @@ impl PoxConstants {
         anchor_threshold: u32,
         pox_rejection_fraction: u64,
         pox_participation_threshold_pct: u64,
-        sunset_start: u64,
-        sunset_end: u64,
         v1_unlock_height: u32,
     ) -> PoxConstants {
         assert!(anchor_threshold > (prepare_length / 2));
         assert!(prepare_length < reward_cycle_length);
-        assert!(sunset_start <= sunset_end);
 
         PoxConstants {
             reward_cycle_length,
             prepare_length,
             anchor_threshold,
             pox_rejection_fraction,
             pox_participation_threshold_pct,
-            sunset_start,
-            sunset_end,
             v1_unlock_height,
             _shadow: PhantomData,
         }
     }
     #[cfg(test)]
     pub fn test_default() -> PoxConstants {
         // 20 reward slots; 10 prepare-phase slots
-        PoxConstants::new(10, 5, 3, 25, 5, 5000, 10000, u32::max_value())
+        PoxConstants::new(10, 5, 3, 25, 5, u32::max_value())
     }
 
     /// Returns the PoX contract that is "active" at the given burn block height
@@ -375,8 +366,6 @@ impl PoxConstants {
             80,
             25,
             5,
-            BITCOIN_MAINNET_FIRST_BLOCK_HEIGHT + POX_SUNSET_START,
-            BITCOIN_MAINNET_FIRST_BLOCK_HEIGHT + POX_SUNSET_END,
             POX_V1_MAINNET_EARLY_UNLOCK_HEIGHT,
         )
     }
@@ -388,23 +377,12 @@ impl PoxConstants {
             40,
             12,
             2,
-            BITCOIN_TESTNET_FIRST_BLOCK_HEIGHT + POX_SUNSET_START,
-            BITCOIN_TESTNET_FIRST_BLOCK_HEIGHT + POX_SUNSET_END,
             POX_V1_TESTNET_EARLY_UNLOCK_HEIGHT,
         ) // total liquid supply is 40000000000000000 µSTX
     }
 
     pub fn regtest_default() -> PoxConstants {
-        PoxConstants::new(
-            5,
-            1,
-            1,
-            3333333333333333,
-            1,
-            BITCOIN_REGTEST_FIRST_BLOCK_HEIGHT + POX_SUNSET_START,
-            BITCOIN_REGTEST_FIRST_BLOCK_HEIGHT + POX_SUNSET_END,
-            1_000_000,
-        )
+        PoxConstants::new(5, 1, 1, 3333333333333333, 1, 1_000_000)
     }
 }
 

src/chainstate/burn/db/processing.rs

@@ -116,7 +116,7 @@ impl<'a> SortitionHandleTx<'a> {
         let this_block_hash = block_header.block_hash.clone();
 
         // make the burn distribution, and in doing so, identify the user burns that we'll keep
-        let state_transition = BurnchainStateTransition::from_block_ops(self, burnchain, parent_snapshot, this_block_ops, missed_commits, burnchain.pox_constants.sunset_end)
+        let state_transition = BurnchainStateTransition::from_block_ops(self, burnchain, parent_snapshot, this_block_ops, missed_commits)
             .map_err(|e| {
                 error!("TRANSACTION ABORTED when converting {} blockstack operations in block {} ({}) to a burn distribution: {:?}", this_block_ops.len(), this_block_height, &this_block_hash, e);
                 e
@@ -412,7 +412,6 @@ mod tests {
         };
 
         let block_commit = LeaderBlockCommitOp {
-            sunset_burn: 0,
             block_header_hash: BlockHeaderHash([0x22; 32]),
             new_seed: VRFSeed::from_hex(
                 "3333333333333333333333333333333333333333333333333333333333333333",