Add StateMachineUpdateContent::V1 which inculdes a vector of replay_transactions

jferrant · hstove · commit 2e6770631199 · 2025-04-30T09:31:37.000-07:00
Signed-off-by: Jacinta Ferrant &lt;jacinta.ferrant@gmail.com&gt;
diff --git a/CHANGELOG.md b/CHANGELOG.md
@@ -7,6 +7,11 @@ and this project adheres to the versioning scheme outlined in the [README.md](RE
 
 ## [Unreleased]
 
+### Added
+
+- 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
+
 ### Changed
 
 - Reduce the default `block_rejection_timeout_steps` configuration so that miners will retry faster when blocks fail to reach 70% approved or 30% rejected.
diff --git a/libsigner/src/v0/messages.rs b/libsigner/src/v0/messages.rs
@@ -571,6 +571,17 @@ pub enum StateMachineUpdateContent {
         /// The signer's view of who the current miner should be (and their tenure building info)
         current_miner: StateMachineUpdateMinerState,
     },
+    /// Version 1
+    V1 {
+        /// The tip burn block (i.e., the latest bitcoin block) seen by this signer
+        burn_block: ConsensusHash,
+        /// The tip burn block height (i.e., the latest bitcoin block) seen by this signer
+        burn_block_height: u64,
+        /// The signer's view of who the current miner should be (and their tenure building info)
+        current_miner: StateMachineUpdateMinerState,
+        /// The replay transactions
+        replay_transactions: Vec<StacksTransaction>,
+    },
 }
 
 /// Message for update the Signer State infos
@@ -676,6 +687,7 @@ impl StateMachineUpdateContent {
     fn is_protocol_version_compatible(&self, version: u64) -> bool {
         match self {
             Self::V0 { .. } => version == 0,
+            Self::V1 { .. } => version == 1,
         }
     }
 
@@ -690,6 +702,17 @@ impl StateMachineUpdateContent {
                 burn_block_height.consensus_serialize(fd)?;
                 current_miner.consensus_serialize(fd)?;
             }
+            Self::V1 {
+                burn_block,
+                burn_block_height,
+                current_miner,
+                replay_transactions,
+            } => {
+                burn_block.consensus_serialize(fd)?;
+                burn_block_height.consensus_serialize(fd)?;
+                current_miner.consensus_serialize(fd)?;
+                replay_transactions.consensus_serialize(fd)?;
+            }
         }
         Ok(())
     }
@@ -705,6 +728,18 @@ impl StateMachineUpdateContent {
                     current_miner,
                 })
             }
+            1 => {
+                let burn_block = read_next(fd)?;
+                let burn_block_height = read_next(fd)?;
+                let current_miner = read_next(fd)?;
+                let replay_transactions = read_next(fd)?;
+                Ok(Self::V1 {
+                    burn_block,
+                    burn_block_height,
+                    current_miner,
+                    replay_transactions,
+                })
+            }
             other => Err(CodecError::DeserializeError(format!(
                 "Unknown state machine update version: {other}"
             ))),
@@ -1716,15 +1751,17 @@ impl From<StateMachineUpdate> for SignerMessage {
 mod test {
     use blockstack_lib::chainstate::nakamoto::NakamotoBlockHeader;
     use blockstack_lib::chainstate::stacks::{
-        TransactionAnchorMode, TransactionAuth, TransactionPayload, TransactionPostConditionMode,
-        TransactionSmartContract, TransactionVersion,
+        TransactionAnchorMode, TransactionAuth, TransactionContractCall, TransactionPayload,
+        TransactionPostConditionMode, TransactionSmartContract, TransactionSpendingCondition,
+        TransactionVersion,
     };
     use blockstack_lib::util_lib::strings::StacksString;
     use clarity::consts::CHAIN_ID_MAINNET;
-    use clarity::types::chainstate::{ConsensusHash, StacksBlockId, TrieHash};
+    use clarity::types::chainstate::{ConsensusHash, StacksAddress, StacksBlockId, TrieHash};
     use clarity::types::PrivateKey;
     use clarity::util::hash::{hex_bytes, MerkleTree};
     use clarity::util::secp256k1::MessageSignature;
+    use clarity::vm::{ClarityName, ContractName};
     use rand::rngs::mock;
     use rand::{thread_rng, Rng, RngCore};
     use rand_core::OsRng;
@@ -2316,4 +2353,84 @@ mod test {
 
         assert_eq!(signer_message, signer_message_deserialized);
     }
+
+    #[test]
+    fn deserialize_state_machine_update_v1() {
+        let signer_message = StateMachineUpdate::new(
+            1,
+            3,
+            StateMachineUpdateContent::V1 {
+                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,
+                },
+                replay_transactions: vec![],
+            },
+        )
+        .unwrap();
+
+        let mut bytes = vec![];
+        signer_message.consensus_serialize(&mut bytes).unwrap();
+
+        // check for raw content for avoiding regressions when structure changes
+        let raw_signer_message: Vec<&[u8]> = vec![
+            /* active_signer_protocol_version*/ &[0, 0, 0, 0, 0, 0, 0, 1],
+            /* local_supported_signer_protocol_version*/ &[0, 0, 0, 0, 0, 0, 0, 3],
+            /* content_len*/ &[0, 0, 0, 133],
+            /* burn_block*/ &[0x55; 20],
+            /* burn_block_height*/ &[0, 0, 0, 0, 0, 0, 0, 100],
+            /* current_miner_variant */ &[0x01],
+            /* current_miner_pkh */ &[0xab; 20],
+            /* tenure_id*/ &[0x44; 20],
+            /* parent_tenure_id*/ &[0x22; 20],
+            /* parent_tenure_last_block */ &[0x33; 32],
+            /* parent_tenure_last_block_height*/ &[0, 0, 0, 0, 0, 0, 0, 1],
+            /* replay_transactions */ &[0, 0, 0, 0],
+        ];
+
+        assert_eq!(bytes, raw_signer_message.concat());
+
+        let signer_message_deserialized =
+            StateMachineUpdate::consensus_deserialize(&mut &bytes[..]).unwrap();
+
+        assert_eq!(signer_message, signer_message_deserialized);
+
+        let signer_message = StateMachineUpdate::new(
+            1,
+            4,
+            StateMachineUpdateContent::V1 {
+                burn_block: ConsensusHash([0x55; 20]),
+                burn_block_height: 100,
+                current_miner: StateMachineUpdateMinerState::NoValidMiner,
+                replay_transactions: vec![],
+            },
+        )
+        .unwrap();
+
+        let mut bytes = vec![];
+        signer_message.consensus_serialize(&mut bytes).unwrap();
+
+        // check for raw content for avoiding regressions when structure changes
+        let raw_signer_message: Vec<&[u8]> = vec![
+            /* active_signer_protocol_version*/ &[0, 0, 0, 0, 0, 0, 0, 1],
+            /* local_supported_signer_protocol_version*/ &[0, 0, 0, 0, 0, 0, 0, 4],
+            /* content_len*/ &[0, 0, 0, 33],
+            /* burn_block*/ &[0x55; 20],
+            /* burn_block_height*/ &[0, 0, 0, 0, 0, 0, 0, 100],
+            /* current_miner_variant */ &[0x00],
+            /* replay_transactions */ &[0, 0, 0, 0],
+        ];
+
+        assert_eq!(bytes, raw_signer_message.concat());
+
+        let signer_message_deserialized =
+            StateMachineUpdate::consensus_deserialize(&mut &bytes[..]).unwrap();
+
+        assert_eq!(signer_message, signer_message_deserialized);
+    }
 }
diff --git a/stacks-signer/CHANGELOG.md b/stacks-signer/CHANGELOG.md
@@ -5,6 +5,12 @@ 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]
+
+### Changed
+
+- Upgraded `SUPPORTED_SIGNER_PROTOCOL_VERSION` to 1
+
 ## [3.1.0.0.8.0]
 
 ### Changed
diff --git a/stacks-signer/src/client/stacks_client.rs b/stacks-signer/src/client/stacks_client.rs
@@ -463,7 +463,7 @@ impl StacksClient {
             return Err(ClientError::RequestFailure(response.status()));
         }
         let sortition_info = response.json::<Vec<SortitionInfo>>()?;
-        sortition_info.get(0).cloned().ok_or_else(|| {
+        sortition_info.first().cloned().ok_or_else(|| {
             ClientError::InvalidResponse("No sortition info found for given consensus hash".into())
         })
     }
diff --git a/stacks-signer/src/signerdb.rs b/stacks-signer/src/signerdb.rs
@@ -21,12 +21,12 @@ use std::time::{Duration, SystemTime};
 
 use blockstack_lib::chainstate::nakamoto::NakamotoBlock;
 use blockstack_lib::chainstate::stacks::TransactionPayload;
+#[cfg(any(test, feature = "testing"))]
+use blockstack_lib::util_lib::db::FromColumn;
 use blockstack_lib::util_lib::db::{
     query_row, query_rows, sqlite_open, table_exists, tx_begin_immediate, u64_to_sql,
-    Error as DBError,
+    Error as DBError, FromRow,
 };
-#[cfg(any(test, feature = "testing"))]
-use blockstack_lib::util_lib::db::{FromColumn, FromRow};
 use clarity::types::chainstate::{BurnchainHeaderHash, StacksAddress};
 use clarity::types::Address;
 use libsigner::v0::messages::{RejectReason, RejectReasonPrefix, StateMachineUpdate};
diff --git a/stacks-signer/src/tests/signer_state.rs b/stacks-signer/src/tests/signer_state.rs
@@ -84,7 +84,10 @@ fn determine_latest_supported_signer_protocol_versions() {
                 current_miner,
             },
         ..
-    } = local_update.clone();
+    } = 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() {
@@ -151,7 +154,10 @@ fn determine_global_burn_views() {
                 current_miner,
             },
         ..
-    } = local_update.clone();
+    } = local_update.clone()
+    else {
+        panic!("Unexpected state machine update message version");
+    };
 
     assert_eq!(
         global_eval
@@ -212,7 +218,10 @@ fn determine_global_states() {
                 current_miner,
             },
         ..
-    } = local_update.clone();
+    } = local_update.clone()
+    else {
+        panic!("Unexpected state machine update message version");
+    };
 
     let state_machine = SignerStateMachine {
         burn_block,
@@ -297,7 +306,10 @@ fn check_capitulate_miner_view() {
                 current_miner,
             },
         ..
-    } = local_update.clone();
+    } = local_update.clone()
+    else {
+        panic!("Unexpected state machine update message version");
+    };
     // Let's create a new miner view
     let new_tenure_id = ConsensusHash([0x00; 20]);
     let new_miner = StateMachineUpdateMinerState::ActiveMiner {
diff --git a/stacks-signer/src/v0/signer_state.rs b/stacks-signer/src/v0/signer_state.rs
diff --git a/stackslib/src/chainstate/stacks/mod.rs b/stackslib/src/chainstate/stacks/mod.rs
diff --git a/testnet/stacks-node/src/tests/signer/v0.rs b/testnet/stacks-node/src/tests/signer/v0.rs

Original file line number	Diff line number	Diff line change
`@@ -463,7 +463,7 @@ impl StacksClient {`
`463`	`463`	`return Err(ClientError::RequestFailure(response.status()));`
`464`	`464`	`}`
`465`	`465`	`let sortition_info = response.json::<Vec<SortitionInfo>>()?;`
`466`		`- sortition_info.get(0).cloned().ok_or_else(\|\| {`
	`466`	`+ sortition_info.first().cloned().ok_or_else(\|\| {`
`467`	`467`	`ClientError::InvalidResponse("No sortition info found for given consensus hash".into())`
`468`	`468`	`})`
`469`	`469`	`}`