Merge pull request #5959 from jferrant/feat/send-signer-state-updates

Signers send updates to stackerdb when their state is Initialized/changes

Author: obycode

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

@@ -212,6 +212,7 @@ impl SignerTrait<SignerMessage> for Signer {
             return;
         }
 
+        let prior_state = self.local_state_machine.clone();
         if self.reward_cycle <= current_reward_cycle {
             self.local_state_machine.handle_pending_update(&self.signer_db, stacks_client, &self.proposal_config)
                 .unwrap_or_else(|e| error!("{self}: failed to update local state machine for pending update"; "err" => ?e));
@@ -233,10 +234,17 @@ impl SignerTrait<SignerMessage> for Signer {
                 );
                 // try and gather signatures
                 for message in messages {
-                    let SignerMessage::BlockResponse(block_response) = message else {
-                        continue;
-                    };
-                    self.handle_block_response(stacks_client, block_response, sortition_state);
+                    match message {
+                        SignerMessage::BlockResponse(block_response) => self.handle_block_response(
+                            stacks_client,
+                            block_response,
+                            sortition_state,
+                        ),
+                        SignerMessage::StateMachineUpdate(_update) => {
+                            // TODO: should make note of this update view point to determine if there is an agreed upon global state
+                        }
+                        _ => {}
+                    }
                 }
             }
             SignerEvent::MinerMessages(messages) => {
@@ -374,6 +382,10 @@ impl SignerTrait<SignerMessage> for Signer {
                 }
             }
         }
+        if prior_state != self.local_state_machine {
+            self.local_state_machine
+                .send_signer_update_message(&mut self.stackerdb);
+        }
     }
 
     fn has_unprocessed_blocks(&self) -> bool {

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
@@ -158,7 +158,22 @@ 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 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();
+        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:?}");
+            }
         }
     }
 
@@ -256,7 +271,6 @@ impl LocalStateMachine {
                 "inactive_tenure_ch" => %inactive_tenure_ch,
                 "new_active_tenure_ch" => %new_active_tenure_ch
             );
-
             Ok(())
         } else {
             warn!("Current miner timed out due to inactivity, but prior miner is not valid. Allowing current miner to continue");

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;
@@ -15,8 +14,7 @@ use stacks::chainstate::stacks::{
 };
 use stacks::config::{EventKeyType, InitialBalance};
 use stacks::core::test_util::{
-    make_contract_call, make_contract_call_mblock_only, make_contract_publish,
-    make_contract_publish_microblock_only, to_addr,
+    make_contract_call, make_contract_call_mblock_only, make_contract_publish, to_addr,
 };
 use stacks::core::{
     self, EpochList, StacksEpoch, StacksEpochId, PEER_VERSION_EPOCH_1_0, PEER_VERSION_EPOCH_2_0,
@@ -25,7 +23,6 @@ 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::*;

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,