fix: clippy by allowing _ binding

Author: LeoPatOZ

src/block_range_scanner.rs

@@ -294,6 +294,7 @@ impl<N: Network> Service<N> {
             tokio::select! {
                 cmd = self.command_receiver.recv() => {
                     if let Some(command) = cmd {
+                        #[allow(clippy::used_underscore_binding)]
                         if let Err(_e) = self.handle_command(command).await {
                             opt_error!("Command handling error: {}", _e);
                             self.error_count += 1;

src/block_range_scanner/reorg_handler.rs

@@ -97,6 +97,7 @@ impl<N: Network> ReorgHandler<N> {
 
         let finalized = self.provider.get_block_by_number(BlockNumberOrTag::Finalized).await?;
 
+        #[allow(clippy::used_underscore_binding)]
         let _header = finalized.header();
         opt_info!(finalized_hash = %_header.hash(), block_number = _header.number(), "Finalized block set as common ancestor");
 

src/event_scanner/scanner/common.rs

@@ -76,6 +76,7 @@ pub(crate) async fn handle_stream<N: Network, S: Stream<Item = BlockScannerResul
     };
 
     while let Some(message) = stream.next().await {
+        #[allow(clippy::used_underscore_binding)]
         if let Err(_err) = range_tx.send(message) {
             opt_warn!(error = %_err, "No log consumers, stopping stream");
             break;
@@ -153,6 +154,7 @@ fn spawn_log_consumers_in_stream_mode<N: Network>(
                         opt_debug!("No more block ranges to receive");
                         break;
                     }
+                    #[allow(clippy::used_underscore_binding)]
                     Err(RecvError::Lagged(_skipped)) => {
                         opt_debug!("Channel lagged, skipped {_skipped} messages");
                     }
@@ -299,6 +301,7 @@ fn spawn_log_consumers_in_collection_mode<N: Network>(
                         opt_debug!("No more block ranges to receive");
                         break;
                     }
+                    #[allow(clippy::used_underscore_binding)]
                     Err(RecvError::Lagged(_skipped)) => {
                         opt_debug!("Channel lagged, skipped {_skipped} messages");
                     }
@@ -368,6 +371,7 @@ fn collect_logs<T>(collected: &mut Vec<T>, logs: Vec<T>, count: usize, prepend:
     collected.len() >= count
 }
 
+#[allow(clippy::used_underscore_binding)]
 async fn get_logs<N: Network>(
     range: RangeInclusive<u64>,
     _event_filter: &EventFilter,

src/robust_provider/provider.rs

@@ -121,6 +121,7 @@ impl<N: Network> RobustProvider<N> {
                 false,
             )
             .await;
+        #[allow(clippy::used_underscore_binding)]
         if let Err(_e) = &result {
             opt_error!(error = %_e, "eth_getByBlockNumber failed");
         }
@@ -143,6 +144,7 @@ impl<N: Network> RobustProvider<N> {
                 false,
             )
             .await;
+        #[allow(clippy::used_underscore_binding)]
         if let Err(_e) = &result {
             opt_error!(error = %_e, "eth_getByBlockNumber failed");
         }
@@ -165,6 +167,7 @@ impl<N: Network> RobustProvider<N> {
             )
             .await
             .map_err(Error::from);
+        #[allow(clippy::used_underscore_binding)]
         if let Err(_e) = &result {
             opt_error!(error = %_e, "eth_getBlockNumber failed");
         }
@@ -190,6 +193,7 @@ impl<N: Network> RobustProvider<N> {
                 false,
             )
             .await;
+        #[allow(clippy::used_underscore_binding)]
         if let Err(_e) = &result {
             opt_error!(error = %_e, "get_block_number_by_id failed");
         }
@@ -231,6 +235,7 @@ impl<N: Network> RobustProvider<N> {
                 false,
             )
             .await;
+        #[allow(clippy::used_underscore_binding)]
         if let Err(_e) = &result {
             opt_error!(error = %_e, "eth_getBlockByHash failed");
         }
@@ -254,6 +259,7 @@ impl<N: Network> RobustProvider<N> {
             )
             .await
             .map_err(Error::from);
+        #[allow(clippy::used_underscore_binding)]
         if let Err(_e) = &result {
             opt_error!(error = %_e, "eth_getLogs failed");
         }
@@ -414,9 +420,12 @@ impl<N: Network> RobustProvider<N> {
             self.call_timeout,
             (|| operation(provider.clone()))
                 .retry(retry_strategy)
-                .notify(|_err: &RpcError<TransportErrorKind>, _dur: Duration| {
-                    opt_info!(error = %_err, "RPC error retrying after {:?}", _dur);
-                })
+                .notify(
+                    #[allow(clippy::used_underscore_binding)]
+                    |_err: &RpcError<TransportErrorKind>, _dur: Duration| {
+                        opt_info!(error = %_err, "RPC error retrying after {:?}", _dur);
+                    },
+                )
                 .sleep(tokio::time::sleep),
         )
         .await

src/robust_provider/subscription.rs

@@ -128,6 +128,7 @@ impl<N: Network> RobustSubscription<N> {
                             RecvError::Closed => {
                                 opt_error!("Provider closed the subscription channel");
                             }
+                            #[allow(clippy::used_underscore_binding)]
                             RecvError::Lagged(_count) => {
                                 opt_error!(skipped = _count, "Receiver lagged");
                             }
@@ -180,6 +181,7 @@ impl<N: Network> RobustSubscription<N> {
                 self.last_reconnect_attempt = None;
                 true
             }
+            #[allow(clippy::used_underscore_binding)]
             Err(_e) => {
                 self.last_reconnect_attempt = Some(Instant::now());
                 opt_warn!(error = %_e, "Failed to reconnect to primary provider");

src/types.rs

@@ -106,6 +106,7 @@ pub(crate) trait TryStream<T: Clone> {
     async fn try_stream<M: IntoScannerResult<T>>(&self, msg: M) -> bool;
 }
 
+#[allow(clippy::used_underscore_binding)]
 impl<T: Clone + Debug> TryStream<T> for mpsc::Sender<ScannerResult<T>> {
     async fn try_stream<M: IntoScannerResult<T>>(&self, msg: M) -> bool {
         let item = msg.into_scanner_message_result();