chore: Implement DB read for /v3/signer/ endpoint

Author: jbencin

stackslib/src/chainstate/nakamoto/mod.rs

@@ -30,6 +30,7 @@ use lazy_static::{__Deref, lazy_static};
 use rusqlite::blob::Blob;
 use rusqlite::types::{FromSql, FromSqlError, FromSqlResult, ToSql, ToSqlOutput};
 use rusqlite::{params, Connection, OpenFlags, OptionalExtension};
+use sha2::digest::typenum::Integer;
 use sha2::{Digest as Sha2Digest, Sha512_256};
 use stacks_common::bitvec::BitVec;
 use stacks_common::codec::{
@@ -3287,12 +3288,37 @@ impl NakamotoChainState {
                 StacksPublicKey::recover_to_pubkey(signer_sighash.bits(), &signer_signature)
                     .map_err(|e| ChainstateError::InvalidStacksBlock(e.to_string()))?;
             let sql = "INSERT INTO signer_stats(public_key,reward_cycle) VALUES(?1,?2) ON CONFLICT(public_key,reward_cycle) DO UPDATE SET blocks_signed=blocks_signed+1";
-            let args = params![serde_json::to_string(&signer_pubkey).unwrap(), reward_cycle];
-            tx.execute(sql, args)?;
+            let params = params![serde_json::to_string(&signer_pubkey).unwrap(), reward_cycle];
+            tx.execute(sql, params)?;
         }
         Ok(())
     }
 
+    /// Fetch number of blocks signed for a given signer and reward cycle
+    /// This is the data tracked by `record_block_signers()`
+    pub fn get_signer_block_count(
+        chainstate_db: &Connection,
+        signer_pubkey: &Secp256k1PublicKey,
+        reward_cycle: u64,
+    ) -> Result<Option<u64>, ChainstateError> {
+        let sql =
+            "SELECT blocks_signed FROM signer_stats WHERE public_key = ?1 AND reward_cycle = ?2";
+        let params = params![serde_json::to_string(&signer_pubkey).unwrap(), reward_cycle];
+        chainstate_db
+            .query_row(sql, params, |row| {
+                let value: String = row.get(2)?;
+                value.parse::<u64>().map_err(|e| {
+                    rusqlite::Error::FromSqlConversionFailure(
+                        size_of::<u64>(),
+                        rusqlite::types::Type::Integer,
+                        e.into(),
+                    )
+                })
+            })
+            .optional()
+            .map_err(ChainstateError::from)
+    }
+
     /// Begin block-processing and return all of the pre-processed state within a
     /// `SetupBlockResult`.
     ///

stackslib/src/net/api/getsigner.rs

@@ -22,6 +22,7 @@ use stacks_common::util::hash::Sha256Sum;
 use crate::burnchains::Burnchain;
 use crate::chainstate::burn::db::sortdb::SortitionDB;
 use crate::chainstate::coordinator::OnChainRewardSetProvider;
+use crate::chainstate::nakamoto::NakamotoChainState;
 use crate::chainstate::stacks::boot::{
     PoxVersions, RewardSet, POX_1_NAME, POX_2_NAME, POX_3_NAME, POX_4_NAME,
 };
@@ -53,38 +54,6 @@ pub struct GetSignerResponse {
     pub blocks_signed: u64,
 }
 
-pub enum GetSignerErrors {
-    NotAvailableYet(crate::chainstate::coordinator::Error),
-    Other(String),
-}
-
-impl GetSignerErrors {
-    pub const NOT_AVAILABLE_ERR_TYPE: &'static str = "not_available_try_again";
-    pub const OTHER_ERR_TYPE: &'static str = "other";
-
-    pub fn error_type_string(&self) -> &'static str {
-        match self {
-            Self::NotAvailableYet(_) => Self::NOT_AVAILABLE_ERR_TYPE,
-            Self::Other(_) => Self::OTHER_ERR_TYPE,
-        }
-    }
-}
-
-impl From<&str> for GetSignerErrors {
-    fn from(value: &str) -> Self {
-        GetSignerErrors::Other(value.into())
-    }
-}
-
-impl std::fmt::Display for GetSignerErrors {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        match self {
-            GetSignerErrors::NotAvailableYet(e) => write!(f, "Could not read reward set. Prepare phase may not have started for this cycle yet. Err = {e:?}"),
-            GetSignerErrors::Other(msg) => write!(f, "{msg}")
-        }
-    }
-}
-
 /// Decode the HTTP request
 impl HttpRequest for GetSignerRequestHandler {
     fn verb(&self) -> &'static str {
@@ -128,12 +97,12 @@ impl HttpRequest for GetSignerRequestHandler {
             ));
         };
 
-        let cycle_num = u64::from_str_radix(cycle_num_str.into(), 10)
-            .map_err(|e| Error::DecodeError(format!("Failed to parse cycle number: {e}")))?;
-
         let signer_pubkey = Secp256k1PublicKey::from_hex(signer_pubkey_str.into())
             .map_err(|e| Error::DecodeError(format!("Failed to signer public key: {e}")))?;
 
+        let cycle_num = u64::from_str_radix(cycle_num_str.into(), 10)
+            .map_err(|e| Error::DecodeError(format!("Failed to parse cycle number: {e}")))?;
+
         self.signer_pubkey = Some(signer_pubkey);
         self.reward_cycle = Some(cycle_num);
 
@@ -152,16 +121,9 @@ impl RPCRequestHandler for GetSignerRequestHandler {
     fn try_handle_request(
         &mut self,
         preamble: HttpRequestPreamble,
-        contents: HttpRequestContents,
+        _contents: HttpRequestContents,
         node: &mut StacksNodeState,
     ) -> Result<(HttpResponsePreamble, HttpResponseContents), NetError> {
-        let tip = match node.load_stacks_chain_tip(&preamble, &contents) {
-            Ok(tip) => tip,
-            Err(error_resp) => {
-                return error_resp.try_into_contents().map_err(NetError::from);
-            }
-        };
-
         let signer_pubkey = self
             .signer_pubkey
             .take()
@@ -172,13 +134,12 @@ impl RPCRequestHandler for GetSignerRequestHandler {
             .take()
             .ok_or(NetError::SendError("Missing `reward_cycle`".into()))?;
 
-        let result = node.with_node_state(|_network, _sortdb, _chainstate, _mempool, _rpc_args| {
-            // TODO
-            if true {
-                Ok(0u64)
-            } else {
-                Err("Something went wrong")
-            }
+        let result = node.with_node_state(|_network, _sortdb, chainstate, _mempool, _rpc_args| {
+            NakamotoChainState::get_signer_block_count(
+                &chainstate.index_conn(),
+                &signer_pubkey,
+                reward_cycle,
+            )
         });
 
         let response = match result {
@@ -238,31 +199,3 @@ impl StacksHttpResponse {
         Ok(response)
     }
 }
-
-#[cfg(test)]
-mod test {
-    use super::GetSignerErrors;
-
-    #[test]
-    // Test the formatting and error type strings of GetSignerErrors
-    fn get_signer_errors() {
-        let not_available_err = GetSignerErrors::NotAvailableYet(
-            crate::chainstate::coordinator::Error::PoXNotProcessedYet,
-        );
-        let other_err = GetSignerErrors::Other("foo".into());
-
-        assert_eq!(
-            not_available_err.error_type_string(),
-            GetSignerErrors::NOT_AVAILABLE_ERR_TYPE
-        );
-        assert_eq!(
-            other_err.error_type_string(),
-            GetSignerErrors::OTHER_ERR_TYPE
-        );
-
-        assert!(not_available_err
-            .to_string()
-            .starts_with("Could not read reward set"));
-        assert_eq!(other_err.to_string(), "foo".to_string());
-    }
-}