feat: test for handling pending block proposal at tenure change

Author: hstove

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

@@ -107,7 +107,7 @@ impl SignerCoordinator {
 
         // Spawn the signer DB listener thread
         let listener_thread = std::thread::Builder::new()
-            .name("stackerdb_listener".to_string())
+            .name(format!("stackerdb_listener_{}", burn_tip.block_height))
             .spawn(move || {
                 if let Err(e) = listener.run() {
                     error!("StackerDBListener: exited with error: {e:?}");

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

@@ -7892,6 +7892,177 @@ fn block_validation_pending_table() {
     signer_test.shutdown();
 }
 
+/// Test scenario:
+///
+/// - Miner A proposes a block in tenure A
+/// - While that block is pending validation,
+///   Miner B proposes a new block in tenure B
+/// - After A's block is validated, Miner B's block is
+///   rejected (because it's a sister block)
+/// - Miner B retries and successfully mines a block
+#[test]
+#[ignore]
+fn new_tenure_while_validating_previous_scenario() {
+    if env::var("BITCOIND_TEST") != Ok("1".into()) {
+        return;
+    }
+
+    tracing_subscriber::registry()
+        .with(fmt::layer())
+        .with(EnvFilter::from_default_env())
+        .init();
+
+    info!("------------------------- Test Setup -------------------------");
+    let num_signers = 5;
+    let timeout = Duration::from_secs(30);
+    let sender_sk = Secp256k1PrivateKey::new();
+    let sender_addr = tests::to_addr(&sender_sk);
+    let send_amt = 100;
+    let send_fee = 180;
+    let recipient = PrincipalData::from(StacksAddress::burn_address(false));
+
+    let mut signer_test: SignerTest<SpawnedSigner> = SignerTest::new_with_config_modifications(
+        num_signers,
+        vec![(sender_addr, send_amt + send_fee)],
+        |_| {},
+        |_| {},
+        None,
+        None,
+    );
+    let db_path = signer_test.signer_configs[0].db_path.clone();
+    let http_origin = format!("http://{}", &signer_test.running_nodes.conf.node.rpc_bind);
+    signer_test.boot_to_epoch_3();
+
+    info!("----- Starting test -----";
+        "db_path" => db_path.clone().to_str(),
+    );
+    signer_test.mine_and_verify_confirmed_naka_block(timeout, num_signers, true);
+    TEST_VALIDATE_DELAY_DURATION_SECS.set(30);
+
+    let proposals_before = signer_test.get_miner_proposal_messages().len();
+
+    let peer_info_before_stall = signer_test.get_peer_info();
+    let burn_height_before_stall = peer_info_before_stall.burn_block_height;
+    let stacks_height_before_stall = peer_info_before_stall.stacks_tip_height;
+
+    // STEP 1: Miner A proposes a block in tenure A
+
+    // submit a tx so that the miner will attempt to mine an extra block
+    let sender_nonce = 0;
+    let transfer_tx = make_stacks_transfer(
+        &sender_sk,
+        sender_nonce,
+        send_fee,
+        signer_test.running_nodes.conf.burnchain.chain_id,
+        &recipient,
+        send_amt,
+    );
+    submit_tx(&http_origin, &transfer_tx);
+
+    info!("----- Waiting for miner to propose a block -----");
+
+    // Wait for the miner to propose a block
+    wait_for(30, || {
+        Ok(signer_test.get_miner_proposal_messages().len() > proposals_before)
+    })
+    .expect("Timed out waiting for miner to propose a block");
+
+    let proposals_before = signer_test.get_miner_proposal_messages().len();
+    let info_before = signer_test.get_peer_info();
+
+    // STEP 2: Miner B proposes a block in tenure B, while A's block is pending validation
+
+    info!("----- Mining a new BTC block -----");
+    signer_test
+        .running_nodes
+        .btc_regtest_controller
+        .build_next_block(1);
+
+    let mut last_log = Instant::now();
+    last_log -= Duration::from_secs(5);
+    let mut new_block_hash = None;
+    wait_for(120, || {
+        let proposals = signer_test.get_miner_proposal_messages();
+        let new_proposal = proposals.iter().find(|p| {
+            p.burn_height > burn_height_before_stall
+                && p.block.header.chain_length == info_before.stacks_tip_height + 1
+        });
+
+        let has_new_proposal = new_proposal.is_some() && proposals.len() > proposals_before;
+        if last_log.elapsed() > Duration::from_secs(5) && !has_new_proposal {
+            info!(
+                "----- Waiting for a new proposal -----";
+                "proposals_len" => proposals.len(),
+                "burn_height_before" => info_before.burn_block_height,
+            );
+            last_log = Instant::now();
+        }
+        if let Some(proposal) = new_proposal {
+            new_block_hash = Some(proposal.block.header.signer_signature_hash());
+        }
+        Ok(has_new_proposal)
+    })
+    .expect("Timed out waiting for pending block proposal");
+
+    info!("----- Waiting for pending block validation to be submitted -----");
+    let new_block_hash = new_block_hash.unwrap();
+
+    // Set the delay to 0 so that the block validation finishes quickly
+    TEST_VALIDATE_DELAY_DURATION_SECS.set(0);
+
+    wait_for(30, || {
+        let proposal_responses = test_observer::get_proposal_responses();
+        let found_proposal = proposal_responses
+            .iter()
+            .any(|p| p.signer_signature_hash() == new_block_hash);
+        Ok(found_proposal)
+    })
+    .expect("Timed out waiting for pending block validation to be submitted");
+
+    // STEP 3: Miner B is rejected, retries, and mines a block
+
+    // Now, wait for miner B to propose a new block
+    let mut last_log = Instant::now();
+    last_log -= Duration::from_secs(5);
+    wait_for(30, || {
+        let proposals = signer_test.get_miner_proposal_messages();
+        let new_proposal = proposals.iter().find(|p| {
+            p.burn_height > burn_height_before_stall
+                && p.block.header.chain_length == stacks_height_before_stall + 2
+        });
+        if last_log.elapsed() > Duration::from_secs(5) && !new_proposal.is_some() {
+            let last_proposal = proposals.last().unwrap();
+            info!(
+                "----- Waiting for a new proposal -----";
+                "proposals_len" => proposals.len(),
+                "burn_height_before" => burn_height_before_stall,
+                "stacks_height_before" => stacks_height_before_stall,
+                "last_proposal_burn_height" => last_proposal.burn_height,
+                "last_proposal_stacks_height" => last_proposal.block.header.chain_length,
+            );
+            last_log = Instant::now();
+        }
+        Ok(new_proposal.is_some())
+    })
+    .expect("Timed out waiting for miner to try a new block proposal");
+
+    // Wait for the new block to be mined
+    wait_for(30, || {
+        let peer_info = signer_test.get_peer_info();
+        Ok(
+            peer_info.stacks_tip_height == stacks_height_before_stall + 2
+                && peer_info.burn_block_height == burn_height_before_stall + 1,
+        )
+    })
+    .expect("Timed out waiting for new block to be mined");
+
+    // Ensure that we didn't tenure extend
+    verify_last_block_contains_tenure_change_tx(TenureChangeCause::BlockFound);
+
+    info!("------------------------- Shutdown -------------------------");
+    signer_test.shutdown();
+}
+
 #[test]
 #[ignore]
 /// Test that a miner will extend its tenure after the succeding miner fails to mine a block.