Merge pull request #5070 from stacks-network/feat/mock-signature-aggregation

Feat/mock signing revamp

Author: jferrant

libsigner/src/v0/messages.rs

@@ -18,13 +18,12 @@ use std::sync::mpsc::Sender;
 
 use blockstack_lib::chainstate::nakamoto::NakamotoBlockHeader;
 use blockstack_lib::net::api::postblock_proposal::BlockValidateResponse;
-use clarity::consts::{CHAIN_ID_MAINNET, CHAIN_ID_TESTNET};
 use clarity::types::chainstate::StacksPrivateKey;
 use clarity::types::{PrivateKey, StacksEpochId};
 use clarity::util::hash::MerkleHashFunc;
 use clarity::util::secp256k1::Secp256k1PublicKey;
 use libsigner::v0::messages::{
-    BlockResponse, MessageSlotID, MockSignature, RejectCode, SignerMessage,
+    BlockResponse, MessageSlotID, MockProposal, MockSignature, RejectCode, SignerMessage,
 };
 use libsigner::{BlockProposal, SignerEvent};
 use slog::{slog_debug, slog_error, slog_info, slog_warn};
@@ -159,6 +158,25 @@ impl SignerTrait<SignerMessage> for Signer {
                                 "push_result" => ?block_push_result,
                             );
                         }
+                        SignerMessage::MockProposal(mock_proposal) => {
+                            let epoch = match stacks_client.get_node_epoch() {
+                                Ok(epoch) => epoch,
+                                Err(e) => {
+                                    warn!("{self}: Failed to determine node epoch. Cannot mock sign: {e}");
+                                    return;
+                                }
+                            };
+                            info!("{self}: received a mock block proposal.";
+                                "current_reward_cycle" => current_reward_cycle,
+                                "epoch" => ?epoch
+                            );
+                            if epoch == StacksEpochId::Epoch25
+                                && self.reward_cycle == current_reward_cycle
+                            {
+                                // We are in epoch 2.5, so we should mock sign to prove we are still alive.
+                                self.mock_sign(mock_proposal.clone());
+                            }
+                        }
                         _ => {}
                     }
                 }
@@ -184,22 +202,6 @@ impl SignerTrait<SignerMessage> for Signer {
                     );
                 }
                 *sortition_state = None;
-                let epoch = match stacks_client.get_node_epoch() {
-                    Ok(epoch) => epoch,
-                    Err(e) => {
-                        warn!("{self}: Failed to determine node epoch. Cannot mock sign: {e}");
-                        return;
-                    }
-                };
-                debug!("{self}: Epoch 2.5 signer received a new burn block event.";
-                    "burn_height" => burn_height,
-                    "current_reward_cycle" => current_reward_cycle,
-                    "epoch" => ?epoch
-                );
-                if epoch == StacksEpochId::Epoch25 && self.reward_cycle == current_reward_cycle {
-                    // We are in epoch 2.5, so we should mock mine to prove we are still alive.
-                    self.mock_sign(*burn_height, stacks_client);
-                }
             }
         }
     }
@@ -720,26 +722,9 @@ impl Signer {
     }
 
     /// Send a mock signature to stackerdb to prove we are still alive
-    fn mock_sign(&mut self, burn_block_height: u64, stacks_client: &StacksClient) {
-        let Ok(peer_info) = stacks_client.get_peer_info() else {
-            warn!("{self}: Failed to get peer info. Cannot mock sign.");
-            return;
-        };
-        let chain_id = if self.mainnet {
-            CHAIN_ID_MAINNET
-        } else {
-            CHAIN_ID_TESTNET
-        };
-        info!("Mock signing for burn block {burn_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" => chain_id
-        );
-        let mock_signature =
-            MockSignature::new(burn_block_height, peer_info, chain_id, &self.private_key);
+    fn mock_sign(&mut self, mock_proposal: MockProposal) {
+        info!("{self}: Mock signing mock proposal: {mock_proposal:?}");
+        let mock_signature = MockSignature::new(mock_proposal, &self.private_key);
         let message = SignerMessage::MockSignature(mock_signature);
         if let Err(e) = self
             .stackerdb

stacks-signer/src/v0/signer.rs

@@ -4191,7 +4191,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/chainstate/nakamoto/mod.rs

@@ -1168,6 +1168,10 @@ impl Config {
             .validate()
             .map_err(|e| format!("Atlas config error: {e}"))?;
 
+        if miner.mining_key.is_none() && miner.pre_nakamoto_mock_signing {
+            return Err("Cannot use pre_nakamoto_mock_signing without a mining_key".to_string());
+        }
+
         Ok(Config {
             config_path: config_file.__path,
             node,
@@ -2352,6 +2356,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 mock sign in Epoch 2.5 through the .miners and .signers contracts. This is used for testing purposes in Epoch 2.5 only.
+    pub pre_nakamoto_mock_signing: bool,
 }
 
 impl Default for MinerConfig {
@@ -2382,6 +2388,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_mock_signing: false, // Should only default true if mining key is set
         }
     }
 }
@@ -2731,10 +2738,17 @@ pub struct MinerConfigFile {
     pub filter_origins: Option<String>,
     pub max_reorg_depth: Option<u64>,
     pub wait_on_signers_ms: Option<u64>,
+    pub pre_nakamoto_mock_signing: Option<bool>,
 }
 
 impl MinerConfigFile {
     fn into_config_default(self, miner_default_config: MinerConfig) -> Result<MinerConfig, String> {
+        let mining_key = self
+            .mining_key
+            .as_ref()
+            .map(|x| Secp256k1PrivateKey::from_hex(x))
+            .transpose()?;
+        let pre_nakamoto_mock_signing = mining_key.is_some();
         Ok(MinerConfig {
             first_attempt_time_ms: self
                 .first_attempt_time_ms
@@ -2833,6 +2847,9 @@ impl MinerConfigFile {
                 .wait_on_signers_ms
                 .map(Duration::from_millis)
                 .unwrap_or(miner_default_config.wait_on_signers),
+            pre_nakamoto_mock_signing: self
+                .pre_nakamoto_mock_signing
+                .unwrap_or(pre_nakamoto_mock_signing), // Should only default true if mining key is set
         })
     }
 }

testnet/stacks-node/src/config.rs

@@ -860,8 +860,10 @@ impl SignCoordinator {
                         debug!("Received block pushed message. Ignoring.");
                         continue;
                     }
-                    SignerMessageV0::MockSignature(_) => {
-                        debug!("Received mock signature message. Ignoring.");
+                    SignerMessageV0::MockSignature(_)
+                    | SignerMessageV0::MockProposal(_)
+                    | SignerMessageV0::MockBlock(_) => {
+                        debug!("Received mock message. Ignoring.");
                         continue;
                     }
                 };