fix: improve block commit wait logic

* fix block commit wait logic (so that it actually waits the configured time)
* cleanup/refactor some of the block commit logic
* add test assertion for block commit waits (assert that only 1 commit is submitted when the wait time is high)
* add test assertions for immediate commits on empty sortition
* light test cleanup/refactors

Author: kantai

CHANGELOG.md

@@ -15,6 +15,8 @@ and this project adheres to the versioning scheme outlined in the [README.md](RE
 ### Changed
 
 - Miner will stop waiting for signatures on a block if the Stacks tip advances (causing the block it had proposed to be invalid).
+- By default, miners will wait for a new tenure to start for a configurable amount of time after receiving a burn block before 
+  submitting a block commit. This will reduce the amount of RBF transactions miners are expected to need.
 - Logging improvements:
   - P2P logs now includes a reason for dropping a peer or neighbor
   - Improvements to how a PeerAddress is logged (human readable format vs hex)

stackslib/src/chainstate/burn/db/sortdb.rs

@@ -95,6 +95,12 @@ pub const REWARD_WINDOW_END: u64 = 144 * 90 + REWARD_WINDOW_START;
 
 pub type BlockHeaderCache = HashMap<ConsensusHash, (Option<BlockHeaderHash>, ConsensusHash)>;
 
+pub enum FindIter<R> {
+    Found(R),
+    Continue,
+    Halt,
+}
+
 impl FromRow<SortitionId> for SortitionId {
     fn from_row(row: &Row) -> Result<SortitionId, db_error> {
         SortitionId::from_column(row, "sortition_id")
@@ -4989,6 +4995,60 @@ impl SortitionDB {
         Ok(handle.get_reward_set_size_at(&sort_id_of_start)? > 0)
     }
 
+    /// Find a sortition by traversing the sortition history backwards, starting
+    ///  from the current canonical burn tip.
+    ///
+    /// The supplied function `f` is applied to each traversed snapshot
+    ///  and the return value of `f` controls the iteration.
+    ///
+    /// FindIter::Found(x) => tells the search to stop, and return `Ok(Some(x))`
+    /// FindIter::Halt => tells the search to stop, and return `Ok(None)`
+    /// FindIter::Continue will continue the iteration
+    ///
+    /// This function exits early and returns the error if either `f` or a SortitionDB
+    ///  error occurs while processing.
+    /// It returns `Ok(None)` if the traversal reaches the sortition root without finding `x`
+    pub fn find_in_canonical<F, R, E>(&self, f: F) -> Result<Option<R>, E>
+    where
+        F: FnMut(&BlockSnapshot) -> Result<FindIter<R>, E>,
+        E: From<db_error>,
+    {
+        let cursor = Self::get_canonical_burn_chain_tip(self.conn())?;
+        self.find_from(cursor, f)
+    }
+
+    /// Find a sortition by traversing the sortition history backwards, starting
+    ///  from `sn`. The supplied function `f` is applied to each traversed snapshot
+    ///  and the return value of `f` controls the iteration.
+    ///
+    /// FindIter::Found(x) => tells the search to stop, and return `Ok(Some(x))`
+    /// FindIter::Halt => tells the search to stop, and return `Ok(None)`
+    /// FindIter::Continue will continue the iteration
+    ///
+    /// This function exits early and returns the error if either `f` or a SortitionDB
+    ///  error occurs while processing.
+    /// It returns `Ok(None)` if the traversal reaches the sortition root without finding `x`
+    pub fn find_from<F, R, E>(&self, sn: BlockSnapshot, mut f: F) -> Result<Option<R>, E>
+    where
+        F: FnMut(&BlockSnapshot) -> Result<FindIter<R>, E>,
+        E: From<db_error>,
+    {
+        let mut cursor_opt = Some(sn);
+        loop {
+            let Some(ref cursor) = cursor_opt else {
+                return Ok(None);
+            };
+            let next_id = &cursor.parent_sortition_id;
+            match f(cursor)? {
+                FindIter::Found(x) => return Ok(Some(x)),
+                FindIter::Halt => return Ok(None),
+                FindIter::Continue => {
+                    cursor_opt = Self::get_block_snapshot(self.conn(), next_id)?;
+                }
+            }
+        }
+    }
+
     /// Find out how any burn tokens were destroyed in a given block on a given fork.
     pub fn get_block_burn_amount(
         conn: &Connection,

testnet/stacks-node/src/burnchains/bitcoin_regtest_controller.rs

@@ -2000,6 +2000,30 @@ impl BitcoinRegtestController {
         }
     }
 
+    #[cfg(test)]
+    /// Instruct a regtest Bitcoin node to build an empty block.
+    pub fn build_empty_block(&self) {
+        info!("Generate empty block");
+        let public_key_bytes = match &self.config.burnchain.local_mining_public_key {
+            Some(public_key) => hex_bytes(public_key).expect("Invalid byte sequence"),
+            None => panic!("Unable to make new block, mining public key"),
+        };
+
+        // NOTE: miner address is whatever the configured segwit setting is
+        let public_key = Secp256k1PublicKey::from_slice(&public_key_bytes)
+            .expect("FATAL: invalid public key bytes");
+        let address = self.get_miner_address(StacksEpochId::Epoch21, &public_key);
+        let result = BitcoinRPCRequest::generate_empty_to_address(&self.config, addr2str(&address));
+
+        match result {
+            Ok(_) => {}
+            Err(e) => {
+                error!("Bitcoin RPC failure: error generating block {e:?}");
+                panic!();
+            }
+        }
+    }
+
     #[cfg(test)]
     pub fn invalidate_block(&self, block: &BurnchainHeaderHash) {
         info!("Invalidating block {block}");
@@ -2538,6 +2562,21 @@ impl BitcoinRPCRequest {
         Ok(())
     }
 
+    #[cfg(test)]
+    pub fn generate_empty_to_address(config: &Config, address: String) -> RPCResult<()> {
+        debug!("Generate empty block to {address}");
+        let payload = BitcoinRPCRequest {
+            method: "generateblock".to_string(),
+            params: vec![address.clone().into(), serde_json::Value::Array(vec![])],
+            id: "stacks".to_string(),
+            jsonrpc: "2.0".to_string(),
+        };
+
+        let res = BitcoinRPCRequest::send(config, payload)?;
+        debug!("Generated empty block to {address}: {res:?}");
+        Ok(())
+    }
+
     pub fn list_unspent(
         config: &Config,
         addresses: Vec<String>,