feat: replace recipient addr in sip31 when deploying

hstove · hstove · commit 89560397ec08 · 2025-07-18T07:16:43.000-07:00
diff --git a/stacks-node/src/tests/nakamoto_integrations.rs b/stacks-node/src/tests/nakamoto_integrations.rs
@@ -24,8 +24,8 @@ use std::time::{Duration, Instant};
 use std::{env, thread};
 
 use clarity::vm::ast::ASTRules;
-use clarity::vm::costs::ExecutionCost;
-use clarity::vm::types::{PrincipalData, QualifiedContractIdentifier};
+use clarity::vm::costs::{ExecutionCost, LimitedCostTracker};
+use clarity::vm::types::{PrincipalData, QualifiedContractIdentifier, StandardPrincipalData};
 use clarity::vm::{ClarityName, ClarityVersion, Value};
 use http_types::headers::AUTHORIZATION;
 use lazy_static::lazy_static;
@@ -51,7 +51,7 @@ use stacks::chainstate::nakamoto::test_signers::TestSigners;
 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,
+    MINERS_NAME, SIGNERS_VOTING_FUNCTION_NAME, SIGNERS_VOTING_NAME, SIP_031_TESTNET_ADDR,
 };
 use stacks::chainstate::stacks::db::{StacksChainState, StacksHeaderInfo};
 use stacks::chainstate::stacks::miner::{
@@ -12910,6 +12910,40 @@ fn test_sip_031_activation() {
         coinbase_txid.unwrap()
     );
 
+    // Check that the boot contract has the right recipient
+    let sip_031_recipient = chainstate
+        .with_read_only_clarity_tx(
+            &sortdb
+                .index_handle_at_block(&chainstate, &latest_stacks_block_id)
+                .unwrap(),
+            &latest_stacks_block_id,
+            |conn| {
+                conn.with_readonly_clarity_env(
+                    naka_conf.is_mainnet(),
+                    naka_conf.burnchain.chain_id,
+                    ClarityVersion::Clarity3,
+                    PrincipalData::Standard(StandardPrincipalData::transient()),
+                    None,
+                    LimitedCostTracker::new_free(),
+                    |tx| {
+                        tx.eval_read_only(
+                            &boot_code_id(SIP_031_NAME, naka_conf.is_mainnet()),
+                            "(get-recipient)",
+                        )
+                    },
+                )
+                .unwrap()
+            },
+        )
+        .unwrap()
+        .expect_principal()
+        .unwrap();
+
+    assert_eq!(
+        sip_031_recipient,
+        PrincipalData::Standard(StandardPrincipalData::from(SIP_031_TESTNET_ADDR.clone()))
+    );
+
     coord_channel
         .lock()
         .expect("Mutex poisoned")
diff --git a/stackslib/src/chainstate/stacks/boot/mod.rs b/stackslib/src/chainstate/stacks/boot/mod.rs
@@ -16,7 +16,9 @@
 
 use std::cmp;
 use std::collections::BTreeMap;
+use std::sync::LazyLock;
 
+use clarity::types::Address;
 use clarity::vm::analysis::CheckErrors;
 use clarity::vm::ast::ASTRules;
 use clarity::vm::clarity::{Error as ClarityError, TransactionConnection};
@@ -34,6 +36,8 @@ use serde::Deserialize;
 use stacks_common::codec::StacksMessageCodec;
 use stacks_common::types::chainstate::{StacksAddress, StacksBlockId};
 use stacks_common::util::hash::{hex_bytes, to_hex};
+#[cfg(test)]
+use stacks_common::util::tests::TestFlag;
 
 use crate::burnchains::{Burnchain, PoxConstants};
 use crate::chainstate::burn::db::sortdb::SortitionDB;
@@ -77,7 +81,8 @@ 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");
+/// Not public - be sure to use [make_sip_031_body]
+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";
@@ -90,6 +95,22 @@ pub const BOOT_TEST_POX_4_AGG_KEY_FNAME: &str = "aggregate-key";
 
 pub const MINERS_NAME: &str = "miners";
 
+/// The initial recipient address for SIP-031 on mainnet.
+/// TODO: replace with actual address
+pub const SIP_031_MAINNET_ADDR: LazyLock<StacksAddress> = LazyLock::new(|| {
+    StacksAddress::from_string("SP1A2K3ENNA6QQ7G8DVJXM24T6QMBDVS7D0TRTAR5").unwrap()
+});
+
+/// The initial recipient address for SIP-031 on testnet.
+/// TODO: replace with actual address
+pub const SIP_031_TESTNET_ADDR: LazyLock<StacksAddress> = LazyLock::new(|| {
+    StacksAddress::from_string("ST1PQHQKV0RJXZFY1DGX8MNSNYVE3VGZJSRTPGZGM").unwrap()
+});
+
+#[cfg(test)]
+pub static TEST_SIP_031_ADDR: LazyLock<TestFlag<Option<StacksAddress>>> =
+    LazyLock::new(TestFlag::default);
+
 pub mod docs;
 
 lazy_static! {
@@ -139,6 +160,40 @@ fn make_testnet_cost_voting() -> String {
         )
 }
 
+#[cfg(test)]
+pub fn get_sip_031_recipient_addr(is_mainnet: bool) -> StacksAddress {
+    if is_mainnet {
+        SIP_031_MAINNET_ADDR.clone()
+    } else {
+        TEST_SIP_031_ADDR
+            .get()
+            .unwrap_or(SIP_031_TESTNET_ADDR.clone())
+    }
+}
+
+#[cfg(not(test))]
+pub fn get_sip_031_recipient_addr(is_mainnet: bool) -> StacksAddress {
+    if is_mainnet {
+        SIP_031_MAINNET_ADDR.clone()
+    } else {
+        SIP_031_TESTNET_ADDR.clone()
+    }
+}
+
+/// Generate the contract body for the SIP-031 contract.
+///
+/// When on mainnet, only the constant [SIP_031_MAINNET_ADDR] is used.
+/// Otherwise, on testnet, you can provide a configurable address.
+pub fn make_sip_031_body(is_mainnet: bool) -> String {
+    let addr = get_sip_031_recipient_addr(is_mainnet).to_string();
+
+    SIP_031_BODY.replacen(
+        "(define-data-var recipient principal tx-sender)",
+        &format!("(define-data-var recipient principal '{})", addr),
+        1,
+    )
+}
+
 pub fn make_contract_id(addr: &StacksAddress, name: &str) -> QualifiedContractIdentifier {
     QualifiedContractIdentifier::new(
         StandardPrincipalData::from(addr.clone()),
@@ -2631,7 +2686,7 @@ pub mod test {
             )
             (begin
                 ;; take the stx from the tx-sender
-                
+
                 (unwrap-panic (stx-transfer? amount-ustx tx-sender this-contract))
 
                 ;; this contract stacks the stx given to it
@@ -5847,5 +5902,34 @@ pub mod test {
         }
     }
 
+    #[test]
+    fn test_sip031_addrs() {
+        assert_eq!(
+            SIP_031_MAINNET_ADDR.to_string(),
+            "SP1A2K3ENNA6QQ7G8DVJXM24T6QMBDVS7D0TRTAR5"
+        );
+        assert_eq!(
+            SIP_031_TESTNET_ADDR.to_string(),
+            "ST1PQHQKV0RJXZFY1DGX8MNSNYVE3VGZJSRTPGZGM"
+        );
+
+        assert_eq!(
+            get_sip_031_recipient_addr(true),
+            SIP_031_MAINNET_ADDR.clone()
+        );
+        assert_eq!(
+            get_sip_031_recipient_addr(false),
+            SIP_031_TESTNET_ADDR.clone()
+        );
+
+        let transient = StacksAddress::from(StandardPrincipalData::transient().clone());
+        TEST_SIP_031_ADDR.set(Some(transient.clone()));
+        assert_eq!(get_sip_031_recipient_addr(false), transient.clone());
+        assert_eq!(
+            get_sip_031_recipient_addr(true),
+            SIP_031_MAINNET_ADDR.clone()
+        );
+    }
+
     // TODO: need Stacking-rejection with a BTC address -- contract name in OP_RETURN? (NEXT)
 }
diff --git a/stackslib/src/chainstate/stacks/boot/sip-031.clar b/stackslib/src/chainstate/stacks/boot/sip-031.clar
@@ -1,11 +1,11 @@
-(define-data-var recipient principal 'ST000000000000000000002AMW42H)
+(define-data-var recipient principal tx-sender)
 
 (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-read-only (get-recipient) (var-get recipient))
 
 (define-public (claim) (ok true) ) ;; Returns (response uint uint)
diff --git a/stackslib/src/clarity_vm/clarity.rs b/stackslib/src/clarity_vm/clarity.rs
@@ -39,12 +39,12 @@ use stacks_common::types::chainstate::{StacksBlockId, TrieHash};
 use crate::burnchains::PoxConstants;
 use crate::chainstate::nakamoto::signer_set::NakamotoSigners;
 use crate::chainstate::stacks::boot::{
-    BOOT_CODE_COSTS, BOOT_CODE_COSTS_2, BOOT_CODE_COSTS_2_TESTNET, BOOT_CODE_COSTS_3,
-    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, SIP_031_BODY,
-    SIP_031_NAME,
+    make_sip_031_body, BOOT_CODE_COSTS, BOOT_CODE_COSTS_2, BOOT_CODE_COSTS_2_TESTNET,
+    BOOT_CODE_COSTS_3, 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, SIP_031_NAME,
 };
 use crate::chainstate::stacks::db::{StacksAccount, StacksChainState};
 use crate::chainstate::stacks::events::{StacksTransactionEvent, StacksTransactionReceipt};
@@ -1643,7 +1643,7 @@ impl<'a> ClarityBlockConnection<'a, '_> {
                 TransactionSmartContract {
                     name: ContractName::try_from(SIP_031_NAME)
                         .expect("FATAL: invalid boot-code contract name"),
-                    code_body: StacksString::from_str(SIP_031_BODY)
+                    code_body: StacksString::from_str(&make_sip_031_body(mainnet))
                         .expect("FATAL: invalid boot code body"),
                 },
                 Some(ClarityVersion::Clarity3),
