WIP: missing stackerdb messages

Signed-off-by: Jacinta Ferrant <[email protected]>

Author: jferrant

libsigner/src/v0/messages.rs

@@ -88,7 +88,9 @@ MinerSlotID {
     /// Block proposal from the miner
     BlockProposal = 0,
     /// Block pushed from the miner
-    BlockPushed = 1
+    BlockPushed = 1,
+    /// Mock Miner Message from the miner
+    MockMinerMessage = 2
 });
 
 impl MessageSlotIDTrait for MessageSlotID {

stackslib/src/net/stackerdb/mod.rs

@@ -152,7 +152,7 @@ pub const STACKERDB_MAX_PAGE_COUNT: u32 = 2;
 
 pub const STACKERDB_SLOTS_FUNCTION: &str = "stackerdb-get-signer-slots";
 pub const STACKERDB_CONFIG_FUNCTION: &str = "stackerdb-get-config";
-pub const MINER_SLOT_COUNT: u32 = 2;
+pub const MINER_SLOT_COUNT: u32 = 3;
 
 /// Final result of synchronizing state with a remote set of DB replicas
 #[derive(Clone)]

testnet/stacks-node/src/neon_node.rs

@@ -2288,11 +2288,8 @@ impl BlockMinerThread {
         let miner_contract_id = boot_code_id(MINERS_NAME, self.config.is_mainnet());
         let mut miners_stackerdb =
             StackerDBSession::new(&self.config.node.rpc_bind, miner_contract_id);
-        let slot_id = MinerSlotID::BlockProposal.to_u8().into();
-        if let Ok(messages) =
-            miners_stackerdb.get_latest_chunks(&[slot_id, slot_id * MINER_SLOT_COUNT])
-        {
-            debug!("Miner got messages: {:?}", messages.len());
+        let miner_slot_ids: Vec<_> = (0..MINER_SLOT_COUNT * 2).collect();
+        if let Ok(messages) = miners_stackerdb.get_latest_chunks(&miner_slot_ids) {
             for message in messages {
                 if let Some(message) = message {
                     if message.is_empty() {
@@ -2303,7 +2300,7 @@ impl BlockMinerThread {
                     else {
                         continue;
                     };
-                    if miner_message.peer_info.burn_block_height == self.burn_block.block_height {
+                    if miner_message.tenure_burn_block_height == self.burn_block.block_height {
                         debug!(
                             "Already sent mock miner message for tenure burn block height {:?}",
                             self.burn_block.block_height
@@ -2368,29 +2365,30 @@ impl BlockMinerThread {
             server_version,
         };
 
-        info!("Sending mock miner message in response to mock signatures for burn block {:?}", &self.burn_block.block_height;
-            "stacks_tip_consensus_hash" => ?peer_info.stacks_tip_consensus_hash.clone(),
-            "stacks_tip" => ?peer_info.stacks_tip.clone(),
-            "peer_burn_block_height" => peer_info.burn_block_height,
-            "pox_consensus" => ?peer_info.pox_consensus.clone(),
-            "server_version" => peer_info.server_version.clone(),
-            "chain_id" => self.config.burnchain.chain_id,
-            "num_mock_signatures" => mock_signatures.len(),
-        );
         let message = MockMinerMessage {
             peer_info,
             chain_id: self.config.burnchain.chain_id,
             mock_signatures,
             tenure_burn_block_height: self.burn_block.block_height,
         };
 
+        info!("Sending mock miner message in response to mock signatures for burn block {:?}", message.tenure_burn_block_height;
+            "stacks_tip_consensus_hash" => ?message.peer_info.stacks_tip_consensus_hash.clone(),
+            "stacks_tip" => ?message.peer_info.stacks_tip.clone(),
+            "peer_burn_block_height" => message.peer_info.burn_block_height,
+            "pox_consensus" => ?message.peer_info.pox_consensus.clone(),
+            "server_version" => message.peer_info.server_version.clone(),
+            "chain_id" => message.chain_id,
+            "num_mock_signatures" => message.mock_signatures.len(),
+        );
+
         if let Err(e) = SignCoordinator::send_miners_message(
             &miner_config.mining_key.expect("BUG: no mining key"),
             &burn_db,
             &self.burn_block,
             &stackerdbs,
-            SignerMessage::MockMinerMessage(message),
-            MinerSlotID::BlockProposal, // We are sending a mock miner message NOT a block proposal, but since we do not propose blocks in epoch 2.5, it is fine
+            SignerMessage::MockMinerMessage(message.clone()),
+            MinerSlotID::MockMinerMessage,
             self.config.is_mainnet(),
             &mut miners_stackerdb,
             &self.burn_block.consensus_hash,

testnet/stacks-node/src/tests/signer/v0.rs

@@ -23,7 +23,7 @@ use std::{env, thread};
 use clarity::vm::types::PrincipalData;
 use clarity::vm::StacksEpoch;
 use libsigner::v0::messages::{
-    BlockRejection, BlockResponse, MessageSlotID, MinerSlotID, RejectCode, SignerMessage,
+    BlockRejection, BlockResponse, MessageSlotID, RejectCode, SignerMessage,
 };
 use libsigner::{BlockProposal, SignerSession, StackerDBSession};
 use rand::RngCore;
@@ -2408,6 +2408,7 @@ fn mock_miner_message_epoch_25() {
         .unwrap();
     let epoch_3 = &epochs[StacksEpoch::find_epoch_by_id(&epochs, StacksEpochId::Epoch30).unwrap()];
     let epoch_3_start_height = epoch_3.start_height;
+    debug!("Epoch 3.0 starts at height {}", epoch_3_start_height);
 
     signer_test.boot_to_epoch_25_reward_cycle();
 
@@ -2447,20 +2448,22 @@ fn mock_miner_message_epoch_25() {
                 })
                 .flatten()
             {
-                if chunk.slot_id == MinerSlotID::BlockProposal.to_u8() as u32 {
-                    if chunk.data.is_empty() {
-                        continue;
-                    }
-                    let SignerMessage::MockMinerMessage(message) =
-                        SignerMessage::consensus_deserialize(&mut chunk.data.as_slice())
-                            .expect("Failed to deserialize MockMinerMessage")
-                    else {
-                        continue;
-                    };
-                    if message.peer_info.burn_block_height == current_burn_block_height {
-                        mock_miner_message = Some(message);
-                        break;
-                    }
+                if chunk.data.is_empty() {
+                    continue;
+                }
+                let SignerMessage::MockMinerMessage(message) =
+                    SignerMessage::consensus_deserialize(&mut chunk.data.as_slice())
+                        .expect("Failed to deserialize SignerMessage")
+                else {
+                    continue;
+                };
+                if message.tenure_burn_block_height == current_burn_block_height {
+                    mock_miner_message = Some(message);
+                    break;
+                } else {
+                    info!(
+                            "Received MockMinerMessage for burn block height {} but expected {current_burn_block_height}", message.tenure_burn_block_height
+                        );
                 }
             }
             assert!(