Merge pull request #5997 from obycode/feat/empty_mempool_sleep

feat: add `empty_mempool_sleep_ms`

Author: obycode

CHANGELOG.md

@@ -20,7 +20,8 @@ and this project adheres to the versioning scheme outlined in the [README.md](RE
 - When a miner times out waiting for signatures, it will re-propose the same block instead of building a new block ([#5877](https://github.com/stacks-network/stacks-core/pull/5877))
 - Improve tenure downloader trace verbosity applying proper logging level depending on the tenure state ("debug" if unconfirmed, "info" otherwise) ([#5871](https://github.com/stacks-network/stacks-core/issues/5871))
 - Remove warning log about missing UTXOs when a node is configured as `miner` with `mock_mining` mode enabled ([#5841](https://github.com/stacks-network/stacks-core/issues/5841)) 
-- Deprecated the `wait_on_interim_blocks` option in the miner config file. This option is no longer needed, as the miner will always wait for interim blocks to be processed before mining a new block. To wait extra time in between blocks, use the `min_time_between_blocks_ms` option instead.
+- Deprecated the `wait_on_interim_blocks` option in the miner config file. This option is no longer needed, as the miner will always wait for interim blocks to be processed before mining a new block. To wait extra time in between blocks, use the `min_time_between_blocks_ms` option instead. ([#5979](https://github.com/stacks-network/stacks-core/pull/5979))
+- Added `empty_mempool_sleep_ms` to the miner config file to control the time to wait in between mining attempts when the mempool is empty. If not set, the default sleep time is 2.5s. ([#5997](https://github.com/stacks-network/stacks-core/pull/5997))
 
 ## [3.1.0.0.7]
 

stackslib/src/config/mod.rs

@@ -123,6 +123,9 @@ const DEFAULT_TENURE_TIMEOUT_SECS: u64 = 180;
 /// Default percentage of block budget that must be used before attempting a
 /// time-based tenure extend
 const DEFAULT_TENURE_EXTEND_COST_THRESHOLD: u64 = 50;
+/// Default number of milliseconds that the miner should sleep between mining
+/// attempts when the mempool is empty.
+const DEFAULT_EMPTY_MEMPOOL_SLEEP_MS: u64 = 2_500;
 
 static HELIUM_DEFAULT_CONNECTION_OPTIONS: LazyLock<ConnectionOptions> =
     LazyLock::new(|| ConnectionOptions {
@@ -2172,6 +2175,9 @@ pub struct MinerConfig {
     /// The minimum time to wait between mining blocks in milliseconds. The value must be greater than or equal to 1000 ms because if a block is mined
     /// within the same second as its parent, it will be rejected by the signers.
     pub min_time_between_blocks_ms: u64,
+    /// The amount of time that the miner should sleep in between attempts to
+    /// mine a block when the mempool is empty
+    pub empty_mempool_sleep_time: Duration,
     /// Time in milliseconds to pause after receiving the first threshold rejection, before proposing a new block.
     pub first_rejection_pause_ms: u64,
     /// Time in milliseconds to pause after receiving subsequent threshold rejections, before proposing a new block.
@@ -2224,6 +2230,7 @@ impl Default for MinerConfig {
             max_reorg_depth: 3,
             pre_nakamoto_mock_signing: false, // Should only default true if mining key is set
             min_time_between_blocks_ms: DEFAULT_MIN_TIME_BETWEEN_BLOCKS_MS,
+            empty_mempool_sleep_time: Duration::from_millis(DEFAULT_EMPTY_MEMPOOL_SLEEP_MS),
             first_rejection_pause_ms: DEFAULT_FIRST_REJECTION_PAUSE_MS,
             subsequent_rejection_pause_ms: DEFAULT_SUBSEQUENT_REJECTION_PAUSE_MS,
             block_commit_delay: Duration::from_millis(DEFAULT_BLOCK_COMMIT_DELAY_MS),
@@ -2639,6 +2646,7 @@ pub struct MinerConfigFile {
     pub max_reorg_depth: Option<u64>,
     pub pre_nakamoto_mock_signing: Option<bool>,
     pub min_time_between_blocks_ms: Option<u64>,
+    pub empty_mempool_sleep_ms: Option<u64>,
     pub first_rejection_pause_ms: Option<u64>,
     pub subsequent_rejection_pause_ms: Option<u64>,
     pub block_commit_delay_ms: Option<u64>,
@@ -2795,6 +2803,7 @@ impl MinerConfigFile {
             } else {
                 ms
             }).unwrap_or(miner_default_config.min_time_between_blocks_ms),
+            empty_mempool_sleep_time: self.empty_mempool_sleep_ms.map(Duration::from_millis).unwrap_or(miner_default_config.empty_mempool_sleep_time),
             first_rejection_pause_ms: self.first_rejection_pause_ms.unwrap_or(miner_default_config.first_rejection_pause_ms),
             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),

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

@@ -568,8 +568,38 @@ impl BlockMinerThread {
                     continue;
                 }
                 Err(NakamotoNodeError::MiningFailure(ChainstateError::NoTransactionsToMine)) => {
-                    debug!("Miner did not find any transactions to mine");
+                    debug!(
+                        "Miner did not find any transactions to mine, sleeping for {:?}",
+                        self.config.miner.empty_mempool_sleep_time
+                    );
                     self.reset_nonce_cache = false;
+
+                    // Pause the miner to wait for transactions to arrive
+                    let now = Instant::now();
+                    while now.elapsed() < self.config.miner.empty_mempool_sleep_time {
+                        if self.abort_flag.load(Ordering::SeqCst) {
+                            info!("Miner interrupted while mining in order to shut down");
+                            self.globals
+                                .raise_initiative(format!("MiningFailure: aborted by node"));
+                            return Err(ChainstateError::MinerAborted.into());
+                        }
+
+                        // Check if the burnchain tip has changed
+                        let Ok(sort_db) = SortitionDB::open(
+                            &self.config.get_burn_db_file_path(),
+                            false,
+                            self.burnchain.pox_constants.clone(),
+                        ) else {
+                            error!("Failed to open sortition DB. Will try mining again.");
+                            continue;
+                        };
+                        if self.check_burn_tip_changed(&sort_db).is_err() {
+                            return Err(NakamotoNodeError::BurnchainTipChanged);
+                        }
+
+                        thread::sleep(Duration::from_millis(ABORT_TRY_AGAIN_MS));
+                    }
+
                     break None;
                 }
                 Err(e) => {
@@ -680,6 +710,13 @@ impl BlockMinerThread {
 
                 thread::sleep(Duration::from_millis(ABORT_TRY_AGAIN_MS));
 
+                if self.abort_flag.load(Ordering::SeqCst) {
+                    info!("Miner interrupted while mining in order to shut down");
+                    self.globals
+                        .raise_initiative(format!("MiningFailure: aborted by node"));
+                    return Err(ChainstateError::MinerAborted.into());
+                }
+
                 // Check if the burnchain tip has changed
                 let Ok(sort_db) = SortitionDB::open(
                     &self.config.get_burn_db_file_path(),

testnet/stacks-node/src/tests/nakamoto_integrations.rs

@@ -9819,7 +9819,11 @@ fn skip_mining_long_tx() {
 
             // Sleep for longer than the miner's attempt time, so that the miner will
             // mark this tx as long-running and skip it in the next attempt
-            sleep_ms(naka_conf.miner.nakamoto_attempt_time_ms + 1000);
+            sleep_ms(
+                naka_conf.miner.nakamoto_attempt_time_ms
+                    + naka_conf.miner.empty_mempool_sleep_time.as_millis() as u64
+                    + 1000,
+            );
 
             TEST_TX_STALL.set(false);
 
@@ -12339,3 +12343,114 @@ fn handle_considered_txs_foreign_key_failure() {
 
     run_loop_thread.join().unwrap();
 }
+
+#[test]
+#[ignore]
+fn empty_mempool_sleep_ms() {
+    if env::var("BITCOIND_TEST") != Ok("1".into()) {
+        return;
+    }
+
+    let (mut conf, _miner_account) = naka_neon_integration_conf(None);
+    let password = "12345".to_string();
+    conf.connection_options.auth_token = Some(password.clone());
+    let stacker_sk = setup_stacker(&mut conf);
+    let signer_sk = Secp256k1PrivateKey::random();
+    let signer_addr = tests::to_addr(&signer_sk);
+    let sender_sk = Secp256k1PrivateKey::random();
+    // setup sender + recipient for a stx transfer
+    let sender_addr = tests::to_addr(&sender_sk);
+    let send_amt = 100;
+    let send_fee = 180;
+    conf.add_initial_balance(
+        PrincipalData::from(sender_addr).to_string(),
+        send_amt + send_fee,
+    );
+    conf.add_initial_balance(PrincipalData::from(signer_addr).to_string(), 100000);
+
+    // Set the empty mempool sleep time to something long enough that we can
+    // see the effect in the test.
+    conf.miner.empty_mempool_sleep_time = Duration::from_secs(30);
+
+    let mut btcd_controller = BitcoinCoreController::new(conf.clone());
+    btcd_controller
+        .start_bitcoind()
+        .expect("Failed starting bitcoind");
+    let mut btc_regtest_controller = BitcoinRegtestController::new(conf.clone(), None);
+    btc_regtest_controller.bootstrap_chain(201);
+
+    let mut run_loop = boot_nakamoto::BootRunLoop::new(conf.clone()).unwrap();
+    let run_loop_stopper = run_loop.get_termination_switch();
+    let Counters {
+        blocks_processed,
+        naka_submitted_commits: commits_submitted,
+        naka_proposed_blocks,
+        ..
+    } = run_loop.counters();
+    let counters = run_loop.counters();
+
+    let coord_channel = run_loop.coordinator_channels();
+    let http_origin = format!("http://{}", &conf.node.rpc_bind);
+
+    let run_loop_thread = thread::spawn(move || run_loop.start(None, 0));
+    let mut signers = TestSigners::new(vec![signer_sk]);
+    wait_for_runloop(&blocks_processed);
+    boot_to_epoch_3(
+        &conf,
+        &blocks_processed,
+        &[stacker_sk],
+        &[signer_sk],
+        &mut Some(&mut signers),
+        &mut btc_regtest_controller,
+    );
+
+    info!("------------------------- Reached Epoch 3.0 -------------------------");
+
+    blind_signer(&conf, &signers, &counters);
+
+    wait_for_first_naka_block_commit(60, &commits_submitted);
+
+    next_block_and_wait(&mut btc_regtest_controller, &blocks_processed);
+
+    // Sleep for 5 seconds to ensure that the miner tries to mine and sees an
+    // empty mempool.
+    thread::sleep(Duration::from_secs(5));
+
+    info!("------------------------- Submit a transaction -------------------------");
+    let proposals_before = naka_proposed_blocks.load(Ordering::SeqCst);
+
+    let transfer_tx = make_stacks_transfer(
+        &sender_sk,
+        0,
+        send_fee,
+        conf.burnchain.chain_id,
+        &signer_addr.into(),
+        send_amt,
+    );
+    submit_tx(&http_origin, &transfer_tx);
+
+    // The miner should have slept for 30 seconds after seeing an empty mempool
+    // before trying to mine again. Let's check that there was at least 10s
+    // before the next block proposal.
+    wait_for(10, || {
+        let proposals_after = naka_proposed_blocks.load(Ordering::SeqCst);
+        Ok(proposals_after > proposals_before)
+    })
+    .expect_err("Expected to wait for 30 seconds before mining a block");
+
+    // Wait for the transaction to be mined
+    wait_for(60, || {
+        let account = get_account(&http_origin, &sender_addr);
+        Ok(account.nonce == 1)
+    })
+    .expect("Timed out waiting for transaction to be mined after delay");
+
+    coord_channel
+        .lock()
+        .expect("Mutex poisoned")
+        .stop_chains_coordinator();
+
+    run_loop_stopper.store(false, Ordering::SeqCst);
+
+    run_loop_thread.join().unwrap();
+}

testnet/stacks-node/src/tests/signer/v0.rs

@@ -9360,10 +9360,7 @@ fn injected_signatures_are_ignored_across_boundaries() {
     }
 
     info!("---- Manually mine a single burn block to force the signers to update ----");
-    next_block_and_wait(
-        &mut signer_test.running_nodes.btc_regtest_controller,
-        &signer_test.running_nodes.counters.blocks_processed,
-    );
+    signer_test.mine_nakamoto_block(Duration::from_secs(60), true);
 
     signer_test.wait_for_registered_both_reward_cycles();