Merge branch 'develop' into feat/signature-count-endpoint

Author: saralab

libsigner/src/v0/messages.rs

@@ -275,6 +275,8 @@ pub struct PeerInfo {
     pub pox_consensus: ConsensusHash,
     /// The server version
     pub server_version: String,
+    /// The network id
+    pub network_id: u32,
 }
 
 impl StacksMessageCodec for PeerInfo {
@@ -287,6 +289,7 @@ impl StacksMessageCodec for PeerInfo {
         fd.write_all(self.server_version.as_bytes())
             .map_err(CodecError::WriteError)?;
         write_next(fd, &self.pox_consensus)?;
+        write_next(fd, &self.network_id)?;
         Ok(())
     }
 
@@ -305,13 +308,15 @@ impl StacksMessageCodec for PeerInfo {
             )
         })?;
         let pox_consensus = read_next::<ConsensusHash, _>(fd)?;
+        let network_id = read_next(fd)?;
         Ok(Self {
             burn_block_height,
             stacks_tip_consensus_hash,
             stacks_tip,
             stacks_tip_height,
             server_version,
             pox_consensus,
+            network_id,
         })
     }
 }
@@ -321,18 +326,15 @@ impl StacksMessageCodec for PeerInfo {
 pub struct MockProposal {
     /// The view of the stacks node peer information at the time of the mock proposal
     pub peer_info: PeerInfo,
-    /// The chain id for the mock proposal
-    pub chain_id: u32,
     /// The miner's signature across the peer info
     signature: MessageSignature,
 }
 
 impl MockProposal {
     /// Create a new mock proposal data struct from the provided peer info, chain id, and private key.
-    pub fn new(peer_info: PeerInfo, chain_id: u32, stacks_private_key: &StacksPrivateKey) -> Self {
+    pub fn new(peer_info: PeerInfo, stacks_private_key: &StacksPrivateKey) -> Self {
         let mut sig = Self {
             signature: MessageSignature::empty(),
-            chain_id,
             peer_info,
         };
         sig.sign(stacks_private_key)
@@ -342,7 +344,8 @@ impl MockProposal {
 
     /// The signature hash for the mock proposal
     pub fn miner_signature_hash(&self) -> Sha256Sum {
-        let domain_tuple = make_structured_data_domain("mock-miner", "1.0.0", self.chain_id);
+        let domain_tuple =
+            make_structured_data_domain("mock-miner", "1.0.0", self.peer_info.network_id);
         let data_tuple = Value::Tuple(
             TupleData::from_data(vec![
                 (
@@ -375,7 +378,8 @@ impl MockProposal {
 
     /// The signature hash including the miner's signature. Used by signers.
     fn signer_signature_hash(&self) -> Sha256Sum {
-        let domain_tuple = make_structured_data_domain("mock-signer", "1.0.0", self.chain_id);
+        let domain_tuple =
+            make_structured_data_domain("mock-signer", "1.0.0", self.peer_info.network_id);
         let data_tuple = Value::Tuple(
             TupleData::from_data(vec![
                 (
@@ -413,18 +417,15 @@ impl MockProposal {
 impl StacksMessageCodec for MockProposal {
     fn consensus_serialize<W: Write>(&self, fd: &mut W) -> Result<(), CodecError> {
         self.peer_info.consensus_serialize(fd)?;
-        write_next(fd, &self.chain_id)?;
         write_next(fd, &self.signature)?;
         Ok(())
     }
 
     fn consensus_deserialize<R: Read>(fd: &mut R) -> Result<Self, CodecError> {
         let peer_info = PeerInfo::consensus_deserialize(fd)?;
-        let chain_id = read_next::<u32, _>(fd)?;
         let signature = read_next::<MessageSignature, _>(fd)?;
         Ok(Self {
             peer_info,
-            chain_id,
             signature,
         })
     }
@@ -1024,26 +1025,26 @@ mod test {
         let stacks_tip_height = thread_rng().next_u64();
         let server_version = "0.0.0".to_string();
         let pox_consensus_byte: u8 = thread_rng().gen();
+        let network_byte: u8 = thread_rng().gen_range(0..=1);
+        let network_id = if network_byte == 1 {
+            CHAIN_ID_TESTNET
+        } else {
+            CHAIN_ID_MAINNET
+        };
         PeerInfo {
             burn_block_height,
             stacks_tip_consensus_hash: ConsensusHash([stacks_tip_consensus_byte; 20]),
             stacks_tip: BlockHeaderHash([stacks_tip_byte; 32]),
             stacks_tip_height,
             server_version,
             pox_consensus: ConsensusHash([pox_consensus_byte; 20]),
+            network_id,
         }
     }
     fn random_mock_proposal() -> MockProposal {
-        let chain_byte: u8 = thread_rng().gen_range(0..=1);
-        let chain_id = if chain_byte == 1 {
-            CHAIN_ID_TESTNET
-        } else {
-            CHAIN_ID_MAINNET
-        };
         let peer_info = random_peer_data();
         MockProposal {
             peer_info,
-            chain_id,
             signature: MessageSignature::empty(),
         }
     }

stacks-signer/src/cli.rs

@@ -97,6 +97,8 @@ pub enum Command {
     GenerateVote(GenerateVoteArgs),
     /// Verify the vote for a specified SIP against a public key and vote info
     VerifyVote(VerifyVoteArgs),
+    /// Verify signer signatures by checking stackerdb slots contain the correct data
+    MonitorSigners(MonitorSignersArgs),
 }
 
 /// Basic arguments for all cyrptographic and stacker-db functionality
@@ -258,6 +260,20 @@ impl TryFrom<u8> for Vote {
     }
 }
 
+#[derive(Parser, Debug, Clone)]
+/// Arguments for the MonitorSigners command
+pub struct MonitorSignersArgs {
+    /// The Stacks node to connect to
+    #[arg(long)]
+    pub host: String,
+    /// Set the polling interval in seconds.
+    #[arg(long, short, default_value = "60")]
+    pub interval: u64,
+    /// Max age in seconds before a signer message is considered stale.
+    #[arg(long, short, default_value = "1200")]
+    pub max_age: u64,
+}
+
 #[derive(Clone, Debug, PartialEq)]
 /// Wrapper around `Pox4SignatureTopic` to implement `ValueEnum`
 pub struct StackingSignatureMethod(Pox4SignatureTopic);

stacks-signer/src/client/mod.rs

@@ -23,6 +23,7 @@ use std::time::Duration;
 
 use clarity::vm::errors::Error as ClarityError;
 use clarity::vm::types::serialization::SerializationError;
+use libsigner::RPCError;
 use libstackerdb::Error as StackerDBError;
 use slog::slog_debug;
 pub use stackerdb::*;
@@ -94,6 +95,9 @@ pub enum ClientError {
     /// A successful sortition's info response should be parseable into a SortitionState
     #[error("A successful sortition's info response should be parseable into a SortitionState")]
     UnexpectedSortitionInfo,
+    /// An RPC libsigner error occurred
+    #[error("A libsigner RPC error occurred: {0}")]
+    RPCError(#[from] RPCError),
 }
 
 /// Retry a function F with an exponential backoff and notification on transient failure

stacks-signer/src/client/stacks_client.rs

@@ -13,8 +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::VecDeque;
-use std::net::SocketAddr;
+use std::collections::{HashMap, VecDeque};
 
 use blockstack_lib::burnchains::Txid;
 use blockstack_lib::chainstate::nakamoto::NakamotoBlock;
@@ -57,6 +56,7 @@ use stacks_common::types::StacksEpochId;
 use stacks_common::{debug, warn};
 use wsts::curve::point::{Compressed, Point};
 
+use super::SignerSlotID;
 use crate::client::{retry_with_exponential_backoff, ClientError};
 use crate::config::GlobalConfig;
 use crate::runloop::RewardCycleInfo;
@@ -75,7 +75,7 @@ pub struct StacksClient {
     /// The chain we are interacting with
     chain_id: u32,
     /// Whether we are mainnet or not
-    mainnet: bool,
+    pub mainnet: bool,
     /// The Client used to make HTTP connects
     stacks_node_client: reqwest::blocking::Client,
     /// the auth password for the stacks node
@@ -116,7 +116,7 @@ impl StacksClient {
     /// Create a new signer StacksClient with the provided private key, stacks node host endpoint, version, and auth password
     pub fn new(
         stacks_private_key: StacksPrivateKey,
-        node_host: SocketAddr,
+        node_host: String,
         auth_password: String,
         mainnet: bool,
     ) -> Self {
@@ -144,6 +144,28 @@ impl StacksClient {
         }
     }
 
+    /// Create a new signer StacksClient and attempt to connect to the stacks node to determine the version
+    pub fn try_from_host(
+        stacks_private_key: StacksPrivateKey,
+        node_host: String,
+        auth_password: String,
+    ) -> Result<Self, ClientError> {
+        let mut stacks_client = Self::new(stacks_private_key, node_host, auth_password, true);
+        let pubkey = StacksPublicKey::from_private(&stacks_private_key);
+        let info = stacks_client.get_peer_info()?;
+        if info.network_id == CHAIN_ID_MAINNET {
+            stacks_client.mainnet = true;
+            stacks_client.chain_id = CHAIN_ID_MAINNET;
+            stacks_client.tx_version = TransactionVersion::Mainnet;
+        } else {
+            stacks_client.mainnet = false;
+            stacks_client.chain_id = CHAIN_ID_TESTNET;
+            stacks_client.tx_version = TransactionVersion::Testnet;
+        }
+        stacks_client.stacks_address = StacksAddress::p2pkh(stacks_client.mainnet, &pubkey);
+        Ok(stacks_client)
+    }
+
     /// Get our signer address
     pub const fn get_signer_address(&self) -> &StacksAddress {
         &self.stacks_address
@@ -204,7 +226,7 @@ impl StacksClient {
     }
 
     /// Helper function  that attempts to deserialize a clarity hext string as a list of signer slots and their associated number of signer slots
-    pub fn parse_signer_slots(
+    fn parse_signer_slots(
         &self,
         value: ClarityValue,
     ) -> Result<Vec<(StacksAddress, u128)>, ClientError> {
@@ -226,6 +248,31 @@ impl StacksClient {
         Ok(signer_slots)
     }
 
+    /// Get the stackerdb signer slots for a specific reward cycle
+    pub fn get_parsed_signer_slots(
+        &self,
+        reward_cycle: u64,
+    ) -> Result<HashMap<StacksAddress, SignerSlotID>, ClientError> {
+        let signer_set =
+            u32::try_from(reward_cycle % 2).expect("FATAL: reward_cycle % 2 exceeds u32::MAX");
+        let signer_stackerdb_contract_id = boot_code_id(SIGNERS_NAME, self.mainnet);
+        // Get the signer writers from the stacker-db to find the signer slot id
+        let stackerdb_signer_slots =
+            self.get_stackerdb_signer_slots(&signer_stackerdb_contract_id, signer_set)?;
+        Ok(stackerdb_signer_slots
+            .into_iter()
+            .enumerate()
+            .map(|(index, (address, _))| {
+                (
+                    address,
+                    SignerSlotID(
+                        u32::try_from(index).expect("FATAL: number of signers exceeds u32::MAX"),
+                    ),
+                )
+            })
+            .collect())
+    }
+
     /// Get the vote for a given  round, reward cycle, and signer address
     pub fn get_vote_for_aggregate_public_key(
         &self,

stacks-signer/src/lib.rs

@@ -29,12 +29,16 @@ pub mod cli;
 pub mod client;
 /// The configuration module for the signer
 pub mod config;
+/// The signer monitor for observing signer behaviours in the network
+pub mod monitor_signers;
 /// The monitoring server for the signer
 pub mod monitoring;
 /// The primary runloop for the signer
 pub mod runloop;
 /// The signer state module
 pub mod signerdb;
+/// The util module for the signer
+pub mod utils;
 /// The v0 implementation of the signer. This does not include WSTS support
 pub mod v0;
 /// The v1 implementation of the singer. This includes WSTS support

stacks-signer/src/main.rs

@@ -31,29 +31,25 @@ use std::io::{self, Write};
 use blockstack_lib::util_lib::signed_structured_data::pox4::make_pox_4_signer_key_signature;
 use clap::Parser;
 use clarity::types::chainstate::StacksPublicKey;
-use clarity::vm::types::QualifiedContractIdentifier;
-use libsigner::{SignerSession, StackerDBSession};
+use clarity::util::sleep_ms;
+use libsigner::SignerSession;
 use libstackerdb::StackerDBChunkData;
-use slog::slog_debug;
-use stacks_common::debug;
+use slog::{slog_debug, slog_error};
 use stacks_common::util::hash::to_hex;
 use stacks_common::util::secp256k1::MessageSignature;
+use stacks_common::{debug, error};
 use stacks_signer::cli::{
     Cli, Command, GenerateStackingSignatureArgs, GenerateVoteArgs, GetChunkArgs,
-    GetLatestChunkArgs, PutChunkArgs, RunSignerArgs, StackerDBArgs, VerifyVoteArgs,
+    GetLatestChunkArgs, MonitorSignersArgs, PutChunkArgs, RunSignerArgs, StackerDBArgs,
+    VerifyVoteArgs,
 };
 use stacks_signer::config::GlobalConfig;
+use stacks_signer::monitor_signers::SignerMonitor;
+use stacks_signer::utils::stackerdb_session;
 use stacks_signer::v0::SpawnedSigner;
 use tracing_subscriber::prelude::*;
 use tracing_subscriber::{fmt, EnvFilter};
 
-/// Create a new stacker db session
-fn stackerdb_session(host: &str, contract: QualifiedContractIdentifier) -> StackerDBSession {
-    let mut session = StackerDBSession::new(host, contract.clone());
-    session.connect(host.to_string(), contract).unwrap();
-    session
-}
-
 /// Write the chunk to stdout
 fn write_chunk_to_stdout(chunk_opt: Option<Vec<u8>>) {
     if let Some(chunk) = chunk_opt.as_ref() {
@@ -188,6 +184,20 @@ fn handle_verify_vote(args: VerifyVoteArgs, do_print: bool) -> bool {
     valid_vote
 }
 
+fn handle_monitor_signers(args: MonitorSignersArgs) {
+    // Verify that the host is a valid URL
+    let mut signer_monitor = SignerMonitor::new(args);
+    loop {
+        if let Err(e) = signer_monitor.start() {
+            error!(
+                "Error occurred monitoring signers: {:?}. Waiting and trying again.",
+                e
+            );
+            sleep_ms(1000);
+        }
+    }
+}
+
 fn main() {
     let cli = Cli::parse();
 
@@ -224,6 +234,9 @@ fn main() {
         Command::VerifyVote(args) => {
             handle_verify_vote(args, true);
         }
+        Command::MonitorSigners(args) => {
+            handle_monitor_signers(args);
+        }
     }
 }