CRC: move sortition time out check into its own function

Signed-off-by: Jacinta Ferrant <[email protected]>

Author: jferrant

stacks-signer/src/chainstate.rs

@@ -78,6 +78,39 @@ pub struct SortitionState {
     pub burn_block_hash: BurnchainHeaderHash,
 }
 
+impl SortitionState {
+    /// Check if the sortition is timed out (i.e., the miner did not propose a block in time)
+    pub fn is_timed_out(
+        &self,
+        timeout: Duration,
+        signer_db: &SignerDb,
+    ) -> Result<bool, SignerChainstateError> {
+        // if the miner has already been invalidated, we don't need to check if they've timed out.
+        if self.miner_status != SortitionMinerStatus::Valid {
+            return Ok(false);
+        }
+        // if we've already signed a block in this tenure, the miner can't have timed out.
+        let has_blocks = signer_db
+            .get_last_signed_block_in_tenure(&self.consensus_hash)?
+            .is_some();
+        if has_blocks {
+            return Ok(false);
+        }
+        let Some(received_ts) = signer_db.get_burn_block_receive_time(&self.burn_block_hash)?
+        else {
+            return Ok(false);
+        };
+        let received_time = UNIX_EPOCH + Duration::from_secs(received_ts);
+        let Ok(elapsed) = std::time::SystemTime::now().duration_since(received_time) else {
+            return Ok(false);
+        };
+        if elapsed > timeout {
+            return Ok(true);
+        }
+        Ok(false)
+    }
+}
+
 /// Captures the configuration settings used by the signer when evaluating block proposals.
 #[derive(Debug, Clone)]
 pub struct ProposalEvalConfig {
@@ -156,32 +189,15 @@ impl SortitionsView {
         block: &NakamotoBlock,
         block_pk: &StacksPublicKey,
     ) -> Result<bool, SignerChainstateError> {
-        // If this is the first block in the tenure, check if it was proposed after the timeout
-        if signer_db
-            .get_last_signed_block_in_tenure(&block.header.consensus_hash)?
-            .is_none()
+        if self
+            .cur_sortition
+            .is_timed_out(self.config.block_proposal_timeout, signer_db)?
         {
-            if let Some(received_ts) =
-                signer_db.get_burn_block_receive_time(&self.cur_sortition.burn_block_hash)?
-            {
-                let received_time = UNIX_EPOCH + Duration::from_secs(received_ts);
-                let elapsed = std::time::SystemTime::now()
-                    .duration_since(received_time)
-                    .unwrap_or_else(|_| {
-                        panic!("Failed to calculate time since burn block received")
-                    });
-                if elapsed >= self.config.block_proposal_timeout {
-                    warn!(
-                        "Miner proposed first block after block proposal timeout.";
-                        "proposed_block_consensus_hash" => %block.header.consensus_hash,
-                        "proposed_block_signer_sighash" => %block.header.signer_signature_hash(),
-                        "current_sortition_consensus_hash" => ?self.cur_sortition.consensus_hash,
-                        "last_sortition_consensus_hash" => ?self.last_sortition.as_ref().map(|x| x.consensus_hash),
-                        "burn_block_received_time" => ?received_time,
-                    );
-                    self.cur_sortition.miner_status =
-                        SortitionMinerStatus::InvalidatedBeforeFirstBlock;
-                }
+            self.cur_sortition.miner_status = SortitionMinerStatus::InvalidatedBeforeFirstBlock;
+        }
+        if let Some(last_sortition) = self.last_sortition.as_mut() {
+            if last_sortition.is_timed_out(self.config.block_proposal_timeout, signer_db)? {
+                last_sortition.miner_status = SortitionMinerStatus::InvalidatedBeforeFirstBlock;
             }
         }
         let bitvec_all_1s = block.header.pox_treatment.iter().all(|entry| entry);

stacks-signer/src/tests/chainstate.rs

@@ -387,3 +387,80 @@ fn check_block_proposal_timeout() {
         .check_proposal(&stacks_client, &signer_db, &last_sortition_block, &block_pk)
         .unwrap());
 }
+
+#[test]
+fn check_sortition_timeout() {
+    let signer_db_dir = "/tmp/stacks-node-tests/signer-units/";
+    let signer_db_path = format!(
+        "{signer_db_dir}/sortition_timeout.{}.sqlite",
+        get_epoch_time_secs()
+    );
+    fs::create_dir_all(signer_db_dir).unwrap();
+    let mut signer_db = SignerDb::new(signer_db_path).unwrap();
+
+    let mut sortition = SortitionState {
+        miner_pkh: Hash160([0; 20]),
+        miner_pubkey: None,
+        prior_sortition: ConsensusHash([0; 20]),
+        parent_tenure_id: ConsensusHash([0; 20]),
+        consensus_hash: ConsensusHash([1; 20]),
+        miner_status: SortitionMinerStatus::Valid,
+        burn_header_timestamp: 2,
+        burn_block_hash: BurnchainHeaderHash([1; 32]),
+    };
+    // Ensure we have a burn height to compare against
+    let burn_hash = sortition.burn_block_hash;
+    let burn_height = 1;
+    let received_time = SystemTime::now();
+    signer_db
+        .insert_burn_block(&burn_hash, burn_height, &received_time)
+        .unwrap();
+
+    std::thread::sleep(Duration::from_secs(1));
+    // We have not yet timed out
+    assert!(!sortition
+        .is_timed_out(Duration::from_secs(10), &signer_db)
+        .unwrap());
+    // We are a valid sortition, have an empty tenure, and have now timed out
+    assert!(sortition
+        .is_timed_out(Duration::from_secs(1), &signer_db)
+        .unwrap());
+    // This will not be marked as timed out as the status is no longer valid
+    sortition.miner_status = SortitionMinerStatus::InvalidatedAfterFirstBlock;
+    assert!(!sortition
+        .is_timed_out(Duration::from_secs(1), &signer_db)
+        .unwrap());
+
+    // Revert the status to continue other checks
+    sortition.miner_status = SortitionMinerStatus::Valid;
+    // Insert a signed over block so its no longer an empty tenure
+    let block_proposal = BlockProposal {
+        block: NakamotoBlock {
+            header: NakamotoBlockHeader {
+                version: 1,
+                chain_length: 10,
+                burn_spent: 10,
+                consensus_hash: sortition.consensus_hash,
+                parent_block_id: StacksBlockId([0; 32]),
+                tx_merkle_root: Sha512Trunc256Sum([0; 32]),
+                state_index_root: TrieHash([0; 32]),
+                timestamp: 11,
+                miner_signature: MessageSignature::empty(),
+                signer_signature: vec![],
+                pox_treatment: BitVec::ones(1).unwrap(),
+            },
+            txs: vec![],
+        },
+        burn_height: 2,
+        reward_cycle: 1,
+    };
+
+    let mut block_info = BlockInfo::from(block_proposal);
+    block_info.signed_over = true;
+    signer_db.insert_block(&block_info).unwrap();
+
+    // This will no longer be timed out as we have a non-empty tenure
+    assert!(!sortition
+        .is_timed_out(Duration::from_secs(1), &signer_db)
+        .unwrap());
+}