Merge pull request #6048 from jferrant/feat/signer-sends-replay-set-in-update

Add StateMachineUpdateContent::V1 which inculdes a vector of replay_transactions

Author: obycode

CHANGELOG.md

@@ -10,6 +10,7 @@ and this project adheres to the versioning scheme outlined in the [README.md](RE
 ### 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
 

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);
+    }
 }

stacks-signer/CHANGELOG.md

@@ -5,12 +5,19 @@ 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.1]
 
 ### Added
 
 - The signer will now check if their associated stacks-node has processed the parent block for a block proposal before submitting that block proposal. If it cannot confirm that the parent block has been processed, it waits a default time of 15s before submitting, configurable via `proposal_wait_for_parent_time_secs` in the signer config.toml.
 
+
 ## [3.1.0.0.8.0]
 
 ### Changed

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,13 +218,17 @@ 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,
         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,
     };
 
     assert_eq!(
@@ -263,6 +273,7 @@ fn determine_global_states() {
         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,
     };
 
     // Let's tip the scales over to a different miner
@@ -295,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 {

stacks-signer/src/v0/signer.rs

@@ -300,8 +300,9 @@ impl SignerTrait<SignerMessage> for Signer {
         self.check_pending_block_validations(stacks_client);
 
         if prior_state != self.local_state_machine {
+            let version = self.get_signer_protocol_version();
             self.local_state_machine
-                .send_signer_update_message(&mut self.stackerdb);
+                .send_signer_update_message(&mut self.stackerdb, version);
         }
     }
 
@@ -725,10 +726,12 @@ impl Signer {
             .insert_update(address, update.clone());
 
         // See if this update means we should capitulate our viewpoint...
+        let version = self.get_signer_protocol_version();
         self.local_state_machine.capitulate_viewpoint(
             &mut self.signer_db,
             &mut self.global_state_evaluator,
             self.stacks_address,
+            version,
         );
     }
 
@@ -1677,6 +1680,16 @@ impl Signer {
             None
         }
     }
+
+    #[cfg(not(any(test, feature = "testing")))]
+    fn get_signer_protocol_version(&self) -> u64 {
+        SUPPORTED_SIGNER_PROTOCOL_VERSION
+    }
+
+    #[cfg(any(test, feature = "testing"))]
+    fn get_signer_protocol_version(&self) -> u64 {
+        self.test_get_signer_protocol_version()
+    }
 }
 
 /// Determine if a block should be re-evaluated based on its rejection reason˝