feat: shared error enum accross both scanners

Author: LeoPatOZ

src/block_range_scanner.rs

@@ -0,0 +1,78 @@
+use std::{ops::RangeInclusive, sync::Arc};
+
+use alloy::{
+    eips::BlockNumberOrTag,
+    primitives::BlockNumber,
+    transports::{RpcError, TransportErrorKind, http::reqwest},
+};
+use thiserror::Error;
+
+use crate::block_range_scanner::Message;
+
+#[derive(Error, Debug, Clone)]
+pub enum ScannerError {
+    #[error("HTTP request failed: {0}")]
+    HttpError(Arc<reqwest::Error>),
+
+    // #[error("WebSocket error: {0}")]
+    // WebSocketError(#[from] tokio_tungstenite::tungstenite::Error),
+    #[error("Serialization error: {0}")]
+    SerializationError(Arc<serde_json::Error>),
+
+    #[error("RPC error: {0}")]
+    RpcError(Arc<RpcError<TransportErrorKind>>),
+
+    #[error("Channel send error")]
+    ChannelError,
+
+    #[error("Service is shutting down")]
+    ServiceShutdown,
+
+    #[error("Only one subscriber allowed at a time")]
+    MultipleSubscribers,
+
+    #[error("No subscriber set for streaming")]
+    NoSubscriber,
+
+    #[error("Historical sync failed: {0}")]
+    HistoricalSyncError(String),
+
+    #[error("WebSocket connection failed after {0} attempts")]
+    WebSocketConnectionFailed(usize),
+
+    #[error("Block not found, block number: {0}")]
+    BlockNotFound(BlockNumberOrTag),
+}
+
+impl From<Result<RangeInclusive<BlockNumber>, ScannerError>> for Message {
+    fn from(logs: Result<RangeInclusive<BlockNumber>, ScannerError>) -> Self {
+        match logs {
+            Ok(logs) => Message::Data(logs),
+            Err(e) => Message::Error(e),
+        }
+    }
+}
+
+impl From<reqwest::Error> for ScannerError {
+    fn from(error: reqwest::Error) -> Self {
+        ScannerError::HttpError(Arc::new(error))
+    }
+}
+
+impl From<serde_json::Error> for ScannerError {
+    fn from(error: serde_json::Error) -> Self {
+        ScannerError::SerializationError(Arc::new(error))
+    }
+}
+
+impl From<RpcError<TransportErrorKind>> for ScannerError {
+    fn from(error: RpcError<TransportErrorKind>) -> Self {
+        ScannerError::RpcError(Arc::new(error))
+    }
+}
+
+impl From<ScannerError> for Message {
+    fn from(error: ScannerError) -> Self {
+        Message::Error(error)
+    }
+}

src/error.rs

@@ -1,36 +1,19 @@
-use std::sync::Arc;
-
 use alloy::{
     rpc::types::Log,
     transports::{RpcError, TransportErrorKind},
 };
-use thiserror::Error;
-
-use crate::{block_range_scanner::BlockRangeScannerError, event_scanner::message::Message};
-
-#[derive(Error, Debug, Clone)]
-pub enum EventScannerError {
-    #[error("Block range scanner error: {0}")]
-    BlockRangeScanner(#[from] BlockRangeScannerError),
-    #[error("Provider error: {0}")]
-    Provider(Arc<RpcError<TransportErrorKind>>),
-}
 
-impl From<RpcError<TransportErrorKind>> for EventScannerError {
-    fn from(e: RpcError<TransportErrorKind>) -> Self {
-        EventScannerError::Provider(Arc::new(e))
-    }
-}
+use crate::{Message, ScannerError};
 
 impl From<RpcError<TransportErrorKind>> for Message {
     fn from(e: RpcError<TransportErrorKind>) -> Self {
         Message::Error(e.into())
     }
 }
 
-impl From<BlockRangeScannerError> for Message {
-    fn from(e: BlockRangeScannerError) -> Self {
-        Message::Error(e.into())
+impl From<ScannerError> for Message {
+    fn from(error: ScannerError) -> Self {
+        Message::Error(error)
     }
 }
 

src/event_scanner/error.rs

@@ -1,8 +1,8 @@
 use alloy::{rpc::types::Log, sol_types::SolEvent};
 
-use crate::{EventScannerError, ScannerMessage};
+use crate::{ScannerError, ScannerMessage};
 
-pub type Message = ScannerMessage<Vec<Log>, EventScannerError>;
+pub type Message = ScannerMessage<Vec<Log>, ScannerError>;
 
 impl From<Vec<Log>> for Message {
     fn from(logs: Vec<Log>) -> Self {

src/event_scanner/message.rs

@@ -4,7 +4,7 @@ pub mod listener;
 pub mod message;
 pub mod modes;
 
-pub use error::EventScannerError;
+// pub use error::EventScannerError;
 pub use filter::EventFilter;
 pub use message::Message;
 pub use modes::{

src/event_scanner/mod.rs

@@ -9,9 +9,9 @@ use tokio::sync::mpsc;
 use tokio_stream::wrappers::ReceiverStream;
 
 use crate::{
+    ScannerError,
     block_range_scanner::{BlockRangeScanner, ConnectedBlockRangeScanner, MAX_BUFFERED_MESSAGES},
     event_scanner::{
-        EventScannerError,
         filter::EventFilter,
         listener::EventListener,
         message::Message,
@@ -119,7 +119,7 @@ impl<N: Network> HistoricEventScanner<N> {
     /// # Errors
     ///
     /// - `EventScannerMessage::ServiceShutdown` if the service is already shutting down.
-    pub async fn start(self) -> Result<(), EventScannerError> {
+    pub async fn start(self) -> Result<(), ScannerError> {
         let client = self.block_range_scanner.run()?;
         let stream = client.stream_historical(self.config.from_block, self.config.to_block).await?;
         handle_stream(

src/event_scanner/modes/historic.rs

@@ -9,12 +9,12 @@ use tokio::sync::mpsc;
 use tokio_stream::wrappers::ReceiverStream;
 
 use crate::{
+    ScannerError,
     block_range_scanner::{
         BlockRangeScanner, ConnectedBlockRangeScanner, DEFAULT_BLOCK_CONFIRMATIONS,
         MAX_BUFFERED_MESSAGES,
     },
     event_scanner::{
-        EventScannerError,
         filter::EventFilter,
         listener::EventListener,
         message::Message,
@@ -145,7 +145,7 @@ impl<N: Network> LatestEventScanner<N> {
     /// - Returns `EventScannerError` if the scanner fails to start or fetching logs fails.
     ///
     /// [`ScannerStatus::ReorgDetected`]: crate::types::ScannerStatus::ReorgDetected
-    pub async fn start(self) -> Result<(), EventScannerError> {
+    pub async fn start(self) -> Result<(), ScannerError> {
         let client = self.block_range_scanner.run()?;
         let stream = client.rewind(self.config.from_block, self.config.to_block).await?;
         handle_stream(

src/event_scanner/modes/latest.rs

@@ -8,12 +8,12 @@ use tokio::sync::mpsc;
 use tokio_stream::wrappers::ReceiverStream;
 
 use crate::{
+    ScannerError,
     block_range_scanner::{
         BlockRangeScanner, ConnectedBlockRangeScanner, DEFAULT_BLOCK_CONFIRMATIONS,
         MAX_BUFFERED_MESSAGES,
     },
     event_scanner::{
-        EventScannerError,
         filter::EventFilter,
         listener::EventListener,
         message::Message,
@@ -115,7 +115,7 @@ impl<N: Network> LiveEventScanner<N> {
     /// # Errors
     ///
     /// - `EventScannerMessage::ServiceShutdown` if the service is already shutting down.
-    pub async fn start(self) -> Result<(), EventScannerError> {
+    pub async fn start(self) -> Result<(), ScannerError> {
         let client = self.block_range_scanner.run()?;
         let stream = client.stream_live(self.config.block_confirmations).await?;
         handle_stream(

src/event_scanner/modes/live.rs

@@ -9,12 +9,12 @@ use tokio::sync::mpsc;
 use tokio_stream::wrappers::ReceiverStream;
 
 use crate::{
+    ScannerError,
     block_range_scanner::{
         BlockRangeScanner, ConnectedBlockRangeScanner, DEFAULT_BLOCK_CONFIRMATIONS,
         MAX_BUFFERED_MESSAGES,
     },
     event_scanner::{
-        EventScannerError,
         filter::EventFilter,
         listener::EventListener,
         message::Message,
@@ -124,7 +124,7 @@ impl<N: Network> SyncEventScanner<N> {
     /// # Errors
     ///
     /// - `EventScannerMessage::ServiceShutdown` if the service is already shutting down.
-    pub async fn start(self) -> Result<(), EventScannerError> {
+    pub async fn start(self) -> Result<(), ScannerError> {
         let client = self.block_range_scanner.run()?;
         let stream =
             client.stream_from(self.config.from_block, self.config.block_confirmations).await?;

src/event_scanner/modes/sync.rs

@@ -1,13 +1,15 @@
 pub mod block_range_scanner;
+pub mod error;
 pub mod event_scanner;
 #[cfg(any(test, feature = "test-utils"))]
 pub mod test_utils;
 pub mod types;
 
+pub use error::ScannerError;
 pub use types::{ScannerMessage, ScannerStatus};
 
 pub use event_scanner::{
-    EventFilter, EventScanner, EventScannerError, HistoricEventScanner, HistoricScannerBuilder,
-    LatestEventScanner, LatestScannerBuilder, LiveEventScanner, LiveScannerBuilder, Message,
-    SyncEventScanner, SyncScannerBuilder,
+    EventFilter, EventScanner, HistoricEventScanner, HistoricScannerBuilder, LatestEventScanner,
+    LatestScannerBuilder, LiveEventScanner, LiveScannerBuilder, Message, SyncEventScanner,
+    SyncScannerBuilder,
 };