Merge pull request #4989 from stacks-network/test/btc-reorgs

test: add bitcoin reorg test to bitcoind/stacks-node/signers integrations

Author: kantai

.github/workflows/bitcoin-tests.yml

@@ -89,6 +89,7 @@ jobs:
           - tests::signer::v0::end_of_tenure
           - tests::signer::v0::forked_tenure_okay
           - tests::signer::v0::forked_tenure_invalid
+          - tests::signer::v0::bitcoind_forking_test
           - tests::nakamoto_integrations::stack_stx_burn_op_integration_test
           - tests::nakamoto_integrations::check_block_heights
           - tests::nakamoto_integrations::clarity_burn_state

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

@@ -112,6 +112,7 @@ pub struct LastCommit {
     /// the tenure consensus hash for the tip's tenure
     tenure_consensus_hash: ConsensusHash,
     /// the start-block hash of the tip's tenure
+    #[allow(dead_code)]
     start_block_hash: BlockHeaderHash,
     /// What is the epoch in which this was sent?
     epoch_id: StacksEpochId,
@@ -838,14 +839,20 @@ impl RelayerThread {
                 })?
         };
 
-        if last_winner_snapshot.miner_pk_hash != Some(mining_pkh) {
-            debug!("Relayer: the miner did not win the last sortition. No tenure to continue.";
-                   "current_mining_pkh" => %mining_pkh,
-                   "last_winner_snapshot.miner_pk_hash" => ?last_winner_snapshot.miner_pk_hash,
-            );
+        let won_last_sortition = last_winner_snapshot.miner_pk_hash == Some(mining_pkh);
+        debug!(
+            "Relayer: Current burn block had no sortition. Checking for tenure continuation.";
+            "won_last_sortition" => won_last_sortition,
+            "current_mining_pkh" => %mining_pkh,
+            "last_winner_snapshot.miner_pk_hash" => ?last_winner_snapshot.miner_pk_hash,
+            "canonical_stacks_tip_id" => %canonical_stacks_tip,
+            "canonical_stacks_tip_ch" => %canonical_stacks_tip_ch,
+            "block_election_ch" => %block_election_snapshot.consensus_hash,
+            "burn_view_ch" => %new_burn_view,
+        );
+
+        if !won_last_sortition {
             return Ok(());
-        } else {
-            debug!("Relayer: the miner won the last sortition. Continuing tenure.");
         }
 
         match self.start_new_tenure(

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

@@ -46,10 +46,10 @@ use crate::nakamoto_node::miner::TEST_BROADCAST_STALL;
 use crate::nakamoto_node::relayer::TEST_SKIP_COMMIT_OP;
 use crate::tests::nakamoto_integrations::{boot_to_epoch_3_reward_set, next_block_and};
 use crate::tests::neon_integrations::{
-    get_chain_info, next_block_and_wait, submit_tx, test_observer,
+    get_account, get_chain_info, next_block_and_wait, submit_tx, test_observer,
 };
 use crate::tests::{self, make_stacks_transfer};
-use crate::{nakamoto_node, BurnchainController};
+use crate::{nakamoto_node, BurnchainController, Keychain};
 
 impl SignerTest<SpawnedSigner> {
     /// Run the test until the epoch 3 boundary
@@ -787,6 +787,155 @@ fn forked_tenure_testing(
     }
 }
 
+#[test]
+#[ignore]
+fn bitcoind_forking_test() {
+    if env::var("BITCOIND_TEST") != Ok("1".into()) {
+        return;
+    }
+
+    let num_signers = 5;
+    let sender_sk = Secp256k1PrivateKey::new();
+    let sender_addr = tests::to_addr(&sender_sk);
+    let send_amt = 100;
+    let send_fee = 180;
+    let mut signer_test: SignerTest<SpawnedSigner> = SignerTest::new_with_config_modifications(
+        num_signers,
+        vec![(sender_addr.clone(), send_amt + send_fee)],
+        Some(Duration::from_secs(15)),
+        |_config| {},
+    );
+    let conf = signer_test.running_nodes.conf.clone();
+    let http_origin = format!("http://{}", &conf.node.rpc_bind);
+    let miner_address = Keychain::default(conf.node.seed.clone())
+        .origin_address(conf.is_mainnet())
+        .unwrap();
+
+    signer_test.boot_to_epoch_3();
+    info!("------------------------- Reached Epoch 3.0 -------------------------");
+    let pre_epoch_3_nonce = get_account(&http_origin, &miner_address).nonce;
+    let pre_fork_tenures = 10;
+
+    for _i in 0..pre_fork_tenures {
+        let _mined_block = signer_test.mine_nakamoto_block(Duration::from_secs(30));
+    }
+
+    let pre_fork_1_nonce = get_account(&http_origin, &miner_address).nonce;
+
+    assert_eq!(pre_fork_1_nonce, pre_epoch_3_nonce + 2 * pre_fork_tenures);
+
+    info!("------------------------- Triggering Bitcoin Fork -------------------------");
+
+    let burn_block_height = get_chain_info(&signer_test.running_nodes.conf).burn_block_height;
+    let burn_header_hash_to_fork = signer_test
+        .running_nodes
+        .btc_regtest_controller
+        .get_block_hash(burn_block_height);
+    signer_test
+        .running_nodes
+        .btc_regtest_controller
+        .invalidate_block(&burn_header_hash_to_fork);
+    signer_test
+        .running_nodes
+        .btc_regtest_controller
+        .build_next_block(1);
+
+    info!("Wait for block off of shallow fork");
+    thread::sleep(Duration::from_secs(15));
+
+    // we need to mine some blocks to get back to being considered a frequent miner
+    for _i in 0..3 {
+        let commits_count = signer_test
+            .running_nodes
+            .commits_submitted
+            .load(Ordering::SeqCst);
+        next_block_and(
+            &mut signer_test.running_nodes.btc_regtest_controller,
+            60,
+            || {
+                Ok(signer_test
+                    .running_nodes
+                    .commits_submitted
+                    .load(Ordering::SeqCst)
+                    > commits_count)
+            },
+        )
+        .unwrap();
+    }
+
+    let post_fork_1_nonce = get_account(&http_origin, &miner_address).nonce;
+
+    assert_eq!(post_fork_1_nonce, pre_fork_1_nonce - 1 * 2);
+
+    for _i in 0..5 {
+        signer_test.mine_nakamoto_block(Duration::from_secs(30));
+    }
+
+    let pre_fork_2_nonce = get_account(&http_origin, &miner_address).nonce;
+    assert_eq!(pre_fork_2_nonce, post_fork_1_nonce + 2 * 5);
+
+    info!(
+        "New chain info: {:?}",
+        get_chain_info(&signer_test.running_nodes.conf)
+    );
+
+    info!("------------------------- Triggering Deeper Bitcoin Fork -------------------------");
+
+    let burn_block_height = get_chain_info(&signer_test.running_nodes.conf).burn_block_height;
+    let burn_header_hash_to_fork = signer_test
+        .running_nodes
+        .btc_regtest_controller
+        .get_block_hash(burn_block_height - 3);
+    signer_test
+        .running_nodes
+        .btc_regtest_controller
+        .invalidate_block(&burn_header_hash_to_fork);
+    signer_test
+        .running_nodes
+        .btc_regtest_controller
+        .build_next_block(4);
+
+    info!("Wait for block off of shallow fork");
+    thread::sleep(Duration::from_secs(15));
+
+    // we need to mine some blocks to get back to being considered a frequent miner
+    for _i in 0..3 {
+        let commits_count = signer_test
+            .running_nodes
+            .commits_submitted
+            .load(Ordering::SeqCst);
+        next_block_and(
+            &mut signer_test.running_nodes.btc_regtest_controller,
+            60,
+            || {
+                Ok(signer_test
+                    .running_nodes
+                    .commits_submitted
+                    .load(Ordering::SeqCst)
+                    > commits_count)
+            },
+        )
+        .unwrap();
+    }
+
+    let post_fork_2_nonce = get_account(&http_origin, &miner_address).nonce;
+
+    assert_eq!(post_fork_2_nonce, pre_fork_2_nonce - 4 * 2);
+
+    for _i in 0..5 {
+        signer_test.mine_nakamoto_block(Duration::from_secs(30));
+    }
+
+    let test_end_nonce = get_account(&http_origin, &miner_address).nonce;
+    assert_eq!(test_end_nonce, post_fork_2_nonce + 2 * 5);
+
+    info!(
+        "New chain info: {:?}",
+        get_chain_info(&signer_test.running_nodes.conf)
+    );
+    signer_test.shutdown();
+}
+
 #[test]
 #[ignore]
 /// This test checks the behavior at the end of a tenure. Specifically: