clippy

SWvheerden · SWvheerden · commit be87e395c351 · 2026-04-01T12:29:18.000+02:00
diff --git a/applications/minotari_console_wallet/src/grpc/wallet_grpc_server.rs b/applications/minotari_console_wallet/src/grpc/wallet_grpc_server.rs
@@ -2652,25 +2652,22 @@ impl wallet_server::Wallet for WalletGrpcServer {
         let mut tms = self.get_transaction_service();
 
         // Look up current payref
-        let current_tx = match tms.get_transaction_by_payref(payment_ref).await {
-            Ok(txn) => Some(txn),
-            Err(_) => None,
-        };
+        let current_tx = tms.get_transaction_by_payref(payment_ref).await.ok();
 
         // Look up historical payrefs (from reorgs)
-        let historical_txs = tms.get_transaction_by_historical_payref(payment_ref).await.unwrap_or_else(|e| {
-            debug!(
+        let historical_txs = tms
+            .get_transaction_by_historical_payref(payment_ref)
+            .await
+            .unwrap_or_else(|e| {
+                debug!(
                     target: LOG_TARGET,
                     "get_payment_by_reference: Error looking up historical PayRef: {e}"
                 );
-            vec![]
-        });
+                vec![]
+            });
 
         if current_tx.is_none() && historical_txs.is_empty() {
-            return Err(Status::not_found(format!(
-                "PayRef {} not found",
-                payment_ref.to_hex()
-            )));
+            return Err(Status::not_found(format!("PayRef {} not found", payment_ref.to_hex())));
         }
 
         let transaction = current_tx.map(|txn| {
@@ -2801,10 +2798,7 @@ impl wallet_server::Wallet for WalletGrpcServer {
         };
 
         // Fetch historical payrefs for this transaction
-        let historical_payment_references = match transaction_service
-            .get_payref_history_by_tx_id(tx_id)
-            .await
-        {
+        let historical_payment_references = match transaction_service.get_payref_history_by_tx_id(tx_id).await {
             Ok(history) => history
                 .into_iter()
                 .map(|(output_hash, payref)| tari_rpc::HistoricalPayRef {
diff --git a/base_layer/wallet/src/output_manager_service/storage/sqlite_db/mod.rs b/base_layer/wallet/src/output_manager_service/storage/sqlite_db/mod.rs
@@ -906,73 +906,73 @@ impl OutputManagerBackend for OutputManagerSqliteDatabase {
         outputs_to_receive: &[DbWalletOutput],
     ) -> Result<(), OutputManagerStorageError> {
         retry_db("short_term_encumber_outputs", || {
-        let start = Instant::now();
-        let mut conn = self.database_connection.get_pooled_connection()?;
-        let acquire_lock = start.elapsed();
+            let start = Instant::now();
+            let mut conn = self.database_connection.get_pooled_connection()?;
+            let acquire_lock = start.elapsed();
 
-        let mut commitments = Vec::with_capacity(outputs_to_send.len());
-        for output in outputs_to_send {
-            commitments.push(output.commitment.as_bytes());
-        }
-        conn.transaction::<_, _, _>(|conn| {
-            // Any output in the list without the `Unspent` or `EncumberedToBeReceived` status will invalidate the
-            // encumberance. `EncumberedToBeReceived` outputs are allowed because they represent pending
-            // transaction outputs that can be spent in chained transactions (e.g. user_pay_for_fee).
-            // Any output in the list without the `Unspent` or `EncumberedToBeReceived` status will invalidate the
-            // encumberance. `EncumberedToBeReceived` outputs are allowed because they represent pending
-            // transaction outputs that can be spent in chained transactions (e.g. user_pay_for_fee).
-            if !OutputSql::find_by_commitments_excluding_statuses(
-                commitments.clone(),
-                &[OutputStatus::Unspent, OutputStatus::EncumberedToBeReceived],
-                conn,
-            )?
-            .is_empty()
-            {
-                return Err(OutputManagerStorageError::OutputAlreadySpent);
-            };
-
-            let count = OutputSql::update_by_commitments(
-                commitments,
-                UpdateOutput {
-                    status: Some(OutputStatus::ShortTermEncumberedToBeSpent),
-                    spent_in_tx_id: Some(Some(tx_id)),
-                    ..Default::default()
-                },
-                conn,
-            )?;
-            if count != outputs_to_send.len() {
-                let msg = format!(
-                    "Inconsistent short term encumbering! Lengths do not match - {} vs {}",
-                    count,
-                    outputs_to_send.len()
-                );
-                error!(target: LOG_TARGET, "{msg}");
-                return Err(OutputManagerStorageError::UnexpectedResult(msg));
+            let mut commitments = Vec::with_capacity(outputs_to_send.len());
+            for output in outputs_to_send {
+                commitments.push(output.commitment.as_bytes());
             }
+            conn.transaction::<_, _, _>(|conn| {
+                // Any output in the list without the `Unspent` or `EncumberedToBeReceived` status will invalidate the
+                // encumberance. `EncumberedToBeReceived` outputs are allowed because they represent pending
+                // transaction outputs that can be spent in chained transactions (e.g. user_pay_for_fee).
+                // Any output in the list without the `Unspent` or `EncumberedToBeReceived` status will invalidate the
+                // encumberance. `EncumberedToBeReceived` outputs are allowed because they represent pending
+                // transaction outputs that can be spent in chained transactions (e.g. user_pay_for_fee).
+                if !OutputSql::find_by_commitments_excluding_statuses(
+                    commitments.clone(),
+                    &[OutputStatus::Unspent, OutputStatus::EncumberedToBeReceived],
+                    conn,
+                )?
+                .is_empty()
+                {
+                    return Err(OutputManagerStorageError::OutputAlreadySpent);
+                };
+
+                let count = OutputSql::update_by_commitments(
+                    commitments,
+                    UpdateOutput {
+                        status: Some(OutputStatus::ShortTermEncumberedToBeSpent),
+                        spent_in_tx_id: Some(Some(tx_id)),
+                        ..Default::default()
+                    },
+                    conn,
+                )?;
+                if count != outputs_to_send.len() {
+                    let msg = format!(
+                        "Inconsistent short term encumbering! Lengths do not match - {} vs {}",
+                        count,
+                        outputs_to_send.len()
+                    );
+                    error!(target: LOG_TARGET, "{msg}");
+                    return Err(OutputManagerStorageError::UnexpectedResult(msg));
+                }
 
-            Ok(())
-        })?;
+                Ok(())
+            })?;
 
-        for co in outputs_to_receive {
-            let new_output = NewOutputSql::new(
-                co.clone(),
-                Some(OutputStatus::ShortTermEncumberedToBeReceived),
-                Some(tx_id),
-            )?;
-            new_output.commit(&mut conn)?;
-        }
-        if start.elapsed().as_millis() > 0 {
-            trace!(
-                target: LOG_TARGET,
-                "sqlite profile - short_term_encumber_outputs (TxId: {}): lock {} + db_op {} = {} ms",
-                tx_id,
-                acquire_lock.as_millis(),
-                (start.elapsed() - acquire_lock).as_millis(),
-                start.elapsed().as_millis()
-            );
-        }
+            for co in outputs_to_receive {
+                let new_output = NewOutputSql::new(
+                    co.clone(),
+                    Some(OutputStatus::ShortTermEncumberedToBeReceived),
+                    Some(tx_id),
+                )?;
+                new_output.commit(&mut conn)?;
+            }
+            if start.elapsed().as_millis() > 0 {
+                trace!(
+                    target: LOG_TARGET,
+                    "sqlite profile - short_term_encumber_outputs (TxId: {}): lock {} + db_op {} = {} ms",
+                    tx_id,
+                    acquire_lock.as_millis(),
+                    (start.elapsed() - acquire_lock).as_millis(),
+                    start.elapsed().as_millis()
+                );
+            }
 
-        Ok::<_, OutputManagerStorageError>(())
+            Ok::<_, OutputManagerStorageError>(())
         }) // retry_db
     }
 
@@ -1405,24 +1405,23 @@ impl OutputManagerBackend for OutputManagerSqliteDatabase {
         tip_height: Option<u64>,
         key_manager: &KM,
     ) -> Result<Vec<DbWalletOutput>, OutputManagerStorageError> {
-        let outputs: Vec<OutputSql> =
-            retry_db("fetch_unspent_outputs_for_spending", || {
-                let start = Instant::now();
-                let mut conn = self.database_connection.get_pooled_connection()?;
-                let acquire_lock = start.elapsed();
+        let outputs: Vec<OutputSql> = retry_db("fetch_unspent_outputs_for_spending", || {
+            let start = Instant::now();
+            let mut conn = self.database_connection.get_pooled_connection()?;
+            let acquire_lock = start.elapsed();
 
-                let outputs =
-                    OutputSql::fetch_unspent_outputs_for_spending(selection_criteria, amount, tip_height, &mut conn)?;
+            let outputs =
+                OutputSql::fetch_unspent_outputs_for_spending(selection_criteria, amount, tip_height, &mut conn)?;
 
-                trace!(
-                    target: LOG_TARGET,
-                    "sqlite profile - fetch_unspent_outputs_for_spending: lock {} + db_op {} = {} ms",
-                    acquire_lock.as_millis(),
-                    (start.elapsed() - acquire_lock).as_millis(),
-                    start.elapsed().as_millis()
-                );
-                Ok::<_, OutputManagerStorageError>(outputs)
-            })?;
+            trace!(
+                target: LOG_TARGET,
+                "sqlite profile - fetch_unspent_outputs_for_spending: lock {} + db_op {} = {} ms",
+                acquire_lock.as_millis(),
+                (start.elapsed() - acquire_lock).as_millis(),
+                start.elapsed().as_millis()
+            );
+            Ok::<_, OutputManagerStorageError>(outputs)
+        })?;
         outputs
             .iter()
             .map(|o| o.clone().to_db_wallet_output(key_manager))
diff --git a/base_layer/wallet/src/transaction_service/handle.rs b/base_layer/wallet/src/transaction_service/handle.rs
@@ -1989,8 +1989,7 @@ impl TransactionServiceHandle {
             .await
             .inspect_err(
                 |e| warn!(target: LOG_TARGET, "TransactionServiceRequest::GetTransactionByHistoricalPayref({e})"),
-            )??
-        {
+            )?? {
             TransactionServiceResponse::HistoricalPayrefTransactions(txs) => Ok(txs),
             _ => Err(TransactionServiceError::UnexpectedApiResponse(
                 "TransactionServiceRequest::GetTransactionByHistoricalPayref".to_string(),
diff --git a/base_layer/wallet/src/transaction_service/storage/sqlite_db.rs b/base_layer/wallet/src/transaction_service/storage/sqlite_db.rs
@@ -59,7 +59,12 @@ use zeroize::Zeroize;
 use crate::{
     schema,
     schema::{
-        completed_transactions, inbound_transactions, outbound_transactions, payref_history, payrefs, scanned_blocks,
+        completed_transactions,
+        inbound_transactions,
+        outbound_transactions,
+        payref_history,
+        payrefs,
+        scanned_blocks,
     },
     storage::{
         serializers,
@@ -872,42 +877,42 @@ impl TransactionBackend for TransactionServiceSqliteDatabase {
         status: LegacyTransactionStatus,
     ) -> Result<(), TransactionStorageError> {
         retry_db("update_mined_height", || {
-        let start = Instant::now();
-        let mut conn = self.database_connection.get_pooled_connection()?;
-        let acquire_lock = start.elapsed();
-        let status = if must_be_confirmed {
-            status.mined_confirm()
-        } else {
-            status.mined_unconfirm()
-        };
+            let start = Instant::now();
+            let mut conn = self.database_connection.get_pooled_connection()?;
+            let acquire_lock = start.elapsed();
+            let status = if must_be_confirmed {
+                status.mined_confirm()
+            } else {
+                status.mined_unconfirm()
+            };
 
-        match CompletedTransactionSql::update_mined_height(
-            tx_id,
-            status,
-            mined_height,
-            mined_in_block,
-            mined_timestamp,
-            &mut conn,
-        ) {
-            Ok(_) => {},
-            Err(TransactionStorageError::DieselError(DieselError::NotFound)) => {
-                return Err(TransactionStorageError::ValueNotFound(DbKey::CompletedTransaction(
-                    tx_id,
-                )));
-            },
-            Err(e) => return Err(e),
-        }
+            match CompletedTransactionSql::update_mined_height(
+                tx_id,
+                status,
+                mined_height,
+                mined_in_block,
+                mined_timestamp,
+                &mut conn,
+            ) {
+                Ok(_) => {},
+                Err(TransactionStorageError::DieselError(DieselError::NotFound)) => {
+                    return Err(TransactionStorageError::ValueNotFound(DbKey::CompletedTransaction(
+                        tx_id,
+                    )));
+                },
+                Err(e) => return Err(e),
+            }
 
-        if start.elapsed().as_millis() > 0 {
-            trace!(
-                target: LOG_TARGET,
-                "sqlite profile - update_mined_height: lock {} + db_op {} = {} ms",
-                acquire_lock.as_millis(),
-                (start.elapsed() - acquire_lock).as_millis(),
-                start.elapsed().as_millis()
-            );
-        }
-        Ok::<_, TransactionStorageError>(())
+            if start.elapsed().as_millis() > 0 {
+                trace!(
+                    target: LOG_TARGET,
+                    "sqlite profile - update_mined_height: lock {} + db_op {} = {} ms",
+                    acquire_lock.as_millis(),
+                    (start.elapsed() - acquire_lock).as_millis(),
+                    start.elapsed().as_millis()
+                );
+            }
+            Ok::<_, TransactionStorageError>(())
         }) // retry_db
     }
 
@@ -2857,15 +2862,16 @@ pub struct NewPayrefHistorySql {
 }
 
 impl PayrefHistorySql {
-    pub fn archive_from_payref(payref_sql: &PayrefSql, conn: &mut SqliteConnection) -> Result<(), TransactionStorageError> {
+    pub fn archive_from_payref(
+        payref_sql: &PayrefSql,
+        conn: &mut SqliteConnection,
+    ) -> Result<(), TransactionStorageError> {
         let new = NewPayrefHistorySql {
             output_hash: payref_sql.output_hash.clone(),
             payref: payref_sql.payref.clone(),
             tx_id: payref_sql.tx_id,
         };
-        diesel::insert_into(payref_history::table)
-            .values(&new)
-            .execute(conn)?;
+        diesel::insert_into(payref_history::table).values(&new).execute(conn)?;
         Ok(())
     }
 
diff --git a/common_sqlite/src/util/retry.rs b/common_sqlite/src/util/retry.rs
@@ -48,8 +48,8 @@ pub fn is_database_locked_error(err: &dyn Display) -> bool {
 ///
 /// # Arguments
 /// * `op_name` - A label for logging which operation is being retried.
-/// * `f` - The closure to execute. Called repeatedly until it succeeds or
-///   the error is not a "database is locked" error or retries are exhausted.
+/// * `f` - The closure to execute. Called repeatedly until it succeeds or the error is not a "database is locked" error
+///   or retries are exhausted.
 pub fn retry_db<T, E, F>(op_name: &str, mut f: F) -> Result<T, E>
 where
     E: Display,
diff --git a/integration_tests/tests/steps/wallet_steps.rs b/integration_tests/tests/steps/wallet_steps.rs
@@ -3568,9 +3568,7 @@ async fn wallet_has_payrefs_for_all_mined_transactions(world: &mut TariWorld, wa
         let mut found = false;
         for retry in 0..num_retries {
             let resp = client
-                .get_transaction_pay_refs(GetTransactionPayRefsRequest {
-                    transaction_id: *tx_id,
-                })
+                .get_transaction_pay_refs(GetTransactionPayRefsRequest { transaction_id: *tx_id })
                 .await;
 
             match resp {
@@ -3587,9 +3585,7 @@ async fn wallet_has_payrefs_for_all_mined_transactions(world: &mut TariWorld, wa
                 },
                 Err(e) => {
                     if retry == num_retries - 1 {
-                        panic!(
-                            "Failed to get PayRefs for tx {tx_id} in wallet {wallet_name}: {e}"
-                        );
+                        panic!("Failed to get PayRefs for tx {tx_id} in wallet {wallet_name}: {e}");
                     }
                 },
             }
@@ -3622,9 +3618,7 @@ async fn wallet_has_historical_payrefs(world: &mut TariWorld, wallet_name: Strin
         let num_retries = TWO_MINUTES_WITH_HALF_SECOND_SLEEP;
         for retry in 0..num_retries {
             let resp = client
-                .get_transaction_pay_refs(GetTransactionPayRefsRequest {
-                    transaction_id: *tx_id,
-                })
+                .get_transaction_pay_refs(GetTransactionPayRefsRequest { transaction_id: *tx_id })
                 .await;
 
             match resp {
@@ -3643,6 +3637,8 @@ async fn wallet_has_historical_payrefs(world: &mut TariWorld, wallet_name: Strin
                             "Wallet {wallet_name} tx {tx_id}: waiting for historical PayRefs (retry {}/{})",
                             retry, num_retries
                         ));
+                    } else {
+                        // clippy
                     }
                 },
                 Err(e) => {
