Merge branch 'develop' into test/btc-reorgs

Author: kantai

libsigner/src/events.rs

@@ -393,7 +393,6 @@ fn process_stackerdb_event<T: SignerEventTrait>(
     local_addr: Option<SocketAddr>,
     mut request: HttpRequest,
 ) -> Result<SignerEvent<T>, EventError> {
-    debug!("Got stackerdb_chunks event");
     let mut body = String::new();
     if let Err(e) = request.as_reader().read_to_string(&mut body) {
         error!("Failed to read body: {:?}", &e);
@@ -404,6 +403,7 @@ fn process_stackerdb_event<T: SignerEventTrait>(
         )));
     }
 
+    debug!("Got stackerdb_chunks event"; "chunks_event_body" => %body);
     let event: StackerDBChunksEvent = serde_json::from_slice(body.as_bytes())
         .map_err(|e| EventError::Deserialize(format!("Could not decode body to JSON: {:?}", &e)))?;
 

stacks-common/src/deps_common/httparse/mod.rs

@@ -1280,7 +1280,6 @@ mod tests {
         );
     }
 
-    #[cfg(feature = "std")]
     #[test]
     fn test_std_error() {
         use std::error::Error as StdError;

stacks-signer/src/chainstate.rs

@@ -438,7 +438,7 @@ impl SortitionsView {
             Ok(true)
         } else {
             warn!(
-                "Miner block proposal's tenure change transaction does not confirm as many blocks as we expect in the parent tenure";
+                "Miner's block proposal does not confirm as many blocks as we expect";
                 "proposed_block_consensus_hash" => %block.header.consensus_hash,
                 "proposed_block_signer_sighash" => %block.header.signer_signature_hash(),
                 "proposed_chain_length" => block.header.chain_length,

stacks-signer/src/signerdb.rs

@@ -34,6 +34,53 @@ use stacks_common::util::hash::Sha512Trunc256Sum;
 use stacks_common::{debug, error};
 use wsts::net::NonceRequest;
 
+#[derive(Serialize, Deserialize, Debug, PartialEq, Default)]
+/// Information specific to Signer V1
+pub struct BlockInfoV1 {
+    /// The associated packet nonce request if we have one
+    pub nonce_request: Option<NonceRequest>,
+}
+
+impl From<NonceRequest> for BlockInfoV1 {
+    fn from(value: NonceRequest) -> Self {
+        Self {
+            nonce_request: Some(value),
+        }
+    }
+}
+
+#[derive(Serialize, Deserialize, Debug, PartialEq, Default)]
+/// Store extra version-specific info in `BlockInfo`
+pub enum ExtraBlockInfo {
+    #[default]
+    /// Don't know what version
+    None,
+    /// Extra data for Signer V0
+    V0,
+    /// Extra data for Signer V1
+    V1(BlockInfoV1),
+}
+
+impl ExtraBlockInfo {
+    /// Take `nonce_request` if it exists
+    pub fn take_nonce_request(&mut self) -> Option<NonceRequest> {
+        match self {
+            ExtraBlockInfo::None | ExtraBlockInfo::V0 => None,
+            ExtraBlockInfo::V1(v1) => v1.nonce_request.take(),
+        }
+    }
+    /// Set `nonce_request` if it exists
+    pub fn set_nonce_request(&mut self, value: NonceRequest) -> Result<(), &str> {
+        match self {
+            ExtraBlockInfo::None | ExtraBlockInfo::V0 => Err("Field doesn't exist"),
+            ExtraBlockInfo::V1(v1) => {
+                v1.nonce_request = Some(value);
+                Ok(())
+            }
+        }
+    }
+}
+
 /// Additional Info about a proposed block
 #[derive(Serialize, Deserialize, Debug, PartialEq)]
 pub struct BlockInfo {
@@ -47,8 +94,6 @@ pub struct BlockInfo {
     pub vote: Option<NakamotoBlockVote>,
     /// Whether the block contents are valid
     pub valid: Option<bool>,
-    /// The associated packet nonce request if we have one
-    pub nonce_request: Option<NonceRequest>,
     /// Whether this block is already being signed over
     pub signed_over: bool,
     /// Time at which the proposal was received by this signer (epoch time in seconds)
@@ -57,6 +102,8 @@ pub struct BlockInfo {
     pub signed_self: Option<u64>,
     /// Time at which the proposal was signed by a threshold in the signer set (epoch time in seconds)
     pub signed_group: Option<u64>,
+    /// Extra data specific to v0, v1, etc.
+    pub ext: ExtraBlockInfo,
 }
 
 impl From<BlockProposal> for BlockInfo {
@@ -67,19 +114,19 @@ impl From<BlockProposal> for BlockInfo {
             reward_cycle: value.reward_cycle,
             vote: None,
             valid: None,
-            nonce_request: None,
             signed_over: false,
             proposed_time: get_epoch_time_secs(),
             signed_self: None,
             signed_group: None,
+            ext: ExtraBlockInfo::default(),
         }
     }
 }
 impl BlockInfo {
     /// Create a new BlockInfo with an associated nonce request packet
-    pub fn new_with_request(block_proposal: BlockProposal, nonce_request: NonceRequest) -> Self {
+    pub fn new_v1_with_request(block_proposal: BlockProposal, nonce_request: NonceRequest) -> Self {
         let mut block_info = BlockInfo::from(block_proposal);
-        block_info.nonce_request = Some(nonce_request);
+        block_info.ext = ExtraBlockInfo::V1(BlockInfoV1::from(nonce_request));
         block_info.signed_over = true;
         block_info
     }
@@ -89,9 +136,7 @@ impl BlockInfo {
     pub fn mark_signed_and_valid(&mut self) {
         self.valid = Some(true);
         self.signed_over = true;
-        if self.signed_self.is_none() {
-            self.signed_self = Some(get_epoch_time_secs());
-        }
+        self.signed_self.get_or_insert(get_epoch_time_secs());
     }
 
     /// Return the block's signer signature hash
@@ -115,7 +160,7 @@ CREATE TABLE IF NOT EXISTS blocks (
     block_info TEXT NOT NULL,
     consensus_hash TEXT NOT NULL,
     signed_over INTEGER NOT NULL,
-    stacks_height INTEGER NOT NULL, 
+    stacks_height INTEGER NOT NULL,
     burn_block_height INTEGER NOT NULL,
     PRIMARY KEY (reward_cycle, signer_signature_hash)
 ) STRICT";
@@ -189,7 +234,7 @@ impl SignerDb {
             })
             .optional();
         match result {
-            Ok(x) => Ok(x.unwrap_or_else(|| 0)),
+            Ok(x) => Ok(x.unwrap_or(0)),
             Err(e) => Err(DBError::from(e)),
         }
     }

stacks-signer/src/v1/signer.rs

@@ -692,7 +692,7 @@ impl Signer {
                 block_info
             }
         };
-        if let Some(mut nonce_request) = block_info.nonce_request.take() {
+        if let Some(mut nonce_request) = block_info.ext.take_nonce_request() {
             debug!("{self}: Received a block validate response from the stacks node for a block we already received a nonce request for. Responding to the nonce request...");
             // We have received validation from the stacks node. Determine our vote and update the request message
             self.determine_vote(&mut block_info, &mut nonce_request);
@@ -916,7 +916,7 @@ impl Signer {
                 "{self}: received a nonce request for a new block. Submit block for validation. ";
                 "signer_sighash" => %signer_signature_hash,
             );
-            let block_info = BlockInfo::new_with_request(block_proposal, nonce_request.clone());
+            let block_info = BlockInfo::new_v1_with_request(block_proposal, nonce_request.clone());
             stacks_client
                 .submit_block_for_validation(block_info.block.clone())
                 .unwrap_or_else(|e| {
@@ -928,7 +928,12 @@ impl Signer {
         if block_info.valid.is_none() {
             // We have not yet received validation from the stacks node. Cache the request and wait for validation
             debug!("{self}: We have yet to receive validation from the stacks node for a nonce request. Cache the nonce request and wait for block validation...");
-            block_info.nonce_request = Some(nonce_request.clone());
+            block_info
+                .ext
+                .set_nonce_request(nonce_request.clone())
+                .unwrap_or_else(|e| {
+                    warn!("{self}: Failed to set nonce_request: {e:?}",);
+                });
             return Some(block_info);
         }
 

stackslib/src/chainstate/burn/operations/mod.rs

@@ -249,6 +249,7 @@ pub struct LeaderBlockCommitOp {
     /// of the PoX addresses active during the block commit.
     ///
     /// This value is set by the check() call, not during parsing.
+    #[serde(default = "default_treatment")]
     pub treatment: Vec<Treatment>,
 
     // PoX sunset burn
@@ -261,6 +262,10 @@ pub struct LeaderBlockCommitOp {
     pub burn_header_hash: BurnchainHeaderHash, // hash of the burn chain block header
 }
 
+fn default_treatment() -> Vec<Treatment> {
+    Vec::new()
+}
+
 #[derive(Debug, PartialEq, Clone, Eq, Serialize, Deserialize)]
 pub struct LeaderKeyRegisterOp {
     pub consensus_hash: ConsensusHash, // consensus hash at time of issuance

testnet/stacks-node/src/event_dispatcher.rs

@@ -296,6 +296,9 @@ impl RewardSetEventPayload {
 
 impl EventObserver {
     pub fn send_payload(&self, payload: &serde_json::Value, path: &str) {
+        debug!(
+            "Event dispatcher: Sending payload"; "url" => %path, "payload" => ?payload
+        );
         let body = match serde_json::to_vec(&payload) {
             Ok(body) => body,
             Err(err) => {

testnet/stacks-node/src/nakamoto_node.rs

@@ -14,9 +14,10 @@
 // You should have received a copy of the GNU General Public License
 // along with this program.  If not, see <http://www.gnu.org/licenses/>.
 use std::collections::HashSet;
+use std::io::Write;
 use std::sync::mpsc::Receiver;
-use std::thread;
 use std::thread::JoinHandle;
+use std::{fs, thread};
 
 use stacks::burnchains::{BurnchainSigner, Txid};
 use stacks::chainstate::burn::db::sortdb::SortitionDB;
@@ -277,6 +278,7 @@ impl StacksNode {
     /// Called from the main thread.
     pub fn process_burnchain_state(
         &mut self,
+        config: &Config,
         sortdb: &SortitionDB,
         sort_id: &SortitionId,
         ibd: bool,
@@ -316,9 +318,18 @@ impl StacksNode {
 
         let num_key_registers = key_registers.len();
 
-        self.globals
+        let activated_key_opt = self
+            .globals
             .try_activate_leader_key_registration(block_height, key_registers);
 
+        // save the registered VRF key
+        if let (Some(activated_key), Some(path)) = (
+            activated_key_opt,
+            config.miner.activated_vrf_key_path.as_ref(),
+        ) {
+            save_activated_vrf_key(path, &activated_key);
+        }
+
         debug!(
             "Processed burnchain state";
             "burn_height" => block_height,
@@ -339,3 +350,27 @@ impl StacksNode {
         self.p2p_thread_handle.join().unwrap();
     }
 }
+
+pub(crate) fn save_activated_vrf_key(path: &str, activated_key: &RegisteredKey) {
+    info!("Activated VRF key; saving to {}", path);
+
+    let Ok(key_json) = serde_json::to_string(&activated_key) else {
+        warn!("Failed to serialize VRF key");
+        return;
+    };
+
+    let mut f = match fs::File::create(&path) {
+        Ok(f) => f,
+        Err(e) => {
+            warn!("Failed to create {}: {:?}", &path, &e);
+            return;
+        }
+    };
+
+    if let Err(e) = f.write_all(key_json.as_str().as_bytes()) {
+        warn!("Failed to write activated VRF key to {}: {:?}", &path, &e);
+        return;
+    }
+
+    info!("Saved activated VRF key to {}", &path);
+}