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

Author: kantai

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/chainstate/stacks/miner.rs

@@ -2228,10 +2228,10 @@ impl StacksBlockBuilder {
 
         debug!("Block transaction selection begins (parent height = {tip_height})");
         let result = {
-            let mut intermediate_result: Result<_, Error> = Ok(0);
+            let mut loop_result = Ok(());
             while block_limit_hit != BlockLimitFunction::LIMIT_REACHED {
                 let mut num_considered = 0;
-                intermediate_result = mempool.iterate_candidates(
+                let intermediate_result = mempool.iterate_candidates(
                     epoch_tx,
                     &mut tx_events,
                     mempool_settings.clone(),
@@ -2390,16 +2390,27 @@ impl StacksBlockBuilder {
                     let _ = mempool.drop_and_blacklist_txs(&to_drop_and_blacklist);
                 }
 
-                if intermediate_result.is_err() {
-                    break;
+                match intermediate_result {
+                    Err(e) => {
+                        loop_result = Err(e);
+                        break;
+                    }
+                    Ok((_txs_considered, stop_reason)) => {
+                        match stop_reason {
+                            MempoolIterationStopReason::NoMoreCandidates => break,
+                            MempoolIterationStopReason::DeadlineReached => break,
+                            // if the iterator function exited, let the loop tick: it checks the block limits
+                            MempoolIterationStopReason::IteratorExited => {}
+                        }
+                    }
                 }
 
                 if num_considered == 0 {
                     break;
                 }
             }
             debug!("Block transaction selection finished (parent height {}): {} transactions selected ({} considered)", &tip_height, num_txs, considered.len());
-            intermediate_result
+            loop_result
         };
 
         mempool.drop_txs(&invalidated_txs)?;

stackslib/src/chainstate/stacks/tests/block_construction.rs

@@ -5072,6 +5072,7 @@ fn paramaterized_mempool_walk_test(
                         },
                     )
                     .unwrap()
+                    .0
                     == 0
                 {
                     break;

stackslib/src/core/mempool.rs

@@ -144,6 +144,14 @@ pub enum MemPoolSyncData {
     TxTags([u8; 32], Vec<TxTag>),
 }
 
+pub enum MempoolIterationStopReason {
+    NoMoreCandidates,
+    DeadlineReached,
+    /// If the iteration function supplied to mempool iteration exited
+    ///  (i.e., the transaction evaluator returned an early exit command)
+    IteratorExited,
+}
+
 impl StacksMessageCodec for MemPoolSyncData {
     fn consensus_serialize<W: Write>(&self, fd: &mut W) -> Result<(), codec_error> {
         match *self {
@@ -1592,7 +1600,7 @@ impl MemPoolDB {
         output_events: &mut Vec<TransactionEvent>,
         settings: MemPoolWalkSettings,
         mut todo: F,
-    ) -> Result<u64, E>
+    ) -> Result<(u64, MempoolIterationStopReason), E>
     where
         C: ClarityConnection,
         F: FnMut(
@@ -1643,11 +1651,11 @@ impl MemPoolDB {
             .query(NO_PARAMS)
             .map_err(|err| Error::SqliteError(err))?;
 
-        loop {
+        let stop_reason = loop {
             if start_time.elapsed().as_millis() > settings.max_walk_time_ms as u128 {
                 debug!("Mempool iteration deadline exceeded";
                        "deadline_ms" => settings.max_walk_time_ms);
-                break;
+                break MempoolIterationStopReason::DeadlineReached;
             }
 
             let start_with_no_estimate =
@@ -1687,7 +1695,7 @@ impl MemPoolDB {
                                 ),
                                 None => {
                                     debug!("No more transactions to consider in mempool");
-                                    break;
+                                    break MempoolIterationStopReason::NoMoreCandidates;
                                 }
                             }
                         }
@@ -1875,7 +1883,7 @@ impl MemPoolDB {
                 }
                 None => {
                     debug!("Mempool iteration early exit from iterator");
-                    break;
+                    break MempoolIterationStopReason::IteratorExited;
                 }
             }
 
@@ -1885,7 +1893,7 @@ impl MemPoolDB {
                 candidate_cache.len()
             );
             candidate_cache.reset();
-        }
+        };
 
         // drop these rusqlite statements and queries, since their existence as immutable borrows on the
         // connection prevents us from beginning a transaction below (which requires a mutable
@@ -1908,7 +1916,7 @@ impl MemPoolDB {
             "considered_txs" => u128::from(total_considered),
             "elapsed_ms" => start_time.elapsed().as_millis()
         );
-        Ok(total_considered)
+        Ok((total_considered, stop_reason))
     }
 
     pub fn conn(&self) -> &DBConn {

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());