Merge pull request #6261 from rdeioris/feat/sip_031_boot_contract

Feat/sip 031 boot contract

Author: rdeioris

stacks-node/src/tests/nakamoto_integrations.rs

@@ -129,6 +129,10 @@ use crate::{tests, BitcoinRegtestController, BurnchainController, Config, Config
 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;
 
+use clarity::vm::database::STXBalance;
+use stacks::chainstate::stacks::boot::SIP_031_NAME;
+use stacks::clarity_vm::clarity::SIP_031_INITIAL_MINT;
+
 use crate::clarity::vm::clarity::ClarityConnection;
 
 lazy_static! {
@@ -12635,7 +12639,7 @@ fn write_signer_update(
 /// Test SIP-031 activation
 ///
 /// - check epoch 3.2 is active
-/// - TODO: check sip031 boot contract has a balance of 200_000_000 STX (TODO)
+/// - check sip031 boot contract has a balance of 200_000_000 STX
 #[test]
 #[ignore]
 fn test_sip_031_activation() {
@@ -12717,7 +12721,29 @@ fn test_sip_031_activation() {
 
     wait_for_first_naka_block_commit(60, &commits_submitted);
 
-    // mine until epooch 3.2 height
+    // retrieve current liquidity
+    let last_block_id = StacksBlockId::from_hex(
+        &test_observer::get_blocks()
+            .last()
+            .unwrap()
+            .get("index_block_hash")
+            .unwrap()
+            .as_str()
+            .unwrap()[2..],
+    )
+    .unwrap();
+
+    let sip_031_initial_total_liquid_ustx = chainstate
+        .with_read_only_clarity_tx(
+            &sortdb
+                .index_handle_at_block(&chainstate, &last_block_id)
+                .unwrap(),
+            &last_block_id,
+            |conn| conn.with_clarity_db_readonly(|db| db.get_total_liquid_ustx().unwrap()),
+        )
+        .unwrap();
+
+    // 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)
@@ -12756,6 +12782,134 @@ fn test_sip_031_activation() {
 
     assert_eq!(epoch_version, Some(StacksEpochId::Epoch32));
 
+    // check if sip-031 boot contract has been deployed
+    let sip_031_boot_contract_exists = 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.has_contract(&boot_code_id(SIP_031_NAME, naka_conf.is_mainnet()))
+            })
+        },
+    );
+
+    assert_eq!(sip_031_boot_contract_exists, Some(true));
+
+    // 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
+        }))
+    );
+
+    // check liquidity has been updated accordingly
+    let sip_031_total_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();
+
+    assert!(sip_031_total_liquid_ustx - sip_031_initial_total_liquid_ustx >= SIP_031_INITIAL_MINT);
+
+    // check if the coinbase activation block receipt has the mint event
+    let mut mint_event_found: Option<serde_json::Value> = None;
+    let mut coinbase_txid: Option<String> = None;
+    for block in test_observer::get_blocks().iter().rev() {
+        let burn_block_height = block.get("burn_block_height").unwrap().as_u64().unwrap();
+        if burn_block_height
+            == naka_conf.burnchain.epochs.clone().unwrap()[StacksEpochId::Epoch32].start_height
+        {
+            // the first transaction is the coinbase
+            coinbase_txid = Some(
+                block
+                    .get("transactions")
+                    .unwrap()
+                    .as_array()
+                    .unwrap()
+                    .first()
+                    .unwrap()
+                    .get("txid")
+                    .unwrap()
+                    .as_str()
+                    .unwrap()
+                    .into(),
+            );
+            let events = block.get("events").unwrap().as_array().unwrap();
+            for event in events {
+                if let Some(_) = event.get("stx_mint_event") {
+                    mint_event_found = Some(event.clone());
+                    break;
+                }
+            }
+            break;
+        }
+    }
+
+    assert!(coinbase_txid.is_some());
+    assert!(mint_event_found.is_some());
+
+    // check the amount
+    assert_eq!(
+        mint_event_found
+            .clone()
+            .unwrap()
+            .get("stx_mint_event")
+            .unwrap()
+            .get("amount")
+            .unwrap()
+            .as_str()
+            .unwrap(),
+        SIP_031_INITIAL_MINT.to_string()
+    );
+
+    // check the recipient
+    assert_eq!(
+        mint_event_found
+            .clone()
+            .unwrap()
+            .get("stx_mint_event")
+            .unwrap()
+            .get("recipient")
+            .unwrap()
+            .as_str()
+            .unwrap(),
+        boot_code_id(SIP_031_NAME, naka_conf.is_mainnet()).to_string()
+    );
+
+    // check the txid
+    assert_eq!(
+        mint_event_found
+            .clone()
+            .unwrap()
+            .get("txid")
+            .unwrap()
+            .as_str()
+            .unwrap(),
+        coinbase_txid.unwrap()
+    );
+
     coord_channel
         .lock()
         .expect("Mutex poisoned")

stackslib/src/chainstate/stacks/boot/mod.rs

@@ -63,6 +63,7 @@ pub const POX_4_NAME: &str = "pox-4";
 pub const SIGNERS_NAME: &str = "signers";
 pub const SIGNERS_VOTING_NAME: &str = "signers-voting";
 pub const SIGNERS_VOTING_FUNCTION_NAME: &str = "vote-for-aggregate-public-key";
+pub const SIP_031_NAME: &str = "sip-031";
 /// This is the name of a variable in the `.signers` contract which tracks the most recently updated
 /// reward cycle number.
 pub const SIGNERS_UPDATE_STATE: &str = "last-set-cycle";
@@ -76,6 +77,7 @@ pub const SIGNERS_BODY: &str = std::include_str!("signers.clar");
 pub const SIGNERS_DB_0_BODY: &str = std::include_str!("signers-0-xxx.clar");
 pub const SIGNERS_DB_1_BODY: &str = std::include_str!("signers-1-xxx.clar");
 pub const SIGNERS_VOTING_BODY: &str = std::include_str!("signers-voting.clar");
+pub const SIP_031_BODY: &str = std::include_str!("sip-031.clar");
 
 pub const COSTS_1_NAME: &str = "costs";
 pub const COSTS_2_NAME: &str = "costs-2";

stackslib/src/chainstate/stacks/boot/sip-031.clar

@@ -0,0 +1,11 @@
+(define-data-var recipient principal 'ST000000000000000000002AMW42H)
+
+(define-public (update-recipient (new-recipient principal)) (begin
+    (asserts! (is-eq tx-sender (var-get recipient)) (err u101))
+    (var-set recipient new-recipient)
+    (ok true)
+)) ;; Returns (response bool uint)
+
+(define-read-only (get-recipient) (ok (var-get recipient))) ;; Returns (response principal uint)
+
+(define-public (claim) (ok true) ) ;; Returns (response uint uint)

stackslib/src/clarity_vm/clarity.rs

@@ -29,6 +29,7 @@ use clarity::vm::database::{
     RollbackWrapperPersistedLog, STXBalance, NULL_BURN_STATE_DB, NULL_HEADER_DB,
 };
 use clarity::vm::errors::Error as InterpreterError;
+use clarity::vm::events::{STXEventType, STXMintEventData};
 use clarity::vm::representations::SymbolicExpression;
 use clarity::vm::types::{PrincipalData, QualifiedContractIdentifier, Value};
 use clarity::vm::{ClarityVersion, ContractName};
@@ -42,7 +43,8 @@ use crate::chainstate::stacks::boot::{
     BOOT_CODE_COST_VOTING_TESTNET as BOOT_CODE_COST_VOTING, BOOT_CODE_POX_TESTNET, COSTS_2_NAME,
     COSTS_3_NAME, POX_2_MAINNET_CODE, POX_2_NAME, POX_2_TESTNET_CODE, POX_3_MAINNET_CODE,
     POX_3_NAME, POX_3_TESTNET_CODE, POX_4_CODE, POX_4_NAME, SIGNERS_BODY, SIGNERS_DB_0_BODY,
-    SIGNERS_DB_1_BODY, SIGNERS_NAME, SIGNERS_VOTING_BODY, SIGNERS_VOTING_NAME,
+    SIGNERS_DB_1_BODY, SIGNERS_NAME, SIGNERS_VOTING_BODY, SIGNERS_VOTING_NAME, SIP_031_BODY,
+    SIP_031_NAME,
 };
 use crate::chainstate::stacks::db::{StacksAccount, StacksChainState};
 use crate::chainstate::stacks::events::{StacksTransactionEvent, StacksTransactionReceipt};
@@ -57,6 +59,8 @@ use crate::util_lib::boot::{boot_code_acc, boot_code_addr, boot_code_id, boot_co
 use crate::util_lib::db::Error as DatabaseError;
 use crate::util_lib::strings::StacksString;
 
+pub const SIP_031_INITIAL_MINT: u128 = 200_000_000_000_000;
+
 ///
 /// A high-level interface for interacting with the Clarity VM.
 ///
@@ -1617,10 +1621,89 @@ impl<'a> ClarityBlockConnection<'a, '_> {
                 tx_conn.epoch = StacksEpochId::Epoch32;
             });
 
-            // TODO: SIP-031 setup (minting and transfer to the boot contract)
+            let mut receipts = vec![];
+
+            let boot_code_account = self
+                .get_boot_code_account()
+                .expect("FATAL: did not get boot account");
+
+            let mainnet = self.mainnet;
+            let tx_version = if mainnet {
+                TransactionVersion::Mainnet
+            } else {
+                TransactionVersion::Testnet
+            };
+
+            let boot_code_address = boot_code_addr(mainnet);
+            let boot_code_auth = boot_code_tx_auth(boot_code_address);
+
+            // SIP-031 setup (deploy of the boot contract, minting and transfer to the boot contract)
+            let sip_031_contract_id = boot_code_id(SIP_031_NAME, mainnet);
+            let payload = TransactionPayload::SmartContract(
+                TransactionSmartContract {
+                    name: ContractName::try_from(SIP_031_NAME)
+                        .expect("FATAL: invalid boot-code contract name"),
+                    code_body: StacksString::from_str(SIP_031_BODY)
+                        .expect("FATAL: invalid boot code body"),
+                },
+                Some(ClarityVersion::Clarity3),
+            );
+
+            let sip_031_contract_tx =
+                StacksTransaction::new(tx_version.clone(), boot_code_auth, payload);
+
+            let mut sip_031_initialization_receipt = self.as_transaction(|tx_conn| {
+                // initialize with a synthetic transaction
+                info!("Instantiate {} contract", &sip_031_contract_id);
+                let receipt = StacksChainState::process_transaction_payload(
+                    tx_conn,
+                    &sip_031_contract_tx,
+                    &boot_code_account,
+                    ASTRules::PrecheckSize,
+                    None,
+                )
+                .expect("FATAL: Failed to process .sip-031 contract initialization");
+                receipt
+            });
+
+            if sip_031_initialization_receipt.result != Value::okay_true()
+                || sip_031_initialization_receipt.post_condition_aborted
+            {
+                panic!(
+                    "FATAL: Failure processing sip-031 contract initialization: {:#?}",
+                    &sip_031_initialization_receipt
+                );
+            }
+
+            let recipient = PrincipalData::Contract(sip_031_contract_id);
+
+            self.as_transaction(|tx_conn| {
+                tx_conn
+                    .with_clarity_db(|db| {
+                        db.increment_ustx_liquid_supply(SIP_031_INITIAL_MINT)
+                            .map_err(|e| e.into())
+                    })
+                    .expect("FATAL: `SIP-031 initial mint` overflowed");
+                StacksChainState::account_credit(
+                    tx_conn,
+                    &recipient,
+                    u64::try_from(SIP_031_INITIAL_MINT)
+                        .expect("FATAL: transferred more STX than exist"),
+                );
+            });
+
+            let event = STXEventType::STXMintEvent(STXMintEventData {
+                recipient,
+                amount: SIP_031_INITIAL_MINT,
+            });
+            sip_031_initialization_receipt
+                .events
+                .push(StacksTransactionEvent::STXEvent(event));
+
+            receipts.push(sip_031_initialization_receipt);
 
             debug!("Epoch 3.2 initialized");
-            (old_cost_tracker, Ok(vec![]))
+            (old_cost_tracker, Ok(receipts))
         })
     }