Merge branch 'develop' into chore/document-node-config

Author: Jiloc

CHANGELOG.md

@@ -5,6 +5,11 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to the versioning scheme outlined in the [README.md](README.md).
 
+## [Unreleased]
+
+### Added
+- Persisted tracking of StackerDB slot versions for mining. This improves miner p2p performance.
+
 ## [3.1.0.0.9]
 
 ### Added
@@ -13,6 +18,8 @@ and this project adheres to the versioning scheme outlined in the [README.md](RE
 - Added new `ValidateRejectCode` values to the `/v3/block_proposal` endpoint
 - Added `StateMachineUpdateContent::V1` to support a vector of `StacksTransaction` expected to be replayed in subsequent Stacks blocks
 - Include a reason string in the transaction receipt when a transaction is rolled back due to a post-condition. This should help users in understanding what went wrong.
+- Updated `StackerDBListener` to monitor signer state machine updates and store signer global state information, enabling miners to perform transaction replays.
+- Added a testnet `replay_transactions` flag to the miner configuration to feature-gate transaction replay. When enabled, the miner will construct a replay block if a threshold of signers signals that a transaction set requires replay.
 
 ### Changed
 

clarity/src/vm/analysis/mod.rs

@@ -34,13 +34,16 @@ use self::trait_checker::TraitChecker;
 use self::type_checker::v2_05::TypeChecker as TypeChecker2_05;
 use self::type_checker::v2_1::TypeChecker as TypeChecker2_1;
 pub use self::types::{AnalysisPass, ContractAnalysis};
+#[cfg(feature = "rusqlite")]
 use crate::vm::ast::{build_ast_with_rules, ASTRules};
 use crate::vm::costs::LimitedCostTracker;
 #[cfg(feature = "rusqlite")]
 use crate::vm::database::MemoryBackingStore;
 use crate::vm::database::STORE_CONTRACT_SRC_INTERFACE;
 use crate::vm::representations::SymbolicExpression;
-use crate::vm::types::{QualifiedContractIdentifier, TypeSignature};
+use crate::vm::types::QualifiedContractIdentifier;
+#[cfg(feature = "rusqlite")]
+use crate::vm::types::TypeSignature;
 use crate::vm::ClarityVersion;
 
 /// Used by CLI tools like the docs generator. Not used in production

clarity/src/vm/docs/contracts.rs

@@ -4,13 +4,10 @@ use hashbrown::{HashMap, HashSet};
 use stacks_common::consts::CHAIN_ID_TESTNET;
 use stacks_common::types::StacksEpochId;
 
-#[cfg(feature = "rusqlite")]
-use crate::vm::analysis::mem_type_check;
-use crate::vm::analysis::ContractAnalysis;
+use crate::vm::analysis::{mem_type_check, ContractAnalysis};
 use crate::vm::ast::{build_ast_with_rules, ASTRules};
 use crate::vm::contexts::GlobalContext;
 use crate::vm::costs::LimitedCostTracker;
-#[cfg(feature = "rusqlite")]
 use crate::vm::database::MemoryBackingStore;
 use crate::vm::docs::{get_input_type_string, get_output_type_string, get_signature};
 use crate::vm::types::{FunctionType, QualifiedContractIdentifier, Value};
@@ -63,7 +60,6 @@ fn make_func_ref(func_name: &str, func_type: &FunctionType, description: &str) -
     }
 }
 
-#[cfg(feature = "rusqlite")]
 #[allow(clippy::expect_used)]
 fn get_constant_value(var_name: &str, contract_content: &str) -> Value {
     let to_eval = format!("{}\n{}", contract_content, var_name);
@@ -72,7 +68,6 @@ fn get_constant_value(var_name: &str, contract_content: &str) -> Value {
         .expect("BUG: failed to return constant value")
 }
 
-#[cfg(feature = "rusqlite")]
 fn doc_execute(program: &str) -> Result<Option<Value>, vm::Error> {
     let contract_id = QualifiedContractIdentifier::transient();
     let mut contract_context = ContractContext::new(contract_id.clone(), ClarityVersion::Clarity2);
@@ -99,7 +94,6 @@ fn doc_execute(program: &str) -> Result<Option<Value>, vm::Error> {
     })
 }
 
-#[cfg(feature = "rusqlite")]
 #[allow(clippy::expect_used)]
 pub fn make_docs(
     content: &str,
@@ -185,7 +179,6 @@ pub fn make_docs(
 
 /// Produce a set of documents for multiple contracts, supplied as a list of `(contract_name, contract_content)` pairs,
 ///  and a map from `contract_name` to corresponding `ContractSupportDocs`
-#[cfg(feature = "rusqlite")]
 pub fn produce_docs_refs<A: AsRef<str>, B: AsRef<str>>(
     contracts: &[(A, B)],
     support_docs: &HashMap<&str, ContractSupportDocs>,

clarity/src/vm/docs/mod.rs

@@ -23,6 +23,7 @@ use crate::vm::types::{FixedFunction, FunctionType};
 use crate::vm::variables::NativeVariables;
 use crate::vm::ClarityVersion;
 
+#[cfg(feature = "rusqlite")]
 pub mod contracts;
 
 #[derive(Serialize)]

libsigner/src/tests/mod.rs

@@ -1,5 +1,5 @@
 // Copyright (C) 2013-2020 Blockstack PBC, a public benefit corporation
-// Copyright (C) 2020-2023 Stacks Open Internet Foundation
+// Copyright (C) 2020-2025 Stacks Open Internet Foundation
 //
 // This program is free software: you can redistribute it and/or modify
 // it under the terms of the GNU General Public License as published by
@@ -15,6 +15,7 @@
 // along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
 mod http;
+mod signer_state;
 
 use std::fmt::Debug;
 use std::io::{Read, Write};

libsigner/src/tests/signer_state.rs

@@ -0,0 +1,285 @@
+// Copyright (C) 2020-2025 Stacks Open Internet Foundation
+//
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+//
+// 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::HashMap;
+
+use clarity::types::chainstate::{
+    ConsensusHash, StacksAddress, StacksBlockId, StacksPrivateKey, StacksPublicKey,
+};
+use clarity::util::hash::Hash160;
+use clarity::util::secp256k1::MessageSignature;
+
+use crate::v0::messages::{
+    StateMachineUpdate as StateMachineUpdateMessage, StateMachineUpdateContent,
+    StateMachineUpdateMinerState,
+};
+use crate::v0::signer_state::{GlobalStateEvaluator, SignerStateMachine};
+
+fn generate_global_state_evaluator(num_addresses: u32) -> GlobalStateEvaluator {
+    let address_weights = generate_random_address_with_equal_weights(num_addresses);
+    let active_protocol_version = 0;
+    let local_supported_signer_protocol_version = 1;
+
+    let update = StateMachineUpdateMessage::new(
+        active_protocol_version,
+        local_supported_signer_protocol_version,
+        StateMachineUpdateContent::V0 {
+            burn_block: ConsensusHash([0x55; 20]),
+            burn_block_height: 100,
+            current_miner: StateMachineUpdateMinerState::ActiveMiner {
+                current_miner_pkh: Hash160([0xab; 20]),
+                tenure_id: ConsensusHash([0x44; 20]),
+                parent_tenure_id: ConsensusHash([0x22; 20]),
+                parent_tenure_last_block: StacksBlockId([0x33; 32]),
+                parent_tenure_last_block_height: 1,
+            },
+        },
+    )
+    .unwrap();
+
+    let mut address_updates = HashMap::new();
+    for address in address_weights.keys() {
+        address_updates.insert(*address, update.clone());
+    }
+    GlobalStateEvaluator::new(address_updates, address_weights)
+}
+
+fn generate_random_address_with_equal_weights(num_addresses: u32) -> HashMap<StacksAddress, u32> {
+    let mut address_weights = HashMap::new();
+    for _ in 0..num_addresses {
+        let stacks_address = StacksAddress::p2pkh(
+            false,
+            &StacksPublicKey::from_private(&StacksPrivateKey::random()),
+        );
+        address_weights.insert(stacks_address, 10);
+    }
+    address_weights
+}
+
+#[test]
+fn determine_latest_supported_signer_protocol_versions() {
+    let mut global_eval = generate_global_state_evaluator(5);
+
+    let addresses: Vec<_> = global_eval.address_weights.keys().cloned().collect();
+    let local_address = addresses[0];
+
+    let local_update = global_eval
+        .address_updates
+        .get(&local_address)
+        .unwrap()
+        .clone();
+    assert_eq!(
+        global_eval
+            .determine_latest_supported_signer_protocol_version()
+            .unwrap(),
+        local_update.local_supported_signer_protocol_version
+    );
+
+    let StateMachineUpdateMessage {
+        active_signer_protocol_version,
+        local_supported_signer_protocol_version,
+        content:
+            StateMachineUpdateContent::V0 {
+                burn_block,
+                burn_block_height,
+                current_miner,
+            },
+        ..
+    } = local_update.clone()
+    else {
+        panic!("Unexpected state machine update message version");
+    };
+
+    // Let's update 3 signers (60 percent) to support seperate but greater protocol versions
+    for (i, address) in addresses.into_iter().skip(1).take(3).enumerate() {
+        let new_version = local_update.local_supported_signer_protocol_version + i as u64 + 1;
+        let new_update = StateMachineUpdateMessage::new(
+            active_signer_protocol_version,
+            new_version,
+            StateMachineUpdateContent::V0 {
+                burn_block,
+                burn_block_height,
+                current_miner: current_miner.clone(),
+            },
+        )
+        .unwrap();
+        global_eval.insert_update(address, new_update);
+    }
+
+    assert_eq!(
+        global_eval
+            .determine_latest_supported_signer_protocol_version()
+            .unwrap(),
+        local_supported_signer_protocol_version
+    );
+
+    // Let's tip the scales over to version number 2 by updating the local signer's version...
+    // i.e. > 70% will have version 2 or higher in their map
+    let local_update = StateMachineUpdateMessage::new(
+        active_signer_protocol_version,
+        3,
+        StateMachineUpdateContent::V0 {
+            burn_block,
+            burn_block_height,
+            current_miner,
+        },
+    )
+    .unwrap();
+
+    global_eval.insert_update(local_address, local_update);
+
+    assert_eq!(
+        global_eval
+            .determine_latest_supported_signer_protocol_version()
+            .unwrap(),
+        local_supported_signer_protocol_version + 1
+    );
+}
+
+#[test]
+fn determine_global_burn_views() {
+    let mut global_eval = generate_global_state_evaluator(5);
+
+    let addresses: Vec<_> = global_eval.address_weights.keys().cloned().collect();
+    let local_address = addresses[0];
+    let local_update = global_eval
+        .address_updates
+        .get(&local_address)
+        .unwrap()
+        .clone();
+    let StateMachineUpdateMessage {
+        active_signer_protocol_version,
+        local_supported_signer_protocol_version,
+        content:
+            StateMachineUpdateContent::V0 {
+                burn_block,
+                burn_block_height,
+                current_miner,
+            },
+        ..
+    } = local_update.clone()
+    else {
+        panic!("Unexpected state machine update message version");
+    };
+
+    assert_eq!(
+        global_eval.determine_global_burn_view().unwrap(),
+        (burn_block, burn_block_height)
+    );
+
+    // Let's update 3 signers (60 percent) to support a new burn block view
+    let new_update = StateMachineUpdateMessage::new(
+        active_signer_protocol_version,
+        local_supported_signer_protocol_version,
+        StateMachineUpdateContent::V0 {
+            burn_block,
+            burn_block_height: burn_block_height.wrapping_add(1),
+            current_miner: current_miner.clone(),
+        },
+    )
+    .unwrap();
+    for address in addresses.into_iter().skip(1).take(3) {
+        global_eval.insert_update(address, new_update.clone());
+    }
+
+    assert!(
+        global_eval.determine_global_burn_view().is_none(),
+        "We should not have reached agreement on the burn block height"
+    );
+
+    // Let's tip the scales over to burn block height + 1
+    global_eval.insert_update(local_address, new_update);
+    assert_eq!(
+        global_eval.determine_global_burn_view().unwrap(),
+        (burn_block, burn_block_height.wrapping_add(1))
+    );
+}
+
+#[test]
+fn determine_global_states() {
+    let mut global_eval = generate_global_state_evaluator(5);
+
+    let addresses: Vec<_> = global_eval.address_weights.keys().cloned().collect();
+    let local_address = addresses[0];
+    let local_update = global_eval
+        .address_updates
+        .get(&local_address)
+        .unwrap()
+        .clone();
+    let StateMachineUpdateMessage {
+        active_signer_protocol_version,
+        local_supported_signer_protocol_version,
+        content:
+            StateMachineUpdateContent::V0 {
+                burn_block,
+                burn_block_height,
+                current_miner,
+            },
+        ..
+    } = local_update.clone()
+    else {
+        panic!("Unexpected state machine update message version");
+    };
+
+    let state_machine = SignerStateMachine {
+        burn_block,
+        burn_block_height,
+        current_miner: (&current_miner).into(),
+        active_signer_protocol_version: local_supported_signer_protocol_version, // a majority of signers are saying they support version the same local_supported_signer_protocol_version, so update it here...
+        tx_replay_set: None,
+    };
+
+    global_eval.insert_update(local_address, local_update);
+    assert_eq!(global_eval.determine_global_state().unwrap(), state_machine);
+    let new_miner = StateMachineUpdateMinerState::ActiveMiner {
+        current_miner_pkh: Hash160([0x00; 20]),
+        tenure_id: ConsensusHash([0x44; 20]),
+        parent_tenure_id: ConsensusHash([0x22; 20]),
+        parent_tenure_last_block: StacksBlockId([0x33; 32]),
+        parent_tenure_last_block_height: 1,
+    };
+
+    let new_update = StateMachineUpdateMessage::new(
+        active_signer_protocol_version,
+        local_supported_signer_protocol_version,
+        StateMachineUpdateContent::V0 {
+            burn_block,
+            burn_block_height,
+            current_miner: new_miner.clone(),
+        },
+    )
+    .unwrap();
+
+    // Let's update 3 signers to some new miner key (60 percent)
+    for address in addresses.into_iter().skip(1).take(3) {
+        global_eval.insert_update(address, new_update.clone());
+    }
+
+    assert!(
+        global_eval.determine_global_state().is_none(),
+        "We should have a disagreement about the current miner"
+    );
+
+    let state_machine = SignerStateMachine {
+        burn_block,
+        burn_block_height,
+        current_miner: (&new_miner).into(),
+        active_signer_protocol_version: local_supported_signer_protocol_version, // a majority of signers are saying they support version the same local_supported_signer_protocol_version, so update it here...
+        tx_replay_set: None,
+    };
+
+    global_eval.insert_update(local_address, new_update);
+    // Let's tip the scales over to a different miner
+    assert_eq!(global_eval.determine_global_state().unwrap(), state_machine)
+}