fix: last locally or globally accepted block in tenure

In `get_tenure_last_block_info`, if the last accepted block is globally
accepted, then we shouldn't care about the timeout. That should only be
checked for locally accepted blocks.

Author: obycode

stacks-signer/CHANGELOG.md

@@ -13,6 +13,10 @@ and this project adheres to the versioning scheme outlined in the [README.md](RE
 - Introduced `capitulate_miner_view_timeout_secs`: the duration (in seconds) for the signer to wait between updating the local state machine viewpoint and capitulating to other signers' miner views.
 - Added codepath to enable signers to evaluate block proposals and miner activity against global signer state for improved consistency and correctness. Currently feature gated behind the `SUPPORTED_SIGNER_PROTOCOL_VERSION`
 
+### Fixed
+
+- Fixed a bug where signers would incorrectly reject block proposals if the parent block was globally accepted and the signer hadn't signed it within the `tenure_last_block_proposal_timeout` period; if it is globally accepted, the signer should accept it regardless of the timeout.
+
 ## [3.1.0.0.13.0]
 
 ### Changed

stacks-signer/src/chainstate/mod.rs

@@ -268,25 +268,37 @@ impl SortitionData {
         signer_db: &SignerDb,
         tenure_last_block_proposal_timeout: Duration,
     ) -> Result<Option<BlockInfo>, ClientError> {
-        // Get the last known block in the previous tenure
-        let last_locally_accepted_block = signer_db
+        // Get the last accepted block in the tenure
+        let last_accepted_block = signer_db
             .get_last_accepted_block(consensus_hash)
             .map_err(|e| ClientError::InvalidResponse(e.to_string()))?;
-        let Some(local_info) = last_locally_accepted_block else {
+
+        let Some(block_info) = last_accepted_block else {
             return Ok(None);
         };
 
-        let Some(signed_over_time) = local_info.signed_self else {
+        // If the last accepted block was globally accepted, return it
+        if block_info.state == BlockState::GloballyAccepted {
+            return Ok(Some(block_info));
+        }
+
+        // If the last accepted block was locally accepted, check if it has timed out
+        let Some(signed_over_time) = block_info.signed_self else {
             return Ok(None);
         };
 
         if signed_over_time.saturating_add(tenure_last_block_proposal_timeout.as_secs())
             > get_epoch_time_secs()
         {
             // The last locally accepted block is not timed out, return it
-            Ok(Some(local_info))
+            Ok(Some(block_info))
         } else {
             // The last locally accepted block is timed out
+            info!(
+                "Last locally accepted block hass timed out";
+                "signer_signature_hash" => %block_info.block.header.signer_signature_hash(),
+                "signed_over_time" => signed_over_time,
+            );
             Ok(None)
         }
     }