Merge branch 'develop' into fix/5193-stackerdb-decoherence

Author: jcnelson

stacks-signer/src/client/mod.rs

@@ -603,4 +603,9 @@ pub(crate) mod tests {
             serde_json::to_string(header_types).expect("Failed to serialize tenure tip info");
         format!("HTTP/1.1 200 OK\n\n{response_json}")
     }
+
+    pub fn build_get_last_set_cycle_response(cycle: u64) -> String {
+        let clarity_value = ClarityValue::okay(ClarityValue::UInt(cycle as u128)).unwrap();
+        build_read_only_response(&clarity_value)
+    }
 }

stacks-signer/src/client/stacks_client.rs

@@ -19,7 +19,7 @@ use std::net::SocketAddr;
 use blockstack_lib::burnchains::Txid;
 use blockstack_lib::chainstate::nakamoto::NakamotoBlock;
 use blockstack_lib::chainstate::stacks::boot::{
-    NakamotoSignerEntry, SIGNERS_VOTING_FUNCTION_NAME, SIGNERS_VOTING_NAME,
+    NakamotoSignerEntry, SIGNERS_NAME, SIGNERS_VOTING_FUNCTION_NAME, SIGNERS_VOTING_NAME,
 };
 use blockstack_lib::chainstate::stacks::db::StacksBlockHeaderTypes;
 use blockstack_lib::chainstate::stacks::{
@@ -162,6 +162,20 @@ impl StacksClient {
         Ok(sortition_info)
     }
 
+    /// Get the last set reward cycle stored within the stackerdb contract
+    pub fn get_last_set_cycle(&self) -> Result<u128, ClientError> {
+        let signer_stackerdb_contract_id = boot_code_id(SIGNERS_NAME, self.mainnet);
+        let function_name_str = "get-last-set-cycle";
+        let function_name = ClarityName::from(function_name_str);
+        let value = self.read_only_contract_call(
+            &signer_stackerdb_contract_id.issuer.clone().into(),
+            &signer_stackerdb_contract_id.name,
+            &function_name,
+            &[],
+        )?;
+        Ok(value.expect_result_ok()?.expect_u128()?)
+    }
+
     /// Retrieve the signer slots stored within the stackerdb contract
     pub fn get_stackerdb_signer_slots(
         &self,
@@ -450,7 +464,10 @@ impl StacksClient {
             "last_sortition" => %last_sortition,
         );
         let path = self.tenure_forking_info_path(chosen_parent, last_sortition);
-        let timer = crate::monitoring::new_rpc_call_timer(&path, &self.http_origin);
+        let timer = crate::monitoring::new_rpc_call_timer(
+            "/v3/tenures/fork_info/:start/:stop",
+            &self.http_origin,
+        );
         let send_request = || {
             self.stacks_node_client
                 .get(&path)
@@ -491,7 +508,8 @@ impl StacksClient {
     pub fn get_sortition(&self, ch: &ConsensusHash) -> Result<SortitionInfo, ClientError> {
         debug!("stacks_node_client: Getting sortition with consensus hash {ch}...");
         let path = format!("{}/consensus/{}", self.sortition_info_path(), ch.to_hex());
-        let timer = crate::monitoring::new_rpc_call_timer(&path, &self.http_origin);
+        let timer_label = format!("{}/consensus/:consensus_hash", self.sortition_info_path());
+        let timer = crate::monitoring::new_rpc_call_timer(&timer_label, &self.http_origin);
         let send_request = || {
             self.stacks_node_client.get(&path).send().map_err(|e| {
                 warn!("Signer failed to request sortition"; "consensus_hash" => %ch, "err" => ?e);
@@ -561,7 +579,7 @@ impl StacksClient {
     ) -> Result<Option<Vec<NakamotoSignerEntry>>, ClientError> {
         debug!("stacks_node_client: Getting reward set signers for reward cycle {reward_cycle}...");
         let timer = crate::monitoring::new_rpc_call_timer(
-            &self.reward_set_path(reward_cycle),
+            &format!("{}/v3/stacker_set/:reward_cycle", self.http_origin),
             &self.http_origin,
         );
         let send_request = || {
@@ -581,7 +599,7 @@ impl StacksClient {
                 backoff::Error::permanent(e.into())
             })?;
             if error_data.err_type == GetStackersErrors::NOT_AVAILABLE_ERR_TYPE {
-                Err(backoff::Error::transient(ClientError::NoSortitionOnChain))
+                Err(backoff::Error::permanent(ClientError::NoSortitionOnChain))
             } else {
                 warn!("Got error response ({status}): {}", error_data.err_msg);
                 Err(backoff::Error::permanent(ClientError::RequestFailure(
@@ -644,8 +662,8 @@ impl StacksClient {
         address: &StacksAddress,
     ) -> Result<AccountEntryResponse, ClientError> {
         debug!("stacks_node_client: Getting account info...");
-        let timer =
-            crate::monitoring::new_rpc_call_timer(&self.accounts_path(address), &self.http_origin);
+        let timer_label = format!("{}/v2/accounts/:principal", self.http_origin);
+        let timer = crate::monitoring::new_rpc_call_timer(&timer_label, &self.http_origin);
         let send_request = || {
             self.stacks_node_client
                 .get(self.accounts_path(address))
@@ -797,7 +815,11 @@ impl StacksClient {
         let body =
             json!({"sender": self.stacks_address.to_string(), "arguments": args}).to_string();
         let path = self.read_only_path(contract_addr, contract_name, function_name);
-        let timer = crate::monitoring::new_rpc_call_timer(&path, &self.http_origin);
+        let timer_label = format!(
+            "{}/v2/contracts/call-read/:principal/{contract_name}/{function_name}",
+            self.http_origin
+        );
+        let timer = crate::monitoring::new_rpc_call_timer(&timer_label, &self.http_origin);
         let response = self
             .stacks_node_client
             .post(path)
@@ -962,11 +984,11 @@ mod tests {
     use super::*;
     use crate::client::tests::{
         build_account_nonce_response, build_get_approved_aggregate_key_response,
-        build_get_last_round_response, build_get_medium_estimated_fee_ustx_response,
-        build_get_peer_info_response, build_get_pox_data_response, build_get_round_info_response,
-        build_get_tenure_tip_response, build_get_vote_for_aggregate_key_response,
-        build_get_weight_threshold_response, build_read_only_response, write_response,
-        MockServerClient,
+        build_get_last_round_response, build_get_last_set_cycle_response,
+        build_get_medium_estimated_fee_ustx_response, build_get_peer_info_response,
+        build_get_pox_data_response, build_get_round_info_response, build_get_tenure_tip_response,
+        build_get_vote_for_aggregate_key_response, build_get_weight_threshold_response,
+        build_read_only_response, write_response, MockServerClient,
     };
 
     #[test]
@@ -1623,4 +1645,14 @@ mod tests {
         write_response(mock.server, response.as_bytes());
         assert_eq!(h.join().unwrap().unwrap(), header);
     }
+
+    #[test]
+    fn get_last_set_cycle_should_succeed() {
+        let mock = MockServerClient::new();
+        let reward_cycle = thread_rng().next_u64();
+        let response = build_get_last_set_cycle_response(reward_cycle);
+        let h = spawn(move || mock.client.get_last_set_cycle());
+        write_response(mock.server, response.as_bytes());
+        assert_eq!(h.join().unwrap().unwrap(), reward_cycle as u128);
+    }
 }

stacks-signer/src/runloop.rs

@@ -34,6 +34,17 @@ use crate::client::{retry_with_exponential_backoff, ClientError, SignerSlotID, S
 use crate::config::{GlobalConfig, SignerConfig};
 use crate::Signer as SignerTrait;
 
+#[derive(thiserror::Error, Debug)]
+/// Configuration error type
+pub enum ConfigurationError {
+    /// Error occurred while fetching data from the stacks node
+    #[error("{0}")]
+    ClientError(#[from] ClientError),
+    /// The stackerdb signer config is not yet updated
+    #[error("The stackerdb config is not yet updated")]
+    StackerDBNotUpdated,
+}
+
 /// The internal signer state info
 #[derive(PartialEq, Clone, Debug)]
 pub struct StateInfo {
@@ -274,24 +285,40 @@ impl<Signer: SignerTrait<T>, T: StacksMessageCodec + Clone + Send + Debug> RunLo
     fn get_signer_config(
         &mut self,
         reward_cycle: u64,
-    ) -> Result<Option<SignerConfig>, ClientError> {
+    ) -> Result<Option<SignerConfig>, ConfigurationError> {
         // We can only register for a reward cycle if a reward set exists.
         let signer_entries = match self.get_parsed_reward_set(reward_cycle) {
             Ok(Some(x)) => x,
             Ok(None) => return Ok(None),
             Err(e) => {
                 warn!("Error while fetching reward set {reward_cycle}: {e:?}");
-                return Err(e);
+                return Err(e.into());
             }
         };
-        let signer_slot_ids = match self.get_parsed_signer_slots(&self.stacks_client, reward_cycle)
-        {
-            Ok(x) => x,
-            Err(e) => {
+
+        // Ensure that the stackerdb has been updated for the reward cycle before proceeding
+        let last_calculated_reward_cycle =
+            self.stacks_client.get_last_set_cycle().map_err(|e| {
+                warn!(
+                    "Failed to fetch last calculated stackerdb cycle from stacks-node";
+                    "reward_cycle" => reward_cycle,
+                    "err" => ?e
+                );
+                ConfigurationError::StackerDBNotUpdated
+            })?;
+        if last_calculated_reward_cycle < reward_cycle as u128 {
+            warn!(
+                "Stackerdb has not been updated for reward cycle {reward_cycle}. Last calculated reward cycle is {last_calculated_reward_cycle}."
+            );
+            return Err(ConfigurationError::StackerDBNotUpdated);
+        }
+
+        let signer_slot_ids = self
+            .get_parsed_signer_slots(&self.stacks_client, reward_cycle)
+            .map_err(|e| {
                 warn!("Error while fetching stackerdb slots {reward_cycle}: {e:?}");
-                return Err(e);
-            }
-        };
+                e
+            })?;
         let current_addr = self.stacks_client.get_signer_address();
 
         let Some(signer_slot_id) = signer_slot_ids.get(current_addr) else {