Merge pull request #2233 from blockstack/feat/pox-fixes

PoX - Adjustments

Author: lgalabru

src/burnchains/burnchain.rs

@@ -430,7 +430,7 @@ impl Burnchain {
             ),
             ("bitcoin", "regtest") => (
                 BurnchainParameters::bitcoin_regtest(),
-                PoxConstants::testnet_default(),
+                PoxConstants::regtest_default(),
             ),
             (_, _) => {
                 return Err(burnchain_error::UnsupportedBurnchain);
@@ -453,6 +453,10 @@ impl Burnchain {
         })
     }
 
+    pub fn is_mainnet(&self) -> bool {
+        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 {
@@ -487,15 +491,10 @@ impl Burnchain {
             .expect("Overflowed u64 in calculating expected sunset_burn")
     }
 
-    pub fn is_reward_cycle_start(&self, block_height: u64) -> bool {
-        if block_height <= (self.first_block_height + 1) {
-            // not a reward cycle start if we're the first block after genesis.
-            false
-        } else {
-            let effective_height = block_height - self.first_block_height;
-            // first block of the new reward cycle
-            (effective_height % (self.pox_constants.reward_cycle_length as u64)) == 1
-        }
+    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
+        (effective_height % (self.pox_constants.reward_cycle_length as u64)) == 1
     }
 
     pub fn reward_cycle_to_block_height(&self, reward_cycle: u64) -> u64 {

src/burnchains/mod.rs

@@ -392,15 +392,27 @@ impl PoxConstants {
 
     pub fn testnet_default() -> PoxConstants {
         PoxConstants::new(
-            150, // 120 reward slots; 30 prepare-phase slots
-            30,
-            20,
+            50, // 40 reward slots; 10 prepare-phase slots
+            10,
+            6,
             3333333333333333,
-            5,
+            1,
             BITCOIN_TESTNET_FIRST_BLOCK_HEIGHT + POX_SUNSET_START,
             BITCOIN_TESTNET_FIRST_BLOCK_HEIGHT + POX_SUNSET_END,
         ) // 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,
+        )
+    }
 }
 
 /// Structure for encoding our view of the network

src/chainstate/burn/db/sortdb.rs

@@ -1755,31 +1755,30 @@ impl<'a> SortitionHandleConn<'a> {
                     warn!("Missing parent"; "burn_header_hash" => %prepare_end_bhh);
                     BurnchainError::MissingParentBlock
                 })?;
-        let my_height = SortitionDB::get_block_height(self.deref(), &prepare_end_sortid)?
+        let block_height = SortitionDB::get_block_height(self.deref(), &prepare_end_sortid)?
             .expect("CORRUPTION: SortitionID known, but no block height in SQL store");
 
         // if this block is the _end_ of a prepare phase,
-        if !(my_height % pox_consts.reward_cycle_length == 0) {
-            test_debug!(
-                "My height = {}, reward cycle length == {}",
-                my_height,
-                pox_consts.reward_cycle_length
+        let effective_height = block_height - self.context.first_block_height as u32;
+        let position_in_cycle = effective_height % pox_consts.reward_cycle_length;
+        if position_in_cycle != 0 {
+            debug!(
+                "effective_height = {}, reward cycle length == {}",
+                effective_height, pox_consts.reward_cycle_length
             );
             return Err(CoordinatorError::NotPrepareEndBlock);
         }
 
-        let prepare_end = my_height;
-        // if this block isn't greater than prepare_length, then this shouldn't be the end of a prepare block
-        if prepare_end < pox_consts.prepare_length {
-            test_debug!(
-                "prepare_end = {}, pox_consts.prepare_length = {}",
-                prepare_end,
-                pox_consts.prepare_length
+        if effective_height == 0 {
+            debug!(
+                "effective_height = {}, reward cycle length == {}",
+                effective_height, pox_consts.reward_cycle_length
             );
-            return Err(CoordinatorError::NotPrepareEndBlock);
+            return Ok(None);
         }
 
-        let prepare_begin = prepare_end - pox_consts.prepare_length;
+        let prepare_end = block_height;
+        let prepare_begin = prepare_end.saturating_sub(pox_consts.prepare_length);
 
         let mut candidate_anchors = HashMap::new();
         let mut memoized_candidates: HashMap<_, (Txid, u64)> = HashMap::new();

src/chainstate/burn/operations/leader_block_commit.rs

@@ -555,7 +555,20 @@ impl LeaderBlockCommitOp {
                     let expect_pox_descendant = if self.all_outputs_burn() {
                         false
                     } else {
-                        if self.commit_outs.len() != reward_set_info.recipients.len() {
+                        let mut check_recipients: Vec<_> = reward_set_info
+                            .recipients
+                            .iter()
+                            .map(|(addr, _)| addr.clone())
+                            .collect();
+
+                        if check_recipients.len() == 1 {
+                            // If the number of recipients in the set was even, we need to pad
+                            // with a burn address
+                            check_recipients
+                                .push(StacksAddress::burn_address(burnchain.is_mainnet()))
+                        }
+
+                        if self.commit_outs.len() != check_recipients.len() {
                             warn!(
                                 "Invalid block commit: expected {} PoX transfers, but commit has {}",
                                 reward_set_info.recipients.len(),
@@ -566,11 +579,6 @@ impl LeaderBlockCommitOp {
 
                         // sort check_recipients and commit_outs so that we can perform an
                         //  iterative equality check
-                        let mut check_recipients: Vec<_> = reward_set_info
-                            .recipients
-                            .iter()
-                            .map(|(addr, _)| addr.clone())
-                            .collect();
                         check_recipients.sort();
                         let mut commit_outs = self.commit_outs.clone();
                         commit_outs.sort();

src/chainstate/coordinator/mod.rs

@@ -581,14 +581,15 @@ impl<'a, T: BlockEventDispatcher, N: CoordinatorNotices, U: RewardSetProvider>
         &mut self,
         burn_header: &BurnchainBlockHeader,
     ) -> Result<Option<RewardCycleInfo>, Error> {
-        let sortition_tip = self
+        let sortition_tip_id = self
             .canonical_sortition_tip
             .as_ref()
             .expect("FATAL: Processing anchor block, but no known sortition tip");
+
         get_reward_cycle_info(
             burn_header.block_height,
             &burn_header.parent_block_hash,
-            sortition_tip,
+            sortition_tip_id,
             &self.burnchain,
             &mut self.chain_state_db,
             &self.sortition_db,

src/chainstate/coordinator/tests.rs

@@ -462,11 +462,15 @@ fn make_genesis_block_with_recipients(
     builder.epoch_finish(epoch_tx);
 
     let commit_outs = if let Some(recipients) = recipients {
-        recipients
+        let mut commit_outs = recipients
             .recipients
             .iter()
             .map(|(a, _)| a.clone())
-            .collect()
+            .collect::<Vec<StacksAddress>>();
+        if commit_outs.len() == 1 {
+            commit_outs.push(StacksAddress::burn_address(false))
+        }
+        commit_outs
     } else {
         vec![]
     };
@@ -668,11 +672,16 @@ fn make_stacks_block_with_input(
     builder.epoch_finish(epoch_tx);
 
     let commit_outs = if let Some(recipients) = recipients {
-        recipients
+        let mut commit_outs = recipients
             .recipients
             .iter()
             .map(|(a, _)| a.clone())
-            .collect()
+            .collect::<Vec<StacksAddress>>();
+        if commit_outs.len() == 1 {
+            // Padding with burn address if required
+            commit_outs.push(StacksAddress::burn_address(false))
+        }
+        commit_outs
     } else if post_sunset_burn || burnchain.is_in_prepare_phase(parent_height + 1) {
         test_debug!("block-commit in {} will burn", parent_height + 1);
         vec![StacksAddress::burn_address(false)]
@@ -992,7 +1001,7 @@ fn missed_block_commits() {
         let ic = sort_db.index_handle_at_tip();
         let pox_id = ic.get_pox_id().unwrap();
         assert_eq!(&pox_id.to_string(),
-                   "11111111111",
+                   "111111111111",
                    "PoX ID should reflect the 5 reward cycles _with_ a known anchor block, plus the 'initial' known reward cycle at genesis");
     }
 }
@@ -1152,7 +1161,7 @@ fn test_simple_setup() {
         let ic = sort_db.index_handle_at_tip();
         let pox_id = ic.get_pox_id().unwrap();
         assert_eq!(&pox_id.to_string(),
-                   "11111111111",
+                   "111111111111",
                    "PoX ID should reflect the 10 reward cycles _with_ a known anchor block, plus the 'initial' known reward cycle at genesis");
     }
 
@@ -1161,7 +1170,7 @@ fn test_simple_setup() {
         let pox_id = ic.get_pox_id().unwrap();
         assert_eq!(
             &pox_id.to_string(),
-            "10000000000",
+            "110000000000",
             "PoX ID should reflect the initial 'known' reward cycle at genesis"
         );
     }
@@ -1189,10 +1198,11 @@ fn test_simple_setup() {
             pox_id_string.push('1');
         }
 
+        println!("=> {}", pox_id_string);
         assert_eq!(
             pox_id_at_tip.to_string(),
             // right-pad pox_id_string to 11 characters
-            format!("{:0<11}", pox_id_string)
+            format!("1{:0<11}", pox_id_string)
         );
     }
 }
@@ -1449,7 +1459,7 @@ fn test_sortition_with_reward_set() {
         let ic = sort_db.index_handle_at_tip();
         let pox_id = ic.get_pox_id().unwrap();
         assert_eq!(&pox_id.to_string(),
-                   "11111111111",
+                   "111111111111",
                    "PoX ID should reflect the 10 reward cycles _with_ a known anchor block, plus the 'initial' known reward cycle at genesis");
     }
 }
@@ -1680,7 +1690,7 @@ fn test_sortition_with_burner_reward_set() {
         let ic = sort_db.index_handle_at_tip();
         let pox_id = ic.get_pox_id().unwrap();
         assert_eq!(&pox_id.to_string(),
-                   "11111111111",
+                   "111111111111",
                    "PoX ID should reflect the 10 reward cycles _with_ a known anchor block, plus the 'initial' known reward cycle at genesis");
     }
 }
@@ -1940,7 +1950,7 @@ fn test_pox_btc_ops() {
         let ic = sort_db.index_handle_at_tip();
         let pox_id = ic.get_pox_id().unwrap();
         assert_eq!(&pox_id.to_string(),
-                   "11111111111",
+                   "111111111111",
                    "PoX ID should reflect the 5 reward cycles _with_ a known anchor block, plus the 'initial' known reward cycle at genesis");
     }
 }
@@ -2236,7 +2246,7 @@ fn test_stx_transfer_btc_ops() {
         let ic = sort_db.index_handle_at_tip();
         let pox_id = ic.get_pox_id().unwrap();
         assert_eq!(&pox_id.to_string(),
-                   "11111111111",
+                   "111111111111",
                    "PoX ID should reflect the 5 reward cycles _with_ a known anchor block, plus the 'initial' known reward cycle at genesis");
     }
 }
@@ -2724,7 +2734,7 @@ fn test_sortition_with_sunset() {
         let ic = sort_db.index_handle_at_tip();
         let pox_id = ic.get_pox_id().unwrap();
         assert_eq!(&pox_id.to_string(),
-                   "11111111111111111",
+                   "111111111111111111",
                    "PoX ID should reflect the 10 reward cycles _with_ a known anchor block, plus the 'initial' known reward cycle at genesis");
     }
 }
@@ -3159,13 +3169,13 @@ fn test_pox_no_anchor_selected() {
     {
         let ic = sort_db.index_handle_at_tip();
         let pox_id = ic.get_pox_id().unwrap();
-        assert_eq!(&pox_id.to_string(), "111");
+        assert_eq!(&pox_id.to_string(), "1111");
     }
 
     {
         let ic = sort_db_blind.index_handle_at_tip();
         let pox_id = ic.get_pox_id().unwrap();
-        assert_eq!(&pox_id.to_string(), "101");
+        assert_eq!(&pox_id.to_string(), "1101");
     }
 
     for (sort_id, block) in stacks_blocks.iter() {
@@ -3181,7 +3191,7 @@ fn test_pox_no_anchor_selected() {
     {
         let ic = sort_db_blind.index_handle_at_tip();
         let pox_id = ic.get_pox_id().unwrap();
-        assert_eq!(&pox_id.to_string(), "111");
+        assert_eq!(&pox_id.to_string(), "1111");
     }
 
     let block_height = eval_at_chain_tip(path_blinded, &sort_db_blind, "block-height");
@@ -3357,13 +3367,13 @@ fn test_pox_fork_out_of_order() {
     {
         let ic = sort_db.index_handle_at_tip();
         let pox_id = ic.get_pox_id().unwrap();
-        assert_eq!(&pox_id.to_string(), "1111");
+        assert_eq!(&pox_id.to_string(), "11111");
     }
 
     {
         let ic = sort_db_blind.index_handle_at_tip();
         let pox_id = ic.get_pox_id().unwrap();
-        assert_eq!(&pox_id.to_string(), "1000");
+        assert_eq!(&pox_id.to_string(), "11000");
     }
 
     // now, we reveal to the blinded coordinator, but out of order.
@@ -3386,7 +3396,7 @@ fn test_pox_fork_out_of_order() {
     {
         let ic = sort_db_blind.index_handle_at_tip();
         let pox_id = ic.get_pox_id().unwrap();
-        assert_eq!(&pox_id.to_string(), "1110");
+        assert_eq!(&pox_id.to_string(), "11110");
     }
 
     let block_height = eval_at_chain_tip(path_blinded, &sort_db_blind, "block-height");
@@ -3417,7 +3427,7 @@ fn test_pox_fork_out_of_order() {
     {
         let ic = sort_db_blind.index_handle_at_tip();
         let pox_id = ic.get_pox_id().unwrap();
-        assert_eq!(&pox_id.to_string(), "1110");
+        assert_eq!(&pox_id.to_string(), "11110");
     }
 
     let block_height = eval_at_chain_tip(path_blinded, &sort_db_blind, "block-height");
@@ -3478,7 +3488,7 @@ fn test_pox_fork_out_of_order() {
     {
         let ic = sort_db_blind.index_handle_at_tip();
         let pox_id = ic.get_pox_id().unwrap();
-        assert_eq!(&pox_id.to_string(), "1111");
+        assert_eq!(&pox_id.to_string(), "11111");
     }
 
     let block_height = eval_at_chain_tip(path_blinded, &sort_db_blind, "block-height");