Feat/mock signing revamp

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 {
@@ -116,7 +118,9 @@ SignerMessageTypePrefix {
     /// Block Pushed message from miners
     BlockPushed = 2,
     /// Mock Signature message from Epoch 2.5 signers
-    MockSignature = 3
+    MockSignature = 3,
+    /// Mock Pre-Nakamoto message from Epoch 2.5 miners
+    MockMinerMessage = 4
 });
 
 #[cfg_attr(test, mutants::skip)]
@@ -160,6 +164,7 @@ impl From<&SignerMessage> for SignerMessageTypePrefix {
             SignerMessage::BlockResponse(_) => SignerMessageTypePrefix::BlockResponse,
             SignerMessage::BlockPushed(_) => SignerMessageTypePrefix::BlockPushed,
             SignerMessage::MockSignature(_) => SignerMessageTypePrefix::MockSignature,
+            SignerMessage::MockMinerMessage(_) => SignerMessageTypePrefix::MockMinerMessage,
         }
     }
 }
@@ -175,6 +180,8 @@ pub enum SignerMessage {
     BlockPushed(NakamotoBlock),
     /// A mock signature from the epoch 2.5 signers
     MockSignature(MockSignature),
+    /// A mock message from the epoch 2.5 miners
+    MockMinerMessage(MockMinerMessage),
 }
 
 impl SignerMessage {
@@ -184,7 +191,7 @@ impl SignerMessage {
     #[cfg_attr(test, mutants::skip)]
     pub fn msg_id(&self) -> Option<MessageSlotID> {
         match self {
-            Self::BlockProposal(_) | Self::BlockPushed(_) => None,
+            Self::BlockProposal(_) | Self::BlockPushed(_) | Self::MockMinerMessage(_) => None,
             Self::BlockResponse(_) => Some(MessageSlotID::BlockResponse),
             Self::MockSignature(_) => Some(MessageSlotID::MockSignature),
         }
@@ -201,6 +208,7 @@ impl StacksMessageCodec for SignerMessage {
             SignerMessage::BlockResponse(block_response) => block_response.consensus_serialize(fd),
             SignerMessage::BlockPushed(block) => block.consensus_serialize(fd),
             SignerMessage::MockSignature(signature) => signature.consensus_serialize(fd),
+            SignerMessage::MockMinerMessage(message) => message.consensus_serialize(fd),
         }?;
         Ok(())
     }
@@ -226,6 +234,10 @@ impl StacksMessageCodec for SignerMessage {
                 let signature = StacksMessageCodec::consensus_deserialize(fd)?;
                 SignerMessage::MockSignature(signature)
             }
+            SignerMessageTypePrefix::MockMinerMessage => {
+                let message = StacksMessageCodec::consensus_deserialize(fd)?;
+                SignerMessage::MockMinerMessage(message)
+            }
         };
         Ok(message)
     }
@@ -441,6 +453,43 @@ impl StacksMessageCodec for MockSignature {
     }
 }
 
+/// A mock message for the stacks node to be used for mock mining messages
+/// This is only used by Epoch 2.5 miners to simulate miners responding to mock signatures
+#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+pub struct MockMinerMessage {
+    /// The view of the stacks node peer information at the time of the mock signature
+    pub peer_info: PeerInfo,
+    /// The burn block height of the miner's tenure
+    pub tenure_burn_block_height: u64,
+    /// The chain id for the mock signature
+    pub chain_id: u32,
+    /// The mock signatures that the miner received
+    pub mock_signatures: Vec<MockSignature>,
+}
+
+impl StacksMessageCodec for MockMinerMessage {
+    fn consensus_serialize<W: Write>(&self, fd: &mut W) -> Result<(), CodecError> {
+        self.peer_info.consensus_serialize(fd)?;
+        write_next(fd, &self.tenure_burn_block_height)?;
+        write_next(fd, &self.chain_id)?;
+        write_next(fd, &self.mock_signatures)?;
+        Ok(())
+    }
+
+    fn consensus_deserialize<R: Read>(fd: &mut R) -> Result<Self, CodecError> {
+        let peer_info = PeerInfo::consensus_deserialize(fd)?;
+        let tenure_burn_block_height = read_next::<u64, _>(fd)?;
+        let chain_id = read_next::<u32, _>(fd)?;
+        let mock_signatures = read_next::<Vec<MockSignature>, _>(fd)?;
+        Ok(Self {
+            peer_info,
+            tenure_burn_block_height,
+            chain_id,
+            mock_signatures,
+        })
+    }
+}
+
 define_u8_enum!(
 /// Enum representing the reject code type prefix
 RejectCodeTypePrefix {
@@ -940,4 +989,26 @@ mod test {
             .expect("Failed to deserialize MockSignData");
         assert_eq!(sign_data, deserialized_data);
     }
+
+    #[test]
+    fn serde_mock_miner_message() {
+        let mock_signature_1 = MockSignature {
+            signature: MessageSignature::empty(),
+            sign_data: random_mock_sign_data(),
+        };
+        let mock_signature_2 = MockSignature {
+            signature: MessageSignature::empty(),
+            sign_data: random_mock_sign_data(),
+        };
+        let mock_miner_message = MockMinerMessage {
+            peer_info: random_peer_data(),
+            tenure_burn_block_height: thread_rng().next_u64(),
+            chain_id: thread_rng().gen_range(0..=1),
+            mock_signatures: vec![mock_signature_1, mock_signature_2],
+        };
+        let serialized_data = mock_miner_message.serialize_to_vec();
+        let deserialized_data = read_next::<MockMinerMessage, _>(&mut &serialized_data[..])
+            .expect("Failed to deserialize MockSignData");
+        assert_eq!(mock_miner_message, deserialized_data);
+    }
 }

stackslib/src/chainstate/nakamoto/mod.rs

@@ -4210,7 +4210,6 @@ impl NakamotoChainState {
                   "stackerdb_slots" => ?stackerdb_config.signers,
                   "queried_sortition" => %election_sortition,
                   "sortition_hashes" => ?miners_info.get_sortitions());
-
             return Ok(None);
         }
         let slot_id_range = signer_ranges.swap_remove(signer_ix);

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/config.rs

@@ -2332,6 +2332,8 @@ pub struct MinerConfig {
     pub max_reorg_depth: u64,
     /// Amount of time while mining in nakamoto to wait for signers to respond to a proposed block
     pub wait_on_signers: Duration,
+    /// Whether to send miner messages in Epoch 2.5 through the .miners contract. This is used for testing.
+    pub pre_nakamoto_miner_messaging: bool,
 }
 
 impl Default for MinerConfig {
@@ -2362,6 +2364,7 @@ impl Default for MinerConfig {
             max_reorg_depth: 3,
             // TODO: update to a sane value based on stackerdb benchmarking
             wait_on_signers: Duration::from_secs(200),
+            pre_nakamoto_miner_messaging: true,
         }
     }
 }
@@ -2693,6 +2696,7 @@ pub struct MinerConfigFile {
     pub filter_origins: Option<String>,
     pub max_reorg_depth: Option<u64>,
     pub wait_on_signers_ms: Option<u64>,
+    pub pre_nakamoto_miner_messaging: Option<bool>,
 }
 
 impl MinerConfigFile {
@@ -2795,6 +2799,7 @@ impl MinerConfigFile {
                 .wait_on_signers_ms
                 .map(Duration::from_millis)
                 .unwrap_or(miner_default_config.wait_on_signers),
+            pre_nakamoto_miner_messaging: self.pre_nakamoto_miner_messaging.unwrap_or(true),
         })
     }
 }

testnet/stacks-node/src/nakamoto_node/sign_coordinator.rs

@@ -774,6 +774,10 @@ impl SignCoordinator {
                         debug!("Received mock signature message. Ignoring.");
                         continue;
                     }
+                    SignerMessageV0::MockMinerMessage(_) => {
+                        debug!("Received mock miner message. Ignoring.");
+                        continue;
+                    }
                 };
                 let block_sighash = block.header.signer_signature_hash();
                 if block_sighash != response_hash {