integrate with update message

Author: kantai

libsigner/src/v0/messages.rs

@@ -542,47 +542,121 @@ impl StacksMessageCodec for MockBlock {
 }
 
 /// Message for update the Signer State infos
-#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+#[derive(Debug, Clone, PartialEq, Deserialize, Serialize)]
 pub struct StateMachineUpdate {
-    burn_block: ConsensusHash,
-    burn_block_height: u64,
-    current_miner_pkh: Hash160,
-    parent_tenure_id: ConsensusHash,
-    parent_tenure_last_block: StacksBlockId,
-    parent_tenure_last_block_height: u64,
-    active_signer_protocol_version: u64,
-    local_supported_signer_protocol_version: u64,
+    /// The tip burn block (i.e., the latest bitcoin block) seen by this signer
+    pub burn_block: ConsensusHash,
+    /// The tip burn block height (i.e., the latest bitcoin block) seen by this signer
+    pub burn_block_height: u64,
+    /// The signer's view of who the current miner should be (and their tenure building info)
+    pub current_miner: StateMachineUpdateMinerState,
+    /// The active signing protocol version
+    pub active_signer_protocol_version: u64,
+    /// The highest supported signing protocol by the local signer
+    pub local_supported_signer_protocol_version: u64,
+}
+
+/// Message for update the Signer State infos
+#[derive(Debug, Clone, PartialEq, Deserialize, Serialize)]
+pub enum StateMachineUpdateMinerState {
+    /// There is an active miner
+    ActiveMiner {
+        /// The pubkeyhash of the current miner's signing key
+        current_miner_pkh: Hash160,
+        /// The tenure ID of the current miner's active tenure
+        tenure_id: ConsensusHash,
+        /// The tenure that the current miner is building on top of
+        parent_tenure_id: ConsensusHash,
+        /// The last block of the parent tenure (which should be
+        ///  the block that the next tenure starts from)
+        parent_tenure_last_block: StacksBlockId,
+        /// The height of the last block of the parent tenure (which should be
+        ///  the block that the next tenure starts from)
+        parent_tenure_last_block_height: u64,
+    },
+    /// The signer doesn't believe there's any valid miner
+    NoValidMiner,
+}
+
+impl StateMachineUpdateMinerState {
+    fn get_variant_id(&self) -> u8 {
+        match self {
+            StateMachineUpdateMinerState::NoValidMiner => 0,
+            StateMachineUpdateMinerState::ActiveMiner { .. } => 1,
+        }
+    }
+}
+
+impl StacksMessageCodec for StateMachineUpdateMinerState {
+    fn consensus_serialize<W: Write>(&self, fd: &mut W) -> Result<(), CodecError> {
+        self.get_variant_id().consensus_serialize(fd)?;
+        match self {
+            StateMachineUpdateMinerState::ActiveMiner {
+                current_miner_pkh,
+                tenure_id,
+                parent_tenure_id,
+                parent_tenure_last_block,
+                parent_tenure_last_block_height,
+            } => {
+                current_miner_pkh.consensus_serialize(fd)?;
+                tenure_id.consensus_serialize(fd)?;
+                parent_tenure_id.consensus_serialize(fd)?;
+                parent_tenure_last_block.consensus_serialize(fd)?;
+                parent_tenure_last_block_height.consensus_serialize(fd)?;
+            }
+            StateMachineUpdateMinerState::NoValidMiner => return Ok(()),
+        }
+        Ok(())
+    }
+
+    fn consensus_deserialize<R: Read>(fd: &mut R) -> Result<Self, CodecError> {
+        let variant_id: u8 = read_next(fd)?;
+        match variant_id {
+            0 => Ok(StateMachineUpdateMinerState::NoValidMiner),
+            1 => {
+                let current_miner_pkh = read_next(fd)?;
+                let tenure_id = read_next(fd)?;
+                let parent_tenure_id = read_next(fd)?;
+                let parent_tenure_last_block = read_next(fd)?;
+                let parent_tenure_last_block_height = read_next(fd)?;
+                Ok(StateMachineUpdateMinerState::ActiveMiner {
+                    current_miner_pkh,
+                    tenure_id,
+                    parent_tenure_id,
+                    parent_tenure_last_block,
+                    parent_tenure_last_block_height,
+                })
+            }
+            other => Err(CodecError::DeserializeError(format!(
+                "Unexpect miner state variant in StateMachineUpdate: {other}"
+            ))),
+        }
+    }
 }
 
 impl StacksMessageCodec for StateMachineUpdate {
     fn consensus_serialize<W: Write>(&self, fd: &mut W) -> Result<(), CodecError> {
-        write_next(fd, &self.burn_block)?;
-        write_next(fd, &self.burn_block_height)?;
-        write_next(fd, &self.current_miner_pkh)?;
-        write_next(fd, &self.parent_tenure_id)?;
-        write_next(fd, &self.parent_tenure_last_block)?;
-        write_next(fd, &self.parent_tenure_last_block_height)?;
-        write_next(fd, &self.active_signer_protocol_version)?;
-        write_next(fd, &self.local_supported_signer_protocol_version)?;
+        self.active_signer_protocol_version
+            .consensus_serialize(fd)?;
+        self.local_supported_signer_protocol_version
+            .consensus_serialize(fd)?;
+        self.burn_block.consensus_serialize(fd)?;
+        self.burn_block_height.consensus_serialize(fd)?;
+        self.current_miner.consensus_serialize(fd)?;
         Ok(())
     }
 
     fn consensus_deserialize<R: Read>(fd: &mut R) -> Result<Self, CodecError> {
-        let burn_block = read_next::<ConsensusHash, _>(fd)?;
-        let burn_block_height = read_next::<u64, _>(fd)?;
-        let current_miner_pkh = read_next::<Hash160, _>(fd)?;
-        let parent_tenure_id = read_next::<ConsensusHash, _>(fd)?;
-        let parent_tenure_last_block = read_next::<StacksBlockId, _>(fd)?;
-        let parent_tenure_last_block_height = read_next::<u64, _>(fd)?;
-        let active_signer_protocol_version = read_next::<u64, _>(fd)?;
-        let local_supported_signer_protocol_version = read_next::<u64, _>(fd)?;
+        let active_signer_protocol_version = read_next(fd)?;
+        let local_supported_signer_protocol_version = read_next(fd)?;
+        let burn_block = read_next(fd)?;
+        let burn_block_height = read_next(fd)?;
+        let current_miner = read_next(fd)?;
+
         Ok(Self {
             burn_block,
             burn_block_height,
-            current_miner_pkh,
-            parent_tenure_id,
-            parent_tenure_last_block,
-            parent_tenure_last_block_height,
+            current_miner,
             active_signer_protocol_version,
             local_supported_signer_protocol_version,
         })
@@ -2051,72 +2125,66 @@ mod test {
         let signer_message = StateMachineUpdate {
             burn_block: ConsensusHash([0x55; 20]),
             burn_block_height: 100,
-            current_miner_pkh: Hash160([0xab; 20]),
-            parent_tenure_id: ConsensusHash([0x22; 20]),
-            parent_tenure_last_block: StacksBlockId([0x33; 32]),
-            parent_tenure_last_block_height: 1,
             active_signer_protocol_version: 2,
             local_supported_signer_protocol_version: 3,
+            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,
+            },
         };
 
         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, 2],
+            /* local_supported_signer_protocol_version*/ &[0, 0, 0, 0, 0, 0, 0, 3],
             /* 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],
-            /* active_signer_protocol_version*/ &[0, 0, 0, 0, 0, 0, 0, 2],
-            /* local_supported_signer_protocol_version*/ &[0, 0, 0, 0, 0, 0, 0, 3],
         ];
 
         assert_eq!(bytes, raw_signer_message.concat());
 
         let signer_message_deserialized =
             StateMachineUpdate::consensus_deserialize(&mut &bytes[..]).unwrap();
 
-        assert_eq!(
-            signer_message.burn_block,
-            signer_message_deserialized.burn_block
-        );
+        assert_eq!(signer_message, signer_message_deserialized);
 
-        assert_eq!(
-            signer_message.burn_block_height,
-            signer_message_deserialized.burn_block_height
-        );
-
-        assert_eq!(
-            signer_message.current_miner_pkh,
-            signer_message_deserialized.current_miner_pkh
-        );
+        let signer_message = StateMachineUpdate {
+            burn_block: ConsensusHash([0x55; 20]),
+            burn_block_height: 100,
+            active_signer_protocol_version: 2,
+            local_supported_signer_protocol_version: 3,
+            current_miner: StateMachineUpdateMinerState::NoValidMiner,
+        };
 
-        assert_eq!(
-            signer_message.parent_tenure_id,
-            signer_message_deserialized.parent_tenure_id
-        );
+        let mut bytes = vec![];
+        signer_message.consensus_serialize(&mut bytes).unwrap();
 
-        assert_eq!(
-            signer_message.parent_tenure_last_block,
-            signer_message_deserialized.parent_tenure_last_block
-        );
+        // 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, 2],
+            /* local_supported_signer_protocol_version*/ &[0, 0, 0, 0, 0, 0, 0, 3],
+            /* burn_block*/ &[0x55; 20],
+            /* burn_block_height*/ &[0, 0, 0, 0, 0, 0, 0, 100],
+            /* current_miner_variant */ &[0x00],
+        ];
 
-        assert_eq!(
-            signer_message.parent_tenure_last_block_height,
-            signer_message_deserialized.parent_tenure_last_block_height
-        );
+        assert_eq!(bytes, raw_signer_message.concat());
 
-        assert_eq!(
-            signer_message.active_signer_protocol_version,
-            signer_message_deserialized.active_signer_protocol_version
-        );
+        let signer_message_deserialized =
+            StateMachineUpdate::consensus_deserialize(&mut &bytes[..]).unwrap();
 
-        assert_eq!(
-            signer_message.local_supported_signer_protocol_version,
-            signer_message_deserialized.local_supported_signer_protocol_version
-        );
+        assert_eq!(signer_message, signer_message_deserialized);
     }
 }

stacks-signer/src/chainstate.rs

@@ -42,6 +42,9 @@ pub enum SignerChainstateError {
     /// The signer could not find information about the parent tenure
     #[error("No information available for parent tenure '{0}'")]
     NoParentTenureInfo(ConsensusHash),
+    /// The signer could not find information about the parent tenure
+    #[error("The local state machine is not ready, so no update message can be produced")]
+    LocalStateMachineNotReady,
 }
 
 impl From<SignerChainstateError> for RejectReason {

stacks-signer/src/v0/signer_state.rs

@@ -17,6 +17,9 @@ use std::time::{Duration, UNIX_EPOCH};
 
 use blockstack_lib::chainstate::burn::ConsensusHashExtensions;
 use blockstack_lib::chainstate::nakamoto::{NakamotoBlock, NakamotoBlockHeader};
+use libsigner::v0::messages::{
+    StateMachineUpdate as StateMachineUpdateMessage, StateMachineUpdateMinerState,
+};
 use serde::{Deserialize, Serialize};
 use slog::{slog_info, slog_warn};
 use stacks_common::bitvec::BitVec;
@@ -31,6 +34,9 @@ use crate::chainstate::{
 use crate::client::{ClientError, CurrentAndLastSortition, StacksClient};
 use crate::signerdb::SignerDb;
 
+/// This is the latest supported protocol version for this signer binary
+pub static SUPPORTED_SIGNER_PROTOCOL_VERSION: u64 = 1;
+
 /// A signer state machine view. This struct can
 ///  be used to encode the local signer's view or
 ///  the global view.
@@ -93,6 +99,41 @@ pub enum StateMachineUpdate {
     BurnBlock(u64),
 }
 
+impl TryInto<StateMachineUpdateMessage> for &LocalStateMachine {
+    type Error = SignerChainstateError;
+
+    fn try_into(self) -> Result<StateMachineUpdateMessage, Self::Error> {
+        let LocalStateMachine::Initialized(state_machine) = self else {
+            return Err(SignerChainstateError::LocalStateMachineNotReady);
+        };
+
+        let current_miner = match state_machine.current_miner {
+            MinerState::ActiveMiner {
+                current_miner_pkh,
+                tenure_id,
+                parent_tenure_id,
+                parent_tenure_last_block,
+                parent_tenure_last_block_height,
+            } => StateMachineUpdateMinerState::ActiveMiner {
+                current_miner_pkh,
+                tenure_id,
+                parent_tenure_id,
+                parent_tenure_last_block,
+                parent_tenure_last_block_height,
+            },
+            MinerState::NoValidMiner => StateMachineUpdateMinerState::NoValidMiner,
+        };
+
+        Ok(StateMachineUpdateMessage {
+            burn_block: state_machine.burn_block,
+            burn_block_height: state_machine.burn_block_height,
+            current_miner,
+            active_signer_protocol_version: state_machine.active_signer_protocol_version,
+            local_supported_signer_protocol_version: SUPPORTED_SIGNER_PROTOCOL_VERSION,
+        })
+    }
+}
+
 impl LocalStateMachine {
     /// Initialize a local state machine by querying the local stacks-node
     ///  and signerdb for the current sortition information