chore: bugfixes and SIP-029 integration test

Author: jcnelson

.github/workflows/bitcoin-tests.yml

@@ -140,6 +140,7 @@ jobs:
           - tests::nakamoto_integrations::utxo_check_on_startup_recover
           - tests::nakamoto_integrations::v3_signer_api_endpoint
           - tests::nakamoto_integrations::signer_chainstate
+          - tests::nakamoto_integrations::sip029_coinbase_change
           # TODO: enable these once v1 signer is supported by a new nakamoto epoch
           # - tests::signer::v1::dkg
           # - tests::signer::v1::sign_request_rejected

stacks-common/src/types/mod.rs

@@ -459,6 +459,7 @@ impl StacksEpochId {
         match COINBASE_INTERVALS_TEST.lock() {
             Ok(schedule_opt) => {
                 if let Some(schedule) = (*schedule_opt).as_ref() {
+                    info!("Use overridden coinbase schedule {:?}", &schedule);
                     return schedule.clone();
                 }
             }
@@ -520,11 +521,18 @@ impl StacksEpochId {
             | StacksEpochId::Epoch30 => {
                 self.coinbase_reward_pre_sip029(first_burnchain_height, current_burnchain_height)
             }
-            StacksEpochId::Epoch31 => self.coinbase_reward_sip029(
-                mainnet,
-                first_burnchain_height,
-                current_burnchain_height,
-            ),
+            StacksEpochId::Epoch31 => {
+                let cb = self.coinbase_reward_sip029(
+                    mainnet,
+                    first_burnchain_height,
+                    current_burnchain_height,
+                );
+                info!(
+                    "Epoch31 coinbase at ({},{}) is {}",
+                    first_burnchain_height, current_burnchain_height, cb
+                );
+                cb
+            }
         }
     }
 }

stackslib/src/chainstate/stacks/db/blocks.rs

@@ -3618,7 +3618,7 @@ impl StacksChainState {
         burn_block_height: u64,
         first_burn_block_height: u64,
     ) -> u128 {
-        epoch.coinbase_reward(mainnet, burn_block_height, first_burn_block_height)
+        epoch.coinbase_reward(mainnet, first_burn_block_height, burn_block_height)
     }
 
     /// Create the block reward.

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

@@ -38,7 +38,7 @@ use stacks::chainstate::stacks::miner::{
     get_mining_spend_amount, signal_mining_blocked, signal_mining_ready,
 };
 use stacks::core::mempool::MemPoolDB;
-use stacks::core::STACKS_EPOCH_3_0_MARKER;
+use stacks::core::STACKS_EPOCH_3_1_MARKER;
 use stacks::monitoring::increment_stx_blocks_mined_counter;
 use stacks::net::db::LocalPeer;
 use stacks::net::p2p::NetworkHandle;
@@ -689,7 +689,7 @@ impl RelayerThread {
             key_block_ptr: u32::try_from(key.block_height)
                 .expect("FATAL: burn block height exceeded u32"),
             key_vtxindex: u16::try_from(key.op_vtxindex).expect("FATAL: vtxindex exceeded u16"),
-            memo: vec![STACKS_EPOCH_3_0_MARKER],
+            memo: vec![STACKS_EPOCH_3_1_MARKER],
             new_seed: VRFSeed::from_proof(&tip_vrf_proof),
             parent_block_ptr: u32::try_from(commit_parent_block_burn_height)
                 .expect("FATAL: burn block height exceeded u32"),

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

@@ -23,7 +23,7 @@ use stacks_common::types::chainstate::StacksPrivateKey;
 
 use crate::config::InitialBalance;
 use crate::tests::bitcoin_regtest::BitcoinCoreController;
-use crate::tests::nakamoto_integrations::{next_block_and, wait_for};
+use crate::tests::nakamoto_integrations::wait_for;
 use crate::tests::neon_integrations::{
     get_account, get_chain_info, neon_integration_test_conf, next_block_and_wait, submit_tx,
     test_observer, wait_for_runloop,

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

@@ -29,6 +29,7 @@ use http_types::headers::AUTHORIZATION;
 use lazy_static::lazy_static;
 use libsigner::v0::messages::SignerMessage as SignerMessageV0;
 use libsigner::{SignerSession, StackerDBSession};
+use rusqlite::OptionalExtension;
 use stacks::burnchains::{MagicBytes, Txid};
 use stacks::chainstate::burn::db::sortdb::SortitionDB;
 use stacks::chainstate::burn::operations::{
@@ -60,7 +61,7 @@ use stacks::core::{
     StacksEpoch, StacksEpochId, BLOCK_LIMIT_MAINNET_10, HELIUM_BLOCK_LIMIT_20,
     PEER_VERSION_EPOCH_1_0, PEER_VERSION_EPOCH_2_0, PEER_VERSION_EPOCH_2_05,
     PEER_VERSION_EPOCH_2_1, PEER_VERSION_EPOCH_2_2, PEER_VERSION_EPOCH_2_3, PEER_VERSION_EPOCH_2_4,
-    PEER_VERSION_EPOCH_2_5, PEER_VERSION_EPOCH_3_0, PEER_VERSION_TESTNET,
+    PEER_VERSION_EPOCH_2_5, PEER_VERSION_EPOCH_3_0, PEER_VERSION_EPOCH_3_1, PEER_VERSION_TESTNET,
 };
 use stacks::libstackerdb::SlotMetadata;
 use stacks::net::api::callreadonly::CallReadOnlyRequestBody;
@@ -70,7 +71,7 @@ use stacks::net::api::getstackers::GetStackersResponse;
 use stacks::net::api::postblock_proposal::{
     BlockValidateReject, BlockValidateResponse, NakamotoBlockProposal, ValidateRejectCode,
 };
-use stacks::types::chainstate::StacksBlockId;
+use stacks::types::chainstate::{ConsensusHash, StacksBlockId};
 use stacks::util::hash::hex_bytes;
 use stacks::util_lib::boot::boot_code_id;
 use stacks::util_lib::signed_structured_data::pox4::{
@@ -84,7 +85,7 @@ use stacks_common::types::chainstate::{
     BlockHeaderHash, BurnchainHeaderHash, StacksAddress, StacksPrivateKey, StacksPublicKey,
     TrieHash,
 };
-use stacks_common::types::StacksPublicKeyBuffer;
+use stacks_common::types::{set_test_coinbase_schedule, CoinbaseInterval, StacksPublicKeyBuffer};
 use stacks_common::util::hash::{to_hex, Hash160, Sha512Trunc256Sum};
 use stacks_common::util::secp256k1::{MessageSignature, Secp256k1PrivateKey, Secp256k1PublicKey};
 use stacks_common::util::{get_epoch_time_secs, sleep_ms};
@@ -114,7 +115,7 @@ pub static POX_4_DEFAULT_STACKER_BALANCE: u64 = 100_000_000_000_000;
 pub static POX_4_DEFAULT_STACKER_STX_AMT: u128 = 99_000_000_000_000;
 
 lazy_static! {
-    pub static ref NAKAMOTO_INTEGRATION_EPOCHS: [StacksEpoch; 9] = [
+    pub static ref NAKAMOTO_INTEGRATION_EPOCHS: [StacksEpoch; 10] = [
         StacksEpoch {
             epoch_id: StacksEpochId::Epoch10,
             start_height: 0,
@@ -174,10 +175,17 @@ lazy_static! {
         StacksEpoch {
             epoch_id: StacksEpochId::Epoch30,
             start_height: 231,
-            end_height: STACKS_EPOCH_MAX,
+            end_height: 241,
             block_limit: HELIUM_BLOCK_LIMIT_20.clone(),
             network_epoch: PEER_VERSION_EPOCH_3_0
         },
+        StacksEpoch {
+            epoch_id: StacksEpochId::Epoch31,
+            start_height: 241,
+            end_height: STACKS_EPOCH_MAX,
+            block_limit: HELIUM_BLOCK_LIMIT_20.clone(),
+            network_epoch: PEER_VERSION_EPOCH_3_1
+        },
     ];
 }
 
@@ -9500,3 +9508,221 @@ fn skip_mining_long_tx() {
 
     run_loop_thread.join().unwrap();
 }
+
+#[test]
+#[ignore]
+/// Integration test for SIP-029
+fn sip029_coinbase_change() {
+    if env::var("BITCOIND_TEST") != Ok("1".into()) {
+        return;
+    }
+
+    let new_sched = vec![
+        CoinbaseInterval {
+            coinbase: 1_000_000_000,
+            effective_start_height: 0,
+        },
+        // NOTE: epoch 3.1 goes into effect at 241
+        CoinbaseInterval {
+            coinbase: 500_000_000,
+            effective_start_height: 245,
+        },
+        CoinbaseInterval {
+            coinbase: 125_000_000,
+            effective_start_height: 255,
+        },
+        CoinbaseInterval {
+            coinbase: 62_500_000,
+            effective_start_height: 265,
+        },
+    ];
+
+    set_test_coinbase_schedule(Some(new_sched.clone()));
+
+    let (mut naka_conf, _miner_account) = naka_neon_integration_conf(None);
+    naka_conf.miner.wait_on_interim_blocks = Duration::from_secs(1);
+    naka_conf.node.pox_sync_sample_secs = 180;
+    naka_conf.burnchain.max_rbf = 10_000_000;
+
+    let sender_sk = Secp256k1PrivateKey::new();
+    let sender_signer_sk = Secp256k1PrivateKey::new();
+    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);
+
+    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,
+        naka_proposed_blocks: proposals_submitted,
+        ..
+    } = 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 (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, proposals_submitted);
+
+    wait_for_first_naka_block_commit(60, &commits_submitted);
+
+    // mine until burnchain height 270
+    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 >= 270 {
+            break;
+        }
+    }
+
+    info!("Nakamoto miner has advanced to burn height 270");
+
+    // inspect `payments` table to see that coinbase was applied
+    let all_snapshots = sortdb.get_all_snapshots().unwrap();
+
+    // whether or not the last snapshot had a sortition
+    let mut prev_sortition = false;
+
+    // whether or not we witnessed the requisite coinbases
+    let mut witnessed_1000 = false;
+    let mut witnessed_500 = false;
+    let mut witnessed_125 = false;
+    let mut witnessed_62_5 = false;
+
+    // initial mining bonus
+    let initial_mining_bonus = 20400000;
+
+    for sn in all_snapshots {
+        if !sn.sortition {
+            prev_sortition = false;
+            continue;
+        }
+        if sn.consensus_hash == ConsensusHash([0x00; 20]) {
+            continue;
+        }
+        let coinbase = {
+            let sql = "SELECT coinbase FROM payments WHERE consensus_hash = ?1";
+            let args = rusqlite::params![&sn.consensus_hash];
+            let Some(coinbase) = chainstate
+                .db()
+                .query_row(sql, args, |r| {
+                    let coinbase_txt: String = r.get_unwrap(0);
+                    let coinbase: u64 = coinbase_txt.parse().unwrap();
+                    Ok(coinbase)
+                })
+                .optional()
+                .unwrap()
+            else {
+                info!("No coinbase for {} {}", sn.block_height, &sn.consensus_hash);
+                continue;
+            };
+
+            coinbase
+        };
+
+        info!(
+            "Coinbase at {} {}: {}",
+            sn.block_height, &sn.consensus_hash, coinbase
+        );
+        // use >= for coinbases since a missed sortition can lead to coinbase accumulation
+        if sn.block_height < 245 {
+            if prev_sortition {
+                assert_eq!(coinbase, 1_000_000_000 + initial_mining_bonus);
+                witnessed_1000 = true;
+            } else {
+                assert!(coinbase >= 1_000_000_000 + initial_mining_bonus);
+            }
+        } else if sn.block_height < 255 {
+            if prev_sortition {
+                assert_eq!(coinbase, 500_000_000 + initial_mining_bonus);
+                witnessed_500 = true;
+            } else {
+                assert!(coinbase >= 500_000_000 + initial_mining_bonus);
+            }
+        } else if sn.block_height < 265 {
+            if prev_sortition {
+                assert_eq!(coinbase, 125_000_000 + initial_mining_bonus);
+                witnessed_125 = true;
+            } else {
+                assert!(coinbase >= 125_000_000 + initial_mining_bonus);
+            }
+        } else {
+            if prev_sortition {
+                assert_eq!(coinbase, 62_500_000 + initial_mining_bonus);
+                witnessed_62_5 = true;
+            } else {
+                assert!(coinbase >= 62_500_000 + initial_mining_bonus);
+            }
+        }
+
+        prev_sortition = true;
+    }
+
+    assert!(witnessed_1000);
+    assert!(witnessed_500);
+    assert!(witnessed_125);
+    assert!(witnessed_62_5);
+
+    coord_channel
+        .lock()
+        .expect("Mutex poisoned")
+        .stop_chains_coordinator();
+    run_loop_stopper.store(false, Ordering::SeqCst);
+
+    run_loop_thread.join().unwrap();
+}