rename back to client

Author: LeoPatOZ

src/event_scanner.rs

@@ -69,14 +69,11 @@ impl EventScanner {
     /// # Errors
     ///
     /// Returns an error if the connection fails
-    pub async fn connect_ws<N: Network>(
-        self,
-        ws_url: Url,
-    ) -> Result<EventScannerClient<N>, EventScannerError> {
+    pub async fn connect_ws<N: Network>(self, ws_url: Url) -> Result<Client<N>, EventScannerError> {
         let block_range_scanner = self.block_range_scanner.connect_ws(ws_url).await?;
         let event_scanner =
             ConnectedEventScanner { block_range_scanner, event_listeners: Vec::default() };
-        Ok(EventScannerClient { event_scanner })
+        Ok(Client { event_scanner })
     }
 
     /// Connects to the provider via IPC
@@ -87,11 +84,11 @@ impl EventScanner {
     pub async fn connect_ipc<N: Network>(
         self,
         ipc_path: impl Into<String>,
-    ) -> Result<EventScannerClient<N>, EventScannerError> {
+    ) -> Result<Client<N>, EventScannerError> {
         let block_range_scanner = self.block_range_scanner.connect_ipc(ipc_path.into()).await?;
         let event_scanner =
             ConnectedEventScanner { block_range_scanner, event_listeners: Vec::default() };
-        Ok(EventScannerClient { event_scanner })
+        Ok(Client { event_scanner })
     }
 
     /// Connects to an existing provider
@@ -102,11 +99,11 @@ impl EventScanner {
     pub fn connect_provider<N: Network>(
         self,
         provider: RootProvider<N>,
-    ) -> Result<EventScannerClient<N>, EventScannerError> {
+    ) -> Result<Client<N>, EventScannerError> {
         let block_range_scanner = self.block_range_scanner.connect_provider(provider)?;
         let event_scanner =
             ConnectedEventScanner { block_range_scanner, event_listeners: Vec::default() };
-        Ok(EventScannerClient { event_scanner })
+        Ok(Client { event_scanner })
     }
 }
 
@@ -178,7 +175,8 @@ impl<N: Network> ConnectedEventScanner<N> {
 
         while let Some(message) = stream.next().await {
             if let Err(err) = range_tx.send(message) {
-                error!(error = %err, "failed sending message to broadcast channel");
+                error!(error = %err, "Broadcast channel closed, could not send BlockRangeMessage. Stopped streaming block ranges.");
+                break;
             }
         }
     }
@@ -274,11 +272,11 @@ impl<N: Network> ConnectedEventScanner<N> {
     }
 }
 
-pub struct EventScannerClient<N: Network> {
+pub struct Client<N: Network> {
     event_scanner: ConnectedEventScanner<N>,
 }
 
-impl<N: Network> EventScannerClient<N> {
+impl<N: Network> Client<N> {
     pub fn create_event_stream(
         &mut self,
         event_filter: EventFilter,

tests/common.rs

@@ -13,7 +13,7 @@ use alloy_node_bindings::{Anvil, AnvilInstance};
 use event_scanner::{
     EventFilter,
     block_range_scanner::DEFAULT_BLOCKS_READ_PER_EPOCH,
-    event_scanner::{EventScanner, EventScannerClient, EventScannerMessage},
+    event_scanner::{Client, EventScanner, EventScannerMessage},
 };
 use tokio_stream::wrappers::ReceiverStream;
 // Shared test contract used across integration tests
@@ -49,7 +49,7 @@ where
 {
     pub provider: RootProvider,
     pub contract: TestCounter::TestCounterInstance<Arc<P>>,
-    pub client: EventScannerClient<Ethereum>,
+    pub client: Client<Ethereum>,
     pub stream: ReceiverStream<EventScannerMessage>,
     pub anvil: AnvilInstance,
 }