Add rollover_signer_protocol_version test to check upgrading and downgrading signer protocol versions

Signed-off-by: Jacinta Ferrant <jacinta.ferrant@gmail.com>

Author: jferrant

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˝

stacks-signer/src/v0/signer_state.rs

@@ -348,10 +348,25 @@ pub enum StateMachineUpdate {
     BurnBlock(u64),
 }
 
-impl TryInto<StateMachineUpdateMessage> for &LocalStateMachine {
-    type Error = CodecError;
+impl LocalStateMachine {
+    /// Initialize a local state machine by querying the local stacks-node
+    ///  and signerdb for the current sortition information
+    pub fn new(
+        db: &SignerDb,
+        client: &StacksClient,
+        proposal_config: &ProposalEvalConfig,
+    ) -> Result<Self, SignerChainstateError> {
+        let mut instance = Self::Uninitialized;
+        instance.bitcoin_block_arrival(db, client, proposal_config, None)?;
 
-    fn try_into(self) -> Result<StateMachineUpdateMessage, Self::Error> {
+        Ok(instance)
+    }
+
+    /// Convert the local state machine into update message with the specificed supported protocol version
+    pub fn try_into_update_message_with_version(
+        &self,
+        local_supported_signer_protocol_version: u64,
+    ) -> Result<StateMachineUpdateMessage, CodecError> {
         let LocalStateMachine::Initialized(state_machine) = self else {
             return Err(CodecError::SerializeError(
                 "Local state machine is not ready to be serialized into an update message".into(),
@@ -395,25 +410,10 @@ impl TryInto<StateMachineUpdateMessage> for &LocalStateMachine {
         };
         StateMachineUpdateMessage::new(
             state_machine.active_signer_protocol_version,
-            SUPPORTED_SIGNER_PROTOCOL_VERSION,
+            local_supported_signer_protocol_version,
             content,
         )
     }
-}
-
-impl LocalStateMachine {
-    /// Initialize a local state machine by querying the local stacks-node
-    ///  and signerdb for the current sortition information
-    pub fn new(
-        db: &SignerDb,
-        client: &StacksClient,
-        proposal_config: &ProposalEvalConfig,
-    ) -> Result<Self, SignerChainstateError> {
-        let mut instance = Self::Uninitialized;
-        instance.bitcoin_block_arrival(db, client, proposal_config, None)?;
-
-        Ok(instance)
-    }
 
     fn place_holder() -> SignerStateMachine {
         SignerStateMachine {
@@ -426,10 +426,16 @@ impl LocalStateMachine {
     }
 
     /// Send the local state machine as a signer update message to stackerdb
-    pub fn send_signer_update_message(&self, stackerdb: &mut StackerDB<MessageSlotID>) {
-        let update: Result<StateMachineUpdateMessage, _> = self.try_into();
+    pub fn send_signer_update_message(
+        &self,
+        stackerdb: &mut StackerDB<MessageSlotID>,
+        version: u64,
+    ) {
+        let update: Result<StateMachineUpdateMessage, _> =
+            self.try_into_update_message_with_version(version);
         match update {
             Ok(update) => {
+                info!("SENDING SIGNER UPDATE MESSAGE HERE: {update:?}");
                 if let Err(e) = stackerdb.send_message_with_retry::<SignerMessage>(update.into()) {
                     warn!("Failed to send signer update to stacker-db: {e:?}",);
                 }
@@ -815,10 +821,12 @@ impl LocalStateMachine {
         signerdb: &mut SignerDb,
         eval: &mut GlobalStateEvaluator,
         local_address: StacksAddress,
+        local_supported_signer_protocol_version: u64,
     ) {
         // Before we ever access eval...we should make sure to include our own local state machine update message in the evaluation
-        let local_update: Result<StateMachineUpdateMessage, _> = (&*self).try_into();
-        let Ok(mut local_update) = local_update else {
+        let Ok(mut local_update) =
+            self.try_into_update_message_with_version(local_supported_signer_protocol_version)
+        else {
             return;
         };
 
@@ -859,8 +867,9 @@ impl LocalStateMachine {
                 tx_replay_set: tx_replay_set.cloned(),
             });
             // Because we updated our active signer protocol version, update local_update so its included in the subsequent evaluations
-            let update: Result<StateMachineUpdateMessage, _> = (&*self).try_into();
-            let Ok(update) = update else {
+            let Ok(update) =
+                self.try_into_update_message_with_version(local_supported_signer_protocol_version)
+            else {
                 return;
             };
             local_update = update;

stacks-signer/src/v0/tests.rs

@@ -13,6 +13,7 @@
 // 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 std::sync::LazyLock;
 
 use blockstack_lib::chainstate::nakamoto::NakamotoBlock;
@@ -24,8 +25,14 @@ use stacks_common::util::tests::TestFlag;
 use stacks_common::{info, warn};
 
 use super::signer::Signer;
+use super::signer_state::SUPPORTED_SIGNER_PROTOCOL_VERSION;
 use crate::signerdb::BlockInfo;
 
+/// A global variable that can be used to reject all block proposals if the signer's public key is in the provided list
+pub static TEST_PIN_SUPPORTED_SIGNER_PROTOCOL_VERSION: LazyLock<
+    TestFlag<HashMap<StacksPublicKey, u64>>,
+> = LazyLock::new(TestFlag::default);
+
 /// A global variable that can be used to reject all block proposals if the signer's public key is in the provided list
 pub static TEST_REJECT_ALL_BLOCK_PROPOSAL: LazyLock<TestFlag<Vec<StacksPublicKey>>> =
     LazyLock::new(TestFlag::default);
@@ -151,4 +158,16 @@ impl Signer {
             warn!("{self}: Block validation submission is no longer stalled due to testing directive. Continuing...");
         }
     }
+
+    /// Get the pinned signer version for the signer
+    pub fn test_get_signer_protocol_version(&self) -> u64 {
+        let public_keys = TEST_PIN_SUPPORTED_SIGNER_PROTOCOL_VERSION.get();
+        if let Some(version) = public_keys.get(
+            &stacks_common::types::chainstate::StacksPublicKey::from_private(&self.private_key),
+        ) {
+            warn!("{self}: signer version is pinned to {version}");
+            return *version;
+        }
+        SUPPORTED_SIGNER_PROTOCOL_VERSION
+    }
 }