fix(ui): Send Dash screen improvements + unified shield screen merge

src/backend_task/core/mod.rs

@@ -457,8 +457,8 @@ impl AppContext {
         let client = match Client::new(&addr, Auth::CookieFile(cookie_path.clone())) {
             Ok(client) => client,
             Err(_) => {
-                tracing::debug!(
-                    "Failed to authenticate using .cookie file at {:?}, falling back to user/pass",
+                tracing::trace!(
+                    "Cookie auth unavailable at {:?}, using user/pass",
                     cookie_path
                 );
                 match Client::new(

src/backend_task/shielded/bundle.rs

@@ -3,7 +3,7 @@ use crate::context::AppContext;
 use crate::context::shielded::get_proving_key;
 use crate::model::fee_estimation::{format_credits_as_dash, shielded_fee_for_actions};
 use crate::model::wallet::WalletSeedHash;
-use crate::model::wallet::shielded::ShieldedWalletState;
+use crate::model::wallet::shielded::{ShieldedNote, ShieldedWalletState};
 use dash_sdk::dpp::address_funds::{
     AddressFundsFeeStrategy, AddressFundsFeeStrategyStep, OrchardAddress, PlatformAddress,
 };
@@ -15,10 +15,12 @@ use dash_sdk::dpp::shielded::builder::{
 };
 use dash_sdk::dpp::version::PlatformVersion;
 use dash_sdk::dpp::withdrawal::Pooling;
-use dash_sdk::grovedb_commitment_tree::{Nullifier, PaymentAddress, ProvingKey};
+use dash_sdk::grovedb_commitment_tree::{
+    Anchor, ClientPersistentCommitmentTree, Nullifier, PaymentAddress, ProvingKey,
+};
 use dash_sdk::platform::transition::broadcast::BroadcastStateTransition;
 use std::collections::BTreeMap;
-use std::sync::{Arc, Mutex};
+use std::sync::{Arc, Mutex, MutexGuard};
 
 /// Wrapper around a cached `ProvingKey` that implements `OrchardProver`.
 struct CachedProver {
@@ -98,7 +100,7 @@ pub fn build_shield_credit(
     let recipient_addr = payment_address_to_orchard(recipient_payment_address)?;
 
     let wallet_arc = {
-        let wallets = app_context.wallets.read().unwrap();
+        let wallets = app_context.wallets.read()?;
         wallets
             .get(seed_hash)
             .cloned()
@@ -111,7 +113,8 @@ pub fn build_shield_credit(
     let fee_strategy: AddressFundsFeeStrategy =
         vec![AddressFundsFeeStrategyStep::DeductFromInput(0)];
 
-    let wallet = wallet_arc.read().unwrap();
+    let wallet = wallet_arc.read()?;
+    // memo: 36-byte structured memo (4-byte type tag + 32-byte payload); all zeros = empty memo
     build_shield_transition(
         &recipient_addr,
         amount,
@@ -148,7 +151,7 @@ pub async fn shield_credits(
     let recipient_addr = payment_address_to_orchard(recipient_payment_address)?;
 
     let wallet_arc = {
-        let wallets = app_context.wallets.read().unwrap();
+        let wallets = app_context.wallets.read()?;
         wallets
             .get(seed_hash)
             .cloned()
@@ -158,7 +161,7 @@ pub async fn shield_credits(
     let nonce: u32 = if let Some(n) = nonce_override {
         n
     } else {
-        let wallet = wallet_arc.read().unwrap();
+        let wallet = wallet_arc.read()?;
         wallet
             .platform_address_info
             .iter()
@@ -187,11 +190,12 @@ pub async fn shield_credits(
     );
 
     if let Some(s) = &stage {
-        *s.lock().unwrap() = ShieldStage::BuildingProof { nonce };
+        *s.lock()? = ShieldStage::BuildingProof { nonce };
     }
 
     let state_transition = {
-        let wallet = wallet_arc.read().unwrap();
+        let wallet = wallet_arc.read()?;
+        // memo: 36-byte structured memo (4-byte type tag + 32-byte payload); all zeros = empty memo
         build_shield_transition(
             &recipient_addr,
             amount,
@@ -207,7 +211,7 @@ pub async fn shield_credits(
     };
 
     if let Some(s) = &stage {
-        *s.lock().unwrap() = ShieldStage::Broadcasting;
+        *s.lock()? = ShieldStage::Broadcasting;
     }
 
     tracing::trace!("Shield credits: state transition built, broadcasting...");
@@ -269,35 +273,13 @@ pub async fn shielded_transfer(
     let spent_nullifiers: Vec<Nullifier> = spendable_notes.iter().map(|n| n.nullifier).collect();
 
     let (spends, anchor) = {
-        let tree = shielded_state.commitment_tree.lock().unwrap();
-        let spends = spendable_notes
-            .iter()
-            .map(|note| {
-                let merkle_path = tree
-                    .witness(note.position, 0)
-                    .map_err(|e| TaskError::ShieldedMerkleWitnessUnavailable {
-                        detail: e.to_string(),
-                    })?
-                    .ok_or(TaskError::ShieldedMerkleWitnessUnavailable {
-                        detail: "No Merkle path available for note".into(),
-                    })?;
-                Ok(SpendableNote {
-                    note: note.note,
-                    merkle_path,
-                })
-            })
-            .collect::<Result<Vec<_>, TaskError>>()?;
-
-        let anchor = tree
-            .anchor()
-            .map_err(|e| TaskError::ShieldedMerkleWitnessUnavailable {
-                detail: e.to_string(),
-            })?;
-        (spends, anchor)
+        let tree = shielded_state.commitment_tree.lock()?;
+        extract_spends_and_anchor(&tree, &spendable_notes)?
     };
 
     let change_addr = payment_address_to_orchard(&shielded_state.keys.default_address)?;
 
+    // memo: 36-byte structured memo (4-byte type tag + 32-byte payload); all zeros = empty memo
     let state_transition = build_shielded_transfer_transition(
         spends,
         &recipient_addr,
@@ -367,35 +349,13 @@ pub async fn unshield_credits(
     let spent_nullifiers: Vec<Nullifier> = spendable_notes.iter().map(|n| n.nullifier).collect();
 
     let (spends, anchor) = {
-        let tree = shielded_state.commitment_tree.lock().unwrap();
-        let spends = spendable_notes
-            .iter()
-            .map(|note| {
-                let merkle_path = tree
-                    .witness(note.position, 0)
-                    .map_err(|e| TaskError::ShieldedMerkleWitnessUnavailable {
-                        detail: e.to_string(),
-                    })?
-                    .ok_or(TaskError::ShieldedMerkleWitnessUnavailable {
-                        detail: "No Merkle path available for note".into(),
-                    })?;
-                Ok(SpendableNote {
-                    note: note.note,
-                    merkle_path,
-                })
-            })
-            .collect::<Result<Vec<_>, TaskError>>()?;
-
-        let anchor = tree
-            .anchor()
-            .map_err(|e| TaskError::ShieldedMerkleWitnessUnavailable {
-                detail: e.to_string(),
-            })?;
-        (spends, anchor)
+        let tree = shielded_state.commitment_tree.lock()?;
+        extract_spends_and_anchor(&tree, &spendable_notes)?
     };
 
     let change_addr = payment_address_to_orchard(&shielded_state.keys.default_address)?;
 
+    // memo: 36-byte structured memo (4-byte type tag + 32-byte payload); all zeros = empty memo
     let state_transition = build_unshield_transition(
         spends,
         to_platform_address,
@@ -457,7 +417,7 @@ pub async fn shield_from_asset_lock(
     // Step 1: Create the asset lock transaction
     let (asset_lock_transaction, asset_lock_private_key, _asset_lock_address, used_utxos) = {
         let wallet_arc = {
-            let wallets = app_context.wallets.read().unwrap();
+            let wallets = app_context.wallets.read()?;
             wallets
                 .get(seed_hash)
                 .cloned()
@@ -501,10 +461,7 @@ pub async fn shield_from_asset_lock(
 
     // Step 2: Register this transaction as waiting for finality
     {
-        let mut proofs = app_context
-            .transactions_waiting_for_finality
-            .lock()
-            .unwrap();
+        let mut proofs = app_context.transactions_waiting_for_finality.lock()?;
         proofs.insert(tx_id, None);
     }
 
@@ -520,7 +477,7 @@ pub async fn shield_from_asset_lock(
     // Step 4: Remove used UTXOs from wallet
     {
         let wallet_arc = {
-            let wallets = app_context.wallets.read().unwrap();
+            let wallets = app_context.wallets.read()?;
             wallets
                 .get(seed_hash)
                 .cloned()
@@ -573,7 +530,7 @@ pub async fn shield_from_asset_lock(
                 return Err(TaskError::ShieldedAssetLockTimeout);
             }
             _ = tokio::time::sleep(Duration::from_millis(200)) => {
-                let proofs = app_context.transactions_waiting_for_finality.lock().unwrap();
+                let proofs = app_context.transactions_waiting_for_finality.lock()?;
                 if let Some(Some(proof)) = proofs.get(&tx_id) {
                     asset_lock_proof = proof.clone();
                     break;
@@ -584,10 +541,7 @@ pub async fn shield_from_asset_lock(
 
     // Step 6: Clean up the finality tracking
     {
-        let mut proofs = app_context
-            .transactions_waiting_for_finality
-            .lock()
-            .unwrap();
+        let mut proofs = app_context.transactions_waiting_for_finality.lock()?;
         proofs.remove(&tx_id);
     }
 
@@ -611,6 +565,7 @@ pub async fn shield_from_asset_lock(
         shield_amount_credits,
     );
 
+    // memo: 36-byte structured memo (4-byte type tag + 32-byte payload); all zeros = empty memo
     let state_transition = build_shield_from_asset_lock_transition(
         &recipient,
         shield_amount_credits,
@@ -677,35 +632,13 @@ pub async fn shielded_withdrawal(
     let spent_nullifiers: Vec<Nullifier> = spendable_notes.iter().map(|n| n.nullifier).collect();
 
     let (spends, anchor) = {
-        let tree = shielded_state.commitment_tree.lock().unwrap();
-        let spends = spendable_notes
-            .iter()
-            .map(|note| {
-                let merkle_path = tree
-                    .witness(note.position, 0)
-                    .map_err(|e| TaskError::ShieldedMerkleWitnessUnavailable {
-                        detail: e.to_string(),
-                    })?
-                    .ok_or(TaskError::ShieldedMerkleWitnessUnavailable {
-                        detail: "No Merkle path available for note".into(),
-                    })?;
-                Ok(SpendableNote {
-                    note: note.note,
-                    merkle_path,
-                })
-            })
-            .collect::<Result<Vec<_>, TaskError>>()?;
-
-        let anchor = tree
-            .anchor()
-            .map_err(|e| TaskError::ShieldedMerkleWitnessUnavailable {
-                detail: e.to_string(),
-            })?;
-        (spends, anchor)
+        let tree = shielded_state.commitment_tree.lock()?;
+        extract_spends_and_anchor(&tree, &spendable_notes)?
     };
 
     let change_addr = payment_address_to_orchard(&shielded_state.keys.default_address)?;
 
+    // memo: 36-byte structured memo (4-byte type tag + 32-byte payload); all zeros = empty memo
     let state_transition = build_shielded_withdrawal_transition(
         spends,
         amount,
@@ -833,6 +766,40 @@ fn select_notes_for_amount(
     Ok((selected, accumulated))
 }
 
+/// Extract spendable notes with Merkle witnesses and the tree anchor.
+///
+/// Locks the commitment tree, computes a Merkle path for each selected note,
+/// and returns them alongside the current tree anchor for proof construction.
+fn extract_spends_and_anchor(
+    tree: &MutexGuard<'_, ClientPersistentCommitmentTree>,
+    notes: &[&ShieldedNote],
+) -> Result<(Vec<SpendableNote>, Anchor), TaskError> {
+    let spends = notes
+        .iter()
+        .map(|note| {
+            let merkle_path = tree
+                .witness(note.position, 0)
+                .map_err(|e| TaskError::ShieldedMerkleWitnessUnavailable {
+                    detail: e.to_string(),
+                })?
+                .ok_or(TaskError::ShieldedMerkleWitnessUnavailable {
+                    detail: "No Merkle path available for note".into(),
+                })?;
+            Ok(SpendableNote {
+                note: note.note,
+                merkle_path,
+            })
+        })
+        .collect::<Result<Vec<_>, TaskError>>()?;
+
+    let anchor = tree
+        .anchor()
+        .map_err(|e| TaskError::ShieldedMerkleWitnessUnavailable {
+            detail: e.to_string(),
+        })?;
+    Ok((spends, anchor))
+}
+
 /// Convert a PaymentAddress to an OrchardAddress for the builder functions.
 fn payment_address_to_orchard(addr: &PaymentAddress) -> Result<OrchardAddress, TaskError> {
     let raw = addr.to_raw_address_bytes();

src/context/mod.rs

@@ -605,8 +605,8 @@ impl AppContext {
             if let Ok(client) = Client::new(url, Auth::CookieFile(cookie_path.clone())) {
                 return Ok(client);
             }
-            tracing::debug!(
-                "Failed to authenticate using .cookie file at {:?}, falling back to user/pass",
+            tracing::trace!(
+                "Cookie auth unavailable at {:?}, using user/pass",
                 cookie_path,
             );
         }