Process successful .signers-voting results

contrib/core-contract-tests/tests/pox-4/signers-voting.test.ts

@@ -1,34 +1,20 @@
 import { Cl } from "@stacks/transactions";
-import { beforeEach, describe, expect, it } from "vitest";
+import { describe, expect, it } from "vitest";
 
 const accounts = simnet.getAccounts();
 const alice = accounts.get("wallet_1")!;
-const bob = accounts.get("wallet_2")!;
-const charlie = accounts.get("wallet_3")!;
-
-const ERR_SIGNER_INDEX_MISMATCH = 10000;
-const ERR_INVALID_SIGNER_INDEX = 10001;
-const ERR_OUT_OF_VOTING_WINDOW = 10002
-const ERR_OLD_ROUND = 10003;
-const ERR_ILL_FORMED_AGGREGATE_PUBLIC_KEY = 10004;
-const ERR_DUPLICATE_AGGREGATE_PUBLIC_KEY = 10005;
-const ERR_DUPLICATE_VOTE = 10006;
-const ERR_INVALID_BURN_BLOCK_HEIGHT = 10007
-
-const KEY_1 = "123456789a123456789a123456789a123456789a123456789a123456789a010203";
-const KEY_2 = "123456789a123456789a123456789a123456789a123456789a123456789ab0b1b2";
 const SIGNERS_VOTING = "signers-voting";
 
 describe("test signers-voting contract voting rounds", () => {
     describe("test pox-info", () => {
         it("should return correct burn-height", () => {
-            const { result:result1 } = simnet.callReadOnlyFn(SIGNERS_VOTING,
+            const { result: result1 } = simnet.callReadOnlyFn(SIGNERS_VOTING,
                 "reward-cycle-to-burn-height",
                 [Cl.uint(1)],
                 alice)
             expect(result1).toEqual(Cl.uint(1050))
 
-            const { result:result2 } = simnet.callReadOnlyFn(SIGNERS_VOTING,
+            const { result: result2 } = simnet.callReadOnlyFn(SIGNERS_VOTING,
                 "reward-cycle-to-burn-height",
                 [Cl.uint(2)],
                 alice)
@@ -50,7 +36,7 @@ describe("test signers-voting contract voting rounds", () => {
         })
 
         it("should return true if in prepare phase", () => {
-            const { result:result999 } = simnet.callReadOnlyFn(SIGNERS_VOTING,
+            const { result: result999 } = simnet.callReadOnlyFn(SIGNERS_VOTING,
                 "is-in-prepare-phase",
                 [Cl.uint(999)],
                 alice)

stackslib/src/chainstate/nakamoto/coordinator/tests.rs

@@ -36,7 +36,8 @@ use crate::chainstate::nakamoto::tests::node::{TestSigners, TestStacker};
 use crate::chainstate::nakamoto::{NakamotoBlock, NakamotoChainState};
 use crate::chainstate::stacks::address::PoxAddress;
 use crate::chainstate::stacks::boot::test::{
-    key_to_stacks_addr, make_pox_4_aggregate_key, make_pox_4_lockup, make_signer_key_signature,
+    key_to_stacks_addr, make_pox_4_lockup, make_signer_key_signature,
+    make_signers_vote_for_aggregate_public_key,
 };
 use crate::chainstate::stacks::boot::MINERS_NAME;
 use crate::chainstate::stacks::db::{MinerPaymentTxFees, StacksAccount, StacksChainState};
@@ -101,6 +102,23 @@ fn advance_to_nakamoto(
                     )
                 })
                 .collect()
+        } else if sortition_height == 7 {
+            // Vote for the aggregate key
+            test_stackers
+                .iter()
+                .enumerate()
+                .map(|(index, test_stacker)| {
+                    info!("Vote for aggregate key: {}", index);
+                    make_signers_vote_for_aggregate_public_key(
+                        &test_stacker.signer_private_key,
+                        0,
+                        index as u128,
+                        &test_signers.aggregate_public_key,
+                        0,
+                        7,
+                    )
+                })
+                .collect()
         } else {
             vec![]
         };
@@ -111,7 +129,8 @@ fn advance_to_nakamoto(
 }
 
 /// Make a peer and transition it into the Nakamoto epoch.
-/// The node needs to be stacking; otherwise, Nakamoto won't activate.
+/// The node needs to be stacking and it needs to vote for an aggregate key;
+/// otherwise, Nakamoto can't activate.
 pub fn boot_nakamoto<'a>(
     test_name: &str,
     mut initial_balances: Vec<(PrincipalData, u64)>,
@@ -152,7 +171,19 @@ pub fn boot_nakamoto<'a>(
         })
         .collect();
 
+    // Create some balances for test Signers
+    let mut signer_balances = test_stackers
+        .iter()
+        .map(|stacker| {
+            (
+                PrincipalData::from(p2pkh_from(&stacker.signer_private_key)),
+                1000,
+            )
+        })
+        .collect();
+
     peer_config.initial_balances.append(&mut stacker_balances);
+    peer_config.initial_balances.append(&mut signer_balances);
     peer_config.initial_balances.append(&mut initial_balances);
     peer_config.burnchain.pox_constants.v2_unlock_height = 21;
     peer_config.burnchain.pox_constants.pox_3_activation_height = 26;

stackslib/src/chainstate/nakamoto/mod.rs

@@ -1796,7 +1796,7 @@ impl NakamotoChainState {
         Ok(true)
     }
 
-    /// Get the aggregate public key for the given block from the pox-4 contract
+    /// Get the aggregate public key for the given block from the signers-voting contract
     fn load_aggregate_public_key<SH: SortitionHandle>(
         sortdb: &SortitionDB,
         sort_handle: &SH,
@@ -1818,7 +1818,10 @@ impl NakamotoChainState {
             return Err(ChainstateError::InvalidStacksBlock(msg));
         };
 
-        debug!("get-aggregate-public-key {} {}", at_block_id, rc);
+        debug!(
+            "get-approved-aggregate-key at block {}, cycle {}",
+            at_block_id, rc
+        );
         match chainstate.get_aggregate_public_key_pox_4(sortdb, at_block_id, rc)? {
             Some(key) => Ok(key),
             None => {
@@ -2602,15 +2605,6 @@ impl NakamotoChainState {
             );
         }
 
-        if !clarity_tx.config.mainnet {
-            Self::set_aggregate_public_key(
-                &mut clarity_tx,
-                first_block_height,
-                pox_constants,
-                burn_header_height.into(),
-            );
-        }
-
         // Handle signer stackerdb updates
         let signer_set_calc;
         if evaluated_epoch >= StacksEpochId::Epoch25 {
@@ -2675,102 +2669,6 @@ impl NakamotoChainState {
         Ok(lockup_events)
     }
 
-    /// Set the aggregate public key for verifying stacker signatures.
-    /// TODO: rely on signer voting instead
-    /// DO NOT USE IN MAINNET
-    pub(crate) fn set_aggregate_public_key(
-        clarity_tx: &mut ClarityTx,
-        first_block_height: u64,
-        pox_constants: &PoxConstants,
-        burn_header_height: u64,
-    ) {
-        let mainnet = clarity_tx.config.mainnet;
-        let chain_id = clarity_tx.config.chain_id;
-        assert!(!mainnet);
-
-        let my_reward_cycle = pox_constants
-            .block_height_to_reward_cycle(
-                first_block_height,
-                burn_header_height
-                    .try_into()
-                    .expect("Burn block height exceeded u32"),
-            )
-            .expect("FATAL: block height occurs before first block height");
-
-        let parent_reward_cycle = my_reward_cycle.saturating_sub(1);
-        debug!(
-            "Try setting aggregate public key in reward cycle {}, parent {}",
-            my_reward_cycle, parent_reward_cycle
-        );
-
-        // execute `set-aggregate-public-key` using `clarity-tx`
-        let Some(aggregate_public_key) = clarity_tx
-            .connection()
-            .with_readonly_clarity_env(
-                mainnet,
-                chain_id,
-                ClarityVersion::Clarity2,
-                StacksAddress::burn_address(mainnet).into(),
-                None,
-                LimitedCostTracker::Free,
-                |vm_env| {
-                    vm_env.execute_contract_allow_private(
-                        &boot_code_id(POX_4_NAME, mainnet),
-                        "get-aggregate-public-key",
-                        &vec![SymbolicExpression::atom_value(Value::UInt(u128::from(
-                            parent_reward_cycle,
-                        )))],
-                        true,
-                    )
-                },
-            )
-            .ok()
-            .map(|agg_key_value| {
-                let agg_key_opt = agg_key_value
-                    .expect_optional()
-                    .expect("FATAL: not an optional")
-                    .map(|agg_key_buff| {
-                        Value::buff_from(agg_key_buff.expect_buff(33).expect("FATAL: not a buff"))
-                            .expect("failed to reconstruct buffer")
-                    });
-                agg_key_opt
-            })
-            .flatten()
-        else {
-            panic!(
-                "No aggregate public key in parent cycle {}",
-                parent_reward_cycle
-            );
-        };
-
-        clarity_tx.connection().as_transaction(|tx| {
-            tx.with_abort_callback(
-                |vm_env| {
-                    vm_env.execute_in_env(
-                        StacksAddress::burn_address(mainnet).into(),
-                        None,
-                        None,
-                        |vm_env| {
-                            vm_env.execute_contract_allow_private(
-                                &boot_code_id(POX_4_NAME, mainnet),
-                                "set-aggregate-public-key",
-                                &vec![
-                                    SymbolicExpression::atom_value(Value::UInt(u128::from(
-                                        my_reward_cycle,
-                                    ))),
-                                    SymbolicExpression::atom_value(aggregate_public_key),
-                                ],
-                                false,
-                            )
-                        },
-                    )
-                },
-                |_, _| false,
-            )
-            .expect("FATAL: failed to set aggregate public key")
-        });
-    }
-
     /// Append a Nakamoto Stacks block to the Stacks chain state.
     pub fn append_block<'a>(
         chainstate_tx: &mut ChainstateTx,

stackslib/src/chainstate/nakamoto/signer_set.rs

@@ -274,7 +274,7 @@ impl NakamotoSigners {
                                 "signer".into(),
                                 Value::Principal(PrincipalData::from(signing_address)),
                             ),
-                            ("weight".into(), Value::UInt(signer.slots.into())),
+                            ("weight".into(), Value::UInt(signer.stacked_amt.into())),
                         ])
                             .expect(
                                 "BUG: Failed to construct `{ signer: principal, num-slots: u64 }` tuple",

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

@@ -1291,16 +1291,21 @@ impl StacksChainState {
             .eval_boot_code_read_only(
                 sortdb,
                 block_id,
-                POX_4_NAME,
-                &format!("(get-aggregate-public-key u{})", reward_cycle),
+                SIGNERS_VOTING_NAME,
+                &format!("(get-approved-aggregate-key u{})", reward_cycle),
             )?
             .expect_optional()?;
+        debug!(
+            "Aggregate public key for reward cycle {} is {:?}",
+            reward_cycle, aggregate_public_key_opt
+        );
 
         let aggregate_public_key = match aggregate_public_key_opt {
             Some(value) => {
                 // A point should have 33 bytes exactly.
                 let data = value.expect_buff(33)?;
-                let msg = "Pox-4 get-aggregate-public-key returned a corrupted value.";
+                let msg =
+                    "Pox-4 signers-voting get-approved-aggregate-key returned a corrupted value.";
                 let compressed_data = Compressed::try_from(data.as_slice()).expect(msg);
                 Some(Point::try_from(&compressed_data).expect(msg))
             }
@@ -1333,9 +1338,8 @@ pub mod test {
     use clarity::vm::contracts::Contract;
     use clarity::vm::tests::symbols_from_values;
     use clarity::vm::types::*;
-    use stacks_common::types::PrivateKey;
-    use stacks_common::util::hash::Sha256Sum;
-    use stacks_common::util::secp256k1::{Secp256k1PrivateKey, Secp256k1PublicKey};
+    use stacks_common::util::hash::to_hex;
+    use stacks_common::util::secp256k1::Secp256k1PublicKey;
     use stacks_common::util::*;
 
     use super::*;
@@ -1900,30 +1904,13 @@ pub mod test {
         make_tx(key, nonce, 0, payload)
     }
 
-    pub fn make_pox_4_aggregate_key(
-        key: &StacksPrivateKey,
-        nonce: u64,
-        reward_cycle: u64,
-        aggregate_public_key: &Point,
-    ) -> StacksTransaction {
-        let aggregate_public_key = Value::buff_from(aggregate_public_key.compress().data.to_vec())
-            .expect("Failed to serialize aggregate public key");
-        let payload = TransactionPayload::new_contract_call(
-            boot_code_test_addr(),
-            POX_4_NAME,
-            "set-aggregate-public-key",
-            vec![Value::UInt(reward_cycle as u128), aggregate_public_key],
-        )
-        .unwrap();
-        make_tx(key, nonce, 0, payload)
-    }
-
     pub fn make_signers_vote_for_aggregate_public_key(
         key: &StacksPrivateKey,
         nonce: u64,
         signer_index: u128,
         aggregate_public_key: &Point,
         round: u128,
+        cycle: u128,
     ) -> StacksTransaction {
         let aggregate_public_key = Value::buff_from(aggregate_public_key.compress().data.to_vec())
             .expect("Failed to serialize aggregate public key");
@@ -1935,6 +1922,7 @@ pub mod test {
                 Value::UInt(signer_index),
                 aggregate_public_key,
                 Value::UInt(round),
+                Value::UInt(cycle),
             ],
         )
         .unwrap();

stackslib/src/chainstate/stacks/boot/pox-4.clar

@@ -1331,17 +1331,3 @@
 (define-read-only (get-partial-stacked-by-cycle (pox-addr { version: (buff 1), hashbytes: (buff 32) }) (reward-cycle uint) (sender principal))
     (map-get? partial-stacked-by-cycle { pox-addr: pox-addr, reward-cycle: reward-cycle, sender: sender })
 )
-
-;; What is the given reward cycle's stackers' aggregate public key?
-;; *New in Stacks 3.0*
-(define-read-only (get-aggregate-public-key (reward-cycle uint))
-    (map-get? aggregate-public-keys reward-cycle)
-)
-
-;; Set the aggregate public key to the provided value
-;; *New in Stacks 3.0*
-(define-private (set-aggregate-public-key (reward-cycle uint) (aggregate-public-key (buff 33)))
-    (begin
-        (ok (map-set aggregate-public-keys reward-cycle aggregate-public-key))
-    )
-)