FIX

Author: rudy-6-4

coprocessor/fhevm-engine/host-listener/src/cmd/mod.rs

@@ -460,7 +460,8 @@ impl InfiniteLogIter {
                 logs: std::mem::take(&mut current_logs),
                 summary,
                 catchup: true,
-                finalized: self.catchup_finalization_in_blocks > MINIMUM_DELAY_FOR_FINALIZATION_IN_BLOCKS,
+                finalized: self.catchup_finalization_in_blocks
+                    > MINIMUM_DELAY_FOR_FINALIZATION_IN_BLOCKS,
             };
             blocks_logs.push(block_logs);
         }

coprocessor/fhevm-engine/host-listener/src/database/ingest.rs

@@ -310,7 +310,8 @@ pub async fn ingest_block_logs(
             info!(block_number, catchup_insertion, "Catchup inserted events");
         }
     }
-    db.mark_block_as_valid(&mut tx, &block_logs.summary, block_logs.finalized).await?;
+    db.mark_block_as_valid(&mut tx, &block_logs.summary, block_logs.finalized)
+        .await?;
     if at_least_one_insertion {
         db.update_dependence_chain(
             &mut tx,

coprocessor/fhevm-engine/host-listener/tests/host_listener_integration_tests.rs

@@ -945,14 +945,12 @@ async fn test_listener_restart_and_chain_reorg() -> Result<(), anyhow::Error> {
     test_listener_no_event_loss(true, true).await
 }
 
-async fn check_finalization_status(
-    setup: Setup
-) {
+async fn check_finalization_status(setup: Setup) {
     let provider = ProviderBuilder::new()
-                .wallet(setup.wallets[0].clone())
-                .connect_ws(WsConnect::new(setup.args.url.to_string()))
-                .await
-                .unwrap();
+        .wallet(setup.wallets[0].clone())
+        .connect_ws(WsConnect::new(setup.args.url.to_string()))
+        .await
+        .unwrap();
     // Verify block finalization status: for each block number, one should be finalized and others orphaned
     let blocks = sqlx::query!(
         "SELECT block_number, block_hash, block_status FROM host_chain_blocks_valid"
@@ -962,7 +960,10 @@ async fn check_finalization_status(
 
     let blocks = blocks.expect("Failed to fetch blocks from database");
 
-    let mut blocks_by_number: std::collections::HashMap<i64, Vec<(Vec<u8>, String)>> = std::collections::HashMap::new();
+    let mut blocks_by_number: std::collections::HashMap<
+        i64,
+        Vec<(Vec<u8>, String)>,
+    > = std::collections::HashMap::new();
     for block in blocks {
         blocks_by_number
             .entry(block.block_number)
@@ -971,21 +972,37 @@ async fn check_finalization_status(
     }
 
     for (block_number, block_variants) in blocks_by_number.iter() {
-        let finalized_count = block_variants.iter().filter(|(_, status)| status == "finalized").count();
-        let orphan_count = block_variants.iter().filter(|(_, status)| status == "orphaned").count();
+        let finalized_count = block_variants
+            .iter()
+            .filter(|(_, status)| status == "finalized")
+            .count();
+        let orphan_count = block_variants
+            .iter()
+            .filter(|(_, status)| status == "orphaned")
+            .count();
         assert_eq!(
             finalized_count, 1,
             "Block {} should have exactly one finalized variant, found {}",
             block_number, finalized_count
         );
-        let finalized_hash = block_variants.iter().find(|(_, status)| status == "finalized").map(|(hash, _)| hash).unwrap();
+        let finalized_hash = block_variants
+            .iter()
+            .find(|(_, status)| status == "finalized")
+            .map(|(hash, _)| hash)
+            .unwrap();
         assert_eq!(
             orphan_count,
             block_variants.len() - 1,
             "Block {} should have remaining variants as orphan",
             block_number
         );
-        let expected_hash= provider.get_block_by_number((*block_number as u64).into()).await.unwrap().unwrap().header.hash;
+        let expected_hash = provider
+            .get_block_by_number((*block_number as u64).into())
+            .await
+            .unwrap()
+            .unwrap()
+            .header
+            .hash;
         assert_eq!(
             &expected_hash.0,
             finalized_hash.as_slice(),

coprocessor/fhevm-engine/transaction-sender/src/ops/delegate_user_decrypt.rs

@@ -9,13 +9,11 @@ use crate::metrics::{
 use crate::nonce_managed_provider::NonceManagedProvider;
 use crate::ops::common::{try_extract_non_retryable_config_error, CoprocessorConfigError};
 
+use alloy::network::{Ethereum, TransactionBuilder};
 use alloy::primitives::Address;
 use alloy::providers::Provider;
 use alloy::rpc::types::TransactionRequest;
 use alloy::transports::{RpcError, TransportErrorKind};
-use alloy::{
-    network::{Ethereum, TransactionBuilder},
-};
 
 use anyhow::Result;
 use async_trait::async_trait;
@@ -310,7 +308,8 @@ impl<P: Provider<Ethereum> + Clone + 'static> DelegateUserDecryptOperation<P> {
     }
 
     async fn get_block_status(&self, delegation: &DelegationRow) -> BlockStatus {
-        let status = sqlx::query!(r#"
+        let status = sqlx::query!(
+            r#"
             SELECT block_status
             FROM host_chain_blocks_valid
             WHERE block_hash = $2 AND chain_id = $1