Merge pull request #6336 from rdeioris/fix/sip_031_test_flakiness

rdeioris · web-flow · commit e8a60a700f4a · 2025-08-06T15:06:17.000Z
Fix sip 031 test flakiness and refactoring of base types and functions
diff --git a/stacks-common/src/types/mod.rs b/stacks-common/src/types/mod.rs
@@ -254,6 +254,181 @@ impl CoinbaseInterval {
     }
 }
 
+/// Struct describing the intervals in which SIP-031 emission are applied.
+#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+pub struct SIP031EmissionInterval {
+    /// amount of uSTX to emit
+    pub amount: u128,
+    /// height of the burn chain in which the interval starts
+    pub start_height: u64,
+}
+
+// From SIP-031:
+//
+// | Bitcoin Height | STX Emission |
+// |----------------|------------  |
+// |   907,740      |     475      |
+// |   960,300      |   1,140      |
+// | 1,012,860      |   1,705      |
+// | 1,065,420      |   1,305      |
+// | 1,117,980      |   1,155      |
+// | 1,170,540      |       0      |
+
+/// Mainnet sip-031 emission intervals
+pub static SIP031_EMISSION_INTERVALS_MAINNET: LazyLock<[SIP031EmissionInterval; 6]> =
+    LazyLock::new(|| {
+        let emissions_schedule = [
+            SIP031EmissionInterval {
+                amount: 0,
+                start_height: 1_170_540,
+            },
+            SIP031EmissionInterval {
+                amount: 1_155 * u128::from(MICROSTACKS_PER_STACKS),
+                start_height: 1_117_980,
+            },
+            SIP031EmissionInterval {
+                amount: 1_305 * u128::from(MICROSTACKS_PER_STACKS),
+                start_height: 1_065_420,
+            },
+            SIP031EmissionInterval {
+                amount: 1_705 * u128::from(MICROSTACKS_PER_STACKS),
+                start_height: 1_012_860,
+            },
+            SIP031EmissionInterval {
+                amount: 1_140 * u128::from(MICROSTACKS_PER_STACKS),
+                start_height: 960_300,
+            },
+            SIP031EmissionInterval {
+                amount: 475 * u128::from(MICROSTACKS_PER_STACKS),
+                start_height: 907_740,
+            },
+        ];
+        assert!(SIP031EmissionInterval::check_inversed_order(
+            &emissions_schedule
+        ));
+        emissions_schedule
+    });
+
+/// Testnet sip-031 emission intervals (starting from 71_525, 1 interval every 360 bitcoin blocks)
+pub static SIP031_EMISSION_INTERVALS_TESTNET: LazyLock<[SIP031EmissionInterval; 6]> =
+    LazyLock::new(|| {
+        let emissions_schedule = [
+            SIP031EmissionInterval {
+                amount: 0,
+                start_height: 71_525 + (360 * 6),
+            },
+            SIP031EmissionInterval {
+                amount: 5_000,
+                start_height: 71_525 + (360 * 5),
+            },
+            SIP031EmissionInterval {
+                amount: 4_000,
+                start_height: 71_525 + (360 * 4),
+            },
+            SIP031EmissionInterval {
+                amount: 3_000,
+                start_height: 71_525 + (360 * 3),
+            },
+            SIP031EmissionInterval {
+                amount: 2_000,
+                start_height: 71_525 + (360 * 2),
+            },
+            SIP031EmissionInterval {
+                amount: 1_000,
+                start_height: 71_525 + 360,
+            },
+        ];
+        assert!(SIP031EmissionInterval::check_inversed_order(
+            &emissions_schedule
+        ));
+        emissions_schedule
+    });
+
+/// Used for testing to substitute a sip-031 emission schedule
+#[cfg(any(test, feature = "testing"))]
+pub static SIP031_EMISSION_INTERVALS_TEST: std::sync::Mutex<Option<Vec<SIP031EmissionInterval>>> =
+    std::sync::Mutex::new(None);
+
+#[cfg(any(test, feature = "testing"))]
+pub fn set_test_sip_031_emission_schedule(emission_schedule: Option<Vec<SIP031EmissionInterval>>) {
+    if let Some(emission_schedule_vec) = &emission_schedule {
+        assert!(SIP031EmissionInterval::check_inversed_order(
+            emission_schedule_vec
+        ));
+    }
+    match SIP031_EMISSION_INTERVALS_TEST.lock() {
+        Ok(mut schedule_guard) => {
+            *schedule_guard = emission_schedule;
+        }
+        Err(_e) => {
+            panic!("SIP031_EMISSION_INTERVALS_TEST mutex poisoned");
+        }
+    }
+}
+
+#[cfg(any(test, feature = "testing"))]
+fn get_sip_031_emission_schedule(_mainnet: bool) -> Vec<SIP031EmissionInterval> {
+    match SIP031_EMISSION_INTERVALS_TEST.lock() {
+        Ok(schedule_opt) => {
+            if let Some(schedule) = (*schedule_opt).as_ref() {
+                info!("Use overridden SIP-031 emission schedule {:?}", &schedule);
+                schedule.clone()
+            } else {
+                vec![]
+            }
+        }
+        Err(_e) => {
+            panic!("COINBASE_INTERVALS_TEST mutex poisoned");
+        }
+    }
+}
+
+#[cfg(not(any(test, feature = "testing")))]
+fn get_sip_031_emission_schedule(mainnet: bool) -> Vec<SIP031EmissionInterval> {
+    if mainnet {
+        SIP031_EMISSION_INTERVALS_MAINNET.to_vec()
+    } else {
+        SIP031_EMISSION_INTERVALS_TESTNET.to_vec()
+    }
+}
+
+impl SIP031EmissionInterval {
+    /// Look up the amount of STX to emit at the start of the tenure at the specified height.
+    /// Precondition: `intervals` must be sorted in descending order by `start_height`
+    pub fn get_sip_031_emission_at_height(burn_height: u64, mainnet: bool) -> u128 {
+        let intervals = get_sip_031_emission_schedule(mainnet);
+
+        if intervals.is_empty() {
+            return 0;
+        }
+
+        for interval in intervals {
+            if burn_height >= interval.start_height {
+                return interval.amount;
+            }
+        }
+
+        // default emission (out of SIP-031 ranges)
+        0
+    }
+
+    /// Verify that a list of intervals is sorted in descending order by `start_height`
+    pub fn check_inversed_order(intervals: &[SIP031EmissionInterval]) -> bool {
+        let Some(mut ht) = intervals.first().map(|x| x.start_height) else {
+            // if the interval list is empty, its sorted
+            return true;
+        };
+
+        for interval in intervals.iter().skip(1) {
+            if interval.start_height > ht {
+                return false;
+            }
+            ht = interval.start_height;
+        }
+        true
+    }
+}
+
 impl StacksEpochId {
     pub fn latest() -> StacksEpochId {
         StacksEpochId::Epoch32
diff --git a/stacks-node/src/tests/nakamoto_integrations.rs b/stacks-node/src/tests/nakamoto_integrations.rs
@@ -51,10 +51,7 @@ 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::{
-    set_test_sip_031_emission_schedule, NakamotoBlock, NakamotoBlockHeader, NakamotoChainState,
-    SIP031EmissionInterval,
-};
+use stacks::chainstate::nakamoto::{NakamotoBlock, NakamotoBlockHeader, NakamotoChainState};
 use stacks::chainstate::stacks::address::{PoxAddress, StacksAddressExtensions};
 use stacks::chainstate::stacks::boot::{
     MINERS_NAME, SIGNERS_VOTING_FUNCTION_NAME, SIGNERS_VOTING_NAME, SIP_031_TESTNET_ADDR,
@@ -105,7 +102,10 @@ use stacks_common::types::chainstate::{
     BlockHeaderHash, BurnchainHeaderHash, StacksAddress, StacksPrivateKey, StacksPublicKey,
     TrieHash,
 };
-use stacks_common::types::{set_test_coinbase_schedule, CoinbaseInterval, StacksPublicKeyBuffer};
+use stacks_common::types::{
+    set_test_coinbase_schedule, set_test_sip_031_emission_schedule, CoinbaseInterval,
+    SIP031EmissionInterval, 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};
@@ -12701,6 +12701,7 @@ fn write_signer_update(
 /// - check sip031 boot contract has a balance of 200_000_000 STX
 #[test]
 #[ignore]
+#[serial]
 fn test_sip_031_activation() {
     if env::var("BITCOIND_TEST") != Ok("1".into()) {
         return;
@@ -12826,10 +12827,16 @@ fn test_sip_031_activation() {
     );
 
     // check for Epoch 3.2 in clarity db
-    let latest_stacks_block_id = get_latest_block_proposal(&naka_conf, &sortdb)
-        .unwrap()
-        .0
-        .block_id();
+    let latest_stacks_block_id = StacksBlockId::from_hex(
+        &test_observer::get_blocks()
+            .last()
+            .unwrap()
+            .get("index_block_hash")
+            .unwrap()
+            .as_str()
+            .unwrap()[2..],
+    )
+    .unwrap();
 
     let epoch_version = chainstate.with_read_only_clarity_tx(
         &sortdb
@@ -13122,10 +13129,16 @@ fn test_sip_031_last_phase() {
         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();
+    let latest_stacks_block_id = StacksBlockId::from_hex(
+        &test_observer::get_blocks()
+            .last()
+            .unwrap()
+            .get("index_block_hash")
+            .unwrap()
+            .as_str()
+            .unwrap()[2..],
+    )
+    .unwrap();
 
     // 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(
@@ -13244,10 +13257,16 @@ fn test_sip_031_last_phase() {
     // (100_000 + 200_000 + 300_000) * 10
     assert_eq!(total_minted_and_transferred, 6_000_000);
 
-    let latest_stacks_block_id = get_latest_block_proposal(&naka_conf, &sortdb)
-        .unwrap()
-        .0
-        .block_id();
+    let latest_stacks_block_id = StacksBlockId::from_hex(
+        &test_observer::get_blocks()
+            .last()
+            .unwrap()
+            .get("index_block_hash")
+            .unwrap()
+            .as_str()
+            .unwrap()[2..],
+    )
+    .unwrap();
 
     // get sip-031 boot contract balance (will be checked for 200_000_000 STX + total_minted_and_transferred)
     let sip_031_boot_contract_balance = chainstate.with_read_only_clarity_tx(
@@ -13430,10 +13449,16 @@ fn test_sip_031_last_phase_out_of_epoch() {
         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();
+    let latest_stacks_block_id = StacksBlockId::from_hex(
+        &test_observer::get_blocks()
+            .last()
+            .unwrap()
+            .get("index_block_hash")
+            .unwrap()
+            .as_str()
+            .unwrap()[2..],
+    )
+    .unwrap();
 
     // 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(
@@ -13620,10 +13645,16 @@ fn test_sip_031_last_phase_coinbase_matches_activation() {
         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();
+    let latest_stacks_block_id = StacksBlockId::from_hex(
+        &test_observer::get_blocks()
+            .last()
+            .unwrap()
+            .get("index_block_hash")
+            .unwrap()
+            .as_str()
+            .unwrap()[2..],
+    )
+    .unwrap();
 
     // check if sip-031 boot contract has a balance of 200_000_000 STX + coinbase-mint-and-transfer
     let sip_031_boot_contract_balance = chainstate.with_read_only_clarity_tx(
@@ -13801,10 +13832,16 @@ fn test_sip_031_last_phase_coinbase_matches_activation() {
     // 100_000
     assert_eq!(total_minted_and_transferred, 100_000);
 
-    let latest_stacks_block_id = get_latest_block_proposal(&naka_conf, &sortdb)
-        .unwrap()
-        .0
-        .block_id();
+    let latest_stacks_block_id = StacksBlockId::from_hex(
+        &test_observer::get_blocks()
+            .last()
+            .unwrap()
+            .get("index_block_hash")
+            .unwrap()
+            .as_str()
+            .unwrap()[2..],
+    )
+    .unwrap();
 
     // get sip-031 boot contract balance (will be checked for 200_000_000 STX + 100_000 + total_minted_and_transferred)
     let sip_031_boot_contract_balance = chainstate.with_read_only_clarity_tx(
diff --git a/stackslib/src/chainstate/nakamoto/mod.rs b/stackslib/src/chainstate/nakamoto/mod.rs
