feat: clean up NakamotoNodeError with thiserror

Author: hstove

testnet/stacks-node/src/nakamoto_node.rs

@@ -28,6 +28,7 @@ use stacks::monitoring::update_active_miners_count_gauge;
 use stacks::net::atlas::AtlasConfig;
 use stacks::net::relay::Relayer;
 use stacks::net::stackerdb::StackerDBs;
+use stacks::net::Error as NetError;
 use stacks::util_lib::db::Error as DBError;
 use stacks_common::types::chainstate::SortitionId;
 use stacks_common::types::StacksEpochId;
@@ -116,7 +117,7 @@ pub enum Error {
     #[error("The miner didn't accept their own block")]
     CannotSelfSign,
     #[error("A failure occurred while mining: {0}")]
-    MiningFailure(ChainstateError),
+    MiningFailure(#[from] ChainstateError),
     /// The miner didn't accept their own block
     #[error("The miner didn't accept their own block: {0}")]
     AcceptFailure(ChainstateError),
@@ -136,6 +137,9 @@ pub enum Error {
     /// DBError wrapper
     #[error("DBError: {0}")]
     DBError(#[from] DBError),
+    /// NetError wrapper
+    #[error("NetError: {0}")]
+    NetError(#[from] NetError),
 }
 
 impl StacksNode {

testnet/stacks-node/src/nakamoto_node/miner.rs

@@ -256,7 +256,7 @@ impl BlockMinerThread {
         globals.block_miner();
         let prior_miner_result = prior_miner
             .join()
-            .map_err(|_| NakamotoNodeError::MiningFailure(ChainstateError::MinerAborted))?;
+            .map_err(|_| ChainstateError::MinerAborted)?;
         if let Err(e) = prior_miner_result {
             // it's okay if the prior miner thread exited with an error.
             // in many cases this is expected (i.e., a burnchain block occurred)
@@ -285,8 +285,7 @@ impl BlockMinerThread {
         if let Some(prior_miner) = prior_miner {
             Self::stop_miner(&self.globals, prior_miner)?;
         }
-        let mut stackerdbs = StackerDBs::connect(&self.config.get_stacker_db_file_path(), true)
-            .map_err(|e| NakamotoNodeError::MiningFailure(ChainstateError::NetError(e)))?;
+        let mut stackerdbs = StackerDBs::connect(&self.config.get_stacker_db_file_path(), true)?;
         let mut last_block_rejected = false;
 
         // now, actually run this tenure
@@ -360,9 +359,7 @@ impl BlockMinerThread {
                         // try again, in case a new sortition is pending
                         self.globals
                             .raise_initiative(format!("MiningFailure: {e:?}"));
-                        return Err(NakamotoNodeError::MiningFailure(
-                            ChainstateError::MinerAborted,
-                        ));
+                        return Err(ChainstateError::MinerAborted.into());
                     }
                 }
             };
@@ -1052,9 +1049,7 @@ impl BlockMinerThread {
         ) {
             // treat a too-soon-to-mine block as an interrupt: this will let the caller sleep and then re-evaluate
             //  all the pre-mining checks (burnchain tip changes, signal interrupts, etc.)
-            return Err(NakamotoNodeError::MiningFailure(
-                ChainstateError::MinerAborted,
-            ));
+            return Err(ChainstateError::MinerAborted.into());
         }
 
         // build the block itself
@@ -1082,13 +1077,11 @@ impl BlockMinerThread {
             ) {
                 error!("Relayer: Failure mining anchored block: {e}");
             }
-            NakamotoNodeError::MiningFailure(e)
+            e
         })?;
 
         if block.txs.is_empty() {
-            return Err(NakamotoNodeError::MiningFailure(
-                ChainstateError::NoTransactionsToMine,
-            ));
+            return Err(ChainstateError::NoTransactionsToMine.into());
         }
         let mining_key = self.keychain.get_nakamoto_sk();
         let miner_signature = mining_key

testnet/stacks-node/src/nakamoto_node/relayer.rs

@@ -877,25 +877,6 @@ impl RelayerThread {
         Ok(())
     }
 
-    /// Get a snapshot for an existing burn chain block given its consensus hash.
-    fn get_block_snapshot_consensus(
-        &self,
-        ch: &ConsensusHash,
-    ) -> Result<BlockSnapshot, NakamotoNodeError> {
-        SortitionDB::get_block_snapshot_consensus(self.sortdb.conn(), ch)
-            .map_err(|e| {
-                error!(
-                    "Relayer: failed to get block snapshot for new burn view: {:?}",
-                    e
-                );
-                NakamotoNodeError::SnapshotNotFoundForChainTip
-            })?
-            .ok_or_else(|| {
-                error!("Relayer: failed to get block snapshot for new burn view");
-                NakamotoNodeError::SnapshotNotFoundForChainTip
-            })
-    }
-
     /// Get the public key hash for the mining key.
     fn get_mining_key_pkh(&self) -> Option<Hash160> {
         let Some(ref mining_key) = self.config.miner.mining_key else {
@@ -922,13 +903,7 @@ impl RelayerThread {
             &mut self.chainstate.index_conn(),
             tip_block_id,
             &ch,
-        )
-        .map_err(|e| {
-            error!(
-                "Relayer: Failed to get tenure-start block header for stacks tip {tip_block_id}: {e:?}"
-            );
-            NakamotoNodeError::ParentNotFound
-        })?
+        )?
         .ok_or_else(|| {
             error!(
                 "Relayer: Failed to find tenure-start block header for stacks tip {tip_block_id}"
@@ -1005,18 +980,6 @@ impl RelayerThread {
         }
     }
 
-    fn get_block_snapshot(&self, ch: &ConsensusHash) -> Result<BlockSnapshot, NakamotoNodeError> {
-        SortitionDB::get_block_snapshot_consensus(self.sortdb.conn(), &ch)
-            .map_err(|e| {
-                error!("Relayer: failed to get block snapshot for canonical tip: {e:?}");
-                NakamotoNodeError::SnapshotNotFoundForChainTip
-            })?
-            .ok_or_else(|| {
-                error!("Relayer: failed to get block snapshot for canonical tip");
-                NakamotoNodeError::SnapshotNotFoundForChainTip
-            })
-    }
-
     /// Attempt to continue a miner's tenure into the next burn block.
     /// This is allowed if the miner won the last good sortition and one of the
     /// following conditions is met:
@@ -1032,7 +995,12 @@ impl RelayerThread {
         debug!("Relayer: successfully stopped tenure.");
 
         // Get the necessary snapshots and state
-        let burn_tip = self.get_block_snapshot_consensus(&new_burn_view)?;
+        let burn_tip =
+            SortitionDB::get_block_snapshot_consensus(self.sortdb.conn(), &new_burn_view)?
+                .ok_or_else(|| {
+                    error!("Relayer: failed to get block snapshot for new burn view");
+                    NakamotoNodeError::SnapshotNotFoundForChainTip
+                })?;
         let (canonical_stacks_tip_ch, canonical_stacks_tip_bh) =
             SortitionDB::get_canonical_stacks_chain_tip_hash(self.sortdb.conn()).unwrap();
         let canonical_stacks_tip =
@@ -1066,7 +1034,14 @@ impl RelayerThread {
             return Ok(());
         }
 
-        let canonical_snapshot = self.get_block_snapshot(&canonical_stacks_tip_ch)?;
+        let canonical_snapshot = SortitionDB::get_block_snapshot_consensus(
+            self.sortdb.conn(),
+            &canonical_stacks_tip_ch,
+        )?
+        .ok_or_else(|| {
+            error!("Relayer: failed to get block snapshot for canonical tip");
+            NakamotoNodeError::SnapshotNotFoundForChainTip
+        })?;
         let (parent_tenure_start, block_election_snapshot, reason) = self.determine_tenure_type(
             canonical_snapshot,
             last_good_block_election_snapshot,