Merge pull request #5677 from stacks-network/feat/consensus-hash-in-events

feat: include consensus_hash in emitted events

Author: hstove

stackslib/src/burnchains/burnchain.rs

@@ -1128,7 +1128,7 @@ impl Burnchain {
             burnchain,
             &sortition_tip,
             None,
-            |_| {},
+            |_, _| {},
         )
     }
 

stackslib/src/chainstate/burn/db/sortdb.rs

@@ -4285,7 +4285,7 @@ impl SortitionDB {
     /// * `next_pox_info` - iff this sortition is the first block in a reward cycle, this should be Some
     /// * `announce_to` - a function that will be invoked with the calculated reward set before this method
     ///                   commits its results. This is used to post the calculated reward set to an event observer.
-    pub fn evaluate_sortition<F: FnOnce(Option<RewardSetInfo>)>(
+    pub fn evaluate_sortition<F: FnOnce(Option<RewardSetInfo>, ConsensusHash)>(
         &mut self,
         mainnet: bool,
         burn_header: &BurnchainBlockHeader,
@@ -4381,7 +4381,7 @@ impl SortitionDB {
                 .store_transition_ops(&new_snapshot.0.sortition_id, &new_snapshot.1)?;
         }
 
-        announce_to(reward_set_info);
+        announce_to(reward_set_info, new_snapshot.0.consensus_hash);
 
         if !dryrun {
             // commit everything!

stackslib/src/chainstate/coordinator/mod.rs

@@ -194,6 +194,7 @@ pub trait BlockEventDispatcher {
         rewards: Vec<(PoxAddress, u64)>,
         burns: u64,
         reward_recipients: Vec<PoxAddress>,
+        consensus_hash: &ConsensusHash,
     );
 }
 
@@ -938,6 +939,7 @@ pub fn dispatcher_announce_burn_ops<T: BlockEventDispatcher>(
     burn_header: &BurnchainBlockHeader,
     paid_rewards: PaidRewards,
     reward_recipient_info: Option<RewardSetInfo>,
+    consensus_hash: &ConsensusHash,
 ) {
     let recipients = if let Some(recip_info) = reward_recipient_info {
         recip_info
@@ -955,6 +957,7 @@ pub fn dispatcher_announce_burn_ops<T: BlockEventDispatcher>(
         paid_rewards.pox,
         paid_rewards.burns,
         recipients,
+        consensus_hash,
     );
 }
 
@@ -2705,13 +2708,14 @@ impl<
                             &self.burnchain,
                             &last_processed_ancestor,
                             reward_cycle_info,
-                            |reward_set_info| {
+                            |reward_set_info, consensus_hash| {
                                 if let Some(dispatcher) = dispatcher_ref {
                                     dispatcher_announce_burn_ops(
                                         *dispatcher,
                                         &header,
                                         paid_rewards,
                                         reward_set_info,
+                                        &consensus_hash,
                                     );
                                 }
                             },

stackslib/src/chainstate/coordinator/tests.rs

@@ -446,6 +446,7 @@ impl BlockEventDispatcher for NullEventDispatcher {
         _rewards: Vec<(PoxAddress, u64)>,
         _burns: u64,
         _slot_holders: Vec<PoxAddress>,
+        _consensus_hash: &ConsensusHash,
     ) {
     }
 }

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

@@ -1169,13 +1169,14 @@ impl<
                     &self.burnchain,
                     &last_processed_ancestor,
                     reward_cycle_info,
-                    |reward_set_info| {
+                    |reward_set_info, consensus_hash| {
                         if let Some(dispatcher) = dispatcher_ref {
                             dispatcher_announce_burn_ops(
                                 *dispatcher,
                                 &header,
                                 paid_rewards,
                                 reward_set_info,
+                                &consensus_hash,
                             );
                         }
                     },

stackslib/src/chainstate/stacks/db/blocks.rs

@@ -206,6 +206,7 @@ impl BlockEventDispatcher for DummyEventDispatcher {
         _rewards: Vec<(PoxAddress, u64)>,
         _burns: u64,
         _slot_holders: Vec<PoxAddress>,
+        _consensus_hash: &ConsensusHash,
     ) {
         assert!(
             false,

stackslib/src/main.rs

@@ -1484,7 +1484,7 @@ check if the associated microblocks can be downloaded
                         &burnchain,
                         &sortition_tip.sortition_id,
                         None,
-                        |_| {},
+                        |_, _| {},
                     )
                     .unwrap()
             };
@@ -1981,7 +1981,7 @@ fn analyze_sortition_mev(argv: Vec<String>) {
                 &burnchain,
                 &tip_sort_id,
                 rc_info_opt,
-                |_| (),
+                |_, _| (),
             )
             .unwrap();
 

stackslib/src/net/mod.rs

@@ -2554,6 +2554,7 @@ pub mod test {
             _rewards: Vec<(PoxAddress, u64)>,
             _burns: u64,
             _reward_recipients: Vec<PoxAddress>,
+            _consensus_hash: &ConsensusHash,
         ) {
             // pass
         }

testnet/stacks-node/src/event_dispatcher.rs

@@ -593,6 +593,7 @@ impl EventObserver {
         rewards: Vec<(PoxAddress, u64)>,
         burns: u64,
         slot_holders: Vec<PoxAddress>,
+        consensus_hash: &ConsensusHash,
     ) -> serde_json::Value {
         let reward_recipients = rewards
             .into_iter()
@@ -614,7 +615,8 @@ impl EventObserver {
             "burn_block_height": burn_block_height,
             "reward_recipients": serde_json::Value::Array(reward_recipients),
             "reward_slot_holders": serde_json::Value::Array(reward_slot_holders),
-            "burn_amount": burns
+            "burn_amount": burns,
+            "consensus_hash": format!("0x{consensus_hash}"),
         })
     }
 
@@ -867,6 +869,7 @@ impl EventObserver {
             "reward_set": reward_set_value,
             "cycle_number": cycle_number_value,
             "tenure_height": coinbase_height,
+            "consensus_hash": format!("0x{}", metadata.consensus_hash),
         });
 
         let as_object_mut = payload.as_object_mut().unwrap();
@@ -1103,13 +1106,15 @@ impl BlockEventDispatcher for EventDispatcher {
         rewards: Vec<(PoxAddress, u64)>,
         burns: u64,
         recipient_info: Vec<PoxAddress>,
+        consensus_hash: &ConsensusHash,
     ) {
         self.process_burn_block(
             burn_block,
             burn_block_height,
             rewards,
             burns,
             recipient_info,
+            consensus_hash,
         )
     }
 }
@@ -1146,6 +1151,7 @@ impl EventDispatcher {
         rewards: Vec<(PoxAddress, u64)>,
         burns: u64,
         recipient_info: Vec<PoxAddress>,
+        consensus_hash: &ConsensusHash,
     ) {
         // lazily assemble payload only if we have observers
         let interested_observers = self.filter_observers(&self.burn_block_observers_lookup, true);
@@ -1159,6 +1165,7 @@ impl EventDispatcher {
             rewards,
             burns,
             recipient_info,
+            consensus_hash,
         );
 
         for observer in interested_observers.iter() {

testnet/stacks-node/src/tests/nakamoto_integrations.rs

@@ -10492,3 +10492,101 @@ fn clarity_cost_spend_down() {
 
     run_loop_thread.join().unwrap();
 }
+
+#[test]
+#[ignore]
+fn consensus_hash_event_dispatcher() {
+    if env::var("BITCOIND_TEST") != Ok("1".into()) {
+        return;
+    }
+
+    let (mut conf, _miner_account) = naka_neon_integration_conf(None);
+    let password = "12345".to_string();
+    conf.connection_options.auth_token = Some(password.clone());
+    conf.miner.wait_on_interim_blocks = Duration::from_secs(1);
+    let stacker_sk = setup_stacker(&mut conf);
+    let signer_sk = Secp256k1PrivateKey::new();
+    let signer_addr = tests::to_addr(&signer_sk);
+    let sender_sk = Secp256k1PrivateKey::new();
+    // setup sender + recipient for some test stx transfers
+    // these are necessary for the interim blocks to get mined at all
+    let sender_addr = tests::to_addr(&sender_sk);
+    let send_amt = 100;
+    let send_fee = 180;
+    conf.add_initial_balance(
+        PrincipalData::from(sender_addr).to_string(),
+        send_amt + send_fee,
+    );
+    conf.add_initial_balance(PrincipalData::from(signer_addr).to_string(), 100000);
+
+    // only subscribe to the block proposal events
+    test_observer::spawn();
+    test_observer::register(&mut conf, &[EventKeyType::AnyEvent]);
+
+    let mut btcd_controller = BitcoinCoreController::new(conf.clone());
+    btcd_controller
+        .start_bitcoind()
+        .expect("Failed starting bitcoind");
+    let mut btc_regtest_controller = BitcoinRegtestController::new(conf.clone(), None);
+    btc_regtest_controller.bootstrap_chain(201);
+
+    let mut run_loop = boot_nakamoto::BootRunLoop::new(conf.clone()).unwrap();
+    let run_loop_stopper = run_loop.get_termination_switch();
+    let Counters {
+        blocks_processed,
+        naka_submitted_commits: commits_submitted,
+        naka_proposed_blocks: proposals_submitted,
+        ..
+    } = run_loop.counters();
+
+    let coord_channel = run_loop.coordinator_channels();
+
+    let run_loop_thread = thread::spawn(move || run_loop.start(None, 0));
+    let mut signers = TestSigners::new(vec![signer_sk]);
+    wait_for_runloop(&blocks_processed);
+    boot_to_epoch_3(
+        &conf,
+        &blocks_processed,
+        &[stacker_sk],
+        &[signer_sk],
+        &mut Some(&mut signers),
+        &mut btc_regtest_controller,
+    );
+
+    info!("------------------------- Reached Epoch 3.0 -------------------------");
+
+    blind_signer(&conf, &signers, proposals_submitted);
+
+    wait_for_first_naka_block_commit(60, &commits_submitted);
+
+    let burnchain = conf.get_burnchain();
+    let sortdb = burnchain.open_sortition_db(true).unwrap();
+
+    let tip = SortitionDB::get_canonical_burn_chain_tip(sortdb.conn()).unwrap();
+    let expected_consensus_hash = format!("0x{}", tip.consensus_hash);
+
+    let burn_blocks = test_observer::get_burn_blocks();
+    let burn_block = burn_blocks.last().unwrap();
+    assert_eq!(
+        burn_block.get("consensus_hash").unwrap().as_str().unwrap(),
+        expected_consensus_hash
+    );
+
+    let stacks_blocks = test_observer::get_blocks();
+    for block in stacks_blocks.iter() {
+        if block.get("block_height").unwrap().as_u64().unwrap() == tip.stacks_block_height {
+            assert_eq!(
+                block.get("consensus_hash").unwrap().as_str().unwrap(),
+                expected_consensus_hash
+            );
+        }
+    }
+
+    coord_channel
+        .lock()
+        .expect("Mutex poisoned")
+        .stop_chains_coordinator();
+    run_loop_stopper.store(false, Ordering::SeqCst);
+
+    run_loop_thread.join().unwrap();
+}