Merge branch 'pox-wf-integration' into feat/bitcoin-clarity

Author: brice-stacks

Cargo.lock

@@ -123,7 +123,7 @@ impl StandardPrincipalData {
         (version, bytes)
     }
 
-    pub fn is_mainnet(self) -> bool {
+    pub fn is_mainnet(&self) -> bool {
         self.0 == C32_ADDRESS_VERSION_MAINNET_MULTISIG
             || self.0 == C32_ADDRESS_VERSION_MAINNET_SINGLESIG
     }

clarity-types/src/types/mod.rs

@@ -551,10 +551,18 @@ impl<T: SignerEventTrait> TryFrom<StackerDBChunksEvent> for SignerEvent<T> {
         {
             let mut messages = vec![];
             for chunk in event.modified_slots {
-                let Ok(msg) = T::consensus_deserialize(&mut chunk.data.as_slice()) else {
-                    continue;
-                };
-                messages.push(msg);
+                match T::consensus_deserialize(&mut chunk.data.as_slice()) {
+                    Ok(msg) => messages.push(msg),
+                    Err(e) => {
+                        debug!(
+                            "Signer failed to deserialize miner chunk";
+                            "slot_id" => chunk.slot_id,
+                            "slot_version" => chunk.slot_version,
+                            "data_len" => chunk.data.len(),
+                            "error" => %e,
+                        );
+                    }
+                }
             }
             SignerEvent::MinerMessages(messages)
         } else if event.contract_id.name.starts_with(SIGNERS_NAME) && event.contract_id.is_boot() {

libsigner/src/events.rs

@@ -628,6 +628,11 @@ impl StacksEpochId {
         self >= &StacksEpochId::Epoch34
     }
 
+    /// Does this epoch use a mod-0 start for reward cycles?
+    pub fn starts_reward_cycle_at_0(&self) -> bool {
+        self >= &StacksEpochId::Epoch40
+    }
+
     /// What is the coinbase (in uSTX) to award for the given burnchain height?
     /// Applies prior to SIP-029
     fn coinbase_reward_pre_sip029(

stacks-common/src/types/mod.rs

@@ -147,14 +147,29 @@ impl RewardSetEventPayload {
         }
     }
     pub fn from_reward_set(reward_set: &RewardSet) -> Self {
-        Self {
-            rewarded_addresses: reward_set.rewarded_addresses.clone(),
-            start_cycle_state: reward_set.start_cycle_state.clone(),
-            signers: reward_set
-                .signers
-                .as_ref()
-                .map(|signers| signers.iter().map(Self::signer_entry_to_payload).collect()),
-            pox_ustx_threshold: reward_set.pox_ustx_threshold,
+        match reward_set {
+            RewardSet::V0(v0) => Self {
+                rewarded_addresses: v0.rewarded_addresses.clone(),
+                start_cycle_state: v0.start_cycle_state.clone(),
+                signers: v0
+                    .signers
+                    .as_ref()
+                    .map(|signers| signers.iter().map(Self::signer_entry_to_payload).collect()),
+                pox_ustx_threshold: v0.pox_ustx_threshold,
+            },
+            RewardSet::Waterfall(wf) => Self {
+                rewarded_addresses: vec![],
+                start_cycle_state: PoxStartCycleInfo {
+                    missed_reward_slots: vec![],
+                },
+                signers: Some(
+                    wf.signers
+                        .iter()
+                        .map(Self::signer_entry_to_payload)
+                        .collect(),
+                ),
+                pox_ustx_threshold: None,
+            },
         }
     }
 }

stacks-node/src/event_dispatcher/payloads.rs

@@ -1626,7 +1626,10 @@ impl BlockMinerThread {
 
         parent_block_info.stacks_parent_header.microblock_tail = None;
 
-        let signer_bitvec_len = reward_set.rewarded_addresses.len().try_into().ok();
+        // Length of the per-block `pox_treatment` BitVec.
+        // Must be `> 0`:
+        //   the BitVec codec rejects zero-length bitvecs at deserialization.
+        let signer_bitvec_len = reward_set.pox_treatment_bitvec_len();
 
         if !self.validate_timestamp_info(
             get_epoch_time_secs(),
@@ -1688,7 +1691,7 @@ impl BlockMinerThread {
             // we'll invoke the event dispatcher ourselves so that it calculates the
             //  correct signer_signature_hash for `process_mined_nakamoto_block_event`
             Some(&self.event_dispatcher),
-            signer_bitvec_len.unwrap_or(0),
+            signer_bitvec_len,
             &replay_transactions,
         )
         .map_err(|e| {

stacks-node/src/nakamoto_node/miner.rs

@@ -1125,13 +1125,20 @@ impl RelayerThread {
             NakamotoNodeError::SnapshotNotFoundForChainTip
         })?;
 
-        let commit_outs = if self
-            .burnchain
-            .is_in_prepare_phase(sort_tip.block_height + 1)
-        {
-            vec![PoxAddress::standard_burn_address(self.config.is_mainnet())]
-        } else {
-            RewardSetInfo::into_commit_outs(recipients, self.config.is_mainnet())
+        let commit_outs = match recipients.as_ref() {
+            // Under waterfall PoX, every block in the cycle (including
+            // prepare-phase blocks) commits to the cycle's sBTC address.
+            // Don't let the classic prepare-phase burn-output override clobber it.
+            Some(RewardSetInfo::Waterfall(_)) => {
+                RewardSetInfo::into_commit_outs(recipients, self.config.is_mainnet())
+            }
+            _ if self
+                .burnchain
+                .is_in_prepare_phase(sort_tip.block_height + 1) =>
+            {
+                vec![PoxAddress::standard_burn_address(self.config.is_mainnet())]
+            }
+            _ => RewardSetInfo::into_commit_outs(recipients, self.config.is_mainnet()),
         };
 
         // find the sortition that kicked off this tenure (it may be different from the sortition

stacks-node/src/nakamoto_node/relayer.rs

@@ -176,7 +176,7 @@ impl StackerDBListener {
         let signer_set =
             u32::try_from(reward_cycle_id % 2).expect("FATAL: reward cycle id % 2 exceeds u32");
 
-        let Some(ref reward_set_signers) = reward_set.signers else {
+        let Some(reward_set_signers) = reward_set.signers() else {
             error!("Could not initialize signing coordinator for reward set without signer");
             debug!("reward set: {reward_set:?}");
             return Err(ChainstateError::NoRegisteredSigners(0));