Fix version mismatch, send updates when state is Initialized, and add a test

Author: jferrant

libsigner/src/v0/messages.rs

@@ -1705,6 +1705,12 @@ impl From<BlockResponse> for SignerMessage {
     }
 }
 
+impl From<StateMachineUpdate> for SignerMessage {
+    fn from(update: StateMachineUpdate) -> Self {
+        Self::StateMachineUpdate(update)
+    }
+}
+
 #[cfg(test)]
 mod test {
     use blockstack_lib::chainstate::nakamoto::NakamotoBlockHeader;

stacks-signer/src/v0/signer.rs

@@ -129,7 +129,7 @@ impl std::fmt::Display for Signer {
 impl SignerTrait<SignerMessage> for Signer {
     /// Create a new signer from the given configuration
     fn new(stacks_client: &StacksClient, signer_config: SignerConfig) -> Self {
-        let stackerdb = StackerDB::from(&signer_config);
+        let mut stackerdb = StackerDB::from(&signer_config);
         let mode = match signer_config.signer_mode {
             SignerConfigMode::DryRun => SignerMode::DryRun,
             SignerConfigMode::Normal { signer_id, .. } => SignerMode::Normal { signer_id },
@@ -141,11 +141,12 @@ impl SignerTrait<SignerMessage> for Signer {
             SignerDb::new(&signer_config.db_path).expect("Failed to connect to signer Db");
         let proposal_config = ProposalEvalConfig::from(&signer_config);
 
-        let signer_state = LocalStateMachine::new(&signer_db, stacks_client, &proposal_config)
-            .unwrap_or_else(|e| {
-                warn!("Failed to initialize local state machine for signer: {e:?}");
-                LocalStateMachine::Uninitialized
-            });
+        let signer_state =
+            LocalStateMachine::new(&signer_db, &mut stackerdb, stacks_client, &proposal_config)
+                .unwrap_or_else(|e| {
+                    warn!("Failed to initialize local state machine for signer: {e:?}");
+                    LocalStateMachine::Uninitialized
+                });
         Self {
             private_key: signer_config.stacks_private_key,
             stackerdb,
@@ -213,7 +214,7 @@ impl SignerTrait<SignerMessage> for Signer {
         }
 
         if self.reward_cycle <= current_reward_cycle {
-            self.local_state_machine.handle_pending_update(&self.signer_db, stacks_client, &self.proposal_config)
+            self.local_state_machine.handle_pending_update(&self.signer_db, &mut self.stackerdb, stacks_client, &self.proposal_config)
                 .unwrap_or_else(|e| error!("{self}: failed to update local state machine for pending update"; "err" => ?e));
         }
 
@@ -299,6 +300,9 @@ impl SignerTrait<SignerMessage> for Signer {
                                 self.mock_sign(mock_proposal.clone());
                             }
                         }
+                        SignerMessage::StateMachineUpdate(_update) => {
+                            // TODO: should make note of this update view point to determine if there is an agreed upon global state
+                        }
                         _ => {}
                     }
                 }
@@ -330,7 +334,7 @@ impl SignerTrait<SignerMessage> for Signer {
                         panic!("{self} Failed to write burn block event to signerdb: {e}");
                     });
                 self.local_state_machine
-                    .bitcoin_block_arrival(&self.signer_db, stacks_client, &self.proposal_config, Some(*burn_height))
+                    .bitcoin_block_arrival(&self.signer_db, &mut self.stackerdb, stacks_client, &self.proposal_config, Some(*burn_height))
                     .unwrap_or_else(|e| error!("{self}: failed to update local state machine for latest bitcoin block arrival"; "err" => ?e));
                 *sortition_state = None;
             }
@@ -352,7 +356,7 @@ impl SignerTrait<SignerMessage> for Signer {
                     "block_height" => block_height
                 );
                 self.local_state_machine
-                    .stacks_block_arrival(consensus_hash, *block_height, block_id)
+                    .stacks_block_arrival(&mut self.stackerdb, consensus_hash, *block_height, block_id)
                     .unwrap_or_else(|e| error!("{self}: failed to update local state machine for latest stacks block arrival"; "err" => ?e));
 
                 if let Ok(Some(mut block_info)) = self

stacks-signer/src/v0/signer_state.rs

@@ -18,8 +18,8 @@ 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, StateMachineUpdateContent,
-    StateMachineUpdateMinerState,
+    MessageSlotID, SignerMessage, StateMachineUpdate as StateMachineUpdateMessage,
+    StateMachineUpdateContent, StateMachineUpdateMinerState,
 };
 use serde::{Deserialize, Serialize};
 use stacks_common::bitvec::BitVec;
@@ -32,11 +32,11 @@ use stacks_common::{info, warn};
 use crate::chainstate::{
     ProposalEvalConfig, SignerChainstateError, SortitionState, SortitionsView,
 };
-use crate::client::{ClientError, CurrentAndLastSortition, StacksClient};
+use crate::client::{ClientError, CurrentAndLastSortition, StackerDB, StacksClient};
 use crate::signerdb::SignerDb;
 
 /// This is the latest supported protocol version for this signer binary
-pub static SUPPORTED_SIGNER_PROTOCOL_VERSION: u64 = 1;
+pub static SUPPORTED_SIGNER_PROTOCOL_VERSION: u64 = 0;
 
 /// A signer state machine view. This struct can
 ///  be used to encode the local signer's view or
@@ -144,11 +144,12 @@ impl LocalStateMachine {
     ///  and signerdb for the current sortition information
     pub fn new(
         db: &SignerDb,
+        stackerdb: &mut StackerDB<MessageSlotID>,
         client: &StacksClient,
         proposal_config: &ProposalEvalConfig,
     ) -> Result<Self, SignerChainstateError> {
         let mut instance = Self::Uninitialized;
-        instance.bitcoin_block_arrival(db, client, proposal_config, None)?;
+        instance.bitcoin_block_arrival(db, stackerdb, client, proposal_config, None)?;
 
         Ok(instance)
     }
@@ -158,24 +159,44 @@ impl LocalStateMachine {
             burn_block: ConsensusHash::empty(),
             burn_block_height: 0,
             current_miner: MinerState::NoValidMiner,
-            active_signer_protocol_version: 1,
+            active_signer_protocol_version: SUPPORTED_SIGNER_PROTOCOL_VERSION,
+        }
+    }
+
+    /// Send the local tate machine as an signer update message to stackerdb
+    pub fn send_signer_update_message(&self, stackerdb: &mut StackerDB<MessageSlotID>) {
+        let update: Result<StateMachineUpdateMessage, _> = self.try_into();
+        match update {
+            Ok(update) => {
+                if let Err(e) = stackerdb.send_message_with_retry::<SignerMessage>(update.into()) {
+                    warn!("Failed to send signer update to stacker-db: {e:?}",);
+                }
+            }
+            Err(e) => {
+                warn!("Failed to convert local signer state to a signer message: {e:?}");
+            }
         }
     }
 
     /// If this local state machine has pending updates, process them
     pub fn handle_pending_update(
         &mut self,
         db: &SignerDb,
+        stackerdb: &mut StackerDB<MessageSlotID>,
         client: &StacksClient,
         proposal_config: &ProposalEvalConfig,
     ) -> Result<(), SignerChainstateError> {
         let LocalStateMachine::Pending { update, .. } = self else {
-            return self.check_miner_inactivity(db, client, proposal_config);
+            return self.check_miner_inactivity(db, stackerdb, client, proposal_config);
         };
         match update.clone() {
-            StateMachineUpdate::BurnBlock(expected_burn_height) => {
-                self.bitcoin_block_arrival(db, client, proposal_config, Some(expected_burn_height))
-            }
+            StateMachineUpdate::BurnBlock(expected_burn_height) => self.bitcoin_block_arrival(
+                db,
+                stackerdb,
+                client,
+                proposal_config,
+                Some(expected_burn_height),
+            ),
         }
     }
 
@@ -216,6 +237,7 @@ impl LocalStateMachine {
     fn check_miner_inactivity(
         &mut self,
         db: &SignerDb,
+        stackerdb: &mut StackerDB<MessageSlotID>,
         client: &StacksClient,
         proposal_config: &ProposalEvalConfig,
     ) -> Result<(), SignerChainstateError> {
@@ -256,7 +278,8 @@ impl LocalStateMachine {
                 "inactive_tenure_ch" => %inactive_tenure_ch,
                 "new_active_tenure_ch" => %new_active_tenure_ch
             );
-
+            // We have updated our state, so let other signers know.
+            self.send_signer_update_message(stackerdb);
             Ok(())
         } else {
             warn!("Current miner timed out due to inactivity, but prior miner is not valid. Allowing current miner to continue");
@@ -324,6 +347,7 @@ impl LocalStateMachine {
     /// Handle a new stacks block arrival
     pub fn stacks_block_arrival(
         &mut self,
+        stackerdb: &mut StackerDB<MessageSlotID>,
         ch: &ConsensusHash,
         height: u64,
         block_id: &StacksBlockId,
@@ -379,6 +403,8 @@ impl LocalStateMachine {
         *parent_tenure_last_block = *block_id;
         *parent_tenure_last_block_height = height;
         *self = LocalStateMachine::Initialized(prior_state_machine);
+        // We updated the block id and/or the height. Let other signers know our view has changed
+        self.send_signer_update_message(stackerdb);
         Ok(())
     }
 
@@ -426,14 +452,15 @@ impl LocalStateMachine {
     pub fn bitcoin_block_arrival(
         &mut self,
         db: &SignerDb,
+        stackerdb: &mut StackerDB<MessageSlotID>,
         client: &StacksClient,
         proposal_config: &ProposalEvalConfig,
         mut expected_burn_height: Option<u64>,
     ) -> Result<(), SignerChainstateError> {
         // set self to uninitialized so that if this function errors,
         //  self is left as uninitialized.
         let prior_state = std::mem::replace(self, Self::Uninitialized);
-        let prior_state_machine = match prior_state {
+        let prior_state_machine = match prior_state.clone() {
             // if the local state machine was uninitialized, just initialize it
             LocalStateMachine::Uninitialized => Self::place_holder(),
             LocalStateMachine::Initialized(signer_state_machine) => signer_state_machine,
@@ -512,6 +539,10 @@ impl LocalStateMachine {
             active_signer_protocol_version: prior_state_machine.active_signer_protocol_version,
         });
 
+        if prior_state != *self {
+            self.send_signer_update_message(stackerdb);
+        }
+
         Ok(())
     }
 }

testnet/stacks-node/src/tests/epoch_205.rs

@@ -1,5 +1,4 @@
 use std::collections::HashMap;
-use std::sync::atomic::Ordering;
 use std::{env, thread};
 
 use clarity::vm::costs::ExecutionCost;
@@ -21,14 +20,12 @@ use stacks::core::{
 use stacks_common::codec::StacksMessageCodec;
 use stacks_common::types::chainstate::{BlockHeaderHash, BurnchainHeaderHash, VRFSeed};
 use stacks_common::util::hash::hex_bytes;
-use stacks_common::util::sleep_ms;
 
 use crate::tests::bitcoin_regtest::BitcoinCoreController;
 use crate::tests::neon_integrations::*;
 use crate::tests::{
     make_contract_call, make_contract_call_mblock_only, make_contract_publish,
-    make_contract_publish_microblock_only, run_until_burnchain_height, select_transactions_where,
-    to_addr,
+    run_until_burnchain_height, select_transactions_where, to_addr,
 };
 use crate::{neon, BitcoinRegtestController, BurnchainController, Keychain};
 

testnet/stacks-node/src/tests/neon_integrations.rs

@@ -11,7 +11,6 @@ use clarity::vm::costs::ExecutionCost;
 use clarity::vm::types::serialization::SerializationError;
 use clarity::vm::types::PrincipalData;
 use clarity::vm::{ClarityName, ClarityVersion, ContractName, Value, MAX_CALL_STACK_DEPTH};
-use rand::Rng;
 use rusqlite::params;
 use serde::Deserialize;
 use serde_json::json;
@@ -30,12 +29,11 @@ use stacks::chainstate::stacks::address::PoxAddress;
 use stacks::chainstate::stacks::boot::POX_4_NAME;
 use stacks::chainstate::stacks::db::StacksChainState;
 use stacks::chainstate::stacks::miner::{
-    signal_mining_blocked, signal_mining_ready, TransactionErrorEvent, TransactionEvent,
-    TransactionSuccessEvent,
+    TransactionErrorEvent, TransactionEvent, TransactionSuccessEvent,
 };
 use stacks::chainstate::stacks::{
-    StacksBlock, StacksBlockHeader, StacksMicroblock, StacksMicroblockHeader, StacksPrivateKey,
-    StacksPublicKey, StacksTransaction, TransactionContractCall, TransactionPayload,
+    StacksBlock, StacksBlockHeader, StacksMicroblock, StacksPrivateKey, StacksPublicKey,
+    StacksTransaction, TransactionContractCall, TransactionPayload,
 };
 use stacks::clarity_cli::vm_execute as execute;
 use stacks::cli;
@@ -90,8 +88,6 @@ use crate::stacks_common::types::PrivateKey;
 use crate::syncctl::PoxSyncWatchdogComms;
 use crate::tests::gen_random_port;
 use crate::tests::nakamoto_integrations::{get_key_for_cycle, wait_for};
-use crate::util::hash::{MerkleTree, Sha512Trunc256Sum};
-use crate::util::secp256k1::MessageSignature;
 use crate::{neon, BitcoinRegtestController, BurnchainController, Config, ConfigFile, Keychain};
 
 fn inner_neon_integration_test_conf(seed: Option<Vec<u8>>) -> (Config, StacksAddress) {
@@ -3316,34 +3312,6 @@ fn should_fix_2771() {
     channel.stop_chains_coordinator();
 }
 
-/// Returns a StacksMicroblock with the given transactions, sequence, and parent block that is
-/// signed with the given private key.
-fn make_signed_microblock(
-    block_privk: &StacksPrivateKey,
-    txs: Vec<StacksTransaction>,
-    parent_block: BlockHeaderHash,
-    seq: u16,
-) -> StacksMicroblock {
-    let mut rng = rand::thread_rng();
-
-    let txid_vecs: Vec<_> = txs.iter().map(|tx| tx.txid().as_bytes().to_vec()).collect();
-    let merkle_tree = MerkleTree::<Sha512Trunc256Sum>::new(&txid_vecs);
-    let tx_merkle_root = merkle_tree.root();
-
-    let mut mblock = StacksMicroblock {
-        header: StacksMicroblockHeader {
-            version: rng.gen(),
-            sequence: seq,
-            prev_block: parent_block,
-            tx_merkle_root,
-            signature: MessageSignature([0u8; 65]),
-        },
-        txs,
-    };
-    mblock.sign(block_privk).unwrap();
-    mblock
-}
-
 #[test]
 #[ignore]
 fn filter_low_fee_tx_integration_test() {
@@ -8614,38 +8582,6 @@ pub fn make_random_tx_chain(
     chain
 }
 
-fn make_mblock_tx_chain(privk: &StacksPrivateKey, fee_plus: u64, chain_id: u32) -> Vec<Vec<u8>> {
-    let addr = to_addr(privk);
-    let mut chain = vec![];
-
-    for nonce in 0..25 {
-        // N.B. private keys are 32-33 bytes, so this is always safe
-        let random_iters = privk.to_bytes()[nonce as usize] as usize;
-
-        let be_bytes = [
-            privk.to_bytes()[nonce as usize],
-            privk.to_bytes()[(nonce + 1) as usize],
-        ];
-
-        let random_extra_fee = u16::from_be_bytes(be_bytes) as u64;
-
-        let mut addr_prefix = addr.to_string();
-        let _ = addr_prefix.split_off(12);
-        let contract_name = format!("crct-{nonce}-{addr_prefix}-{random_iters}");
-        eprintln!("Make tx {contract_name}");
-        let tx = make_contract_publish_microblock_only(
-            privk,
-            nonce,
-            1049230 + nonce + fee_plus + random_extra_fee,
-            chain_id,
-            &contract_name,
-            &make_runtime_sized_contract(1, nonce, &addr_prefix),
-        );
-        chain.push(tx);
-    }
-    chain
-}
-
 fn test_competing_miners_build_on_same_chain(
     num_miners: usize,
     conf_template: Config,

testnet/stacks-node/src/tests/signer/mod.rs

@@ -1220,6 +1220,13 @@ impl<S: Signer<T> + Send + 'static, T: SignerEventTrait + 'static> SignerTest<Sp
             .send_message_with_retry::<SignerMessage>(accepted.into())
             .expect("Failed to send accept signature");
     }
+
+    pub fn signer_public_keys(&self) -> Vec<StacksPublicKey> {
+        self.signer_stacks_private_keys
+            .iter()
+            .map(StacksPublicKey::from_private)
+            .collect()
+    }
 }
 
 fn setup_stx_btc_node<G: FnMut(&mut NeonConfig)>(