Fix: correct burn view for miner block broadcast

.github/workflows/bitcoin-tests.yml

@@ -125,6 +125,7 @@ jobs:
           - tests::signer::v0::continue_after_tenure_extend
           - tests::signer::v0::tenure_extend_after_idle_signers
           - tests::signer::v0::tenure_extend_after_idle_miner
+          - tests::signer::v0::tenure_extend_after_failed_miner
           - tests::signer::v0::tenure_extend_succeeds_after_rejected_attempt
           - tests::signer::v0::stx_transfers_dont_effect_idle_timeout
           - tests::signer::v0::idle_tenure_extend_active_mining
@@ -158,6 +159,7 @@ jobs:
           - tests::nakamoto_integrations::sip029_coinbase_change
           - tests::nakamoto_integrations::clarity_cost_spend_down
           - tests::nakamoto_integrations::v3_blockbyheight_api_endpoint
+          - tests::nakamoto_integrations::test_tenure_extend_from_flashblocks
           # TODO: enable these once v1 signer is supported by a new nakamoto epoch
           # - tests::signer::v1::dkg
           # - tests::signer::v1::sign_request_rejected

libstackerdb/src/libstackerdb.rs

@@ -135,6 +135,12 @@ pub struct StackerDBChunkAckData {
     pub code: Option<u32>,
 }
 
+impl fmt::Display for StackerDBChunkAckData {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        write!(f, "{:?}", self)
+    }
+}
+
 impl SlotMetadata {
     /// Make a new unsigned slot metadata
     pub fn new_unsigned(

stacks-signer/src/chainstate.rs

@@ -202,6 +202,7 @@ impl SortitionsView {
             info!(
                 "Current miner timed out, marking as invalid.";
                 "block_height" => block.header.chain_length,
+                "block_proposal_timeout" => ?self.config.block_proposal_timeout,
                 "current_sortition_consensus_hash" => ?self.cur_sortition.consensus_hash,
             );
             self.cur_sortition.miner_status = SortitionMinerStatus::InvalidatedBeforeFirstBlock;
@@ -322,7 +323,7 @@ impl SortitionsView {
                     return Ok(false);
                 }
             }
-            ProposedBy::LastSortition(_last_sortition) => {
+            ProposedBy::LastSortition(last_sortition) => {
                 // should only consider blocks from the last sortition if the new sortition was invalidated
                 //  before we signed their first block.
                 if self.cur_sortition.miner_status
@@ -333,6 +334,7 @@ impl SortitionsView {
                         "proposed_block_consensus_hash" => %block.header.consensus_hash,
                         "proposed_block_signer_sighash" => %block.header.signer_signature_hash(),
                         "current_sortition_miner_status" => ?self.cur_sortition.miner_status,
+                        "last_sortition" => %last_sortition.consensus_hash
                     );
                     return Ok(false);
                 }

stackslib/src/config/mod.rs

@@ -94,6 +94,8 @@ const DEFAULT_FIRST_REJECTION_PAUSE_MS: u64 = 5_000;
 const DEFAULT_SUBSEQUENT_REJECTION_PAUSE_MS: u64 = 10_000;
 const DEFAULT_BLOCK_COMMIT_DELAY_MS: u64 = 20_000;
 const DEFAULT_TENURE_COST_LIMIT_PER_BLOCK_PERCENTAGE: u8 = 25;
+const DEFAULT_TENURE_EXTEND_WAIT_SECS: u64 = 30;
+
 // This should be greater than the signers' timeout. This is used for issuing fallback tenure extends
 const DEFAULT_TENURE_TIMEOUT_SECS: u64 = 420;
 
@@ -2149,6 +2151,8 @@ pub struct MinerConfig {
     pub block_commit_delay: Duration,
     /// The percentage of the remaining tenure cost limit to consume each block.
     pub tenure_cost_limit_per_block_percentage: Option<u8>,
+    /// The number of seconds to wait to try to continue a tenure if a BlockFound is expected
+    pub tenure_extend_wait_secs: Duration,
     /// Duration to wait before attempting to issue a tenure extend
     pub tenure_timeout: Duration,
 }
@@ -2187,6 +2191,7 @@ impl Default for MinerConfig {
             tenure_cost_limit_per_block_percentage: Some(
                 DEFAULT_TENURE_COST_LIMIT_PER_BLOCK_PERCENTAGE,
             ),
+            tenure_extend_wait_secs: Duration::from_secs(DEFAULT_TENURE_EXTEND_WAIT_SECS),
             tenure_timeout: Duration::from_secs(DEFAULT_TENURE_TIMEOUT_SECS),
         }
     }
@@ -2582,6 +2587,7 @@ pub struct MinerConfigFile {
     pub subsequent_rejection_pause_ms: Option<u64>,
     pub block_commit_delay_ms: Option<u64>,
     pub tenure_cost_limit_per_block_percentage: Option<u8>,
+    pub tenure_extend_wait_secs: Option<u64>,
     pub tenure_timeout_secs: Option<u64>,
 }
 
@@ -2723,6 +2729,7 @@ impl MinerConfigFile {
             subsequent_rejection_pause_ms: self.subsequent_rejection_pause_ms.unwrap_or(miner_default_config.subsequent_rejection_pause_ms),
             block_commit_delay: self.block_commit_delay_ms.map(Duration::from_millis).unwrap_or(miner_default_config.block_commit_delay),
             tenure_cost_limit_per_block_percentage,
+            tenure_extend_wait_secs: self.tenure_extend_wait_secs.map(Duration::from_secs).unwrap_or(miner_default_config.tenure_extend_wait_secs),
             tenure_timeout: self.tenure_timeout_secs.map(Duration::from_secs).unwrap_or(miner_default_config.tenure_timeout),
         })
     }

stackslib/src/net/api/postblock_proposal.rs

@@ -15,6 +15,8 @@
 // along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
 use std::io::{Read, Write};
+#[cfg(any(test, feature = "testing"))]
+use std::sync::LazyLock;
 use std::thread::{self, JoinHandle, Thread};
 #[cfg(any(test, feature = "testing"))]
 use std::time::Duration;
@@ -35,6 +37,8 @@ use stacks_common::types::net::PeerHost;
 use stacks_common::types::StacksPublicKeyBuffer;
 use stacks_common::util::hash::{hex_bytes, to_hex, Hash160, Sha256Sum, Sha512Trunc256Sum};
 use stacks_common::util::retry::BoundReader;
+#[cfg(any(test, feature = "testing"))]
+use stacks_common::util::tests::TestFlag;
 use stacks_common::util::{get_epoch_time_ms, get_epoch_time_secs};
 
 use crate::burnchains::affirmation::AffirmationMap;
@@ -67,11 +71,11 @@ use crate::net::{
 use crate::util_lib::db::Error as DBError;
 
 #[cfg(any(test, feature = "testing"))]
-pub static TEST_VALIDATE_STALL: std::sync::Mutex<Option<bool>> = std::sync::Mutex::new(None);
+pub static TEST_VALIDATE_STALL: LazyLock<TestFlag<bool>> = LazyLock::new(TestFlag::default);
 #[cfg(any(test, feature = "testing"))]
 /// Artificial delay to add to block validation.
-pub static TEST_VALIDATE_DELAY_DURATION_SECS: std::sync::Mutex<Option<u64>> =
-    std::sync::Mutex::new(None);
+pub static TEST_VALIDATE_DELAY_DURATION_SECS: LazyLock<TestFlag<u64>> =
+    LazyLock::new(TestFlag::default);
 
 // This enum is used to supply a `reason_code` for validation
 //  rejection responses. This is serialized as an enum with string
@@ -353,10 +357,10 @@ impl NakamotoBlockProposal {
     ) -> Result<BlockValidateOk, BlockValidateRejectReason> {
         #[cfg(any(test, feature = "testing"))]
         {
-            if *TEST_VALIDATE_STALL.lock().unwrap() == Some(true) {
+            if TEST_VALIDATE_STALL.get() {
                 // Do an extra check just so we don't log EVERY time.
                 warn!("Block validation is stalled due to testing directive.");
-                while *TEST_VALIDATE_STALL.lock().unwrap() == Some(true) {
+                while TEST_VALIDATE_STALL.get() {
                     std::thread::sleep(std::time::Duration::from_millis(10));
                 }
                 info!(
@@ -368,7 +372,8 @@ impl NakamotoBlockProposal {
 
         #[cfg(any(test, feature = "testing"))]
         {
-            if let Some(delay) = *TEST_VALIDATE_DELAY_DURATION_SECS.lock().unwrap() {
+            let delay = TEST_VALIDATE_DELAY_DURATION_SECS.get();
+            if delay > 0 {
                 warn!("Sleeping for {} seconds to simulate slow processing", delay);
                 thread::sleep(Duration::from_secs(delay));
             }

testnet/stacks-node/src/nakamoto_node.rs

@@ -23,6 +23,7 @@ use stacks::burnchains::{BurnchainSigner, Txid};
 use stacks::chainstate::burn::db::sortdb::SortitionDB;
 use stacks::chainstate::burn::BlockSnapshot;
 use stacks::chainstate::stacks::Error as ChainstateError;
+use stacks::libstackerdb::StackerDBChunkAckData;
 use stacks::monitoring;
 use stacks::monitoring::update_active_miners_count_gauge;
 use stacks::net::atlas::AtlasConfig;
@@ -130,6 +131,9 @@ pub enum Error {
     /// An error occurred while operating as the signing coordinator
     #[error("An error occurred while operating as the signing coordinator: {0}")]
     SigningCoordinatorFailure(String),
+    /// An error occurred on StackerDB post
+    #[error("An error occurred while uploading data to StackerDB: {0}")]
+    StackerDBUploadError(StackerDBChunkAckData),
     // The thread that we tried to send to has closed
     #[error("The thread that we tried to send to has closed")]
     ChannelClosed,