chore: cargo fmt

Author: jcnelson

stacks-signer/src/client/stacks_client.rs

@@ -685,7 +685,11 @@ impl StacksClient {
     pub fn post_block(&self, block: &NakamotoBlock) -> Result<bool, ClientError> {
         let response = self
             .stacks_node_client
-            .post(format!("{}{}?broadcast=1", self.http_origin, postblock_v3::PATH))
+            .post(format!(
+                "{}{}?broadcast=1",
+                self.http_origin,
+                postblock_v3::PATH
+            ))
             .header("Content-Type", "application/octet-stream")
             .header(AUTHORIZATION, self.auth_password.clone())
             .body(block.serialize_to_vec())

stacks-signer/src/signerdb.rs

@@ -554,19 +554,17 @@ impl SignerDb {
         let args = params![block_sighash];
         let sigs_txt: Vec<String> = query_rows(&self.db, qry, args)?;
         sigs_txt
-           .into_iter()
-           .map(|sig_txt| {
-                serde_json::from_str(&sig_txt).map_err(|_| DBError::ParseError)
-            })
-           .collect()
+            .into_iter()
+            .map(|sig_txt| serde_json::from_str(&sig_txt).map_err(|_| DBError::ParseError))
+            .collect()
     }
 
     /// Mark a block as having been broadcasted
     pub fn set_block_broadcasted(
         &self,
         reward_cycle: u64,
         block_sighash: &Sha512Trunc256Sum,
-        ts: u64
+        ts: u64,
     ) -> Result<(), DBError> {
         let qry = "UPDATE blocks SET broadcasted = ?1 WHERE reward_cycle = ?2 AND signer_signature_hash = ?3";
         let args = params![u64_to_sql(ts)?, u64_to_sql(reward_cycle)?, block_sighash];
@@ -917,19 +915,20 @@ mod tests {
         db.set_block_broadcasted(
             block_info_1.reward_cycle,
             &block_info_1.signer_signature_hash(),
-            12345
+            12345,
         )
         .unwrap();
         db.insert_block(&block_info_1)
             .expect("Unable to insert block into db a second time");
 
-        assert_eq!(db
-            .get_block_broadcasted(
+        assert_eq!(
+            db.get_block_broadcasted(
                 block_info_1.reward_cycle,
                 &block_info_1.signer_signature_hash()
             )
             .unwrap()
             .unwrap(),
-            12345);
+            12345
+        );
     }
 }

stacks-signer/src/v0/signer.rs

@@ -29,9 +29,9 @@ use libsigner::v0::messages::{
 use libsigner::{BlockProposal, SignerEvent};
 use slog::{slog_debug, slog_error, slog_info, slog_warn};
 use stacks_common::types::chainstate::StacksAddress;
+use stacks_common::util::get_epoch_time_secs;
 use stacks_common::util::hash::Sha512Trunc256Sum;
 use stacks_common::util::secp256k1::MessageSignature;
-use stacks_common::util::get_epoch_time_secs;
 use stacks_common::{debug, error, info, warn};
 
 use crate::chainstate::{ProposalEvalConfig, SortitionsView};
@@ -482,7 +482,7 @@ impl Signer {
                 (
                     BlockResponse::accepted(signer_signature_hash, signature),
                     block_info,
-                    Some(signature.clone())
+                    Some(signature.clone()),
                 )
             }
             BlockValidateResponse::Reject(block_validate_reject) => {
@@ -507,7 +507,7 @@ impl Signer {
                 (
                     BlockResponse::from(block_validate_reject.clone()),
                     block_info,
-                    None
+                    None,
                 )
             }
         };
@@ -545,7 +545,7 @@ impl Signer {
     /// Compute the signing weight, given a list of signatures
     fn compute_signature_signing_weight<'a>(
         &self,
-        addrs: impl Iterator<Item=&'a StacksAddress>
+        addrs: impl Iterator<Item = &'a StacksAddress>,
     ) -> u32 {
         let signing_weight = addrs.fold(0usize, |signing_weight, stacker_address| {
             let stacker_weight = self.signer_weights.get(&stacker_address).unwrap_or(&0);
@@ -587,13 +587,15 @@ impl Signer {
                 panic!("{self}: failed to determine if block {block_hash} was broadcasted")
             })
         {
-            debug!("{self}: have already broadcasted block {} at {}, so will not re-attempt", block_hash, ts);
+            debug!(
+                "{self}: have already broadcasted block {} at {}, so will not re-attempt",
+                block_hash, ts
+            );
             return;
         }
 
         // recover public key
-        let Ok(public_key) =
-            Secp256k1PublicKey::recover_to_pubkey(block_hash.bits(), signature)
+        let Ok(public_key) = Secp256k1PublicKey::recover_to_pubkey(block_hash.bits(), signature)
         else {
             debug!("{self}: Received unrecovarable signature. Will not store.";
                    "signature" => %signature,
@@ -675,13 +677,13 @@ impl Signer {
 
         // record time at which we reached the threshold
         block_info.signed_group = Some(get_epoch_time_secs());
-        let _ = self
-            .signer_db
-            .insert_block(&block_info)
-            .map_err(|e| {
-                warn!("Failed to set group threshold signature timestamp for {}: {:?}", block_hash, &e);
-                e
-            });
+        let _ = self.signer_db.insert_block(&block_info).map_err(|e| {
+            warn!(
+                "Failed to set group threshold signature timestamp for {}: {:?}",
+                block_hash, &e
+            );
+            e
+        });
 
         // collect signatures for the block
         let signatures: Vec<_> = self

stackslib/src/net/api/mod.rs

@@ -131,7 +131,9 @@ impl StacksHttp {
         self.register_rpc_endpoint(postblock_proposal::RPCBlockProposalRequestHandler::new(
             self.auth_token.clone(),
         ));
-        self.register_rpc_endpoint(postblock_v3::RPCPostBlockRequestHandler::new(self.auth_token.clone()));
+        self.register_rpc_endpoint(postblock_v3::RPCPostBlockRequestHandler::new(
+            self.auth_token.clone(),
+        ));
         self.register_rpc_endpoint(postfeerate::RPCPostFeeRateRequestHandler::new());
         self.register_rpc_endpoint(postmempoolquery::RPCMempoolQueryRequestHandler::new());
         self.register_rpc_endpoint(postmicroblock::RPCPostMicroblockRequestHandler::new());

stackslib/src/net/api/postblock_v3.rs

@@ -16,6 +16,7 @@
 use regex::{Captures, Regex};
 use stacks_common::codec::{Error as CodecError, StacksMessageCodec, MAX_PAYLOAD_LEN};
 use stacks_common::types::net::PeerHost;
+use url::form_urlencoded;
 
 use super::postblock::StacksBlockAcceptedData;
 use crate::chainstate::nakamoto::staging_blocks::NakamotoBlockObtainMethod;
@@ -31,23 +32,21 @@ use crate::net::httpcore::{
 use crate::net::relay::Relayer;
 use crate::net::{Error as NetError, NakamotoBlocksData, StacksMessageType, StacksNodeState};
 
-use url::form_urlencoded;
-
 pub static PATH: &'static str = "/v3/blocks/upload/";
 
 #[derive(Clone, Default)]
 pub struct RPCPostBlockRequestHandler {
     pub block: Option<NakamotoBlock>,
     pub auth: Option<String>,
-    pub broadcast: Option<bool>
+    pub broadcast: Option<bool>,
 }
 
 impl RPCPostBlockRequestHandler {
     pub fn new(auth: Option<String>) -> Self {
         Self {
             block: None,
             auth,
-            broadcast: None
+            broadcast: None,
         }
     }
 
@@ -172,7 +171,7 @@ impl RPCRequestHandler for RPCPostBlockRequestHandler {
                     &block,
                     rpc_args.coord_comms,
                     NakamotoBlockObtainMethod::Uploaded,
-                    self.broadcast.unwrap_or(false)
+                    self.broadcast.unwrap_or(false),
                 )
             })
             .map_err(|e| {
@@ -226,9 +225,13 @@ impl StacksHttpRequest {
         )
         .expect("FATAL: failed to construct request from infallible data")
     }
-    
+
     /// Make a new post-block request, with intent to broadcast
-    pub fn new_post_block_v3_broadcast(host: PeerHost, block: &NakamotoBlock, auth: &str) -> StacksHttpRequest {
+    pub fn new_post_block_v3_broadcast(
+        host: PeerHost,
+        block: &NakamotoBlock,
+        auth: &str,
+    ) -> StacksHttpRequest {
         let mut request = StacksHttpRequest::new_for_peer(
             host,
             "POST".into(),

stackslib/src/net/api/tests/postblock_v3.rs

@@ -79,14 +79,14 @@ fn parse_request() {
             &bytes[offset..],
         )
         .unwrap();
-    
+
     parsed_request.clear_headers();
     parsed_request.add_header("authorization".into(), "12345".into());
     let (preamble, _contents) = parsed_request.destruct();
 
     assert_eq!(&preamble, request.preamble());
     assert_eq!(handler.broadcast, Some(true));
-     
+
     handler.restart();
     assert!(handler.block.is_none());
     assert!(handler.broadcast.is_none());
@@ -115,7 +115,8 @@ fn parse_request() {
     assert!(handler.broadcast.is_none());
 
     // deal with bad authentication
-    let request = StacksHttpRequest::new_post_block_v3_broadcast(addr.into(), &block, "wrong password");
+    let request =
+        StacksHttpRequest::new_post_block_v3_broadcast(addr.into(), &block, "wrong password");
     let bytes = request.try_serialize().unwrap();
     let (parsed_preamble, offset) = http.read_preamble(&bytes).unwrap();
     let bad_response = http.handle_try_parse_request(

stackslib/src/net/download/nakamoto/download_state_machine.rs

@@ -774,7 +774,10 @@ impl NakamotoDownloadStateMachine {
         let last_sort_height = last_sort_height_opt.unwrap_or(sort_tip.block_height);
         let sort_rc = sortdb
             .pox_constants
-            .block_height_to_reward_cycle(sortdb.first_block_height, last_sort_height.saturating_add(1))
+            .block_height_to_reward_cycle(
+                sortdb.first_block_height,
+                last_sort_height.saturating_add(1),
+            )
             .expect("FATAL: burnchain tip is before system start");
 
         let next_sort_rc = if last_sort_height == sort_tip.block_height {
@@ -788,7 +791,10 @@ impl NakamotoDownloadStateMachine {
         } else {
             sortdb
                 .pox_constants
-                .block_height_to_reward_cycle(sortdb.first_block_height, sort_tip.block_height.saturating_add(1))
+                .block_height_to_reward_cycle(
+                    sortdb.first_block_height,
+                    sort_tip.block_height.saturating_add(1),
+                )
                 .expect("FATAL: burnchain tip is before system start")
         };
 

stackslib/src/net/download/nakamoto/tenure_downloader.rs

@@ -681,9 +681,7 @@ impl NakamotoTenureDownloader {
                 let blocks_opt = self.try_accept_tenure_blocks(blocks)?;
                 Ok(blocks_opt)
             }
-            NakamotoTenureDownloadState::Done => {
-                Err(NetError::InvalidState)
-            }
+            NakamotoTenureDownloadState::Done => Err(NetError::InvalidState),
         };
         self.idle = true;
         handle_result

stackslib/src/net/inv/nakamoto.rs

@@ -812,7 +812,8 @@ impl<NC: NeighborComms> NakamotoInvStateMachine<NC> {
         if let Some(last_sort_tip) = self.last_sort_tip.as_ref() {
             if last_sort_tip.consensus_hash != network.burnchain_tip.consensus_hash {
                 debug!("Forcibly restarting all Nakamoto inventory comms due to burnchain tip change ({} != {})", &last_sort_tip.consensus_hash, &network.burnchain_tip.consensus_hash);
-                let tip_rc = NakamotoTenureInv::get_current_reward_cycle(&network.burnchain_tip, sortdb);
+                let tip_rc =
+                    NakamotoTenureInv::get_current_reward_cycle(&network.burnchain_tip, sortdb);
                 for inv_state in self.inventories.values_mut() {
                     inv_state.reset_comms(tip_rc.saturating_sub(1));
                 }

stackslib/src/net/relay.rs

@@ -790,7 +790,7 @@ impl Relayer {
         }
         Ok(res)
     }
-    
+
     /// Wrapper around inner_process_new_nakamoto_block
     pub fn process_new_nakamoto_block(
         burnchain: &Burnchain,
@@ -811,7 +811,7 @@ impl Relayer {
             block,
             coord_comms,
             obtained_method,
-            false
+            false,
         )
     }
 
@@ -836,7 +836,7 @@ impl Relayer {
         block: &NakamotoBlock,
         coord_comms: Option<&CoordinatorChannels>,
         obtained_method: NakamotoBlockObtainMethod,
-        force_broadcast: bool
+        force_broadcast: bool,
     ) -> Result<bool, chainstate_error> {
         debug!(
             "Handle incoming Nakamoto block {}/{} obtained via {}",
@@ -862,10 +862,12 @@ impl Relayer {
             if force_broadcast {
                 // it's possible that the signer sent this block to us, in which case, we should
                 // broadcast it
-                debug!("Already have Nakamoto block {}, but broadcasting anyway", &block.header.block_id());
+                debug!(
+                    "Already have Nakamoto block {}, but broadcasting anyway",
+                    &block.header.block_id()
+                );
                 return Ok(true);
-            }
-            else {
+            } else {
                 debug!("Already have Nakamoto block {}", &block.header.block_id());
                 return Ok(false);
             }