Merge branch 'develop' of https://github.com/stacks-network/stacks-core into feature/timed-out-block-proposal-handling

Author: jferrant

.github/workflows/bitcoin-tests.yml

@@ -90,13 +90,15 @@ jobs:
           - tests::signer::v0::forked_tenure_okay
           - tests::signer::v0::forked_tenure_invalid
           - tests::signer::v0::empty_sortition
+          - tests::signer::v0::bitcoind_forking_test
           - tests::nakamoto_integrations::stack_stx_burn_op_integration_test
           - tests::nakamoto_integrations::check_block_heights
           - tests::nakamoto_integrations::clarity_burn_state
           - tests::nakamoto_integrations::check_block_times
           - tests::nakamoto_integrations::check_block_info
           - tests::nakamoto_integrations::check_block_info_rewards
           - tests::nakamoto_integrations::continue_tenure_extend
+          - tests::nakamoto_integrations::multiple_miners
           # Do not run this one until we figure out why it fails in CI
           # - tests::neon_integrations::bitcoin_reorg_flap
           # - tests::neon_integrations::bitcoin_reorg_flap_with_follower

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

@@ -485,7 +485,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/cli.rs

@@ -29,6 +29,7 @@ use clarity::util::hash::Sha256Sum;
 use clarity::util::secp256k1::MessageSignature;
 use clarity::vm::types::{QualifiedContractIdentifier, TupleData};
 use clarity::vm::Value;
+use lazy_static::lazy_static;
 use serde::{Deserialize, Serialize};
 use stacks_common::address::{
     b58, AddressHashMode, C32_ADDRESS_VERSION_MAINNET_MULTISIG,
@@ -40,8 +41,34 @@ use stacks_common::types::chainstate::StacksPrivateKey;
 
 extern crate alloc;
 
+const GIT_BRANCH: Option<&'static str> = option_env!("GIT_BRANCH");
+const GIT_COMMIT: Option<&'static str> = option_env!("GIT_COMMIT");
+#[cfg(debug_assertions)]
+const BUILD_TYPE: &'static str = "debug";
+#[cfg(not(debug_assertions))]
+const BUILD_TYPE: &'static str = "release";
+
+lazy_static! {
+    static ref VERSION_STRING: String = {
+        let pkg_version = option_env!("STACKS_NODE_VERSION").unwrap_or(env!("CARGO_PKG_VERSION"));
+        let git_branch = GIT_BRANCH.unwrap_or("");
+        let git_commit = GIT_COMMIT.unwrap_or("");
+        format!(
+            "{} ({}:{}, {} build, {} [{}])",
+            pkg_version,
+            git_branch,
+            git_commit,
+            BUILD_TYPE,
+            std::env::consts::OS,
+            std::env::consts::ARCH
+        )
+    };
+}
+
 #[derive(Parser, Debug)]
 #[command(author, version, about)]
+#[command(long_version = VERSION_STRING.as_str())]
+
 /// The CLI arguments for the stacks signer
 pub struct Cli {
     /// Subcommand action to take

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";

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