Add missing Debug impls (#268)

Author: 0xNeshi

src/block_range_scanner.rs

@@ -121,7 +121,7 @@ impl IntoScannerResult<RangeInclusive<BlockNumber>> for RangeInclusive<BlockNumb
     }
 }
 
-#[derive(Clone)]
+#[derive(Clone, Debug)]
 pub struct BlockRangeScanner {
     pub max_block_range: u64,
     pub past_blocks_storage_capacity: RingBufferCapacity,
@@ -175,6 +175,7 @@ impl BlockRangeScanner {
     }
 }
 
+#[derive(Debug)]
 pub struct ConnectedBlockRangeScanner<N: Network> {
     provider: RobustProvider<N>,
     max_block_range: u64,

src/block_range_scanner/reorg_handler.rs

@@ -14,7 +14,7 @@ use crate::{
 
 use super::ring_buffer::RingBuffer;
 
-#[derive(Clone)]
+#[derive(Clone, Debug)]
 pub(crate) struct ReorgHandler<N: Network = Ethereum> {
     provider: RobustProvider<N>,
     buffer: RingBuffer<BlockHash>,

src/block_range_scanner/ring_buffer.rs

@@ -20,7 +20,7 @@ macro_rules! impl_from_unsigned {
 
 impl_from_unsigned!(RingBufferCapacity; u8, u16, u32, usize);
 
-#[derive(Clone)]
+#[derive(Clone, Debug)]
 pub(crate) struct RingBuffer<T> {
     inner: VecDeque<T>,
     capacity: RingBufferCapacity,

src/block_range_scanner/sync_handler.rs

@@ -12,13 +12,15 @@ use crate::{
 };
 
 /// Represents the initial state when starting a sync operation
+#[derive(Debug)]
 enum SyncState {
     /// Start block is already at or beyond the confirmed tip - go straight to live
     AlreadyLive { start_block: BlockNumber },
     /// Start block is behind - need to catch up first, then go live
     NeedsCatchup { start_block: BlockNumber, confirmed_tip: BlockNumber },
 }
 
+#[derive(Debug)]
 pub(crate) struct SyncHandler<N: Network> {
     provider: RobustProvider<N>,
     max_block_range: u64,

src/event_scanner/listener.rs

@@ -1,7 +1,7 @@
 use crate::event_scanner::{EventScannerResult, filter::EventFilter};
 use tokio::sync::mpsc::Sender;
 
-#[derive(Clone)]
+#[derive(Clone, Debug)]
 pub(crate) struct EventListener {
     pub filter: EventFilter,
     pub sender: Sender<EventScannerResult>,

src/event_scanner/scanner/mod.rs

@@ -24,34 +24,39 @@ mod sync;
 /// Default number of maximum concurrent fetches for each scanner mode.
 pub const DEFAULT_MAX_CONCURRENT_FETCHES: usize = 24;
 
-#[derive(Default)]
+#[derive(Default, Debug)]
 pub struct Unspecified;
+#[derive(Debug)]
 pub struct Historic {
     pub(crate) from_block: BlockId,
     pub(crate) to_block: BlockId,
     /// Controls how many log-fetching RPC requests can run in parallel during the scan.
     pub(crate) max_concurrent_fetches: usize,
 }
+#[derive(Debug)]
 pub struct Live {
     pub(crate) block_confirmations: u64,
     /// Controls how many log-fetching RPC requests can run in parallel during the scan.
     pub(crate) max_concurrent_fetches: usize,
 }
+#[derive(Debug)]
 pub struct LatestEvents {
     pub(crate) count: usize,
     pub(crate) from_block: BlockId,
     pub(crate) to_block: BlockId,
     /// Controls how many log-fetching RPC requests can run in parallel during the scan.
     pub(crate) max_concurrent_fetches: usize,
 }
-#[derive(Default)]
+#[derive(Default, Debug)]
 pub struct Synchronize;
+#[derive(Debug)]
 pub struct SyncFromLatestEvents {
     pub(crate) count: usize,
     pub(crate) block_confirmations: u64,
     /// Controls how many log-fetching RPC requests can run in parallel during the scan.
     pub(crate) max_concurrent_fetches: usize,
 }
+#[derive(Debug)]
 pub struct SyncFromBlock {
     pub(crate) from_block: BlockId,
     pub(crate) block_confirmations: u64,
@@ -78,13 +83,14 @@ impl Default for Live {
     }
 }
 
+#[derive(Debug)]
 pub struct EventScanner<M = Unspecified, N: Network = Ethereum> {
     config: M,
     block_range_scanner: ConnectedBlockRangeScanner<N>,
     listeners: Vec<EventListener>,
 }
 
-#[derive(Default)]
+#[derive(Default, Debug)]
 pub struct EventScannerBuilder<M> {
     pub(crate) config: M,
     pub(crate) block_range_scanner: BlockRangeScanner,

src/robust_provider/builder.rs

@@ -1,4 +1,4 @@
-use std::{pin::Pin, time::Duration};
+use std::{fmt::Debug, pin::Pin, time::Duration};
 
 use alloy::{network::Network, providers::RootProvider};
 
@@ -28,6 +28,28 @@ pub struct RobustProviderBuilder<N: Network, P: IntoRootProvider<N>> {
     reconnect_interval: Duration,
 }
 
+impl<N: Network, P: IntoRootProvider<N>> Debug for RobustProviderBuilder<N, P> {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        struct FallbacksDebug(usize);
+
+        impl Debug for FallbacksDebug {
+            fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                write!(f, "[{} fallback provider(s)]", self.0)
+            }
+        }
+
+        f.debug_struct("RobustProviderBuilder")
+            .field("primary_provider", &"")
+            .field("fallback_providers", &FallbacksDebug(self.fallback_providers.len()))
+            .field("call_timeout", &self.call_timeout)
+            .field("subscription_timeout", &self.subscription_timeout)
+            .field("max_retries", &self.max_retries)
+            .field("min_delay", &self.min_delay)
+            .field("reconnect_interval", &self.reconnect_interval)
+            .finish()
+    }
+}
+
 impl<N: Network, P: IntoRootProvider<N>> RobustProviderBuilder<N, P> {
     /// Create a new [`RobustProvider`] with default settings.
     ///