ensure same behaviour from miner and follower

Author: rdeioris

stacks-node/src/tests/nakamoto_integrations.rs

@@ -48,7 +48,10 @@ use stacks::chainstate::nakamoto::coordinator::{load_nakamoto_reward_set, TEST_C
 use stacks::chainstate::nakamoto::miner::NakamotoBlockBuilder;
 use stacks::chainstate::nakamoto::shadow::shadow_chainstate_repair;
 use stacks::chainstate::nakamoto::test_signers::TestSigners;
-use stacks::chainstate::nakamoto::{NakamotoBlock, NakamotoBlockHeader, NakamotoChainState};
+use stacks::chainstate::nakamoto::{
+    set_test_sip_031_emission_schedule, NakamotoBlock, NakamotoBlockHeader, NakamotoChainState,
+    SIP031EmissionInterval,
+};
 use stacks::chainstate::stacks::address::{PoxAddress, StacksAddressExtensions};
 use stacks::chainstate::stacks::boot::{
     MINERS_NAME, SIGNERS_VOTING_FUNCTION_NAME, SIGNERS_VOTING_NAME,
@@ -3075,6 +3078,7 @@ fn block_proposal_api_endpoint() {
         let mut miner_tenure_info = builder
             .load_tenure_info(&mut chainstate, &burn_dbconn, tenure_cause)
             .unwrap();
+        let burn_chain_height = miner_tenure_info.burn_tip_height;
         let mut tenure_tx = builder
             .tenure_begin(&burn_dbconn, &mut miner_tenure_info)
             .unwrap();
@@ -3103,7 +3107,7 @@ fn block_proposal_api_endpoint() {
             matches!(res, TransactionResult::Success(..)),
             "Transaction failed"
         );
-        builder.mine_nakamoto_block(&mut tenure_tx)
+        builder.mine_nakamoto_block(&mut tenure_tx, burn_chain_height)
     };
 
     // Construct a valid proposal. Make alterations to this to test failure cases
@@ -12918,3 +12922,192 @@ fn test_sip_031_activation() {
 
     run_loop_thread.join().unwrap();
 }
+
+/// Test SIP-031 last phase per-tenure-mint-and-transfer
+///
+/// - check epoch 3.2 is active
+/// - check minting event and boot contract transfer for the first (and only the first) block of a tenure
+#[test]
+#[ignore]
+fn test_sip_031_last_phase() {
+    if env::var("BITCOIND_TEST") != Ok("1".into()) {
+        return;
+    }
+
+    let (mut naka_conf, _miner_account) = naka_neon_integration_conf(None);
+    naka_conf.node.pox_sync_sample_secs = 180;
+    naka_conf.burnchain.max_rbf = 10_000_000;
+
+    let sender_sk = Secp256k1PrivateKey::random();
+    let sender_signer_sk = Secp256k1PrivateKey::random();
+    let sender_signer_addr = tests::to_addr(&sender_signer_sk);
+    let mut signers = TestSigners::new(vec![sender_signer_sk]);
+    let tenure_count = 5;
+    let inter_blocks_per_tenure = 9;
+    // setup sender + recipient for some test stx transfers
+    // these are necessary for the interim blocks to get mined at all
+    let sender_addr = tests::to_addr(&sender_sk);
+    let send_amt = 100;
+    let send_fee = 180;
+    naka_conf.add_initial_balance(
+        PrincipalData::from(sender_addr).to_string(),
+        (send_amt + send_fee) * tenure_count * inter_blocks_per_tenure,
+    );
+    naka_conf.add_initial_balance(PrincipalData::from(sender_signer_addr).to_string(), 100000);
+    let stacker_sk = setup_stacker(&mut naka_conf);
+
+    let epoch32_start_height =
+        naka_conf.burnchain.epochs.clone().unwrap()[StacksEpochId::Epoch32].start_height;
+
+    set_test_sip_031_emission_schedule(Some(vec![
+        SIP031EmissionInterval {
+            amount: 0,
+            start_height: epoch32_start_height + 40,
+        },
+        SIP031EmissionInterval {
+            amount: 300_000,
+            start_height: epoch32_start_height + 30,
+        },
+        SIP031EmissionInterval {
+            amount: 200_000,
+            start_height: epoch32_start_height + 20,
+        },
+        SIP031EmissionInterval {
+            amount: 100_000,
+            start_height: epoch32_start_height + 10,
+        },
+    ]));
+
+    test_observer::spawn();
+    test_observer::register_any(&mut naka_conf);
+
+    let mut btcd_controller = BitcoinCoreController::new(naka_conf.clone());
+    btcd_controller
+        .start_bitcoind()
+        .expect("Failed starting bitcoind");
+    let mut btc_regtest_controller = BitcoinRegtestController::new(naka_conf.clone(), None);
+    btc_regtest_controller.bootstrap_chain(201);
+
+    let mut run_loop = boot_nakamoto::BootRunLoop::new(naka_conf.clone()).unwrap();
+    let run_loop_stopper = run_loop.get_termination_switch();
+    let Counters {
+        blocks_processed,
+        naka_submitted_commits: commits_submitted,
+        ..
+    } = run_loop.counters();
+    let counters = run_loop.counters();
+
+    let coord_channel = run_loop.coordinator_channels();
+
+    let run_loop_thread = thread::Builder::new()
+        .name("run_loop".into())
+        .spawn(move || run_loop.start(None, 0))
+        .unwrap();
+    wait_for_runloop(&blocks_processed);
+    boot_to_epoch_3(
+        &naka_conf,
+        &blocks_processed,
+        &[stacker_sk],
+        &[sender_signer_sk],
+        &mut Some(&mut signers),
+        &mut btc_regtest_controller,
+    );
+
+    info!("Bootstrapped to Epoch-3.0 boundary, starting nakamoto miner");
+
+    let burnchain = naka_conf.get_burnchain();
+    let sortdb = burnchain.open_sortition_db(true).unwrap();
+    let (mut chainstate, _) = StacksChainState::open(
+        naka_conf.is_mainnet(),
+        naka_conf.burnchain.chain_id,
+        &naka_conf.get_chainstate_path_str(),
+        None,
+    )
+    .unwrap();
+
+    info!("Nakamoto miner started...");
+    blind_signer(&naka_conf, &signers, &counters);
+
+    wait_for_first_naka_block_commit(60, &commits_submitted);
+
+    // mine until epoch 3.2 height
+    loop {
+        let commits_before = commits_submitted.load(Ordering::SeqCst);
+        next_block_and_process_new_stacks_block(&mut btc_regtest_controller, 60, &coord_channel)
+            .unwrap();
+        wait_for(20, || {
+            Ok(commits_submitted.load(Ordering::SeqCst) > commits_before)
+        })
+        .unwrap();
+
+        let node_info = get_chain_info_opt(&naka_conf).unwrap();
+        if node_info.burn_block_height >= epoch32_start_height {
+            break;
+        }
+    }
+
+    info!(
+        "Nakamoto miner has advanced to bitcoin height {}",
+        get_chain_info_opt(&naka_conf).unwrap().burn_block_height
+    );
+
+    let latest_stacks_block_id = get_latest_block_proposal(&naka_conf, &sortdb)
+        .unwrap()
+        .0
+        .block_id();
+
+    // check if sip-031 boot contract has a balance of 200_000_000 STX
+    let sip_031_boot_contract_balance = chainstate.with_read_only_clarity_tx(
+        &sortdb
+            .index_handle_at_block(&chainstate, &latest_stacks_block_id)
+            .unwrap(),
+        &latest_stacks_block_id,
+        |conn| {
+            conn.with_clarity_db_readonly(|db| {
+                db.get_account_stx_balance(&PrincipalData::Contract(boot_code_id(
+                    SIP_031_NAME,
+                    naka_conf.is_mainnet(),
+                )))
+            })
+        },
+    );
+
+    assert_eq!(
+        sip_031_boot_contract_balance,
+        Some(Ok(STXBalance::Unlocked {
+            amount: SIP_031_INITIAL_MINT
+        }))
+    );
+
+    // get current liquidity
+    let sip_031_current_liquid_ustx = chainstate
+        .with_read_only_clarity_tx(
+            &sortdb
+                .index_handle_at_block(&chainstate, &latest_stacks_block_id)
+                .unwrap(),
+            &latest_stacks_block_id,
+            |conn| conn.with_clarity_db_readonly(|db| db.get_total_liquid_ustx().unwrap()),
+        )
+        .unwrap();
+
+    // 50 more tenures...
+    for _ in 0..50 {
+        let commits_before = commits_submitted.load(Ordering::SeqCst);
+        next_block_and_process_new_stacks_block(&mut btc_regtest_controller, 60, &coord_channel)
+            .unwrap();
+        wait_for(20, || {
+            Ok(commits_submitted.load(Ordering::SeqCst) > commits_before)
+        })
+        .unwrap();
+
+        let node_info = get_chain_info_opt(&naka_conf).unwrap();
+    }
+
+    coord_channel
+        .lock()
+        .expect("Mutex poisoned")
+        .stop_chains_coordinator();
+    run_loop_stopper.store(false, Ordering::SeqCst);
+
+    run_loop_thread.join().unwrap();
+}

stackslib/src/chainstate/nakamoto/miner.rs

@@ -478,9 +478,20 @@ impl NakamotoBlockBuilder {
     }
 
     /// Finish building the Nakamoto block
-    pub fn mine_nakamoto_block(&mut self, clarity_tx: &mut ClarityTx) -> NakamotoBlock {
+    pub fn mine_nakamoto_block(
+        &mut self,
+        clarity_tx: &mut ClarityTx,
+        burn_block_height: u32,
+    ) -> NakamotoBlock {
         NakamotoChainState::finish_block(clarity_tx, self.matured_miner_rewards_opt.as_ref())
             .expect("FATAL: call to `finish_block` failed");
+        // if coinbase_tx is defined, we are at the start of a new tenure
+        if self.coinbase_tx.is_some() {
+            NakamotoChainState::sip_031_mint_and_transfer_on_new_tenure(
+                clarity_tx,
+                burn_block_height,
+            );
+        }
         self.finalize_block(clarity_tx)
     }
 
@@ -530,6 +541,7 @@ impl NakamotoBlockBuilder {
 
         let mut miner_tenure_info =
             builder.load_tenure_info(&mut chainstate, burn_dbconn, tenure_info.cause())?;
+        let burn_chain_height = miner_tenure_info.burn_tip_height;
         let mut tenure_tx = builder.tenure_begin(burn_dbconn, &mut miner_tenure_info)?;
 
         let tenure_budget = tenure_tx
@@ -607,7 +619,7 @@ impl NakamotoBlockBuilder {
         }
 
         // save the block so we can build microblocks off of it
-        let block = builder.mine_nakamoto_block(&mut tenure_tx);
+        let block = builder.mine_nakamoto_block(&mut tenure_tx, burn_chain_height);
         let tenure_size = builder.bytes_so_far;
         let tenure_consumed = builder.tenure_finish(tenure_tx)?;