Merge branch 'develop' into feat/pox-4-stateful-solo-scenarios

Author: friedger

.github/actions/dockerfiles/Dockerfile.alpine-binary

@@ -23,5 +23,5 @@ RUN case ${TARGETPLATFORM} in \
     && unzip ${BIN_ARCH}.zip -d /out
 
 FROM --platform=${TARGETPLATFORM} alpine
-COPY --from=builder /out/stacks-node /bin/
+COPY --from=builder /out/stacks-node /out/stacks-signer /bin/
 CMD ["stacks-node", "mainnet"]

.github/actions/dockerfiles/Dockerfile.debian-binary

@@ -23,5 +23,5 @@ RUN case ${TARGETPLATFORM} in \
     && unzip ${BIN_ARCH}.zip -d /out
 
 FROM --platform=${TARGETPLATFORM} debian:bookworm
-COPY --from=builder /out/stacks-node /bin/
+COPY --from=builder /out/stacks-node /out/stacks-signer /bin/
 CMD ["stacks-node", "mainnet"]

.github/workflows/bitcoin-tests.yml

@@ -81,15 +81,18 @@ jobs:
           - tests::nakamoto_integrations::correct_burn_outs
           - tests::nakamoto_integrations::vote_for_aggregate_key_burn_op
           - tests::nakamoto_integrations::follower_bootup
+          - tests::nakamoto_integrations::forked_tenure_is_ignored
           - tests::signer::stackerdb_dkg
-          - tests::signer::stackerdb_sign
+          - tests::signer::stackerdb_sign_request_rejected
           - tests::signer::stackerdb_block_proposal
           - tests::signer::stackerdb_filter_bad_transactions
           - tests::signer::stackerdb_mine_2_nakamoto_reward_cycles
           - tests::signer::stackerdb_sign_after_signer_reboot
           - tests::nakamoto_integrations::stack_stx_burn_op_integration_test
+          - tests::signer::stackerdb_delayed_dkg
           # 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
     steps:
       ## Setup test environment
       - name: Setup Test Environment

.github/workflows/github-release.yml

@@ -70,6 +70,8 @@ jobs:
           draft: false
           prerelease: true
           fail_on_unmatched_files: true
+          target_commitish: ${{ github.sha }}
+          generate_release_notes: true
           files: |
             release/*.zip
             CHECKSUMS.txt

CHANGELOG.md

@@ -5,7 +5,30 @@ 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).
 
-## [Next-Branch]
+## [2.5.0.0.3]
+
+This release fixes a regression in `2.5.0.0.0` from `2.4.0.1.0` caused by git merge
+
+## [2.5.0.0.2]
+
+This release fixes two bugs in `2.5.0.0.0`, correctly setting the activation height for 2.5, and the network peer version.
+
+## [2.5.0.0.0]
+
+This release implements the 2.5 Stacks consensus rules which activates at Bitcoin block `840,360`: primarily the instantiation
+of the pox-4 contract. For more details see SIP-021.
+
+This is the first consensus-critical release for Nakamoto. Nodes which do not update before the 2.5 activation height will be forked away from the rest of the network. This release is compatible with 2.4.x chain state directories and does not require resyncing from genesis. The first time a node boots with this version it will perform some database migrations which could lengthen the normal node startup time.
+
+**This is a required release before Nakamoto rules are enabled in 3.0.**
+
+
+### Timing of Release from 2.5 to 3.0
+
+Activating Nakamoto will include two epochs:
+
+- **Epoch 2.5:** Pox-4 contract is booted up but no Nakamoto consensus rules take effect.
+- **Epoch 3:** Nakamoto consensus rules take effect.
 
 ### Added
 

clarity/src/vm/contexts.rs

@@ -1340,7 +1340,7 @@ impl<'a, 'b, 'hooks> Environment<'a, 'b, 'hooks> {
         self.global_context.begin();
         let result = stx_transfer_consolidated(self, from, to, amount, memo);
         match result {
-            Ok(value) => match value.clone().expect_result() {
+            Ok(value) => match value.clone().expect_result()? {
                 Ok(_) => {
                     self.global_context.commit()?;
                     Ok(value)
@@ -1966,8 +1966,14 @@ impl CallStack {
 
 #[cfg(test)]
 mod test {
+    use stacks_common::types::chainstate::StacksAddress;
+    use stacks_common::util::hash::Hash160;
+
     use super::*;
     use crate::vm::callables::DefineType;
+    use crate::vm::tests::{
+        test_epochs, tl_env_factory, MemoryEnvironmentGenerator, TopLevelMemoryEnvironmentGenerator,
+    };
     use crate::vm::types::signatures::CallableSubtype;
     use crate::vm::types::{FixedFunction, FunctionArg, FunctionType, StandardPrincipalData};
 
@@ -2123,6 +2129,35 @@ mod test {
         assert_eq!(table[&p2][&t7], AssetMapEntry::Burn(35 + 36));
     }
 
+    /// Test the stx-transfer consolidation tx invalidation
+    ///  bug from 2.4.0.1.0-rc1
+    #[apply(test_epochs)]
+    fn stx_transfer_consolidate_regr_24010(
+        epoch: StacksEpochId,
+        mut tl_env_factory: TopLevelMemoryEnvironmentGenerator,
+    ) {
+        let mut env = tl_env_factory.get_env(epoch);
+        let u1 = StacksAddress {
+            version: 0,
+            bytes: Hash160([1; 20]),
+        };
+        let u2 = StacksAddress {
+            version: 0,
+            bytes: Hash160([2; 20]),
+        };
+        // insufficient balance must be a non-includable transaction. it must error here,
+        //  not simply rollback the tx and squelch the error as includable.
+        let e = env
+            .stx_transfer(
+                &PrincipalData::from(u1.clone()),
+                &PrincipalData::from(u2.clone()),
+                1000,
+                &BuffData::empty(),
+            )
+            .unwrap_err();
+        assert_eq!(e.to_string(), "Interpreter(InsufficientBalance)");
+    }
+
     #[test]
     fn test_canonicalize_contract_context() {
         let trait_id = TraitIdentifier::new(

clarity/src/vm/tests/mod.rs

@@ -149,7 +149,7 @@ impl MemoryEnvironmentGenerator {
 
 pub struct TopLevelMemoryEnvironmentGenerator(MemoryBackingStore);
 impl TopLevelMemoryEnvironmentGenerator {
-    fn get_env(&mut self, epoch: StacksEpochId) -> OwnedEnvironment {
+    pub fn get_env(&mut self, epoch: StacksEpochId) -> OwnedEnvironment {
         let owned_env = OwnedEnvironment::new(self.0.as_clarity_db(), epoch);
         owned_env
     }

libsigner/src/events.rs

@@ -68,14 +68,9 @@ pub struct BlockProposalSigners {
 #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
 pub enum SignerEvent {
     /// A miner sent a message over .miners
-    /// The `Vec<BlockProposalSigners>` will contain any block proposals made by the miner during this StackerDB event.
     /// The `Vec<SignerMessage>` will contain any signer WSTS messages made by the miner while acting as a coordinator.
-    /// The `Option<StacksPublicKey>` will contain the message sender's public key if either of the vecs is non-empty.
-    MinerMessages(
-        Vec<BlockProposalSigners>,
-        Vec<SignerMessage>,
-        Option<StacksPublicKey>,
-    ),
+    /// The `Option<StacksPublicKey>` will contain the message sender's public key if the vec is non-empty.
+    MinerMessages(Vec<SignerMessage>, Option<StacksPublicKey>),
     /// The signer messages for other signers and miners to observe
     /// The u32 is the signer set to which the message belongs (either 0 or 1)
     SignerMessages(u32, Vec<SignerMessage>),
@@ -417,7 +412,6 @@ impl TryFrom<StackerDBChunksEvent> for SignerEvent {
         let signer_event = if event.contract_id.name.as_str() == MINERS_NAME
             && event.contract_id.is_boot()
         {
-            let mut blocks = vec![];
             let mut messages = vec![];
             let mut miner_pk = None;
             for chunk in event.modified_slots {
@@ -426,28 +420,13 @@ impl TryFrom<StackerDBChunksEvent> for SignerEvent {
                         "Failed to recover PK from StackerDB chunk: {e}"
                     ))
                 })?);
-                if chunk.slot_id % MINER_SLOT_COUNT == 0 {
-                    // block
-                    let Ok(block) =
-                        BlockProposalSigners::consensus_deserialize(&mut chunk.data.as_slice())
-                    else {
-                        continue;
-                    };
-                    blocks.push(block);
-                } else if chunk.slot_id % MINER_SLOT_COUNT == 1 {
-                    // message
-                    let Ok(msg) = SignerMessage::consensus_deserialize(&mut chunk.data.as_slice())
-                    else {
-                        continue;
-                    };
-                    messages.push(msg);
-                } else {
-                    return Err(EventError::UnrecognizedEvent(
-                        "Unrecognized slot_id for miners contract".into(),
-                    ));
+                let Ok(msg) = SignerMessage::consensus_deserialize(&mut chunk.data.as_slice())
+                else {
+                    continue;
                 };
+                messages.push(msg);
             }
-            SignerEvent::MinerMessages(blocks, messages, miner_pk)
+            SignerEvent::MinerMessages(messages, miner_pk)
         } else if event.contract_id.name.starts_with(SIGNERS_NAME) && event.contract_id.is_boot() {
             let Some((signer_set, _)) =
                 get_signers_db_signer_set_message_id(event.contract_id.name.as_str())

libsigner/src/session.rs

@@ -20,7 +20,8 @@ use std::str;
 use clarity::vm::types::QualifiedContractIdentifier;
 use libstackerdb::{
     stackerdb_get_chunk_path, stackerdb_get_metadata_path, stackerdb_post_chunk_path, SlotMetadata,
-    StackerDBChunkAckData, StackerDBChunkData,
+    StackerDBChunkAckData, StackerDBChunkData, SIGNERS_STACKERDB_CHUNK_SIZE,
+    STACKERDB_MAX_CHUNK_SIZE,
 };
 use stacks_common::codec::StacksMessageCodec;
 
@@ -214,10 +215,23 @@ impl SignerSession for StackerDBSession {
     /// query the replica for zero or more latest chunks
     fn get_latest_chunks(&mut self, slot_ids: &[u32]) -> Result<Vec<Option<Vec<u8>>>, RPCError> {
         let mut payloads = vec![];
+        let limit = if self.stackerdb_contract_id.name.starts_with("signer") {
+            SIGNERS_STACKERDB_CHUNK_SIZE
+        } else {
+            usize::try_from(STACKERDB_MAX_CHUNK_SIZE)
+                .expect("infallible: StackerDB chunk size exceeds usize::MAX")
+        };
         for slot_id in slot_ids.iter() {
             let path = stackerdb_get_chunk_path(self.stackerdb_contract_id.clone(), *slot_id, None);
             let chunk = match self.rpc_request("GET", &path, None, &[]) {
-                Ok(body_bytes) => Some(body_bytes),
+                Ok(body_bytes) => {
+                    // Verify that the chunk is not too large
+                    if body_bytes.len() > limit {
+                        None
+                    } else {
+                        Some(body_bytes)
+                    }
+                }
                 Err(RPCError::HttpError(code)) => {
                     if code != 404 {
                         return Err(RPCError::HttpError(code));

libstackerdb/src/libstackerdb.rs

@@ -35,6 +35,8 @@ use stacks_common::util::secp256k1::MessageSignature;
 
 /// maximum chunk size (16 MB; same as MAX_PAYLOAD_SIZE)
 pub const STACKERDB_MAX_CHUNK_SIZE: u32 = 16 * 1024 * 1024;
+/// CHUNK_SIZE constant for signers StackerDBs (2MB)
+pub const SIGNERS_STACKERDB_CHUNK_SIZE: usize = 2 * 1024 * 1024; // 2MB
 
 #[cfg(test)]
 mod tests;