Merge branch 'develop' into feat/audit-fixes

Author: hstove

stacks-signer/src/client/stacks_client.rs

@@ -590,9 +590,10 @@ impl StacksClient {
                 .map_err(|e| backoff::Error::transient(e.into()))?;
             let status = response.status();
             if status.is_success() {
-                return response
-                    .json()
-                    .map_err(|e| backoff::Error::permanent(e.into()));
+                return response.json().map_err(|e| {
+                    warn!("Failed to parse the GetStackers response: {e}");
+                    backoff::Error::permanent(e.into())
+                });
             }
             let error_data = response.json::<GetStackersErrorResp>().map_err(|e| {
                 warn!("Failed to parse the GetStackers error response: {e}");

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

@@ -115,8 +115,6 @@ pub struct NakamotoDownloadStateMachine {
     unconfirmed_tenure_downloads: HashMap<NeighborAddress, NakamotoUnconfirmedTenureDownloader>,
     /// Ongoing confirmed tenure downloads for when we know the start and end block hashes.
     tenure_downloads: NakamotoTenureDownloaderSet,
-    /// resolved tenure-start blocks
-    tenure_start_blocks: HashMap<StacksBlockId, NakamotoBlock>,
     /// comms to remote neighbors
     pub(super) neighbor_rpc: NeighborRPC,
     /// Nakamoto chain tip
@@ -140,7 +138,6 @@ impl NakamotoDownloadStateMachine {
             unconfirmed_tenure_download_schedule: VecDeque::new(),
             tenure_downloads: NakamotoTenureDownloaderSet::new(),
             unconfirmed_tenure_downloads: HashMap::new(),
-            tenure_start_blocks: HashMap::new(),
             neighbor_rpc: NeighborRPC::new(),
             nakamoto_tip,
             last_unconfirmed_download_run_ms: 0,
@@ -367,48 +364,6 @@ impl NakamotoDownloadStateMachine {
         )
     }
 
-    /// Find all stored (but not necessarily processed) tenure-start blocks for a list
-    /// of wanted tenures that this node has locally.  NOTE: these tenure-start blocks
-    /// do not correspond to the tenure; they correspond to the _parent_ tenure (since a
-    /// `WantedTenure` captures the tenure-start block hash of the parent tenure; the same data
-    /// captured by a sortition).
-    ///
-    /// This method is static to ease testing.
-    ///
-    /// Returns Ok(()) on success and fills in newly-discovered blocks into `tenure_start_blocks`.
-    /// Returns Err(..) on DB error.
-    pub(crate) fn load_tenure_start_blocks(
-        wanted_tenures: &[WantedTenure],
-        chainstate: &mut StacksChainState,
-        tenure_start_blocks: &mut HashMap<StacksBlockId, NakamotoBlock>,
-    ) -> Result<(), NetError> {
-        for wt in wanted_tenures {
-            let candidate_tenure_start_blocks = chainstate
-                .nakamoto_blocks_db()
-                .get_nakamoto_tenure_start_blocks(&wt.tenure_id_consensus_hash)?;
-
-            for candidate_tenure_start_block in candidate_tenure_start_blocks.into_iter() {
-                tenure_start_blocks.insert(
-                    candidate_tenure_start_block.block_id(),
-                    candidate_tenure_start_block,
-                );
-            }
-        }
-        Ok(())
-    }
-
-    /// Update our local tenure start block data
-    fn update_tenure_start_blocks(
-        &mut self,
-        chainstate: &mut StacksChainState,
-    ) -> Result<(), NetError> {
-        Self::load_tenure_start_blocks(
-            &self.wanted_tenures,
-            chainstate,
-            &mut self.tenure_start_blocks,
-        )
-    }
-
     /// Update `self.wanted_tenures` with newly-discovered sortition data.
     fn extend_wanted_tenures(
         &mut self,
@@ -670,7 +625,6 @@ impl NakamotoDownloadStateMachine {
         &mut self,
         network: &PeerNetwork,
         sortdb: &SortitionDB,
-        chainstate: &mut StacksChainState,
     ) -> Result<(), NetError> {
         let sort_tip = &network.burnchain_tip;
 
@@ -688,7 +642,6 @@ impl NakamotoDownloadStateMachine {
             // not at a reward cycle boundary, so just extend self.wanted_tenures
             debug!("Extend wanted tenures since no sort_rc change and we have tenure data");
             self.extend_wanted_tenures(network, sortdb)?;
-            self.update_tenure_start_blocks(chainstate)?;
             return Ok(());
         }
 
@@ -728,7 +681,6 @@ impl NakamotoDownloadStateMachine {
         self.wanted_tenures = new_wanted_tenures;
         self.reward_cycle = sort_rc;
 
-        self.update_tenure_start_blocks(chainstate)?;
         Ok(())
     }
 
@@ -1485,21 +1437,6 @@ impl NakamotoDownloadStateMachine {
         // run all downloaders
         let new_blocks = self.tenure_downloads.run(network, &mut self.neighbor_rpc);
 
-        // give blocked downloaders their tenure-end blocks from other downloaders that have
-        // obtained their tenure-start blocks
-        let new_tenure_starts = self.tenure_downloads.find_new_tenure_start_blocks();
-        self.tenure_start_blocks
-            .extend(new_tenure_starts.into_iter());
-
-        let dead = self
-            .tenure_downloads
-            .handle_tenure_end_blocks(&self.tenure_start_blocks);
-
-        // bookkeeping
-        for naddr in dead.into_iter() {
-            self.neighbor_rpc.add_dead(network, &naddr);
-        }
-
         new_blocks
     }
 
@@ -1729,7 +1666,7 @@ impl NakamotoDownloadStateMachine {
     ) -> Result<HashMap<ConsensusHash, Vec<NakamotoBlock>>, NetError> {
         self.nakamoto_tip = network.stacks_tip.block_id();
         debug!("Downloader: Nakamoto tip is {:?}", &self.nakamoto_tip);
-        self.update_wanted_tenures(&network, sortdb, chainstate)?;
+        self.update_wanted_tenures(&network, sortdb)?;
         self.update_processed_tenures(chainstate)?;
         let new_blocks = self.run_downloads(burnchain_height, network, sortdb, chainstate, ibd);
         self.last_sort_tip = Some(network.burnchain_tip.clone());

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

@@ -68,31 +68,7 @@ use crate::util_lib::db::{DBConn, Error as DBError};
 pub enum NakamotoTenureDownloadState {
     /// Getting the tenure-start block (the given StacksBlockId is it's block ID).
     GetTenureStartBlock(StacksBlockId),
-    /// Waiting for the child tenure's tenure-start block to arrive, which is usually (but not
-    /// always) handled by the execution of another NakamotoTenureDownloader.  The only
-    /// exceptions are as follows:
-    ///
-    /// * if this tenure contains the anchor block, and it's the last tenure in the
-    /// reward cycle.  In this case, the end-block must be directly fetched, since there will be no
-    /// follow-on NakamotTenureDownloader in the same reward cycle who can provide this.
-    ///
-    /// * if this tenure is the highest complete tenure, and we just learned the start-block of the
-    /// ongoing tenure, then a NakamotoTenureDownloader will be instantiated with this tenure-end-block
-    /// already known.  This step will be skipped because the end-block is already present in the
-    /// state machine.
-    ///
-    /// * if the deadline (second parameter) is exceeded, the state machine transitions to
-    /// GetTenureEndBlock.
-    ///
-    /// The two fields here are:
-    /// * the block ID of the last block in the tenure (which happens to be the block ID of the
-    /// start block of the next tenure)
-    /// * the deadline by which this state machine needs to have obtained the tenure end-block
-    /// before transitioning to `GetTenureEndBlock`.
-    WaitForTenureEndBlock(StacksBlockId, Instant),
-    /// Getting the tenure-end block directly.  This only happens for tenures whose end-blocks
-    /// cannot be provided by tenure downloaders within the same reward cycle, and for tenures in
-    /// which we cannot quickly get the tenure-end block.
+    /// Getting the tenure-end block.
     ///
     /// The field here is the block ID of the tenure end block.
     GetTenureEndBlock(StacksBlockId),
@@ -163,8 +139,7 @@ pub struct NakamotoTenureDownloader {
     pub tenure_start_block: Option<NakamotoBlock>,
     /// Pre-stored tenure end block.
     /// An instance of this state machine will be used to fetch the highest-confirmed tenure, once
-    /// the start-block for the current tenure is downloaded.  This is that start-block, which is
-    /// used to transition from the `WaitForTenureEndBlock` step to the `GetTenureBlocks` step.
+    /// the start-block for the current tenure is downloaded.
     pub tenure_end_block: Option<NakamotoBlock>,
     /// Tenure blocks
     pub tenure_blocks: Option<Vec<NakamotoBlock>>,
@@ -205,16 +180,6 @@ impl NakamotoTenureDownloader {
         self
     }
 
-    /// Is this downloader waiting for the tenure-end block data from some other downloader?  Per
-    /// the struct documentation, this is case 2(a).
-    pub fn is_waiting(&self) -> bool {
-        if let NakamotoTenureDownloadState::WaitForTenureEndBlock(..) = self.state {
-            return true;
-        } else {
-            return false;
-        }
-    }
-
     /// Validate and accept a given tenure-start block.  If accepted, then advance the state.
     /// Returns Ok(()) if the start-block is valid.
     /// Returns Err(..) if it is not valid.
@@ -266,66 +231,15 @@ impl NakamotoTenureDownloader {
                 tenure_end_block.block_id(),
                 &self.tenure_id_consensus_hash
             );
-            self.state = NakamotoTenureDownloadState::WaitForTenureEndBlock(
-                tenure_end_block.block_id(),
-                Instant::now()
-                    .checked_add(Duration::new(WAIT_FOR_TENURE_END_BLOCK_TIMEOUT, 0))
-                    .ok_or(NetError::OverflowError("Deadline is too big".into()))?,
-            );
             self.try_accept_tenure_end_block(&tenure_end_block)?;
         } else {
-            // need to get tenure_end_block.  By default, assume that another
-            // NakamotoTenureDownloader will provide this block, and allow the
-            // NakamotoTenureDownloaderSet instance that manages a collection of these
-            // state-machines make the call to require this one to fetch the block directly.
-            self.state = NakamotoTenureDownloadState::WaitForTenureEndBlock(
-                self.tenure_end_block_id.clone(),
-                Instant::now()
-                    .checked_add(Duration::new(WAIT_FOR_TENURE_END_BLOCK_TIMEOUT, 0))
-                    .ok_or(NetError::OverflowError("Deadline is too big".into()))?,
-            );
+            // need to get tenure_end_block.
+            self.state =
+                NakamotoTenureDownloadState::GetTenureEndBlock(self.tenure_end_block_id.clone());
         }
         Ok(())
     }
 
-    /// Transition this state-machine from waiting for its tenure-end block from another
-    /// state-machine to directly fetching it.  This only needs to happen if the tenure this state
-    /// machine is downloading contains the PoX anchor block, and it's also the last confirmed
-    /// tenurein this reward cycle.
-    ///
-    /// This function is called by `NakamotoTenureDownloadSet`, which instantiates, schedules, and
-    /// runs a set of these machines based on the peers' inventory vectors.  But because we don't
-    /// know if this is the PoX anchor block tenure (or even the last tenure) until we have
-    /// inventory vectors for this tenure's reward cycle, this state-transition must be driven
-    /// after this machine's instantiation.
-    pub fn transition_to_fetch_end_block(&mut self) -> Result<(), NetError> {
-        let NakamotoTenureDownloadState::WaitForTenureEndBlock(end_block_id, ..) = self.state
-        else {
-            return Err(NetError::InvalidState);
-        };
-        debug!(
-            "Transition downloader to {} to directly fetch tenure-end block {} (direct transition)",
-            &self.naddr, &end_block_id
-        );
-        self.state = NakamotoTenureDownloadState::GetTenureEndBlock(end_block_id);
-        Ok(())
-    }
-
-    /// Transition to fetching the tenure-end block directly if waiting has taken too long.
-    pub fn transition_to_fetch_end_block_on_timeout(&mut self) {
-        if let NakamotoTenureDownloadState::WaitForTenureEndBlock(end_block_id, wait_deadline) =
-            self.state
-        {
-            if wait_deadline < Instant::now() {
-                debug!(
-                    "Transition downloader to {} to directly fetch tenure-end block {} (timed out)",
-                    &self.naddr, &end_block_id
-                );
-                self.state = NakamotoTenureDownloadState::GetTenureEndBlock(end_block_id);
-            }
-        }
-    }
-
     /// Validate and accept a tenure-end block.  If accepted, then advance the state.
     /// Once accepted, this function extracts the tenure-change transaction and block header from
     /// this block (it does not need the entire block).
@@ -338,8 +252,7 @@ impl NakamotoTenureDownloader {
     ) -> Result<(), NetError> {
         if !matches!(
             &self.state,
-            NakamotoTenureDownloadState::WaitForTenureEndBlock(..)
-                | NakamotoTenureDownloadState::GetTenureEndBlock(_)
+            NakamotoTenureDownloadState::GetTenureEndBlock(_)
         ) {
             warn!("Invalid state for this method";
                   "state" => %self.state);
@@ -577,14 +490,6 @@ impl NakamotoTenureDownloader {
                 debug!("Request tenure-start block {}", &start_block_id);
                 StacksHttpRequest::new_get_nakamoto_block(peerhost, start_block_id.clone())
             }
-            NakamotoTenureDownloadState::WaitForTenureEndBlock(_block_id, _deadline) => {
-                // we're waiting for some other downloader's block-fetch to complete
-                debug!(
-                    "Waiting for tenure-end block {} until {:?}",
-                    &_block_id, _deadline
-                );
-                return Ok(None);
-            }
             NakamotoTenureDownloadState::GetTenureEndBlock(end_block_id) => {
                 debug!("Request tenure-end block {}", &end_block_id);
                 StacksHttpRequest::new_get_nakamoto_block(peerhost, end_block_id.clone())
@@ -665,10 +570,6 @@ impl NakamotoTenureDownloader {
                 self.try_accept_tenure_start_block(block)?;
                 Ok(None)
             }
-            NakamotoTenureDownloadState::WaitForTenureEndBlock(..) => {
-                debug!("Invalid state -- Got download response for WaitForTenureBlock");
-                Err(NetError::InvalidState)
-            }
             NakamotoTenureDownloadState::GetTenureEndBlock(_block_id) => {
                 debug!("Got download response to tenure-end block {}", &_block_id);
                 let block = response.decode_nakamoto_block().map_err(|e| {