Time based tenure extend

stacks-signer/CHANGELOG.md

@@ -12,7 +12,7 @@ and this project adheres to the versioning scheme outlined in the [README.md](RE
 ### Changed
 
 - Added tenure extend timestamp to signer block responses
-- Added tenure_idle_timeout_secs configuration option for determining when a tenure extend will be accepted
+- Added tenure_idle_timeout_secs configuration option for determining when a time-based tenure extend will be accepted
 
 ## [3.0.0.0.4.0]
 

stacks-signer/src/chainstate.rs

@@ -365,16 +365,20 @@ impl SortitionsView {
             let sortition_consensus_hash = proposed_by.state().consensus_hash;
             let changed_burn_view =
                 tenure_extend.burn_view_consensus_hash != sortition_consensus_hash;
-            let enough_time_passed = get_epoch_time_secs()
-                > signer_db.calculate_tenure_extend_timestamp(
-                    self.config.tenure_idle_timeout,
-                    &sortition_consensus_hash,
-                );
+            let extend_timestamp = signer_db.calculate_tenure_extend_timestamp(
+                self.config.tenure_idle_timeout,
+                &block,
+                false,
+            );
+            let epoch_time = get_epoch_time_secs();
+            let enough_time_passed = epoch_time > extend_timestamp;
             if !changed_burn_view && !enough_time_passed {
                 warn!(
                     "Miner block proposal contains a tenure extend, but the burnchain view has not changed and enough time has not passed to refresh the block limit. Considering proposal invalid.";
                     "proposed_block_consensus_hash" => %block.header.consensus_hash,
                     "proposed_block_signer_sighash" => %block.header.signer_signature_hash(),
+                    "extend_timestamp" => extend_timestamp,
+                    "epoch_time" => epoch_time,
                 );
                 return Ok(false);
             }

stacks-signer/src/signerdb.rs

@@ -1001,32 +1001,54 @@ impl SignerDb {
         })?;
         let mut tenure_processing_time_ms = 0_u64;
         let mut tenure_start_time = None;
-        for row in rows {
+        let mut nmb_rows = 0;
+        for (i, row) in rows.enumerate() {
+            nmb_rows += 1;
             let (tenure_change_block, proposed_time, validation_time_ms) = row?;
             tenure_processing_time_ms =
                 tenure_processing_time_ms.saturating_add(validation_time_ms.unwrap_or(0));
             tenure_start_time = Some(proposed_time);
             if tenure_change_block {
+                debug!("Found tenure change block {i} blocks ago in tenure {tenure}");
                 break;
             }
         }
+        debug!("Calculated tenure extend timestamp from {nmb_rows} blocks in tenure {tenure}");
         Ok((
             tenure_start_time.unwrap_or(get_epoch_time_secs()),
             tenure_processing_time_ms,
         ))
     }
 
-    /// Calculate the tenure extend timestamp
+    /// Calculate the tenure extend timestamp. If determine the timestamp for a block rejection, check_tenure_extend should be set to false to avoid recalculating
+    /// the tenure extend timestamp for a tenure extend block.
     pub fn calculate_tenure_extend_timestamp(
         &self,
         tenure_idle_timeout: Duration,
-        tenure: &ConsensusHash,
+        block: &NakamotoBlock,
+        check_tenure_extend: bool,
     ) -> u64 {
+        if check_tenure_extend && block.get_tenure_tx_payload().is_some() {
+            let tenure_extend_timestamp =
+                get_epoch_time_secs().wrapping_add(tenure_idle_timeout.as_secs());
+            debug!("Calculated tenure extend timestamp for a tenure extend block. Rolling over timestamp: {tenure_extend_timestamp}");
+            return tenure_extend_timestamp;
+        }
         let tenure_idle_timeout_secs = tenure_idle_timeout.as_secs();
-        let (tenure_start_time, tenure_process_time_ms) = self.get_tenure_times(tenure).inspect_err(|e| error!("Error occurred calculating tenure extend timestamp: {e:?}. Defaulting to {tenure_idle_timeout_secs} from now.")).unwrap_or((get_epoch_time_secs(), 0));
-        tenure_start_time
+        let (tenure_start_time, tenure_process_time_ms) = self.get_tenure_times(&block.header.consensus_hash).inspect_err(|e| error!("Error occurred calculating tenure extend timestamp: {e:?}. Defaulting to {tenure_idle_timeout_secs} from now.")).unwrap_or((get_epoch_time_secs(), 0));
+        // Plus (ms + 999)/1000 to round up to the nearest second
+        let tenure_extend_timestamp = tenure_start_time
             .saturating_add(tenure_idle_timeout_secs)
-            .saturating_add(tenure_process_time_ms / 1000)
+            .saturating_add(tenure_process_time_ms.saturating_add(999) / 1000);
+        debug!("Calculated tenure extend timestamp";
+            "tenure_extend_timestamp" => tenure_extend_timestamp,
+            "tenure_start_time" => tenure_start_time,
+            "tenure_process_time_ms" => tenure_process_time_ms,
+            "tenure_idle_timeout_secs" => tenure_idle_timeout_secs,
+            "tenure_extend_in" => tenure_extend_timestamp.saturating_sub(get_epoch_time_secs()),
+            "consensus_hash" => %block.header.consensus_hash,
+        );
+        tenure_extend_timestamp
     }
 }
 
@@ -1691,17 +1713,16 @@ mod tests {
         let mut db = SignerDb::new(db_path).expect("Failed to create signer db");
 
         let block_infos = generate_tenure_blocks();
-        let consensus_hash_1 = block_infos[0].block.header.consensus_hash;
-        let consensus_hash_2 = block_infos.last().unwrap().block.header.consensus_hash;
-        let consensus_hash_3 = ConsensusHash([0x03; 20]);
+        let mut unknown_block = block_infos[0].block.clone();
+        unknown_block.header.consensus_hash = ConsensusHash([0x03; 20]);
 
         db.insert_block(&block_infos[0]).unwrap();
         db.insert_block(&block_infos[1]).unwrap();
 
         let tenure_idle_timeout = Duration::from_secs(10);
         // Verify tenure consensus_hash_1
         let timestamp_hash_1_before =
-            db.calculate_tenure_extend_timestamp(tenure_idle_timeout, &consensus_hash_1);
+            db.calculate_tenure_extend_timestamp(tenure_idle_timeout, &block_infos[0].block, true);
         assert_eq!(
             timestamp_hash_1_before,
             block_infos[0]
@@ -1714,7 +1735,8 @@ mod tests {
         db.insert_block(&block_infos[3]).unwrap();
 
         let timestamp_hash_1_after =
-            db.calculate_tenure_extend_timestamp(tenure_idle_timeout, &consensus_hash_1);
+            db.calculate_tenure_extend_timestamp(tenure_idle_timeout, &block_infos[0].block, true);
+
         assert_eq!(
             timestamp_hash_1_after,
             block_infos[2]
@@ -1727,8 +1749,11 @@ mod tests {
         db.insert_block(&block_infos[5]).unwrap();
 
         // Verify tenure consensus_hash_2
-        let timestamp_hash_2 =
-            db.calculate_tenure_extend_timestamp(tenure_idle_timeout, &consensus_hash_2);
+        let timestamp_hash_2 = db.calculate_tenure_extend_timestamp(
+            tenure_idle_timeout,
+            &block_infos.last().unwrap().block,
+            true,
+        );
         assert_eq!(
             timestamp_hash_2,
             block_infos[4]
@@ -1737,9 +1762,15 @@ mod tests {
                 .saturating_add(20)
         );
 
+        let now = get_epoch_time_secs().saturating_add(tenure_idle_timeout.as_secs());
+        let timestamp_hash_2_no_tenure_extend =
+            db.calculate_tenure_extend_timestamp(tenure_idle_timeout, &block_infos[0].block, false);
+        assert_ne!(timestamp_hash_2, timestamp_hash_2_no_tenure_extend);
+        assert!(now < timestamp_hash_2_no_tenure_extend);
+
         // Verify tenure consensus_hash_3 (unknown hash)
         let timestamp_hash_3 =
-            db.calculate_tenure_extend_timestamp(tenure_idle_timeout, &consensus_hash_3);
+            db.calculate_tenure_extend_timestamp(tenure_idle_timeout, &unknown_block, true);
         assert!(
             timestamp_hash_3.saturating_add(tenure_idle_timeout.as_secs())
                 < block_infos[0].proposed_time

stacks-signer/src/v0/signer.rs

@@ -305,7 +305,8 @@ impl Signer {
                 signature,
                 self.signer_db.calculate_tenure_extend_timestamp(
                     self.proposal_config.tenure_idle_timeout,
-                    &block_info.block.header.consensus_hash,
+                    &block_info.block,
+                    true,
                 ),
             )
         } else {
@@ -317,7 +318,8 @@ impl Signer {
                 self.mainnet,
                 self.signer_db.calculate_tenure_extend_timestamp(
                     self.proposal_config.tenure_idle_timeout,
-                    &block_info.block.header.consensus_hash,
+                    &block_info.block,
+                    false,
                 ),
             )
         };
@@ -422,7 +424,8 @@ impl Signer {
                         self.mainnet,
                         self.signer_db.calculate_tenure_extend_timestamp(
                             self.proposal_config.tenure_idle_timeout,
-                            &block_proposal.block.header.consensus_hash,
+                            &block_proposal.block,
+                            false,
                         ),
                     ))
                 }
@@ -440,7 +443,8 @@ impl Signer {
                         self.mainnet,
                         self.signer_db.calculate_tenure_extend_timestamp(
                             self.proposal_config.tenure_idle_timeout,
-                            &block_proposal.block.header.consensus_hash,
+                            &block_proposal.block,
+                            false,
                         ),
                     ))
                 }
@@ -460,7 +464,8 @@ impl Signer {
                 self.mainnet,
                 self.signer_db.calculate_tenure_extend_timestamp(
                     self.proposal_config.tenure_idle_timeout,
-                    &block_proposal.block.header.consensus_hash,
+                    &block_proposal.block,
+                    false,
                 ),
             ))
         };
@@ -602,7 +607,8 @@ impl Signer {
             signature,
             self.signer_db.calculate_tenure_extend_timestamp(
                 self.proposal_config.tenure_idle_timeout,
-                &block_info.block.header.consensus_hash,
+                &block_info.block,
+                true,
             ),
         );
         // have to save the signature _after_ the block info
@@ -657,7 +663,8 @@ impl Signer {
             self.mainnet,
             self.signer_db.calculate_tenure_extend_timestamp(
                 self.proposal_config.tenure_idle_timeout,
-                &block_info.block.header.consensus_hash,
+                &block_info.block,
+                false,
             ),
         );
         self.signer_db
@@ -755,7 +762,8 @@ impl Signer {
             self.mainnet,
             self.signer_db.calculate_tenure_extend_timestamp(
                 self.proposal_config.tenure_idle_timeout,
-                &block_proposal.block.header.consensus_hash,
+                &block_proposal.block,
+                false,
             ),
         );
         if let Err(e) = block_info.mark_locally_rejected() {
@@ -1131,7 +1139,8 @@ impl Signer {
                 self.mainnet,
                 self.signer_db.calculate_tenure_extend_timestamp(
                     self.proposal_config.tenure_idle_timeout,
-                    &block_proposal.block.header.consensus_hash,
+                    &block_proposal.block,
+                    false,
                 ),
             ))
         } else {

stackslib/src/chainstate/nakamoto/mod.rs

@@ -131,7 +131,7 @@ pub use self::staging_blocks::{
     NakamotoStagingBlocksConn, NakamotoStagingBlocksConnRef, NakamotoStagingBlocksTx,
 };
 
-pub const NAKAMOTO_BLOCK_VERSION: u8 = 1;
+pub const NAKAMOTO_BLOCK_VERSION: u8 = 0;
 
 define_named_enum!(HeaderTypeNames {
     Nakamoto("nakamoto"),

testnet/stacks-node/src/nakamoto_node/miner.rs

@@ -422,58 +422,64 @@ impl BlockMinerThread {
 
         if let Some(mut new_block) = new_block {
             Self::fault_injection_block_broadcast_stall(&new_block);
-            let mut chain_state =
-                neon_node::open_chainstate_with_faults(&self.config).map_err(|e| {
-                    NakamotoNodeError::SigningCoordinatorFailure(format!(
-                        "Failed to open chainstate DB. Cannot mine! {e:?}"
-                    ))
-                })?;
-            let signer_signature = match coordinator.propose_block(
-                &mut new_block,
-                &self.burn_block,
-                &self.burnchain,
-                &sortdb,
-                &mut chain_state,
-                stackerdbs,
-                &self.globals.counters,
-                &self.burn_election_block.consensus_hash,
-            ) {
-                Ok(x) => x,
-                Err(e) => match e {
-                    NakamotoNodeError::StacksTipChanged => {
-                        info!("Stacks tip changed while waiting for signatures";
-                            "signer_sighash" => %new_block.header.signer_signature_hash(),
-                            "block_height" => new_block.header.chain_length,
-                            "consensus_hash" => %new_block.header.consensus_hash,
-                        );
-                        return Err(e);
-                    }
-                    NakamotoNodeError::BurnchainTipChanged => {
-                        info!("Burnchain tip changed while waiting for signatures";
-                            "signer_sighash" => %new_block.header.signer_signature_hash(),
-                            "block_height" => new_block.header.chain_length,
-                            "consensus_hash" => %new_block.header.consensus_hash,
-                        );
-                        return Err(e);
-                    }
-                    _ => {
-                        // Sleep for a bit to allow signers to catch up
-                        let pause_ms = if *last_block_rejected {
-                            self.config.miner.subsequent_rejection_pause_ms
-                        } else {
-                            self.config.miner.first_rejection_pause_ms
-                        };
-
-                        error!("Error while gathering signatures: {e:?}. Will try mining again in {pause_ms}.";
-                            "signer_sighash" => %new_block.header.signer_signature_hash(),
-                            "block_height" => new_block.header.chain_length,
-                            "consensus_hash" => %new_block.header.consensus_hash,
-                        );
-                        thread::sleep(Duration::from_millis(pause_ms));
-                        *last_block_rejected = true;
-                        return Ok(());
-                    }
-                },
+
+            let signer_signature = if self.config.get_node_config(false).mock_mining {
+                // If we're mock mining, we don't actually propose the block.
+                Vec::new()
+            } else {
+                let mut chain_state = neon_node::open_chainstate_with_faults(&self.config)
+                    .map_err(|e| {
+                        NakamotoNodeError::SigningCoordinatorFailure(format!(
+                            "Failed to open chainstate DB. Cannot mine! {e:?}"
+                        ))
+                    })?;
+                match coordinator.propose_block(
+                    &mut new_block,
+                    &self.burn_block,
+                    &self.burnchain,
+                    &sortdb,
+                    &mut chain_state,
+                    stackerdbs,
+                    &self.globals.counters,
+                    &self.burn_election_block.consensus_hash,
+                ) {
+                    Ok(x) => x,
+                    Err(e) => match e {
+                        NakamotoNodeError::StacksTipChanged => {
+                            info!("Stacks tip changed while waiting for signatures";
+                                "signer_sighash" => %new_block.header.signer_signature_hash(),
+                                "block_height" => new_block.header.chain_length,
+                                "consensus_hash" => %new_block.header.consensus_hash,
+                            );
+                            return Err(e);
+                        }
+                        NakamotoNodeError::BurnchainTipChanged => {
+                            info!("Burnchain tip changed while waiting for signatures";
+                                "signer_sighash" => %new_block.header.signer_signature_hash(),
+                                "block_height" => new_block.header.chain_length,
+                                "consensus_hash" => %new_block.header.consensus_hash,
+                            );
+                            return Err(e);
+                        }
+                        _ => {
+                            // Sleep for a bit to allow signers to catch up
+                            let pause_ms = if *last_block_rejected {
+                                self.config.miner.subsequent_rejection_pause_ms
+                            } else {
+                                self.config.miner.first_rejection_pause_ms
+                            };
+
+                            error!("Error while gathering signatures: {e:?}. Will try mining again in {pause_ms}.";
+                                "signer_sighash" => %new_block.header.signer_signature_hash(),
+                                "block_height" => new_block.header.chain_length,
+                                "consensus_hash" => %new_block.header.consensus_hash,
+                            );
+                            thread::sleep(Duration::from_millis(pause_ms));
+                            *last_block_rejected = true;
+                            return Ok(());
+                        }
+                    },
+                }
             };
             *last_block_rejected = false;
 
@@ -685,6 +691,11 @@ impl BlockMinerThread {
         )
         .expect("FATAL: could not open sortition DB");
 
+        if self.config.get_node_config(false).mock_mining {
+            // If we're mock mining, we don't actually broadcast the block.
+            return Ok(());
+        }
+
         if self.config.miner.mining_key.is_none() {
             return Err(NakamotoNodeError::MinerConfigurationFailed(
                 "No mining key configured, cannot mine",
@@ -1160,7 +1171,7 @@ impl BlockMinerThread {
         if self.last_block_mined.is_some() {
             // Check if we can extend the current tenure
             let tenure_extend_timestamp = coordinator.get_tenure_extend_timestamp();
-            if get_epoch_time_secs() < tenure_extend_timestamp {
+            if get_epoch_time_secs() <= tenure_extend_timestamp {
                 return Ok(NakamotoTenureInfo {
                     coinbase_tx: None,
                     tenure_change_tx: None,