update: fix fmt

Author: heemankv

madara/crates/client/gateway/client/src/health.rs

@@ -2,7 +2,6 @@
 ///
 /// This module provides gateway-specific health monitoring by wrapping the generic
 /// mp-resilience ConnectionHealth with gateway-specific context.
-
 use mp_resilience::ConnectionHealth;
 use std::sync::Arc;
 use tokio::sync::RwLock;

madara/crates/client/gateway/client/src/retry.rs

@@ -2,7 +2,6 @@
 ///
 /// This module wraps the generic mp-resilience retry logic with gateway-specific
 /// error type handling for SequencerError.
-
 use mp_gateway::error::{SequencerError, StarknetErrorCode};
 use std::time::Duration;
 

madara/crates/client/settlement_client/src/eth/mod.rs

@@ -179,9 +179,9 @@ impl SettlementLayerProvider for EthereumClient {
                 logs.into_iter().rev().map(|log| log.log_decode::<StarknetCoreContract::LogStateUpdate>()).next();
 
             match latest_logs {
-                Some(Ok(log)) => log
-                    .block_number
-                    .ok_or_else(|| -> SettlementClientError { EthereumClientError::MissingField("block_number").into() }),
+                Some(Ok(log)) => log.block_number.ok_or_else(|| -> SettlementClientError {
+                    EthereumClientError::MissingField("block_number").into()
+                }),
                 Some(Err(e)) => Err(SettlementClientError::Ethereum(EthereumClientError::Contract(e.to_string()))),
                 None => Err(SettlementClientError::Ethereum(EthereumClientError::EventProcessing {
                     message: format!("no LogStateUpdate event found in block range [None, {}]", latest_block),
@@ -263,18 +263,20 @@ impl SettlementLayerProvider for EthereumClient {
             // Try to create the event stream with retry logic
             let event_filter = self.l1_core_contract.event_filter::<StarknetCoreContract::LogStateUpdate>();
 
-            let event_stream_result = ctx.run_until_cancelled(async {
-                self.retry_l1_call("watch_events", || async {
-                    event_filter.watch().await.map_err(|e| -> SettlementClientError {
-                        EthereumClientError::EventStream { message: format!("Failed to watch events: {}", e) }.into()
+            let event_stream_result = ctx
+                .run_until_cancelled(async {
+                    self.retry_l1_call("watch_events", || async {
+                        event_filter.watch().await.map_err(|e| -> SettlementClientError {
+                            EthereumClientError::EventStream { message: format!("Failed to watch events: {}", e) }
+                                .into()
+                        })
                     })
-                }).await
-            }).await;
+                    .await
+                })
+                .await;
 
             let mut event_stream = match event_stream_result {
-                Some(Ok(stream)) => {
-                    stream.into_stream()
-                },
+                Some(Ok(stream)) => stream.into_stream(),
                 Some(Err(e)) => {
                     // This shouldn't happen since retry_l1_call has infinite retry,
                     // but handle it just in case
@@ -474,18 +476,20 @@ impl SettlementLayerProvider for EthereumClient {
     ) -> Result<BoxStream<'static, Result<MessageToL2WithMetadata, SettlementClientError>>, SettlementClientError> {
         // Wrap the watch call with retry logic to handle L1 being down
         // Note: We need to recreate the filter inside the closure to avoid move issues
-        let event_stream = self.retry_l1_call("watch_message_events", || async {
-            let filter = self.l1_core_contract.event_filter::<LogMessageToL2>();
-            filter.from_block(from_l1_block_n).to_block(BlockNumberOrTag::Finalized).watch().await.map_err(
-                |e| -> SettlementClientError {
-                    EthereumClientError::ArchiveRequired(format!(
-                        "Could not fetch events, archive node may be required: {}",
-                        e
-                    ))
-                    .into()
-                },
-            )
-        }).await?;
+        let event_stream = self
+            .retry_l1_call("watch_message_events", || async {
+                let filter = self.l1_core_contract.event_filter::<LogMessageToL2>();
+                filter.from_block(from_l1_block_n).to_block(BlockNumberOrTag::Finalized).watch().await.map_err(
+                    |e| -> SettlementClientError {
+                        EthereumClientError::ArchiveRequired(format!(
+                            "Could not fetch events, archive node may be required: {}",
+                            e
+                        ))
+                        .into()
+                    },
+                )
+            })
+            .await?;
 
         Ok(EthereumEventStream::new(event_stream).boxed())
     }
@@ -645,14 +649,14 @@ mod l1_messaging_tests {
         transports::http::{Client, Http},
     };
     use mc_db::MadaraBackend;
-    use mp_resilience::ConnectionHealth;
-    use tokio::sync::RwLock;
     use mp_chain_config::ChainConfig;
+    use mp_resilience::ConnectionHealth;
     use mp_transactions::{L1HandlerTransaction, L1HandlerTransactionWithFee};
     use mp_utils::service::ServiceContext;
     use rstest::*;
     use starknet_types_core::felt::Felt;
     use std::{sync::Arc, time::Duration};
+    use tokio::sync::RwLock;
     use tracing_test::traced_test;
     use url::Url;
 

madara/crates/client/settlement_client/src/lib.rs

@@ -191,7 +191,11 @@ pub struct L1ClientImpl {
 }
 
 impl L1ClientImpl {
-    fn new(backend: Arc<MadaraBackend>, provider: Arc<dyn SettlementLayerProvider>, health: Arc<RwLock<ConnectionHealth>>) -> Self {
+    fn new(
+        backend: Arc<MadaraBackend>,
+        provider: Arc<dyn SettlementLayerProvider>,
+        health: Arc<RwLock<ConnectionHealth>>,
+    ) -> Self {
         Self { provider, backend, notify_new_message_to_l2: Default::default(), health }
     }
 

madara/crates/client/settlement_client/src/messaging.rs

@@ -83,11 +83,13 @@ pub async fn sync(
 
     // Infinite retry loop for message syncing
     loop {
-        let result = ctx.run_until_cancelled(sync_inner(
-            Arc::clone(&settlement_client),
-            Arc::clone(&backend),
-            Arc::clone(&notify_consumer),
-        )).await;
+        let result = ctx
+            .run_until_cancelled(sync_inner(
+                Arc::clone(&settlement_client),
+                Arc::clone(&backend),
+                Arc::clone(&notify_consumer),
+            ))
+            .await;
 
         match result {
             Some(Ok(())) => {

madara/crates/primitives/resilience/src/health.rs

@@ -237,8 +237,7 @@ impl ConnectionHealth {
         }
 
         // Standard recovery: enough attempts with low failure rate
-        self.recovery_attempts >= RECOVERY_ATTEMPTS_THRESHOLD
-            && self.failure_rate() < FAILURE_RATE_HEALTHY_THRESHOLD
+        self.recovery_attempts >= RECOVERY_ATTEMPTS_THRESHOLD && self.failure_rate() < FAILURE_RATE_HEALTHY_THRESHOLD
     }
 
     /// Calculate current failure rate

madara/crates/primitives/resilience/src/lib.rs

@@ -34,10 +34,9 @@
 ///     }
 /// }
 /// ```
-
 pub mod health;
 pub mod retry;
 
 // Re-export main types for convenience
-pub use health::{ConnectionHealth, HealthState, start_health_monitor};
+pub use health::{start_health_monitor, ConnectionHealth, HealthState};
 pub use retry::{RetryConfig, RetryPhase, RetryState};

madara/crates/primitives/resilience/src/retry.rs

@@ -104,10 +104,7 @@ pub struct RetryState {
 
 impl std::fmt::Debug for RetryState {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        f.debug_struct("RetryState")
-            .field("config", &self.config)
-            .field("retry_count", &self.retry_count)
-            .finish()
+        f.debug_struct("RetryState").field("config", &self.config).field("retry_count", &self.retry_count).finish()
     }
 }
 

madara/node/src/service/l2.rs

@@ -75,7 +75,7 @@ impl Service for SyncService {
             // TODO(heemankv, 2025-10-26): all_verifications_disabled should be configured from the env
             BlockValidationConfig::default()
                 .trust_parent_hash(this.unsafe_starting_block_enabled)
-                .trust_state_root(this.unsafe_starting_block_enabled)
+                .trust_state_root(this.unsafe_starting_block_enabled),
         ));
 
         let config = SyncControllerConfig::default()