refactor(esplora): define blocking Error enum

Author: reez

crates/esplora/src/blocking_ext.rs

@@ -7,12 +7,54 @@ use bdk_core::{
     BlockId, CheckPoint, ConfirmationBlockTime, Indexed, TxUpdate,
 };
 use esplora_client::{OutputStatus, Tx};
+use std::any::Any;
+use std::fmt;
 use std::thread::JoinHandle;
 
 use crate::{insert_anchor_or_seen_at_from_status, insert_prevouts};
 
-/// [`esplora_client::Error`]
-pub type Error = Box<esplora_client::Error>;
+#[derive(Debug)]
+pub enum Error {
+    Client(esplora_client::Error),
+    ThreadPanic(Option<String>),
+}
+
+impl Error {
+    fn from_thread_panic(err: Box<dyn Any + Send>) -> Self {
+        if let Ok(msg) = err.downcast::<String>() {
+            Self::ThreadPanic(Some(*msg))
+        } else if let Ok(msg) = err.downcast::<&'static str>() {
+            Self::ThreadPanic(Some(msg.to_string()))
+        } else {
+            Self::ThreadPanic(None)
+        }
+    }
+}
+
+impl From<esplora_client::Error> for Error {
+    fn from(err: esplora_client::Error) -> Self {
+        Self::Client(err)
+    }
+}
+
+impl fmt::Display for Error {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        match self {
+            Self::Client(err) => write!(f, "{err}"),
+            Self::ThreadPanic(Some(msg)) => write!(f, "worker thread panicked: {msg}"),
+            Self::ThreadPanic(None) => write!(f, "worker thread panicked"),
+        }
+    }
+}
+
+impl std::error::Error for Error {
+    fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
+        match self {
+            Self::Client(err) => Some(err),
+            _ => None,
+        }
+    }
+}
 
 /// Trait to extend the functionality of [`esplora_client::BlockingClient`].
 ///
@@ -241,15 +283,13 @@ fn chain_update(
     let mut tip = match point_of_agreement {
         Some(tip) => tip,
         None => {
-            return Err(Box::new(esplora_client::Error::HeaderHashNotFound(
-                local_cp_hash,
-            )));
+            return Err(esplora_client::Error::HeaderHashNotFound(local_cp_hash).into());
         }
     };
 
     tip = tip
         .extend(conflicts.into_iter().rev().map(|b| (b.height, b.hash)))
-        .map_err(|_| Box::new(esplora_client::Error::InvalidResponse))?;
+        .map_err(|_| Error::from(esplora_client::Error::InvalidResponse))?;
 
     for (anchor, _) in anchors {
         let height = anchor.block_id.height;
@@ -319,15 +359,15 @@ fn fetch_txs_with_keychain_spks<I: Iterator<Item = Indexed<SpkWithExpectedTxids>
 
         if handles.is_empty() {
             if !processed_any {
-                return Err(Box::new(esplora_client::Error::InvalidResponse));
+                return Err(esplora_client::Error::InvalidResponse.into());
             }
             break;
         }
 
         for handle in handles {
             let handle_result = handle
                 .join()
-                .map_err(|_| Box::new(esplora_client::Error::InvalidResponse))?;
+                .map_err(Error::from_thread_panic)?;
             let (index, txs, evicted) = handle_result?;
             processed_any = true;
             if txs.is_empty() {
@@ -411,7 +451,7 @@ fn fetch_txs_with_txids<I: IntoIterator<Item = Txid>>(
                 std::thread::spawn(move || {
                     client
                         .get_tx_info(&txid)
-                        .map_err(Box::new)
+                        .map_err(Error::from)
                         .map(|t| (txid, t))
                 })
             })
@@ -424,7 +464,7 @@ fn fetch_txs_with_txids<I: IntoIterator<Item = Txid>>(
         for handle in handles {
             let handle_result = handle
                 .join()
-                .map_err(|_| Box::new(esplora_client::Error::InvalidResponse))?;
+                .map_err(Error::from_thread_panic)?;
             let (txid, tx_info) = handle_result?;
             if let Some(tx_info) = tx_info {
                 if inserted_txs.insert(txid) {
@@ -476,7 +516,7 @@ fn fetch_txs_with_outpoints<I: IntoIterator<Item = OutPoint>>(
                 std::thread::spawn(move || {
                     client
                         .get_output_status(&op.txid, op.vout as _)
-                        .map_err(Box::new)
+                        .map_err(Error::from)
                 })
             })
             .collect::<Vec<JoinHandle<Result<Option<OutputStatus>, Error>>>>();
@@ -488,7 +528,7 @@ fn fetch_txs_with_outpoints<I: IntoIterator<Item = OutPoint>>(
         for handle in handles {
             let handle_result = handle
                 .join()
-                .map_err(|_| Box::new(esplora_client::Error::InvalidResponse))?;
+                .map_err(Error::from_thread_panic)?;
             if let Some(op_status) = handle_result? {
                 let spend_txid = match op_status.txid {
                     Some(txid) => txid,
@@ -549,24 +589,23 @@ mod test {
         let res = (|| -> Result<(), Error> {
             let handle_result = handle
                 .join()
-                .map_err(|_| Box::new(esplora_client::Error::InvalidResponse))?;
-            handle_result?;
-            Ok(())
+                .map_err(Error::from_thread_panic)?;
+            handle_result
         })();
 
         assert!(matches!(
-            *res.unwrap_err(),
-            esplora_client::Error::InvalidResponse
+            res.unwrap_err(),
+            Error::ThreadPanic(_)
         ));
     }
 
     #[test]
     fn ensure_last_index_none_returns_error() {
         let last_index: Option<u32> = None;
         let err = last_index
-            .ok_or_else(|| Box::new(esplora_client::Error::InvalidResponse))
+            .ok_or_else(|| Error::from(esplora_client::Error::InvalidResponse))
             .unwrap_err();
-        assert!(matches!(*err, esplora_client::Error::InvalidResponse));
+        assert!(matches!(err, Error::Client(esplora_client::Error::InvalidResponse)));
     }
 
     macro_rules! local_chain {