feat: improve scanning feedback (#7622)

Description
---
Improve the scanning feddback

<!-- This is an auto-generated comment: release notes by coderabbit.ai
-->

## Summary by CodeRabbit

* **Chores**
* Enhanced state inspection and logging for UTXO processing in wallet
server operations, including mined and deletion status tracking.
* Added Display formatting for transaction types to support improved
debugging and logging output.

<sub>✏️ Tip: You can customize this high-level summary in your review
settings.</sub>

<!-- end of auto-generated comment: release notes by coderabbit.ai -->

Author: SWvheerden

applications/minotari_console_wallet/src/grpc/wallet_grpc_server.rs

@@ -3198,13 +3198,53 @@ impl wallet_server::Wallet for WalletGrpcServer {
                 .await
                 .map_err(|e| Status::internal(format!("Failed to get output from Output Manager: {}", e)))?;
             if !db_result.is_empty() {
+                let db_output = &db_result.first().expect("Should not be empty, this is checked").0;
                 debug_info.push(format!("UTXO with hash {} already exists in Output Manager", hex));
-                let tx = db_result
-                    .first()
-                    .expect("Should not be empty, this is checked")
-                    .0
-                    .received_in_tx_id
-                    .unwrap_or_default();
+                match (db_output.mined_in_block, db_output.mined_timestamp) {
+                    (Some(hash), Some(_)) => {
+                        debug_info.push(format!("UTXO with hash {} is already mined in block: {}", hex, hash));
+                    },
+                    _ => {
+                        debug_info.push(format!("UTXO with hash {} is unmined, according to wallet", hex));
+                    },
+                }
+                match (db_output.marked_deleted_in_block, db_output.marked_deleted_at_height) {
+                    (Some(hash), Some(height)) => {
+                        debug_info.push(format!(
+                            "UTXO with hash {} is marked deleted at height: {} in block: {}",
+                            hex, height, hash
+                        ));
+                    },
+                    (None, None) => {},
+                    _ => {
+                        debug_info.push(format!("UTXO with hash {} is has inconsistent mined data", hex));
+                    },
+                }
+                if let Some(tx_id) = db_output.received_in_tx_id {
+                    let tx = tms.get_any_transaction(tx_id).await;
+                    match tx {
+                        Ok(Some(tx)) => {
+                            debug_info.push(format!("UTXO is associated with transaction {}", tx));
+                        },
+                        Ok(None) => {
+                            debug_info.push(format!(
+                                "UTXO is associated with transaction id: {} but transaction not found in Transaction \
+                                 Service",
+                                tx_id.as_u64()
+                            ));
+                        },
+                        Err(e) => {
+                            debug_info.push(format!(
+                                "Error fetching transaction id: {} associated with UTXO: {}: {}",
+                                tx_id.as_u64(),
+                                hex,
+                                e
+                            ));
+                        },
+                    }
+                }
+
+                let tx = db_output.received_in_tx_id.unwrap_or_default();
                 results.push(ScanFeedback {
                     output_hash: hex,
                     is_found: true,

base_layer/wallet/src/transaction_service/storage/models.rs

@@ -89,6 +89,16 @@ impl InboundTransaction {
     }
 }
 
+impl Display for InboundTransaction {
+    fn fmt(&self, fmt: &mut Formatter<'_>) -> Result<(), Error> {
+        write!(
+            fmt,
+            "TxId: {}, Source: {}, Amount: {}, Status: {:?}, Timestamp: {}, Cancelled: {}",
+            self.tx_id, self.source_address, self.amount, self.status, self.timestamp, self.cancelled
+        )
+    }
+}
+
 #[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
 pub struct OutboundTransaction {
     pub tx_id: TxId,
@@ -166,6 +176,16 @@ impl OutboundTransaction {
     }
 }
 
+impl Display for OutboundTransaction {
+    fn fmt(&self, fmt: &mut Formatter<'_>) -> Result<(), Error> {
+        write!(
+            fmt,
+            "TxId: {}, Destination: {}, Amount: {}, Fee: {}, Status: {:?}, Timestamp: {}, Cancelled: {}",
+            self.tx_id, self.destination_address, self.amount, self.fee, self.status, self.timestamp, self.cancelled
+        )
+    }
+}
+
 #[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
 pub struct CompletedTransaction {
     pub tx_id: TxId,
@@ -499,6 +519,37 @@ impl CompletedTransaction {
     }
 }
 
+impl Display for CompletedTransaction {
+    fn fmt(&self, fmt: &mut Formatter<'_>) -> Result<(), Error> {
+        match self.cancelled {
+            Some(cancelled_reason) => write!(
+                fmt,
+                "TxId: {}, Source: {}, Destination: {}, Amount: {}, Fee: {}, Status: {:?}, Timestamp: {}, Cancelled: \
+                 {}",
+                self.tx_id,
+                self.source_address,
+                self.destination_address,
+                self.amount,
+                self.fee,
+                self.status,
+                self.timestamp,
+                cancelled_reason,
+            ),
+            None => write!(
+                fmt,
+                "TxId: {}, Source: {}, Destination: {}, Amount: {}, Fee: {}, Status: {:?}, Timestamp: {}",
+                self.tx_id,
+                self.source_address,
+                self.destination_address,
+                self.amount,
+                self.fee,
+                self.status,
+                self.timestamp,
+            ),
+        }
+    }
+}
+
 impl From<CompletedTransaction> for InboundTransaction {
     fn from(ct: CompletedTransaction) -> Self {
         Self {
@@ -657,6 +708,16 @@ impl From<WalletTransaction> for CompletedTransaction {
     }
 }
 
+impl Display for WalletTransaction {
+    fn fmt(&self, fmt: &mut Formatter<'_>) -> Result<(), Error> {
+        match self {
+            WalletTransaction::PendingInbound(tx) => write!(fmt, "Pending Inbound Transaction: {}", tx),
+            WalletTransaction::PendingOutbound(tx) => write!(fmt, "Pending Outbound Transaction: {}", tx),
+            WalletTransaction::Completed(tx) => write!(fmt, "Completed Transaction: {}", tx),
+        }
+    }
+}
+
 #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, Serialize, Deserialize)]
 pub enum TxCancellationReason {
     Unknown,            // 0