fix: wire up DashPay payment history to wallet transactions

The Payment History screen was always empty because it only read from
the dashpay_payments database table, which was only populated when
payments were sent through the app's DashPay UI. The
process_incoming_payment() function existed but was never called.

Changes:
- Add scan_wallet_transactions_for_dashpay_payments() that cross-
  references SPV wallet transactions against DashPay address mappings
  and saves matches to the dashpay_payments table (idempotent)
- Call it from LoadPaymentHistory backend task for immediate retroactive
  detection when the user opens the Payment History screen
- Call it during SPV reconcile for ongoing automatic detection
- Fix ContactDetailsScreen to load per-contact payment history from DB
  (was initialized empty and never populated)

Closes #688

Author: thepastaclaw

src/backend_task/dashpay.rs

@@ -171,6 +171,40 @@ impl AppContext {
             ),
             DashPayTask::LoadPaymentHistory { identity } => {
                 let identity_id = identity.identity.id();
+
+                // Retroactively scan wallet transactions for DashPay payments
+                // that may not yet be in the dashpay_payments table.
+                // Clone transactions and drop the read lock before scanning
+                // to reduce lock contention.
+                // Iterate all associated wallets — an identity can have multiple.
+                for wallet_arc in identity.associated_wallets.values() {
+                    let wallet_txs = match wallet_arc.read() {
+                        Ok(guard) => guard.transactions.clone(),
+                        Err(_) => continue,
+                    };
+
+                    if wallet_txs.is_empty() {
+                        continue;
+                    }
+
+                    match incoming_payments::scan_wallet_transactions_for_dashpay_payments(
+                        self,
+                        &identity_id,
+                        &wallet_txs,
+                    ) {
+                        Ok(n) if n > 0 => {
+                            tracing::info!(
+                                "Retroactively discovered {} DashPay payment(s) from wallet transactions",
+                                n
+                            );
+                        }
+                        Err(e) => {
+                            tracing::warn!("Wallet transaction scan failed: {}", e);
+                        }
+                        _ => {}
+                    }
+                }
+
                 let records = payments::load_payment_history(self, &identity_id, None).await?;
 
                 let network_str = self.network.to_string();

src/backend_task/dashpay/incoming_payments.rs

@@ -282,6 +282,42 @@ pub fn match_transaction_to_contact(
         .map_err(|e| format!("Failed to lookup address: {}", e))
 }
 
+/// Record a single incoming DashPay payment in the database.
+///
+/// Saves the payment record and updates the highest receive index for the
+/// contact.  This is the shared core of [`process_incoming_payment`] (real-time
+/// SPV path) and [`scan_wallet_transactions_for_dashpay_payments`] (retroactive
+/// scan).
+fn record_incoming_payment(
+    app_context: &AppContext,
+    tx_id: &str,
+    owner_id: &Identifier,
+    contact_id: &Identifier,
+    amount_duffs: u64,
+    address_index: u32,
+) -> Result<(), String> {
+    app_context
+        .db
+        .save_payment(
+            tx_id,
+            contact_id, // from contact
+            owner_id,   // to us
+            amount_duffs as i64,
+            None, // memo — not available for incoming
+            "received",
+        )
+        .map_err(|e| format!("Failed to save payment: {}", e))?;
+
+    // update_highest_receive_index uses MAX() internally, so calling
+    // unconditionally is safe and idempotent.
+    app_context
+        .db
+        .update_highest_receive_index(owner_id, contact_id, address_index + 1)
+        .map_err(|e| format!("Failed to update receive index: {}", e))?;
+
+    Ok(())
+}
+
 /// Process an incoming transaction that was detected by SPV
 /// This should be called when WalletEvent::TransactionReceived is received
 pub async fn process_incoming_payment(
@@ -298,31 +334,15 @@ pub async fn process_incoming_payment(
 
     let (owner_id, contact_id, address_index) = mapping;
 
-    // Update the highest receive index if needed
-    let current_indices = app_context
-        .db
-        .get_contact_address_indices(&owner_id, &contact_id)
-        .map_err(|e| format!("Failed to get address indices: {}", e))?;
-
-    if address_index >= current_indices.highest_receive_index {
-        app_context
-            .db
-            .update_highest_receive_index(&owner_id, &contact_id, address_index + 1)
-            .map_err(|e| format!("Failed to update receive index: {}", e))?;
-    }
-
-    // Save the payment record
-    app_context
-        .db
-        .save_payment(
-            tx_id,
-            &contact_id, // from contact
-            &owner_id,   // to us
-            amount_duffs as i64,
-            None, // memo - not available for incoming
-            "received",
-        )
-        .map_err(|e| format!("Failed to save payment: {}", e))?;
+    // Record the payment and update address index
+    record_incoming_payment(
+        app_context,
+        tx_id,
+        &owner_id,
+        &contact_id,
+        amount_duffs,
+        address_index,
+    )?;
 
     Ok(Some(IncomingPaymentInfo {
         tx_id: tx_id.to_string(),
@@ -345,6 +365,123 @@ pub struct IncomingPaymentInfo {
     pub address_index: u32,
 }
 
+/// Scan wallet transactions against DashPay address mappings and save any
+/// matched payments to the `dashpay_payments` table.
+///
+/// This is the retroactive counterpart of [`process_incoming_payment`]: it
+/// iterates over *all* wallet transactions (already synced via SPV) and checks
+/// every output address against the stored address-mapping table.  Payments
+/// that are already recorded (by tx_id) are skipped, so calling this function
+/// repeatedly is safe and idempotent.
+///
+/// It is designed to be called from:
+/// - the SPV reconcile flow (after wallet transactions are updated), and
+/// - the `LoadPaymentHistory` backend task (for immediate retroactive
+///   detection when the user opens the Payment History screen).
+pub fn scan_wallet_transactions_for_dashpay_payments(
+    app_context: &AppContext,
+    identity_id: &Identifier,
+    transactions: &[crate::model::wallet::WalletTransaction],
+) -> Result<usize, String> {
+    use dash_sdk::dpp::dashcore::Address;
+    use std::collections::HashSet;
+
+    // Build a lookup set of addresses → (owner_id, contact_id, address_index)
+    let mappings = app_context
+        .db
+        .get_all_dashpay_address_mappings(identity_id)
+        .map_err(|e| format!("Failed to load DashPay address mappings: {}", e))?;
+
+    if mappings.is_empty() {
+        return Ok(0);
+    }
+
+    // address string → (contact_id, address_index)
+    let address_map: std::collections::HashMap<String, (Identifier, u32)> = mappings
+        .into_iter()
+        .map(|(addr_str, contact_id, idx)| (addr_str, (contact_id, idx)))
+        .collect();
+
+    // Collect already-known tx_ids to avoid duplicates.
+    // We load up to 10,000 recent payments for client-side dedup; for identities
+    // with more history the DB's `tx_id UNIQUE` constraint provides server-side
+    // protection (at the cost of a benign constraint-violation log on collisions).
+    let existing_payments = app_context
+        .db
+        .load_payment_history(identity_id, 10_000)
+        .unwrap_or_default();
+    let known_tx_ids: HashSet<String> = existing_payments.iter().map(|p| p.tx_id.clone()).collect();
+
+    let network = app_context.network;
+    let mut saved = 0usize;
+
+    for wtx in transactions {
+        let txid_str = wtx.txid.to_string();
+        if known_tx_ids.contains(&txid_str) {
+            continue;
+        }
+
+        // Check every output for a matching DashPay address
+        for output in &wtx.transaction.output {
+            let addr = match Address::from_script(&output.script_pubkey, network) {
+                Ok(a) => a,
+                Err(_) => continue,
+            };
+
+            let addr_str = addr.to_string();
+            if let Some((contact_id, address_index)) = address_map.get(&addr_str) {
+                // The address_map contains receive-side addresses (addresses contacts
+                // use to pay us). For outgoing transactions, matching an output to
+                // these addresses does NOT reliably mean we sent to the contact —
+                // skip outgoing txs in the retroactive scan.
+                if !wtx.is_incoming() {
+                    continue;
+                }
+
+                let amount_duffs = output.value;
+
+                if let Err(e) = record_incoming_payment(
+                    app_context,
+                    &txid_str,
+                    identity_id,
+                    contact_id,
+                    amount_duffs,
+                    *address_index,
+                ) {
+                    tracing::warn!(
+                        tx_id = %txid_str,
+                        error = %e,
+                        "Failed to save scanned DashPay payment"
+                    );
+                } else {
+                    saved += 1;
+                    tracing::info!(
+                        tx_id = %txid_str,
+                        contact = %contact_id.to_string(Encoding::Base58),
+                        amount = amount_duffs,
+                        direction = "received",
+                        address_index = address_index,
+                        "Saved DashPay payment from wallet transaction scan"
+                    );
+                }
+
+                // One match per transaction is enough (avoid double-counting)
+                break;
+            }
+        }
+    }
+
+    if saved > 0 {
+        tracing::info!(
+            identity = %identity_id.to_string(Encoding::Base58),
+            new_payments = saved,
+            "DashPay wallet transaction scan complete"
+        );
+    }
+
+    Ok(saved)
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;

src/context/wallet_lifecycle.rs

@@ -779,11 +779,47 @@ impl AppContext {
                     .map_err(|e| e.to_string())?;
             }
 
-            if let Some(wref) = wallets_guard.get(seed_hash)
+            // Collect identity IDs and clone transactions while the write lock
+            // is held, then drop the lock before scanning to reduce contention.
+            let identity_ids: Vec<dash_sdk::platform::Identifier> = if let Some(wref) =
+                wallets_guard.get(seed_hash)
                 && let Ok(mut wallet) = wref.write()
                 && !wallet_transactions.is_empty()
             {
-                wallet.set_transactions(wallet_transactions);
+                wallet.set_transactions(wallet_transactions.clone());
+                use dash_sdk::dpp::identity::accessors::IdentityGettersV0;
+                wallet.identities.values().map(|id| id.id()).collect()
+            } else {
+                vec![]
+            };
+
+            // Scan wallet transactions for DashPay payments and save any
+            // matches to the dashpay_payments table.  This bridges the gap
+            // between the SPV wallet (which knows about on-chain txs) and
+            // the DashPay payment history (which only knew about payments
+            // initiated through the app UI).
+            for identity_id in &identity_ids {
+                match crate::backend_task::dashpay::incoming_payments::scan_wallet_transactions_for_dashpay_payments(
+                    self,
+                    identity_id,
+                    &wallet_transactions,
+                ) {
+                    Ok(n) if n > 0 => {
+                        tracing::info!(
+                            identity = %identity_id,
+                            new_payments = n,
+                            "SPV reconcile: discovered DashPay payments from wallet transactions"
+                        );
+                    }
+                    Err(e) => {
+                        tracing::debug!(
+                            identity = %identity_id,
+                            error = %e,
+                            "SPV reconcile: DashPay payment scan failed"
+                        );
+                    }
+                    _ => {}
+                }
             }
         }
 

src/database/dashpay.rs

@@ -528,7 +528,7 @@ impl crate::database::Database {
         payment_type: &str,
     ) -> rusqlite::Result<i64> {
         let sql = "
-            INSERT INTO dashpay_payments
+            INSERT OR IGNORE INTO dashpay_payments
             (tx_id, from_identity_id, to_identity_id, amount, memo, payment_type)
             VALUES (?1, ?2, ?3, ?4, ?5, ?6)
         ";
@@ -600,6 +600,48 @@ impl crate::database::Database {
         Ok(payments)
     }
 
+    /// Load payment history filtered to a specific contact relationship.
+    /// Returns payments where both identity_id and contact_id are involved
+    /// (either as sender or receiver), ordered by most recent first.
+    pub fn load_payment_history_for_contact(
+        &self,
+        identity_id: &Identifier,
+        contact_id: &Identifier,
+        limit: u32,
+    ) -> rusqlite::Result<Vec<StoredPayment>> {
+        let conn = self.conn.lock().unwrap();
+        let mut stmt = conn.prepare(
+            "SELECT id, tx_id, from_identity_id, to_identity_id, amount, memo,
+                    payment_type, status, created_at, confirmed_at
+             FROM dashpay_payments
+             WHERE (from_identity_id = ?1 OR to_identity_id = ?1)
+               AND (from_identity_id = ?2 OR to_identity_id = ?2)
+             ORDER BY created_at DESC
+             LIMIT ?3",
+        )?;
+
+        let identity_bytes = identity_id.to_buffer().to_vec();
+        let contact_bytes = contact_id.to_buffer().to_vec();
+        let payments = stmt
+            .query_map(params![identity_bytes, contact_bytes, limit], |row| {
+                Ok(StoredPayment {
+                    id: row.get(0)?,
+                    tx_id: row.get(1)?,
+                    from_identity_id: row.get(2)?,
+                    to_identity_id: row.get(3)?,
+                    amount: row.get(4)?,
+                    memo: row.get(5)?,
+                    payment_type: row.get(6)?,
+                    status: row.get(7)?,
+                    created_at: row.get(8)?,
+                    confirmed_at: row.get(9)?,
+                })
+            })?
+            .collect::<Result<Vec<_>, _>>()?;
+
+        Ok(payments)
+    }
+
     /// Delete all DashPay data for a specific identity
     pub fn delete_dashpay_data_for_identity(
         &self,