sip-031 mint-and-transfer per tenure infrastructure

Author: rdeioris

stacks-common/src/types/mod.rs

@@ -549,6 +549,23 @@ impl StacksEpochId {
             ),
         }
     }
+
+    /// Whether or not this epoch is part of the SIP-031 schedule
+    pub fn includes_sip_031(&self) -> bool {
+        match self {
+            StacksEpochId::Epoch10
+            | StacksEpochId::Epoch20
+            | StacksEpochId::Epoch2_05
+            | StacksEpochId::Epoch21
+            | StacksEpochId::Epoch22
+            | StacksEpochId::Epoch23
+            | StacksEpochId::Epoch24
+            | StacksEpochId::Epoch25
+            | StacksEpochId::Epoch30
+            | StacksEpochId::Epoch31 => false,
+            StacksEpochId::Epoch32 => true,
+        }
+    }
 }
 
 impl std::fmt::Display for StacksEpochId {

stackslib/src/chainstate/nakamoto/mod.rs

@@ -16,11 +16,12 @@
 
 use std::collections::{HashMap, HashSet};
 use std::ops::{Deref, DerefMut, Range};
+use std::sync::LazyLock;
 
 use clarity::util::secp256k1::Secp256k1PublicKey;
 use clarity::vm::ast::ASTRules;
 use clarity::vm::costs::ExecutionCost;
-use clarity::vm::events::StacksTransactionEvent;
+use clarity::vm::events::{STXEventType, STXMintEventData, StacksTransactionEvent};
 use clarity::vm::types::PrincipalData;
 use clarity::vm::{ClarityVersion, Value};
 use lazy_static::lazy_static;
@@ -32,7 +33,9 @@ use stacks_common::codec::{
     read_next, write_next, Error as CodecError, StacksMessageCodec, MAX_MESSAGE_LEN,
     MAX_PAYLOAD_LEN,
 };
-use stacks_common::consts::{FIRST_BURNCHAIN_CONSENSUS_HASH, FIRST_STACKS_BLOCK_HASH};
+use stacks_common::consts::{
+    FIRST_BURNCHAIN_CONSENSUS_HASH, FIRST_STACKS_BLOCK_HASH, MICROSTACKS_PER_STACKS,
+};
 use stacks_common::types::chainstate::{
     BlockHeaderHash, BurnchainHeaderHash, ConsensusHash, SortitionId, StacksAddress, StacksBlockId,
     StacksPrivateKey, StacksPublicKey, TrieHash, VRFSeed,
@@ -74,6 +77,7 @@ use crate::chainstate::nakamoto::tenure::{
     NakamotoTenureEventId, NAKAMOTO_TENURES_SCHEMA_1, NAKAMOTO_TENURES_SCHEMA_2,
     NAKAMOTO_TENURES_SCHEMA_3,
 };
+use crate::chainstate::stacks::boot::SIP_031_NAME;
 use crate::chainstate::stacks::db::blocks::DummyEventDispatcher;
 use crate::chainstate::stacks::db::{
     DBConfig as ChainstateConfig, StacksChainState, StacksDBConn, StacksDBTx,
@@ -573,6 +577,176 @@ impl MaturedMinerRewards {
     }
 }
 
+/// 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 2100, basically dummy values)
+pub static SIP031_EMISSION_INTERVALS_TESTNET: LazyLock<[SIP031EmissionInterval; 6]> =
+    LazyLock::new(|| {
+        let emissions_schedule = [
+            SIP031EmissionInterval {
+                amount: 0,
+                start_height: 2_600,
+            },
+            SIP031EmissionInterval {
+                amount: 0,
+                start_height: 2_500,
+            },
+            SIP031EmissionInterval {
+                amount: 0,
+                start_height: 2_400,
+            },
+            SIP031EmissionInterval {
+                amount: 0,
+                start_height: 2_300,
+            },
+            SIP031EmissionInterval {
+                amount: 0,
+                start_height: 2_200,
+            },
+            SIP031EmissionInterval {
+                amount: 0,
+                start_height: 2_100,
+            },
+        ];
+        assert!(SIP031EmissionInterval::check_inversed_order(
+            &emissions_schedule
+        ));
+        emissions_schedule
+    });
+
+/// Used for testing to substitute a sip-031 emission schedule
+#[cfg(test)]
+pub static SIP031_EMISSION_INTERVALS_TEST: std::sync::Mutex<Option<Vec<SIP031EmissionInterval>>> =
+    std::sync::Mutex::new(None);
+
+#[cfg(test)]
+pub fn set_test_sip_031_emission_schedule(emission_schedule: Option<Vec<SIP031EmissionInterval>>) {
+    match SIP031_EMISSION_INTERVALS_TEST.lock() {
+        Ok(mut schedule_guard) => {
+            *schedule_guard = emission_schedule;
+        }
+        Err(_e) => {
+            panic!("SIP031_EMISSION_INTERVALS_TEST mutex poisoned");
+        }
+    }
+}
+
+#[cfg(test)]
+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);
+                return schedule.clone();
+            } else {
+                return vec![];
+            }
+        }
+        Err(_e) => {
+            panic!("COINBASE_INTERVALS_TEST mutex poisoned");
+        }
+    }
+}
+
+#[cfg(not(test))]
+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(height: u64, mainnet: bool) -> u128 {
+        let intervals = get_sip_031_emission_schedule(mainnet);
+
+        if intervals.is_empty() {
+            return 0;
+        }
+
+        for interval in intervals {
+            if height >= interval.start_height {
+                return interval.amount;
+            }
+        }
+
+        // default emission (out of SIP-031 ranges)
+        return 0;
+    }
+
+    /// Verify that a list of intervals is sorted in descending order by `start_height`
+    pub fn check_inversed_order(intervals: &[SIP031EmissionInterval]) -> bool {
+        if intervals.len() < 2 {
+            return true;
+        }
+
+        let mut ht = intervals[0].start_height;
+        for interval in intervals.iter().skip(1) {
+            if interval.start_height > ht {
+                return false;
+            }
+            ht = interval.start_height;
+        }
+        true
+    }
+}
+
 /// Result of preparing to produce or validate a block
 pub struct SetupBlockResult<'a, 'b> {
     /// Handle to the ClarityVM
@@ -4042,6 +4216,8 @@ impl NakamotoChainState {
             "parent_header_hash" => %parent_header_hash,
         );
 
+        let evaluated_epoch = clarity_tx.get_epoch();
+
         if new_tenure {
             clarity_tx
                 .connection()
@@ -4061,9 +4237,63 @@ impl NakamotoChainState {
                     );
                     e
                 })?;
-        }
 
-        let evaluated_epoch = clarity_tx.get_epoch();
+            let mainnet = clarity_tx.config.mainnet;
+
+            if evaluated_epoch.includes_sip_031() {
+                println!(
+                    "\n\nNEW TENURE {} {} (parent: {}) {:?} {}\n\n",
+                    coinbase_height,
+                    burn_header_height,
+                    parent_burn_height,
+                    evaluated_epoch,
+                    tx_receipts.len()
+                );
+
+                let sip_031_mint_and_transfer_amount =
+                    SIP031EmissionInterval::get_sip_031_emission_at_height(
+                        u64::from(burn_header_height),
+                        mainnet,
+                    );
+
+                if sip_031_mint_and_transfer_amount > 0 {
+                    let boot_code_address = boot_code_addr(mainnet);
+                    let boot_code_auth = boot_code_tx_auth(boot_code_address.clone());
+
+                    let recipient = PrincipalData::Contract(boot_code_id(SIP_031_NAME, mainnet));
+
+                    let mint_and_account_receipt =
+                        clarity_tx.connection().as_transaction(|tx_conn| {
+                            tx_conn
+                                .with_clarity_db(|db| {
+                                    db.increment_ustx_liquid_supply(
+                                        sip_031_mint_and_transfer_amount,
+                                    )
+                                    .map_err(|e| e.into())
+                                })
+                                .expect("FATAL: `SIP-031 mint` overflowed");
+                            StacksChainState::account_credit(
+                                tx_conn,
+                                &recipient,
+                                u64::try_from(sip_031_mint_and_transfer_amount)
+                                    .expect("FATAL: transferred more STX than exist"),
+                            );
+                        });
+
+                    let event = STXEventType::STXMintEvent(STXMintEventData {
+                        recipient,
+                        amount: sip_031_mint_and_transfer_amount,
+                    });
+
+                    /*
+                        .events
+                        .push(StacksTransactionEvent::STXEvent(event));
+
+                    tx_receipts.push(sip_031_initialization_receipt);
+                    */
+                }
+            }
+        }
 
         let auto_unlock_events = if evaluated_epoch >= StacksEpochId::Epoch21 {
             let unlock_events = StacksChainState::check_and_handle_reward_start(