fix(balance): stop the displayed balance cratering during a pending shielded send

Sending a small amount from an address holding a large balance made the displayed
balance collapse to ~0 until the tx confirmed. A shielded spend consumes the whole
source note; the change returns as a 0-confirmation note, and every balance query
used the default minconf=1 — so the spent note dropped out and the change wasn't
counted yet.

Split every balance into two views:

- DISPLAY (balance / privateBalance / transparentBalance / totalBalance) — now
  queried at minconf=0, so it INCLUDES the user's own pending change and no longer
  craters. This is what the Overview, balance tab, market portfolio and receive
  tab show. unconfirmedBalance is now populated (= total - spendable).
- SPENDABLE (new spendableBalance / spendable*Balance) — confirmed (minconf>=1),
  what z_sendmany (run at minconf=1) can actually spend. The Send form's available/
  Max/validation, the from-address selection, the drag-to-transfer dialog cap, the
  chat pay-from and the auto-shield gate all size off these, so they never offer
  0-conf change the daemon would reject.

Implementation: a single z_listunspent(0)/listunspent(0), partitioned per-note by
"confirmations">=1; z_gettotalbalance called at minconf 0 (display) and 1
(spendable); the z_getbalance fallback queries both. applyPendingSendDelta (the
optimistic post-send debit) now touches ONLY the spendable fields — debiting the
display too would re-crater it on top of the honest minconf=0 RPC. Lite mirrors
spendableBalance = balance (its per-address balance is already confirmed) so lite
sends aren't zeroed. The confirmed-only gates (seed-migration/sweep z_gettotalbalance,
sweep z_getbalance(addr,1), z_sendmany's minconf arg) are untouched.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

.gitignore

@@ -33,6 +33,10 @@ imgui.ini
 *.bak*
 *.params
 asmap.dat
+# Wallet files hold PRIVATE KEYS — never commit them
+wallet.dat
+wallet-*.dat
+wallet.dat.*
 /external/drg-xmrig
 /memory
 /todo.md

CHANGELOG.md

@@ -0,0 +1,58 @@
+# Changelog
+
+All notable user-facing changes to ObsidianDragon are documented here. The format loosely
+follows [Keep a Changelog](https://keepachangelog.com/); the project uses Conventional Commits.
+
+## [Unreleased]
+
+### ⚠️ Breaking changes
+
+- **Remote RPC over plain HTTP is now refused by default.** If your wallet is configured to
+  reach a **remote** `rpchost`/`rpcconnect` **without TLS**, it will no longer connect — it
+  previously sent your `rpcuser`/`rpcpassword` in cleartext (capturable by anyone on the
+  network path) after only a dismissible warning. To reconnect, either:
+  - add **`rpctls=1`** to `DRAGONX.conf` (preferred, if your daemon supports TLS), or
+  - add **`rpcallowplaintext=1`** to `DRAGONX.conf` to explicitly accept the plaintext link.
+
+  Local and embedded daemons (`127.0.0.0/8`, `localhost`, `::1`) are unaffected.
+
+### Security
+
+- Refuse remote plaintext RPC credential transmission by default (see Breaking changes above).
+- Tightened localhost detection: a hostname that merely *starts* with `127.` (e.g.
+  `127.evil.com`) is no longer mistaken for a loopback address, so it can no longer bypass the
+  plaintext-RPC protection.
+- Sapling parameters are now integrity-checked (SHA-256) against pinned canonical digests
+  before use, instead of only checking that the files exist. A truncated or corrupt parameter
+  file is caught up front rather than surfacing later as a confusing shielded-operation failure.
+  (Cached via a `size:mtime` marker so it doesn't re-hash ~48 MB on every launch.)
+
+### Fixed
+
+- Daemon crashes are no longer occasionally missed: a race between the UI thread and the
+  process monitor could consume the daemon's exit status, hiding a crash and defeating the
+  automatic-restart cap. The monitor is now the sole reaper.
+- A daemon that fails to launch (missing execute permission, wrong architecture, corrupt
+  binary) now reports a precise error immediately instead of briefly showing "running" and
+  then a generic "exited unexpectedly (exit code 127)".
+- A quick stop→start no longer triggers a restart storm: the wallet now waits briefly for a
+  previous daemon to release the data-directory lock and shows a clear, non-crash message
+  instead of exhausting the crash-restart budget.
+- Failures while writing the daemon binaries or Sapling parameters (disk full, permission
+  denied) are now surfaced clearly up front instead of failing opaquely when the daemon later
+  can't start.
+- Directory-creation failures on startup (read-only home, permission denied) now produce a
+  clear "Cannot create <dir>" message instead of a confusing downstream "config missing" /
+  "binary not found" error (or, in one path, an uncaught exception).
+
+### Added
+
+- A "Taking longer than expected" notice now appears if the daemon is reachable but hasn't
+  finished initializing after ~45 s (configurable via `ui.toml`), with guidance to restart the
+  daemon or open the Console — instead of an indefinite silent spinner. It clears itself
+  automatically once the daemon connects.
+
+---
+
+Engineering detail and the finding-by-finding rationale for this batch live in
+`docs/daemon-startup-hardening.md`.

CMakeLists.txt

@@ -15,7 +15,7 @@ if(APPLE)
 endif()
 
 project(ObsidianDragon
-    VERSION 2.0.0
+    VERSION 2.0.1
     LANGUAGES C CXX
     DESCRIPTION "DragonX Cryptocurrency Wallet"
 )
@@ -544,6 +544,7 @@ set(APP_SOURCES
     src/util/async_task_manager.cpp
     src/util/amount_format.cpp
     src/util/address_validation.cpp
+    src/util/seed_phrase.cpp
     src/util/base64.cpp
     src/util/single_instance.cpp
     src/util/i18n.cpp
@@ -1074,6 +1075,32 @@ install(DIRECTORY ${CMAKE_RUNTIME_OUTPUT_DIRECTORY}/res
     OPTIONAL
 )
 
+# -----------------------------------------------------------------------------
+# dragonx-wallet-rebuild — offline recovery helper for a BDB-inconsistent wallet.dat.
+# Bundled next to the daemon; the app spawns it out-of-process. It is the ONLY thing that links
+# Berkeley DB, so the AGPLv3 BDB never contaminates the GPLv3 GUI (same boundary as the daemon).
+# Release builds should point DRAGONX_BDB_ROOT at the vendored static libdb (external/dragonx/depends);
+# a dev build falls back to the system Berkeley DB. Skipped (with a note) if no BDB is found.
+# -----------------------------------------------------------------------------
+find_path(BDB_INCLUDE_DIR db.h HINTS ${DRAGONX_BDB_ROOT}/include /usr/include /usr/local/include)
+find_library(BDB_LIBRARY NAMES db-6.2 db-6.0 db-5.3 db libdb
+             HINTS ${DRAGONX_BDB_ROOT}/lib /usr/lib /usr/local/lib /usr/lib/x86_64-linux-gnu)
+if(BDB_INCLUDE_DIR AND BDB_LIBRARY)
+    add_executable(dragonx-wallet-rebuild tools/wallet_rebuild/main.cpp)
+    target_include_directories(dragonx-wallet-rebuild PRIVATE ${CMAKE_SOURCE_DIR}/src ${BDB_INCLUDE_DIR})
+    target_link_libraries(dragonx-wallet-rebuild PRIVATE ${BDB_LIBRARY})
+    if(WIN32)
+        target_link_libraries(dragonx-wallet-rebuild PRIVATE ws2_32)   # static libdb-6.2 pulls in winsock
+    else()
+        find_package(Threads REQUIRED)
+        target_link_libraries(dragonx-wallet-rebuild PRIVATE Threads::Threads ${CMAKE_DL_LIBS})  # static libdb needs pthread/dl
+    endif()
+    set_target_properties(dragonx-wallet-rebuild PROPERTIES RUNTIME_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/bin)
+    message(STATUS "wallet-rebuild helper: ON (Berkeley DB ${BDB_LIBRARY})")
+else()
+    message(STATUS "wallet-rebuild helper: OFF (no Berkeley DB found; set DRAGONX_BDB_ROOT for release builds)")
+endif()
+
 # -----------------------------------------------------------------------------
 # Tests
 # -----------------------------------------------------------------------------
@@ -1122,6 +1149,7 @@ if(BUILD_TESTING)
         src/util/payment_uri.cpp
         src/util/amount_format.cpp
         src/util/address_validation.cpp
+        src/util/seed_phrase.cpp
         src/util/i18n.cpp
         src/util/text_format.cpp
         src/data/wallet_state.cpp
@@ -1129,6 +1157,7 @@ if(BUILD_TESTING)
         src/data/address_book.cpp
         src/data/wallet_index.cpp
         src/daemon/lifecycle_adapters.cpp
+        src/daemon/embedded_daemon.cpp
         src/rpc/connection.cpp
         src/config/settings.cpp
         src/resources/embedded_resources.cpp

build.sh

@@ -195,6 +195,24 @@ should_bundle_full_node_assets() {
     ! $DO_LITE
 }
 
+# The offline wallet-rebuild helper is the ONLY thing that repairs a genuinely BDB-inconsistent
+# wallet.dat — plain "Restore" just re-triggers the daemon's salvage cascade. A full-node release must
+# NEVER ship without it (the in-app "Repair automatically" option silently disappears otherwise), so
+# treat a missing helper as a HARD build failure instead of degrading recovery to Restore-only.
+#   $1 = built helper path (e.g. bin/dragonx-wallet-rebuild[.exe]);  $2 = the BDB depends dir for the hint.
+require_wallet_rebuild_helper() {
+    local helper="$1" depends="$2"
+    should_bundle_full_node_assets || return 0     # lite builds have no BDB wallet.dat to rebuild
+    if [[ ! -f "$helper" ]]; then
+        err "wallet-rebuild helper was NOT built: $helper"
+        err "  → the recovery 'Repair automatically' option would be MISSING from this release."
+        err "  Cause: the vendored Berkeley DB depends are absent, so CMake skipped the dragonx-wallet-rebuild target."
+        err "  Fix: provide ${depends}/{lib/libdb-6.2.a,include/db.h} (same static libdb the daemon links), then rebuild."
+        exit 1
+    fi
+    info "  wallet-rebuild helper present: $helper"
+}
+
 # ── Helper: find resource files ──────────────────────────────────────────────
 find_sapling_params() {
     local dirs=(
@@ -286,6 +304,9 @@ bundle_linux_daemon() {
     # asmap.dat
     find_asmap && cp "$ASMAP_DAT" "$dest/asmap.dat" && info "  Bundled asmap.dat"
 
+    # (The dragonx-wallet-rebuild recovery helper is built into bin/ by CMake and packaged explicitly
+    #  by each release path — required via require_wallet_rebuild_helper — so it is not copied here.)
+
     return $found
 }
 
@@ -336,11 +357,24 @@ build_release_linux() {
     mkdir -p "$bd" && cd "$bd"
 
     # ── Compile ──────────────────────────────────────────────────────────────
+    # Point the wallet-rebuild helper at the vendored static Berkeley DB (same libdb the daemon links)
+    # so its output is a v6.2 btree the bundled dragonxd reads. Pass the paths EXPLICITLY (bypasses
+    # find_library + its cache); the helper target is simply not built if the depends tree is absent.
+    local lin_bdb="$SCRIPT_DIR/external/dragonx/depends/x86_64-unknown-linux-gnu"
+    local BDB_ARGS=()
+    if [[ -f "$lin_bdb/lib/libdb-6.2.a" && -f "$lin_bdb/include/db.h" ]]; then
+        BDB_ARGS=( -DBDB_INCLUDE_DIR="$lin_bdb/include" -DBDB_LIBRARY="$lin_bdb/lib/libdb-6.2.a" )
+    elif should_bundle_full_node_assets; then
+        err "Vendored Berkeley DB depends missing at $lin_bdb — the wallet-rebuild recovery helper cannot be built."
+        err "  A full-node release must ship it; aborting rather than degrading recovery to Restore-only."
+        exit 1
+    fi
     info "Configuring ..."
     cmake "$SCRIPT_DIR" \
         -DCMAKE_BUILD_TYPE=Release \
         -DCMAKE_CXX_FLAGS_RELEASE="-O3 -DNDEBUG" \
         -DDRAGONX_USE_SYSTEM_SDL3=ON \
+        "${BDB_ARGS[@]}" \
         "${CMAKE_LITE_ARGS[@]}"
 
     info "Building with $JOBS jobs ..."
@@ -348,8 +382,12 @@ build_release_linux() {
 
     [[ -f "bin/${APP_BASENAME}" ]] || { err "Linux build failed"; exit 1; }
 
+    # A full-node release MUST include the recovery helper — fail loudly, never ship without it.
+    require_wallet_rebuild_helper "bin/dragonx-wallet-rebuild" "$lin_bdb"
+
     info "Stripping ..."
     strip "bin/${APP_BASENAME}"
+    [[ -f "bin/dragonx-wallet-rebuild" ]] && strip "bin/dragonx-wallet-rebuild"
     info "Binary: $(du -h "bin/${APP_BASENAME}" | cut -f1)"
 
     if should_bundle_full_node_assets; then
@@ -384,6 +422,9 @@ build_release_linux() {
         [[ -f bin/asmap.dat ]]               && cp bin/asmap.dat "$dist_dir/"
         [[ -f bin/sapling-spend.params ]]    && cp bin/sapling-spend.params "$dist_dir/"
         [[ -f bin/sapling-output.params ]]   && cp bin/sapling-output.params "$dist_dir/"
+        # Offline wallet-rebuild recovery helper — required (asserted above); ships next to the app.
+        cp bin/dragonx-wallet-rebuild "$dist_dir/" && chmod +x "$dist_dir/dragonx-wallet-rebuild"
+        info "  Bundled dragonx-wallet-rebuild"
     fi
     # Bundle xmrig for mining support
     local XMRIG_LINUX="$SCRIPT_DIR/prebuilt-binaries/drg-xmrig/xmrig"
@@ -417,6 +458,8 @@ build_release_linux() {
         [[ -f bin/asmap.dat ]]             && cp bin/asmap.dat "$APPDIR/usr/bin/"
         [[ -f bin/sapling-spend.params ]]  && cp bin/sapling-spend.params "$APPDIR/usr/bin/"
         [[ -f bin/sapling-output.params ]] && cp bin/sapling-output.params "$APPDIR/usr/bin/"
+        # Offline wallet-rebuild recovery helper — required (asserted above); ships next to the app.
+        cp bin/dragonx-wallet-rebuild "$APPDIR/usr/bin/" && chmod +x "$APPDIR/usr/bin/dragonx-wallet-rebuild"
     fi
     # Bundle xmrig for mining support
     local XMRIG_LINUX_AI="$SCRIPT_DIR/prebuilt-binaries/drg-xmrig/xmrig"
@@ -638,6 +681,30 @@ HDR
             info "Lite mode: skipping embedded daemon binaries"
         fi
 
+        # ── Wallet-rebuild recovery helper ───────────────────────────────
+        # Built in-tree (not a prebuilt like the daemon), so compile it standalone HERE — before the
+        # main app compiles embedded_resources.cpp — and INCBIN it, so a bare, self-extracting
+        # ObsidianDragon.exe carries the recovery tool exactly like it does the daemon.
+        if should_bundle_full_node_assets; then
+            local WBDB="$SCRIPT_DIR/external/dragonx/depends/x86_64-w64-mingw32"
+            if [[ -f "$WBDB/lib/libdb-6.2.a" && -f "$WBDB/include/db.h" ]]; then
+                info "Compiling + embedding wallet-rebuild helper ..."
+                x86_64-w64-mingw32-g++ -std=c++17 -O2 -static -static-libgcc -static-libstdc++ \
+                    -I"$SCRIPT_DIR/src" -I"$WBDB/include" \
+                    "$SCRIPT_DIR/tools/wallet_rebuild/main.cpp" \
+                    "$WBDB/lib/libdb-6.2.a" -lws2_32 \
+                    -o "$RES/dragonx-wallet-rebuild.exe" \
+                    || { err "wallet-rebuild helper failed to compile for embedding"; exit 1; }
+                x86_64-w64-mingw32-strip "$RES/dragonx-wallet-rebuild.exe" 2>/dev/null || true
+                echo -e "\n#define HAS_EMBEDDED_WALLET_REBUILD 1" >> "$GEN/embedded_data.h"
+                echo "INCBIN(dragonx_wallet_rebuild_exe, \"$RES/dragonx-wallet-rebuild.exe\");" >> "$GEN/embedded_data.h"
+                info "  Embedded dragonx-wallet-rebuild.exe ($(du -h "$RES/dragonx-wallet-rebuild.exe" | cut -f1))"
+            else
+                err "Vendored mingw Berkeley DB missing at $WBDB — cannot embed the wallet-rebuild recovery helper."
+                exit 1
+            fi
+        fi
+
         # ── xmrig binary (from prebuilt-binaries/drg-xmrig/) ────────────────
         local XMRIG_DIR="$SCRIPT_DIR/prebuilt-binaries/drg-xmrig"
         # The published DRG-XMRig archives ship the binary inside a versioned subdir, not as a flat
@@ -750,11 +817,24 @@ HDR
     fi
 
     # ── CMake + build ────────────────────────────────────────────────────────
+    # The wallet-rebuild helper links the vendored mingw static Berkeley DB (the mingw toolchain's
+    # find_library is sysroot-only, so pass the depends paths EXPLICITLY to bypass the search). Only
+    # enabled if the depends tree is present; guarded with -DBDB_* left empty otherwise.
+    local win_bdb="$SCRIPT_DIR/external/dragonx/depends/x86_64-w64-mingw32"
+    local BDB_ARGS=()
+    if [[ -f "$win_bdb/lib/libdb-6.2.a" && -f "$win_bdb/include/db.h" ]]; then
+        BDB_ARGS=( -DBDB_INCLUDE_DIR="$win_bdb/include" -DBDB_LIBRARY="$win_bdb/lib/libdb-6.2.a" )
+    elif should_bundle_full_node_assets; then
+        err "Vendored Berkeley DB depends missing at $win_bdb — the wallet-rebuild recovery helper cannot be built."
+        err "  A full-node release must ship it; aborting rather than degrading recovery to Restore-only."
+        exit 1
+    fi
     info "Configuring (cross-compile) ..."
     cmake "$SCRIPT_DIR" \
         -DCMAKE_TOOLCHAIN_FILE="$bd/mingw-toolchain.cmake" \
         -DCMAKE_BUILD_TYPE=Release \
         -DDRAGONX_USE_SYSTEM_SDL3=OFF \
+        "${BDB_ARGS[@]}" \
         "${FT_CMAKE_ARG[@]}" \
         "${CMAKE_LITE_ARGS[@]}"
 
@@ -764,6 +844,9 @@ HDR
     [[ -f "bin/${APP_BASENAME}.exe" ]] || { err "Windows build failed"; exit 1; }
     info "Binary: $(du -h "bin/${APP_BASENAME}.exe" | cut -f1)"
 
+    # A full-node release MUST include the recovery helper — fail loudly, never ship without it.
+    require_wallet_rebuild_helper "bin/dragonx-wallet-rebuild.exe" "$win_bdb"
+
     # ── Package: release/windows/ ────────────────────────────────────────────
     # Remove only THIS variant's prior artifacts so full-node and lite releases coexist here.
     mkdir -p "$out"
@@ -779,6 +862,9 @@ HDR
         for f in dragonxd.exe dragonx-cli.exe dragonx-tx.exe; do
             [[ -f "$DD/$f" ]] && cp "$DD/$f" "$dist_dir/"
         done
+        # dragonx-wallet-rebuild helper (offline recovery for a BDB-inconsistent wallet.dat) — required.
+        cp "bin/dragonx-wallet-rebuild.exe" "$dist_dir/" && info "  Bundled dragonx-wallet-rebuild.exe"
+        [[ -f "$dist_dir/dragonx-wallet-rebuild.exe" ]] || { err "Failed to bundle dragonx-wallet-rebuild.exe"; exit 1; }
 
         # Bundle Sapling params + asmap for the zip distribution
         # (The single-file exe has these embedded via INCBIN, but the zip
@@ -1034,6 +1120,11 @@ TOOLCHAIN
 
     [[ -f "bin/${APP_BASENAME}" ]] || { err "macOS build failed"; exit 1; }
 
+    # A full-node release MUST include the recovery helper. macOS needs a static libdb-6.2 (Homebrew
+    # berkeley-db for a native build, or a vendored external/dragonx/depends/<triple>) — otherwise CMake
+    # skips the target and this fails loudly rather than shipping a mac release with no recovery option.
+    require_wallet_rebuild_helper "bin/dragonx-wallet-rebuild" "$SCRIPT_DIR/external/dragonx/depends/aarch64-apple-darwin"
+
     # Strip — use osxcross strip for cross-builds
     if $IS_CROSS; then
         local STRIP_CMD="${OSXCROSS}/target/bin/${OSXCROSS_TRIPLE}-strip"
@@ -1106,6 +1197,8 @@ TOOLCHAIN
         else
             warn "prebuilt-binaries/dragonxd-mac/ not found — place macOS daemon binaries there for bundling"
         fi
+        # Offline wallet-rebuild recovery helper — required (asserted after build); next to the daemon.
+        cp "bin/dragonx-wallet-rebuild" "$MACOS/" && chmod +x "$MACOS/dragonx-wallet-rebuild" && info "  Bundled dragonx-wallet-rebuild"
     else
         info "Lite mode: skipping macOS daemon and Sapling/asmap bundling"
     fi

docs/daemon-startup-hardening.md

@@ -0,0 +1,549 @@
+# Daemon Startup Hardening — Implementation Plan
+
+Eight verified edge-case defects in how ObsidianDragon brings up (and watches) the
+`dragonxd` daemon at launch. Each entry is a buildable fix: the defect (with exact
+line references), the chosen approach, the call sites, a representative change, and how
+to verify it.
+
+- **Scope:** full-node startup path (`--lite` excludes the embedded daemon entirely).
+- **Source:** line references are exact against branch `dev` @ `45b652f`.
+- **Provenance:** findings verified by direct source read; each fix designed by an
+  independent agent grounded in the cited files, with a sequencing pass for ordering,
+  shared helpers, and merge conflicts.
+
+**Severity:** 2 High, 6 Medium · **Effort:** ≈ 25–35 engineering-hours · **7 landing steps.**
+
+Status legend: ☐ not started · ◐ in progress · ☑ landed & verified
+
+**Status: all 8 landed & verified** (build-clean, `ctest` green after each) across four commits on
+`dev` — lifecycle cluster (F1/F2/F4), filesystem+params cluster (F7/F6/F5), F3, and F8. Six new
+pure-helper unit tests added.
+
+**Wrap-up done:** release notes added (`CHANGELOG.md`, F8 breaking change front and center); i18n
+back-fill applied additively to `res/lang/*.json` (42 keys — all 6 for es/de/fr/pt/ru; 6 zh/ja/ko
+entries whose glyphs aren't in the current `NotoSansCJK-Subset.ttf` were left on English fallback
+rather than render as tofu).
+
+**Still owed before release:** a **CJK subset-font rebuild** (`scripts/build_cjk_subset.py`, needs
+the Noto CJK source font) to cover the 6 deferred zh/ja/ko strings. *(F1 and F2 now have headless
+integration-test coverage — see the progress log — so their GUI repros are optional, not blocking.)*
+
+---
+
+## Recommended rollout sequence
+
+A real dependency order, not a checklist. The daemon-lifecycle cluster lands first
+because it makes the `State::Error` / `crash_count_` contract trustworthy — which the
+connect-stall panel and the lock gate both build on. The filesystem cluster lands
+around a single shared helper. The connectivity-breaking security flip lands last.
+
+| Step | Finding(s) | Site | Why here | Status |
+|------|-----------|------|----------|--------|
+| 1 | **F1** | `embedded_daemon.cpp` · `isRunning()` | Smallest/highest-severity; establishes the reliable Error/crash-count transition steps 3 & 6 depend on. | ☑ |
+| 2 | **F2** | `embedded_daemon.cpp` · `startProcess()` | Same file family, different function; test the F1+F2 pair together with `kill -SEGV` / bad-binary repros. | ☑ |
+| 3 | **F4** | `embedded_daemon.cpp` · `start()` | After F1/F2 so crash-count semantics are settled; its bail deliberately stays out of the crash path. | ☑ |
+| 4 | **F7** | `util/platform` · `connection.cpp` | Structural owner of the fs-error idiom + `ConnectionConfig` that F5/F6/F8 reuse. | ☑ |
+| 5 | **F6 + F5** | `app.cpp` · `verifySaplingParams()` | Same `startEmbeddedDaemon` / `verifySaplingParams` block; land together. | ☑ |
+| 6 | **F3** | `app.cpp` · `renderLoadingOverlay()` | After F1 — panel is guarded off during `State::Error` (owned by the crash-count hint). | ☑ |
+| 7 | **F8** | `connection.cpp` · `tryConnect()` | Largest; only connectivity-breaking default flip — land last, with release notes. | ☑ |
+
+---
+
+## F1 — Double-`waitpid` race can swallow a daemon crash
+
+**Severity:** High · **Effort:** S (~1–2h) · **Status:** ☑ landed & verified
+
+### The defect
+`EmbeddedDaemon::isRunning()` (`embedded_daemon.cpp:1136`, POSIX branch) calls
+`waitpid(WNOHANG)` — from the **UI thread, nearly every frame** — racing
+`monitorProcess()`'s own reap at `:1244`. `waitpid` is one-shot: if the UI thread wins,
+the monitor never decodes the exit, so `crash_count_` never increments, `State::Error`
+never fires, and the 3-strike auto-restart cap (`app_network.cpp:479`) is defeated. The
+sibling `XmrigManager::isRunning()` (`xmrig_manager.cpp:512`) already fixed exactly this
+with an atomic read.
+
+### The fix
+Make `isRunning()` read the existing `std::atomic<State> state_` (member at
+`embedded_daemon.h:253`) instead of calling `waitpid`, leaving `monitorProcess()` as the
+sole reaper. Predicate is `Running || Stopping` — `Stopping` must stay "alive" because
+`stop()`'s graceful/SIGTERM wait loops poll `isRunning()` before the process has exited.
+
+### Files touched
+- `src/daemon/embedded_daemon.cpp` — `isRunning()`, POSIX branch (~1136)
+
+### Core change
+```cpp
+bool EmbeddedDaemon::isRunning() const   // POSIX branch
+{
+    // Read the atomic state_ instead of waitpid() — monitorProcess() is the
+    // sole reaper. Previously both threads reaped; if the UI thread won, the
+    // monitor never saw the exit (crash_count_ / exit code / Error all lost).
+    if (process_pid_ <= 0) return false;
+
+    State s = state_.load(std::memory_order_relaxed);
+    // Stopping stays "alive": stop()'s wait loops poll isRunning() while
+    // state_ == Stopping, before the process has actually terminated.
+    return (s == State::Running || s == State::Stopping);
+}
+```
+
+### Verification
+- Manual: `kill -SEGV` the daemon 10–20×; the monitor must report the exit and increment `crash_count_` every time (previously intermittent).
+- Regression: a normal Settings-driven stop still escalates SIGTERM→SIGKILL (the `Stopping` predicate).
+- Not unit-testable (real fork/exec/waitpid) — consistent with the no-process-spawn harness.
+
+### Dependencies
+Mirrors `XmrigManager::isRunning()`. Flags a separate latent hazard (out of scope):
+`stop()`'s final blocking `waitpid` (`:1220`) can still race a mid-sleep monitor
+iteration — file as its own ticket.
+
+---
+
+## F2 — exec-after-fork silent failure: "Running" for a daemon that never started
+
+**Severity:** High · **Effort:** S (~2–3h) · **Status:** ☑ landed & verified
+
+### The defect
+In `startProcess()` (`embedded_daemon.cpp:957–1061`, POSIX) the parent runs
+`process_pid_ = pid; return true;` **unconditionally** after `fork()` — with no
+exec-status handshake. On a non-executable / wrong-arch / corrupt binary the child's
+`execv` fails and it `_exit(127)`s, but `start()` has already set `State::Running`
+(`:565`). The real cause never reaches `last_error_`; it surfaces later, generically,
+as "exited unexpectedly (exit code 127)".
+
+### The fix
+Add a **close-on-exec self-pipe** handshake — `pipe() + fcntl(FD_CLOEXEC)`, deliberately
+**not** `pipe2()` (macOS lacks it; the POSIX branch is shared). The child writes `errno`
+only on `execv` failure; a successful exec closes the write end for free. Parent reads:
+EOF ⇒ success; 4 bytes ⇒ reap the zombie, set a precise `last_error_` ("not executable
+or wrong architecture"), and return `false` so `start()` never reports Running. EINTR-safe
+on both ends. Also comments the unchecked parent-side `setpgid` at `:1053`.
+
+### Files touched
+- `src/daemon/embedded_daemon.cpp` — `startProcess()` parent read path
+- `src/daemon/embedded_daemon.cpp` — child `execv`-failure write (~1043)
+- `src/daemon/embedded_daemon.cpp` — `setpgid` best-effort comment (~1053)
+
+### Core change
+```cpp
+// Self-pipe exec handshake (pipe()+FD_CLOEXEC; NOT pipe2 — macOS lacks it).
+int execpipe[2]; pipe(execpipe);
+fcntl(execpipe[0], F_SETFD, FD_CLOEXEC);
+fcntl(execpipe[1], F_SETFD, FD_CLOEXEC);
+
+pid_t pid = fork();
+if (pid == 0) {                        // child
+    close(execpipe[0]);
+    /* setpgid / chdir / dup2 / argv … */
+    execv(binary_path.c_str(), argv.data());
+    int e = errno;                     // execv failed
+    while (write(execpipe[1], &e, sizeof e) < 0 && errno == EINTR) {}
+    _exit(127);
+}
+
+close(execpipe[1]);                    // parent: must close or read() never EOFs
+int child_errno = 0, total = 0;
+for (;;) {                             // EOF ⇒ exec ok; 4 bytes ⇒ exec failed
+    ssize_t n = read(execpipe[0], (char*)&child_errno + total, sizeof(int) - total);
+    if (n == 0) break;
+    if (n < 0) { if (errno == EINTR) continue; break; }
+    if ((total += n) >= (int)sizeof(int)) break;
+}
+close(execpipe[0]);
+if (total >= (int)sizeof(int)) {       // exec never happened
+    waitpid(pid, nullptr, 0);          // reap the zombie
+    last_error_ = "dragonxd could not be executed: " +
+                  std::string(strerror(child_errno)) +
+                  " — not executable or wrong architecture";
+    return false;                      // start() no longer reports Running
+}
+```
+
+### Verification
+- Point at a `chmod -x` / wrong-arch file → `start()` returns false immediately, precise message, no leftover zombie.
+- Success path: real binary still starts with no perceptible added latency.
+- Optional pure `formatExecFailureError(errno)` helper for a `test_phase4.cpp` unit test.
+
+### Dependencies
+F1 (same function family; sequence F1→F2). **Highest-risk mistake:** forgetting
+`FD_CLOEXEC` makes every successful start hang the parent read forever.
+
+---
+
+## F4 — Stale datadir-lock start → restart storm that wedges the UI
+
+**Severity:** Medium · **Effort:** S (~3–5h) · **Status:** ☑ landed & verified
+
+### The defect
+`start()` (`embedded_daemon.cpp:466`) gates only on the RPC port (`:482`), never on
+`isDaemonProcessRunning()` (`:1292`). A graceful shutdown frees the port but keeps the
+datadir `.lock` for up to ~90s. A rapid stop→start spawns a daemon that dies "Cannot
+obtain a lock on data directory" — routed to the generic crash path. With a ~4s retry
+cadence, **three lock races in ~12s exhaust the 3-strike budget** and wedge the UI long
+before the lock actually clears.
+
+### The fix
+Fail-fast with a **short bounded local wait (~300ms), not a 90s block**. After the port
+bail, consult `isDaemonProcessRunning()` — gated by `!skip_port_check_` and exempt when
+`override_datadir_` is set, so the isolated migrate-to-seed daemon still works. A pure
+`evaluateDatadirLockGate()` returns a **distinct non-crash Error** that never increments
+`crash_count_`. The connect loop's own retry then absorbs the transient.
+
+### Files touched
+- `src/daemon/embedded_daemon.h` — decision struct, helper decl, poll constants
+- `src/daemon/embedded_daemon.cpp` — `start()` gate + `evaluateDatadirLockGate()`
+
+### Core change
+```cpp
+static StartLockGateDecision evaluateDatadirLockGate(
+        bool skipPortCheck, bool isolatedOverride, bool stillRunningAfterWait) {
+    if (skipPortCheck || isolatedOverride) return {true,  ""};   // migrate-to-seed exempt
+    if (!stillRunningAfterWait)            return {true,  ""};
+    return {false, "A previous dragonxd is still shutting down and holding the "
+                   "data directory lock. Retrying shortly…"};
+}
+
+// start() — after the isPortInUse() bail, before setState(Starting):
+if (!skip_port_check_ && override_datadir_.empty()) {
+    bool stillLocked = false;                       // ~300ms bounded wait, NOT ~90s
+    for (int i = 0; i < kDatadirLockWaitMaxPolls; ++i) {
+        if (!isDaemonProcessRunning()) { stillLocked = false; break; }
+        stillLocked = true;
+        std::this_thread::sleep_for(std::chrono::milliseconds(kDatadirLockWaitPollMs));
+    }
+    auto gate = evaluateDatadirLockGate(false, false, stillLocked);
+    if (!gate.proceed) { setState(State::Error, gate.errorMessage); return false; }
+}
+```
+
+### Verification
+- Unit: `evaluateDatadirLockGate()` across the skip / isolated / still-running matrix.
+- Manual: rapid restart into a lingering lock → distinct message, no crash-cap wedge.
+- Migrate-to-seed second daemon still starts (isolated exemption).
+
+### Dependencies
+F1/F2 (must not touch `crash_count_`; wording must not collide with the monitor's
+"exited unexpectedly"). Same TU, different function.
+
+---
+
+## F5 — Extraction / copy write-failures never surfaced up front
+
+**Severity:** Medium · **Effort:** S (~2–3h) · **Status:** ☑ landed & verified
+
+### The defect
+`startEmbeddedDaemon()` discards `extractEmbeddedResources()`'s `bool` return
+(`app.cpp:4152`) and the second copy-fallback loop drops `copy_file`'s `error_code`
+entirely (`:4236`). Only Sapling params **existence** is re-checked — never the daemon
+binary/CLI/tx/asmap. A disk-full or truncated `dragonxd` write falls straight through to
+spawn and fails opaquely. The innermost write already returns `false`
+(`embedded_resources.cpp:307`) — the signal is simply thrown away.
+
+### The fix
+Minimal, surgical wiring — no new abstraction. Capture the extraction return and, on
+failure, set `daemon_status_ = TR("sb_daemon_extract_failed")` and `return false` before
+spawning. In the second copy loop, check `ec` after each `copy_file`, track `copyFailed`,
+and abort with a dir-parameterized `sb_daemon_files_failed`. An **absent source** stays
+fine (optional files); only an actual `error_code` counts. Written so F6/F7 slot in later
+without re-touching this control flow.
+
+### Files touched
+- `src/app.cpp` — `startEmbeddedDaemon()` extraction check (~4152)
+- `src/app.cpp` — second copy-fallback loop (~4210–4242)
+- `src/util/i18n.cpp` + `res/lang/*.json` — 2 additive keys
+
+### Core change
+```cpp
+// stop discarding the extraction result (~4152)
+if (!resources::extractEmbeddedResources()) {
+    daemon_status_ = TR("sb_daemon_extract_failed");   // disk full / permission denied
+    return false;                                      // abort before spawning
+}
+
+// second copy-fallback loop — was dropping ec entirely (~4236)
+bool copyFailed = false;
+for (const char* name : { "asmap.dat", "dragonxd", "dragonx-cli", "dragonx-tx" }) {
+    fs::path dst = fs::path(daemon_dir) / name;
+    if (fs::exists(dst)) continue;                      // already present — skip
+    for (const auto& dir : searchDirs) {
+        fs::path src = fs::path(dir) / name;
+        if (!fs::exists(src)) continue;                 // absent source is OK, not a failure
+        fs::copy_file(src, dst, ec);
+        if (ec) { copyFailed = true; ec.clear(); }
+        break;
+    }
+}
+if (copyFailed) {
+    char buf[512];
+    snprintf(buf, sizeof buf, TR("sb_daemon_files_failed"), daemon_dir.c_str());
+    daemon_status_ = buf;
+    return false;                                       // don't fall through to spawn
+}
+```
+
+### Verification
+- Unit: `extractEmbeddedResources()` returns false without embedded resources.
+- Extract the copy loop into a testable helper; force one dst write to fail (dst is an existing directory).
+- Manual: near-full tmpfs / read-only dir → clear status, daemon controller never constructed.
+
+### Dependencies
+Shares the `daemon_status_` surfacing convention with F6; its early-return pattern is the
+template F7 matches. Open item: remove truncated dst files so a retry re-copies.
+
+---
+
+## F6 — Sapling params validated by existence/size only, never hashed
+
+**Severity:** Medium · **Effort:** S (~3–5h) · **Status:** ☑ landed & verified
+
+> **As-built note.** `verifySaplingParams()` now delegates to a public, injectable
+> `verifySaplingParamsIn(dir, digests)` so the integrity + marker-cache logic is unit-testable
+> with synthetic small files (the real 48 MB params aren't in the repo). i18n keys for F5 were
+> added to `i18n.cpp` (English source of truth); the `res/lang/*.json` back-fill via
+> `scripts/add_missing_translations.py` is deferred to a single run at the end of the batch,
+> per the cross-cutting note. Non-English locales fall back to English until then.
+
+### The defect
+`verifySaplingParams()` (`connection.cpp:123`) only calls `fs::exists()`;
+`resourceNeedsUpdate()` (`embedded_resources.cpp:250`) is size-only. On Linux (no
+embedded resources) a **truncated-but-present** param passes and is handed to the daemon,
+which then fails to build shielded proofs mid-operation — far from the real cause.
+
+### The fix
+Add a pinned `{ filename → size, sha256 }` table (one source of truth, cross-referenced
+to `scripts/build-lite-backend-artifact.sh`) and hash-check each param after the
+existence check, reusing the existing `util::sha256Hex` (no second implementation). Since
+these are ~48 MB, **cache the result** via a `.sapling_verified` marker keyed on
+`size:mtime` — re-hash only when the stat line changes, so startup isn't slowed.
+
+### Files touched
+- `src/rpc/connection.h` — `verifySaplingParams` decl
+- `src/rpc/connection.cpp` — digest table, marker helpers, rewrite
+
+### Core change
+```cpp
+// connection.cpp — pinned known-good digests
+// (source of truth: scripts/build-lite-backend-artifact.sh ensure_sapling_params)
+constexpr SaplingParamDigest kSaplingParamDigests[] = {
+  { "sapling-spend.params",  47958396, "8e48ffd2…efc13" },
+  { "sapling-output.params",  3592860, "2f0ebbcb…fb0e4" },
+};
+
+bool Connection::verifySaplingParams() {
+    // existence check (unchanged) …
+    // cache: skip re-hashing a ~48 MB file unless size:mtime changed
+    if (readMarkerMatches(marker, statLines)) return true;
+    for (auto& d : kSaplingParamDigests)
+        if (util::sha256Hex(bytes) != d.sha256) return false;   // reuse existing helper
+    writeMarker(marker, statLines);
+    return true;
+}
+```
+
+### Verification
+- Unit: good params pass; truncated / wrong-bytes rejected; marker cache short-circuits re-hash unless size/mtime changed. Real temp-file fixtures (matches existing `sha256Hex` tests).
+
+### Dependencies
+F7 (reuse fs-error idiom; shares the `startEmbeddedDaemon`/`verifySaplingParams` block).
+Third caller of the existing `util::sha256Hex`.
+
+---
+
+## F7 — Directory-create errors universally ignored on the daemon-env path
+
+**Severity:** Medium · **Effort:** S (~3–4h) · **Status:** ☑ landed & verified
+
+> **As-built notes.** Two deviations from the original design, both confirmed against the code:
+> (1) `embedded_resources.cpp:270` already checks its `error_code` and returns `false` on failure — it was **not** a bug, so it is left untouched.
+> (2) Of the four `autoDetectConfig` callers, only the primary connect path (`app_network.cpp:243`) was wired to check `dir_error`; the other three degrade gracefully on their own — `app.cpp:4306` and `app_wizard.cpp:912` are stop paths that already gate on empty creds, and `settings_page.cpp:434` is read-only display. `dir_error` is set by `autoDetectConfig`, so they can be wired later if desired.
+
+### The defect
+Five startup directory-create sites either drop the `error_code` or use the throwing
+overload with no `catch`: `main.cpp:730`, `connection.cpp:216` (can throw **uncaught**
+through its callers), `embedded_resources.cpp:270`, `app.cpp:4172`/`4218`. A read-only
+home or permission-denied yields a confusing "conf missing" / "binary not found"
+downstream — or an uncaught `filesystem_error` — instead of a clear cause.
+
+### The fix
+One shared, non-throwing `Platform::ensureDirectory(dir, outError)` in
+`util/platform.{h,cpp}` that produces a single consistent message. Replace all five
+sites; `autoDetectConfig()` moves off the throwing overload and sets a new
+`ConnectionConfig::dir_error` that its four callers check and bail on. This is the
+**structural owner** of the fs-error idiom that F5 and F6 reuse.
+
+### Files touched
+- `src/util/platform.h` / `.cpp` — `ensureDirectory()`
+- `src/rpc/connection.h` / `.cpp` — `dir_error` + `autoDetectConfig`
+- `main.cpp`, `app.cpp`, `app_network.cpp`, `app_wizard.cpp`, `settings_page.cpp`, `embedded_resources.cpp` — 5 sites + 4 callers
+- `tests/test_phase4.cpp` — `TestPlatformEnsureDirectory`
+
+### Core change
+```cpp
+// util/platform.cpp — one shared, non-throwing helper
+bool Platform::ensureDirectory(const std::string& dir, std::string* outError) {
+    std::error_code ec;
+    if (std::filesystem::is_directory(dir, ec)) return true;
+    ec.clear();
+    std::filesystem::create_directories(dir, ec);
+    if (ec) {
+        if (outError)
+            *outError = "Cannot create " + dir + ": " + ec.message() +
+                        ". Check permissions / free space.";
+        return false;
+    }
+    return true;
+}
+// Replaces 5 ad-hoc sites; autoDetectConfig() now sets ConnectionConfig::dir_error,
+// and its 4 callers bail on it.
+```
+
+### Verification
+- Unit `TestPlatformEnsureDirectory`: existing dir → true; fresh nested → created; POSIX unwritable → false + message.
+- All four `autoDetectConfig` callers tolerate `dir_error`. Pre-App-init site (main.cpp) reports via stderr / MessageBox.
+
+### Dependencies
+**Owns** `Platform::ensureDirectory` (used by F5, F6) and the `ConnectionConfig`
+extension (coordinated with F8). Land before F5/F6/F8.
+
+---
+
+## F8 — Plaintext-remote RPC credential transmission is warn-only
+
+**Severity:** Medium · **Effort:** M (~6–9h) · **Status:** ☑ landed & verified
+
+> **⚠️ RELEASE NOTES REQUIRED — breaking default flip.** A wallet configured to talk to a
+> **remote** `rpchost` over **plain HTTP** (no `rpctls=1`) will now be **refused** at connect
+> time instead of warned. Affected users must add **`rpcallowplaintext=1`** to `DRAGONX.conf`
+> (or switch to `rpctls=1`) to reconnect. Local/embedded daemons (`127.0.0.0/8`, `localhost`,
+> `::1`) are unaffected. Call this out prominently in the release notes.
+>
+> **As-built note.** Shipped the security-complete core: `isLocalHost` tightened to exact
+> loopback (`isExactIPv4Loopback` — `127.evil.com` no longer passes), refuse-by-default in
+> `tryConnect`, and the `rpcallowplaintext` conf-key opt-in. The **Settings toggle UI was
+> deferred** — the RPC section of `settings_page.cpp` is read-only display and a security
+> toggle there is riskier surface; the conf-key opt-in fully covers recovery, and the refusal
+> status/notification tells the user exactly what to add. The toggle can be added later
+> (persist a `Settings` flag and OR it into `allowsPlaintextRemote`).
+
+### The defect
+A remote `rpchost` without `rpctls=1` sends Basic-auth `rpcuser:rpcpassword` over
+cleartext HTTP. `tryConnect()` (`app_network.cpp:314`) only shows a **dismissible
+warning** then proceeds — a local-network MITM sees the credentials. Compounding it,
+`isLocalHost()`'s naive `rfind("127.",0)==0` misclassifies `127.evil.com` as local,
+suppressing even the warning.
+
+### The fix
+Change the policy to **refuse-by-default with an explicit, persisted opt-in** — a
+`rpcallowplaintext=1` conf key (for hand-editors) and a Settings toggle. Block the
+connect and show a **blocking modal** explaining the risk and how to enable TLS or opt
+in; localhost is unaffected. Tighten `isLocalHost()` to exact `127.x.y.z` / `::1` /
+`localhost` via `isExactIPv4Loopback()`. **Back-compat:** default off ⇒ existing remote
+users hit a hard stop until they opt in — **ship with prominent release notes.**
+
+### Files touched
+- `src/rpc/connection.h` / `.cpp` — `isLocalHost`, `allow_plaintext_remote`, `parseConfFile`
+- `src/config/settings.h` / `.cpp` — persisted opt-in
+- `src/app_network.cpp`, `src/app.h` — refuse + modal dispatch
+- `src/ui/windows/plaintext_remote_rpc_dialog.h` — new blocking modal
+- `src/ui/pages/settings_page.cpp` — toggle UI
+
+### Core change
+```cpp
+// Tightened loopback test — "127.evil.com" is NOT local
+bool Connection::isLocalHost(const std::string& host) {
+    std::string h = stripBrackets(lowercase(host));
+    return h == "localhost" || h == "::1" || isExactIPv4Loopback(h);  // exact 127.x.y.z
+}
+
+// Refuse-by-default with an explicit, persisted opt-in
+const bool plaintextRemote  = rpc::Connection::usesPlaintextRemote(config);
+const bool plaintextAllowed = config.allow_plaintext_remote          // rpcallowplaintext=1
+                           || settings_.getAllowPlaintextRemoteRpc(); // Settings toggle
+if (plaintextRemote && !plaintextAllowed) {
+    connection_status_ = TR("sb_plaintext_remote_blocked");
+    showPlaintextRemoteRpcDialog(config.host + ":" + config.port);    // blocking modal
+    return;                                                           // no creds sent
+}
+```
+
+### Verification
+- Unit: `isLocalHost` — `127.evil.com` false, `127.0.0.1`/`::1`/`localhost` true; `allowsPlaintextRemote` honors conf key + settings flag.
+- Manual: remote plaintext blocked; modal fires; opt-in persists across restart.
+
+### Dependencies
+F7 (second extender of `ConnectionConfig`/`parseConfFile`; land after so the struct grows
+once). Wire `renderPlaintextRemoteRpcDialog` into the app modal-dispatch list.
+
+---
+
+## Shared helpers & coordination points
+
+| Helper | Purpose | Used by |
+|--------|---------|---------|
+| `Platform::ensureDirectory()` | Single non-throwing directory-create with one consistent message; replaces five ad-hoc sites. Owned by F7. | F7, F5, F6 |
+| `ConnectionConfig` extension | Coordination point, not a function: F7 adds `dir_error`, F8 adds `allow_plaintext_remote`. Land F7→F8 so it grows once per step. | F7, F8 |
+| `util::sha256Hex` *(existing)* | Already-compiled, curl-free SHA-256. F6 becomes its third caller — no second hash routine. | F6 |
+| `connectHasStalled()` *(new, pure)* | Stall predicate split out of the ImGui/App code for unit testing, per the `*_updater_core.cpp` precedent. | F3 |
+| `evaluateDatadirLockGate()` *(new, pure)* | Lock-gate decision as `{proceed, message}` from three booleans — unit-testable without real process/fs I/O. | F4 |
+
+## F3 — Unbounded connect spinner (deferred to step 6)
+
+**Severity:** Medium · **Effort:** S (~3–5h) · **Status:** ☑ landed & verified
+
+> **As-built note.** `renderLoadingOverlay()` is a pure draw-list overlay with **no interactive
+> widgets** (the existing crash case at ~5289 already communicates via guidance *text*, relying on
+> the sidebar staying reachable). So rather than inject `ActionButton`s — which would fight the
+> non-interactive overlay — the stall notice follows that same idiom: a "Taking longer than
+> expected" title + a reassuring body (with elapsed seconds) + a full-node-gated hint ("Open
+> Settings → Restart Daemon, or check the Console"). This let me drop the planned
+> `WalletState::connect_stalled` flag too: the stalled state is computed locally in the overlay
+> from `connect_stall_since_`, so the only new member is `App::connect_stall_since_`.
+
+The connect loop retries forever while `!state_.connected` (`app.cpp:1239`);
+`loading_timer_` only animates the spinner. Stamp `connect_stall_since_` when
+"reachable but not ready" is first seen; a pure `connectHasStalled()` helper (new
+`util/connect_stall.h`, default 45s from `ui.toml`) flips `state_.connect_stalled` at
+threshold, and `renderLoadingOverlay()` shows a "Taking longer than expected" panel with
+Retry / Restart daemon / Open console (full-node gated). The background retry keeps
+firing — recovery clears the panel automatically. Guarded off while the daemon is in
+`State::Error` (owned by F1's crash-count hint). Full detail lives in the sequencing/
+design record; see the shared-helper table above.
+
+---
+
+## Cross-cutting notes
+
+- **One TU, three functions.** `embedded_daemon.cpp` is edited by F1 (`isRunning`),
+  F2 (`startProcess`) and F4 (`start`) — no literal hunk overlap, but land in order to
+  keep "monitorProcess is the sole reaper" coherent.
+- **Connection struct grows twice.** `connection.h/.cpp` is touched by F6, F7 and F8;
+  F7 and F8 both extend `ConnectionConfig` and `parseConfFile` — highest collision risk.
+  Sequence F7→F6→F8.
+- **Testability split.** The three new pure predicates all get `tests/test_phase4.cpp`
+  coverage. F1/F2's fork/exec/waitpid changes are **not** unit-testable — they rely on
+  manual `kill` / non-executable-binary repros, consistent with the no-process-spawn harness.
+- **i18n is additive-only.** Add each finding's English keys to `strings_`, then run
+  `scripts/add_missing_translations.py` **once at the very end**
+  (`json.dump indent=4, sort_keys=True, ensure_ascii=False`) — never bulk-regenerate a
+  `res/lang/*.json`.
+- **F8 is a breaking default flip.** Refuse-plaintext-by-default stops existing
+  remote-RPC users cold until they opt in. Lands last, gated behind a persisted opt-in,
+  with release notes calling out the new `rpcallowplaintext` key and the Settings toggle.
+- **Latent hazard, out of scope.** F1 surfaces (but doesn't fix) a second
+  double-`waitpid` window between `stop()`'s final blocking reap (`:1220`) and a
+  mid-sleep monitor iteration — file it as its own ticket.
+
+---
+
+## Progress log
+
+- **F1/F2 integration tests** — ☑ added `testExecFailureReported` (F2) and `testDaemonCrashDetected` (F1) to `test_phase4.cpp`, driving the **real** `EmbeddedDaemon` fork/exec/waitpid code headlessly (POSIX; required linking `embedded_daemon.cpp` into the test target — its deps were already there). The F1 test hammers `isRunning()` from the test thread while the child exits, so it's a genuine regression test for the reap race. **The F2 test caught a real bug:** `start()`'s failure branch overwrote `startProcess()`'s precise `last_error_` ("…not executable or wrong architecture") with a generic "Failed to start dragonxd process" (because `setState(Error, …)` stores its message into `last_error_`), so the precise reason never reached `getLastError()`/the UI — **fixed** to preserve the detail (now also surfaced via the state callback / crash panel). Build-clean; `ctest` 1/1.
+
+- **F1** — ☑ landed: `isRunning()` (POSIX) now reads the atomic `state_` (predicate `Running || Stopping`) instead of calling `waitpid`, leaving `monitorProcess()` the sole reaper. Clean build (all targets link); `ctest` 1/1 passing. Not unit-testable — needs the manual `kill -SEGV` repro before release.
+- **F2** — ☑ landed: `startProcess()` (POSIX) now creates a `FD_CLOEXEC` self-pipe before `fork()`; the child writes `errno` to it on `execv` failure, the parent reads EOF-vs-errno and, on failure, reaps the zombie + sets a precise `last_error_` ("not executable or wrong architecture") + returns `false` (so `start()` no longer reports `Running` for a daemon that never started). Parent-side `setpgid` is now best-effort with a `DEBUG_LOGF` on failure. Clean build; `ctest` 1/1 passing. Not unit-testable — needs the manual non-executable / wrong-arch-binary repro before release.
+- **F8** — ☑ landed: `isLocalHost()` tightened to exact loopback via `isExactIPv4Loopback` (a `127.`-prefixed *hostname* like `127.evil.com` is no longer misclassified as local). `tryConnect()` now **refuses** a plaintext connection to a remote host instead of warn-and-proceeding — a local-network MITM can no longer capture `rpcuser:rpcpassword` — unless the user opts in with `rpcallowplaintext=1` in `DRAGONX.conf` (new `ConnectionConfig::allow_plaintext_remote` + `allowsPlaintextRemote()` policy). The refusal surfaces via status line + a one-time notification. New `testIsLocalHost` (12 assertions) + `testAllowsPlaintextRemote` (5). Clean build; `ctest` 1/1 passing. **Breaking — needs release notes; Settings-toggle UI deferred (see as-built note).**
+- **F3** — ☑ landed: the connect loop now stamps `connect_stall_since_ = ImGui::GetTime()` the moment the daemon first goes "reachable but not ready" (warmup branch + `applyDaemonInitStatus`), and clears it in `onConnected` / `onDisconnected` / warmup-complete — all in `app_network.cpp`. The pure `util::connectHasStalled(stallSince, now, threshold)` helper (new `util/connect_stall.h`, default 45 s from `ui.toml`) drives a draw-list "Taking longer than expected" notice in `renderLoadingOverlay()` (title + elapsed-seconds body + full-node hint), guarded off while the daemon is in `State::Error`. Background retry continues, so the notice self-clears on connect. New `testConnectHasStalled` unit test (7 assertions). Clean build; `ctest` 1/1 passing. (Draw-list text, not buttons — see as-built note above.)
+- **F6** — ☑ landed: `verifySaplingParams()` now hash-verifies each Sapling param against its pinned canonical SHA-256 (from `build-lite-backend-artifact.sh`), replacing the existence-only check, so a truncated/corrupt-but-present param is rejected instead of failing later on a shielded op. A `<params_dir>/.sapling_verified` marker keyed on `size:mtime` skips re-hashing ~48 MB on every startup. Logic extracted to the injectable `verifySaplingParamsIn(dir, digests)`; new `testVerifySaplingParams` unit test (valid / marker fast-path / wrong-hash / truncated / missing). Clean build; `ctest` 1/1 passing.
+- **F5** — ☑ landed: `startEmbeddedDaemon()` now checks `extractEmbeddedResources()`'s return (abort with `sb_daemon_extract_failed` on failure) and the previously-dropped `copy_file` `error_code` in the daemon-binary fallback loop (abort with `sb_daemon_files_failed` incl. the dir), so a disk-full / truncated `dragonxd` write is surfaced up front instead of failing opaquely at spawn. An absent source file stays non-fatal. Two i18n keys added to `i18n.cpp`. Clean build; `ctest` 1/1 passing.
+- **F7** — ☑ landed: new non-throwing `Platform::ensureDirectory(dir, outError)` in `util/platform.{h,cpp}` with one consistent message. Replaces the unchecked/throwing directory-create sites at `main.cpp:730` (pre-init: now logs + `MessageBoxA` on Windows + `return 1`), `connection.cpp:216` (autoDetectConfig now uses the ec overload — **no more uncaught `filesystem_error`** — and sets the new `ConnectionConfig::dir_error`), and both `app.cpp` daemon-dir sites (surface via `daemon_status_` + `return false`). Primary connect path (`app_network.cpp:243`) checks `dir_error` and bails to the status line instead of mislabelling it "waiting for config". `embedded_resources.cpp:270` left as-is (already correct). New `testPlatformEnsureDirectory` unit test (existing-dir / fresh-nested / empty / parent-is-file). Clean build; `ctest` 1/1 passing.
+- **F4** — ☑ landed: `start()` now gates on a lingering datadir lock after the port bail. When `!skip_port_check_ && override_datadir_.empty()`, it polls `isDaemonProcessRunning()` with a bounded ~300 ms wait (3 × 100 ms, breaks early), then a pure header-inline `evaluateDatadirLockGate()` decides: if a sibling `dragonxd` is still alive it bails with a distinct **non-crash** `State::Error` ("…holding the data directory lock. Retrying shortly…") that never touches `crash_count_`, so the 3-strike cap can't trip; the connect loop's retry resumes once the lock clears. Isolated migrate-to-seed starts are exempt. New `testDatadirLockGate` unit test (5 assertions, proceed/bail/2× exempt) added to `test_phase4.cpp`. Clean build; `ctest` 1/1 passing.

docs/wallet-hardening.md

@@ -0,0 +1,167 @@
+# Wallet Loading & Management — Hardening Plan
+
+Prioritized, grouped remediation for the wallet loading/management audit (33 verified findings +
+diagnosability QoL). Companion to the findings artifact. Line references are against `dev`.
+
+- **Provenance:** 7 parallel subsystem finders, each finding adversarially verified against the
+  code; the 3 highest-impact confirmed findings re-checked by hand. 32 confirmed, 1 refuted
+  (W1-5), 1 raised (W5-3 Low→Med).
+- **Severity:** 8 High · 12 Medium · 13 Low.
+
+Status legend: ☐ not started · ◐ in progress · ☑ landed & verified
+
+---
+
+## Roadmap (ordered by risk; shared fixes grouped)
+
+| Phase | Findings | Theme | Status |
+|-------|----------|-------|--------|
+| **P0-A** | W7-1, W2-1, W4-1, W4-3, W2-3, W4-5, W5-3 ✓ | Secret hardening (console redaction + delete-export + memzero + lite encrypt-at-create) | ☑ 7/7 |
+| **P0-B** | W2-2/W4-2, W2-4 | Encryption integrity (never silently unencrypted) | ☑ |
+| **P1-A** | W3-1, W3-2, W3-4, W3-3 ✓ | Migrate-to-seed correctness (fund-adjacent) | ☑ 4/4 (W3-3 pending a live-mainnet run) |
+| **P1-B** | W1-1, W1-2, W1-3, W1-4 ✓ + startup guard | Missing/wrong wallet-file safety | ☑ |
+| **P2**  | W5-1, W5-2, W6-1, W6-3, W6-2 ✓ | Stale state & lite save-failure surfacing | ☑ 5/5 |
+| **F**   | W7-2, W7-3, W7-4 ✓ · QoL: copy-diag + open-log + node-error-banner + staleness-badge + alert-history ✓ | Diagnostics foundation + QoL bundle | ☑ |
+
+---
+
+## P0-A — Secret hardening
+
+Shared fix: a `SecureString` RAII buffer (zeroes on destruction) retrofitted onto the un-scrubbed
+key/passphrase paths, plus console redaction and deleting the plaintext export.
+
+- **W7-1 (High)** `console_tab.cpp:1419` — RPC console echoes/stores/clipboards raw secrets. Fix: an
+  allowlist of secret-bearing first-tokens (`walletpassphrase`, `walletpassphrasechange`,
+  `encryptwallet`, `importprivkey`, `importwallet`, `z_importkey`, `z_importviewingkey`,
+  `signrawtransaction`, `magicrecoverkey`, lite equivalents); echo `> walletpassphrase ****` and
+  keep the raw text out of `command_history_`. Extract a pure `redactConsoleCommand(cmd)` helper for
+  unit testing. **← implementing first (self-contained + testable).**
+- **W2-1 (High)** `wallet_security_workflow.cpp:66` — delete the `obsidiandecryptexport<ts>` plaintext
+  key dump after `z_importwallet` succeeds (overwrite-then-unlink).
+- **W4-3 (High)** `app_network.cpp:4481` — `sodium_memzero` the concatenated all-keys string in
+  `exportAllKeys`; write the backup 0600. (Also unify with `ExportAllKeysDialog` — QoL.)
+- **W4-1 (High)** `app_network.cpp:3801` — zero the key copies in `importPrivateKey`/`sweepPrivateKey`
+  (local + worker-lambda copies).
+- **W2-3 (Med)** `app_security.cpp:1481` — zero the passphrase threaded through the decrypt lambda chain.
+- **W4-5 (Med)** `app.cpp:3577` — the seed-backup `.txt` is a permanent predictable cleartext seed;
+  at minimum warn + offer to delete, ideally discourage file save in favor of the on-screen phrase.
+- **W5-3 (Med)** `lite_wallet_lifecycle_service.cpp:322` — remove the dead `passphrase` field from the
+  lite create/open/restore requests (unused; a secret copied for nothing).
+
+## P0-B — Encryption integrity
+
+- **W2-2 / W4-2 (High)** `wallet_security_controller.h:89` — the wizard's deferred encryption is
+  in-memory only and silently lost if the daemon doesn't connect or the app quits/crashes first, so a
+  wallet the user believes is encrypted stays plaintext. Fix: persist a lightweight
+  `encryption_requested_but_incomplete` settings flag (NEVER the passphrase) when
+  `beginDeferredEncryption` is called; surface a persistent warning banner while it's set; clear it
+  only on confirmed `encryptwallet` success; on next connect, if set, re-prompt for the passphrase to
+  complete it.
+- **W2-4 (Med)** `app_security.cpp:480` — `lockWallet` only sets `locked` on RPC success; log the
+  failure and notify (currently a silent no-op that can leave the wallet unlocked).
+
+## P1-A — Migrate-to-seed correctness (fund-adjacent; verify carefully)
+
+- **W3-1 (High)** `app_network.cpp:4327` — adopt hardcodes `datadir + "/wallet.dat"`; use
+  `settings_->getActiveWalletFile()` so migrating a non-default active wallet swaps the right file.
+- **W3-2 (High)** `seed_wallet_creator.cpp:57` — `remove_all(<config>/seed-migrate)` unconditionally
+  at Phase-1 start; refuse to wipe if a temp `DRAGONX/wallet.dat` already exists (a prior un-adopted
+  swept wallet) and surface it, so swept funds in the temp wallet can't be destroyed by re-entry.
+- **W3-4 (Med)** `app_network.cpp:1124` — block wallet switching while a migration is *pending*
+  (`getSeedMigrationPending()`), not only while the dialog is open.
+- **W3-3 (Med)** `app_network.cpp:4231` — persist the sweep opid so an app-close mid-Sweeping can
+  resume/re-poll it instead of silently dropping the txid.
+
+## P1-B — Missing/wrong wallet-file safety
+
+- **W1-1 (High)** `app_network.cpp:1109` — `fs::exists()`-check the target wallet file in
+  `switchToWallet()` and before the first daemon launch at startup; if missing, block with an explicit
+  "Wallet file not found — moved or deleted?" dialog (browse / create-new) instead of letting the
+  daemon fabricate an empty wallet.
+- **W1-3 (Med)** `app_network.cpp:1095` — defer the `syncedHere=true` stamp to the first successful
+  address/balance readback (idHash non-empty), not bare `onConnected()`.
+- **W1-2 (Med)** `app_network.cpp:198` — split `DB_CORRUPT`-specific strings from the generic "Error
+  loading wallet" fallback; give `DB_TOO_NEW` its own message/action (not a salvage offer).
+- **W1-4 (Low)** `wallets_dialog.h:393` — re-`fs::exists()` the in-datadir row before switching (match
+  the out-of-datadir path).
+
+## P2 — State & lite persistence
+
+- **W6-2 (Med)** `network_refresh_service.cpp:1183` — record a per-field last-success timestamp / a
+  "refresh failed" flag so the UI can show a staleness badge instead of last-good-as-current.
+- **W5-1 / W5-2 (Med)** `lite_wallet_controller.cpp:78,603` — `liteLog()` the failed save and bubble a
+  one-shot UI warning (both call sites currently discard the bool).
+- **W6-1 (Med)** `wallet_state.h:313` — reset `mining`/`pool_mining` in `clear()` (or comment why not).
+- **W6-3 (Low)** `address_book.cpp:46` — per-entry try/catch: skip + count malformed entries instead
+  of discarding the whole list.
+
+## F — Diagnostics foundation + QoL
+
+Land W7-2 first — it unblocks the rest.
+
+- **W7-2 (Med)** `logger.cpp:31` — call `Logger::instance().init(<config>/dragonx-debug.log)` early in
+  `main()` on all platforms; add an "Open log folder" action.
+- **W7-3 (Med)** `main.cpp:144` — add a `sigaction`-based crash handler writing `dragonx-crash.log` on
+  POSIX (mirror the Windows SEH path).
+- **W7-4 (Low)** `logger.cpp:39` — size-cap/rotate the log on `init()`.
+- **QoL** — "Copy diagnostics for support" bundle; persistent alert history; daemon/RPC error banner;
+  refresh-staleness badge; multi-wallet diagnostic panel; refresh-diagnostics panel; structured
+  switch/migration audit logging; restore-from-seed entry point (W4-4, effort L).
+
+---
+
+## Progress log
+
+- **Adversarial review of the 3 diagnostics UI features** — ran a 5-dimension finder → per-finding verify workflow over the node-banner + staleness-badge + alert-history commits (the hand-laid ImGui I couldn't visually verify). 4 confirmed, 1 refuted (banner title never overlaps its button — button is absolutely positioned + title is short), and the dedicated ImGui-stack-balance finder found **no** Push/Pop imbalance. Fixes landed:
+  - **(Med) Alert popup grew off the right edge** — pivot `(0,1)` pinned the panel's *left* edge at the bell (which sits near the window's right edge), so a 320px panel overflowed rightward (an explicit `SetNextWindowPos` pivot skips ImGui's on-screen clamp). Fixed to anchor the bottom-*right* corner at the bell (pivot `(1,1)`, at `bellMax.x`) so it grows left over the canvas.
+  - **(Low) Staleness badge could flash red on reconnect** — `WalletState::clear()` reset everything *except* the four `last_*_update` stamps, so after a reconnect the pre-outage timestamp survived and the badge briefly showed "Updated Nm ago" (red) on the same frame the node banner cleared — the exact contradiction the design forbids. Fixed by zeroing the four stamps in `clear()` (all readers treat 0 as "never"; verified `app_network.cpp:1473` guards on `!= 0`).
+  - **(Low) Banner min-height floor wasn't DPI-scaled** — `std::max(minH, baseH*vScale())` compared a raw-px floor against a scaled value; now `minH * dpiScale()`.
+  - **(Low) New i18n keys weren't in `res/lang/`** — back-filled all 16 diagnostics/QoL keys (this session's node_banner_*/data_stale_*/alerts_*/settings_*/tt_*) into all 8 language files, additively (128 insertions, 0 deletions). zh/ja/ko reworded around 2 glyphs missing from the CJK subset (提醒→通知; ko tooltip avoids 닐) and hard-asserted tofu-free against the subset font.
+- **Foundation QoL / Persistent alert history** — ☑ landed. Toasts fade in 1–4s; there was no way to review what scrolled past. `Notifications` now retains every pushed alert in a capped (100) ring buffer with a wall-clock epoch (`AlertRecord`) — separate from the 5-item live-toast deque — plus a monotonic `total_pushed_` counter. A bell in the status-bar right cluster (`ICON_MD_NOTIFICATIONS`) opens an upward popup listing recent alerts newest-first with a severity icon/colour (reusing the toast palette), the message, and a relative age (`formatTimeAgoShort`), with a Clear-all action. An **unread dot** on the bell (coloured by the most-severe unseen alert) marks alerts that arrived since the panel was last opened — driven by `totalPushed()` deltas so it survives capping/clearing. Thread-safety: every push is on the UI thread (RPC results run as main-thread `MainCb`s), matching the class's existing lock-free model — documented as a no-raw-worker-thread invariant. Build-clean; `ctest` 1/1 (adds `testNotificationHistory`: retention, order, cap, monotonic counter, clear). **This closes the QoL bundle and the Foundation tier.**
+- **W6-2 / Refresh-staleness badge** — ☑ landed. The Total Balance card now shows a small pill on its status line ("Updated 2m ago", amber → red past 3 min) **only when connected but the balance stopped refreshing** — a busy daemon can fail `z_gettotalbalance` without dropping the whole connection (only *both* core RPCs failing 3× triggers a disconnect), leaving stale numbers on screen while the node-status banner stays hidden. No refresh-path changes were needed: `WalletState::last_balance_update` is already stamped only on a successful fetch (`network_refresh_service.cpp:1187`), so the badge just reads it and computes age against the same `std::time` clock (`util::formatTimeAgoShort`). Decision is a pure, unit-tested helper (`ui/staleness_badge.h::evaluateStalenessBadge`, thresholds 45s/180s) gated on `connected` so it never contradicts the banner; hover shows a "may be out of date — check your node connection" tooltip. Build-clean; `ctest` 1/1 (adds `testStalenessBadge`). **This closes P2 (5/5).**
+- **Foundation QoL / Persistent node-status banner** — ☑ landed. A persistent horizontal strip now sits at the top of the content column whenever the wallet can't reach its node — distinct from the transient toasts, so an offline wallet is never silently mistaken for a working one. The show/severity/action decision is a pure function (`ui/node_status_banner.h` → `evaluateNodeStatusBanner`, unit-tested) fed a state snapshot by `App::renderNodeStatusBanner()`. Three cases: **full-node offline** (amber, "Reconnect" → `tryConnect`), **embedded daemon crashed & auto-restart gave up** (red, "Restart node" → `restartDaemon`), **lite wallet failed to open** (red, message-only). Suppressed during the wizard / wallet-switch / daemon-restart / screenshot-sweep / shutdown, and while an expected startup phase (warmup/init/connect-in-progress) already owns the screen. Height in `res/themes/ui.toml` (`banners.node-status`); colours from the material semantic palette; detail text ellipsis-clipped so it can't shove the action button off-screen. Build-clean; `ctest` 1/1 (added `testNodeStatusBanner`). **Remaining QoL:** persistent alert history, and the W6-2 refresh-staleness badge.
+- **Foundation QoL / "Copy diagnostics" + "Open log folder"** — ☑ landed: Settings (logging section) now has two actions. **Open log folder** opens the config dir (`Platform::openFolder`) so users can actually find `dragonx-debug.log`/`dragonx-crash.log`. **Copy diagnostics** copies a plaintext support snapshot to the clipboard via the new `App::buildDiagnosticsReport()` — version, build variant, platform, connection status, active wallet path + existence + size, encryption/lock state, sync heights, daemon status/running/crash-count/lastError (full-node), and the log paths. No secrets. Build-clean; `ctest` 1/1. **Remaining QoL:** persistent alert history, a daemon/RPC error banner, and the W6-2 refresh-staleness badge.
+- **Foundation / W7-2 · W7-3 · W7-4 (diagnostics infrastructure)** — ☑ landed (answers the original "easier to diagnose" ask — the logging/crash foundation now actually works):
+  - **W7-2 (Med, keystone):** the app-level `Logger` file sink was never initialized, so `LOG`/`LOGF`/`VERBOSE_LOGF` went nowhere and `dragonx-debug.log` didn't exist on Linux/macOS at all. `main()` now calls `Logger::init(<config>/dragonx-debug.log)` on all platforms. Also fixed a **latent deadlock** this exposed: `init()` wrote its banner via `write()`, which re-locks the non-recursive `mutex_` it already holds — now written directly. On Windows the raw stdout/stderr `freopen` was moved to a separate `dragonx-stdout.log` so the two writers don't contend. New `testLoggerFileSink` (also a deadlock guard — it would hang if that regressed).
+  - **W7-3 (Med):** no crash handler existed on Linux/macOS. Added an **async-signal-safe** `sigaction` handler (SIGSEGV/ABRT/BUS/FPE/ILL) that writes a signal id + `backtrace_symbols_fd` backtrace to `dragonx-crash.log`, then re-raises the default disposition for a core dump — the POSIX counterpart of the Windows SEH filter.
+  - **W7-4 (Low):** `Logger::init` now rotates the log to a single `.1` backup when it exceeds 10 MB, so a long/verbose session can't grow it unbounded.
+  Build-clean; `ctest` 1/1. **Remaining Foundation:** the QoL bundle (mostly UI) — "copy diagnostics for support", an "open log folder" action, persistent alert history, a daemon/RPC error banner, and the W6-2 refresh-staleness badge.
+- **P2 / W5-1 · W5-2 · W6-1 · W6-3 (localized batch)** — ☑ landed:
+  - **W5-1 (Med):** `persistAfterBroadcast` (lite send/shield save) returned false on a persistent save failure but both callers discarded it and it never logged — completely silent. It now `liteLog`s the failure (the note re-derives on next sync, so it's a robustness gap, not fund loss).
+  - **W5-2 (Med):** the post-**sync** and post-**rescan** `save` results (in the detached scan threads) were ignored; both now `liteLog` on failure (`LiteDiagnostics::log` is mutex-guarded, safe from those threads).
+  - **W6-1 (Med):** `WalletState::clear()` didn't reset `mining`/`pool_mining`, so a wallet switch could briefly show the previous wallet's hashrate/blocks. Now reset in `clear()` (the daemon restarts on switch, so mining genuinely stops).
+  - **W6-3 (Low):** `AddressBook::load()` did `entries_.clear()` then threw on the first non-object element — discarding **every** contact. Now it guards `is_object()` + per-entry try/catch, skipping and counting malformed entries.
+  Build-clean; `ctest` 1/1. **Remaining P2:** W6-2 (surface refresh staleness — the timestamps exist in `WalletState`; this needs the UI "updated Xs ago" badge, which overlaps the diagnostics/QoL Foundation bundle).
+- **P1-B / W1-3 + startup wallet-existence guard** — ☑ landed:
+  - **W1-3 (Med):** `syncedHere` was stamped in the `markOpened` block at bare connect (idHash still empty), letting a freshly-restored wallet skip its needed rescan. It's now stamped only once the identity is verified (idHash non-empty), so it takes effect at the post-address-refresh index update (`updateWalletIndexForActiveWallet` after addresses load), while `lastOpenedEpoch` still records at open.
+  - **Startup guard (the W1-1 launch counterpart):** `App::init` now `exists()`-checks the recorded active wallet before the daemon is configured; a **non-default** active wallet that was moved/deleted between sessions falls back to the default `wallet.dat` with a warning, instead of the daemon silently auto-creating an empty wallet under the missing name. Runs before the PIN-vault init so the vault is scoped to the wallet actually opened.
+  Build-clean; `ctest` 1/1.
+- **P1-A / W3-3 (sweep opid persistence)** — ☑ **implemented + two rounds of adversarial review** (the "live mainnet run" the migration code mandates is the remaining gate — see below). The deferral's core fear (re-tracking a stale opid hangs forever) was **refuted by the code**: the opid poller (`app.cpp:1122`) + `parseOperationStatusPoll` classify a tracked opid absent from a *successful* `z_getoperationstatus` as stale, remove it, and fire the callback `ok=false` — a thrown RPC aborts the poll so there's never a *false* stale. So re-tracking yields at worst one clean failure, never a hang.
+  - **What landed:** a persisted `seed_migration_sweep_opid` setting; the opid is adopted **atomically** with clearing any prior txid in the *same* `settings.save()` **only once the submit succeeds** (torn-write safe; txid always outranks opid on resume). Resume routing is a pure, unit-tested helper (`data/seed_migration_resume.h::decideSeedMigrationResume`): txid → Confirming; opid **and connected** → re-track (`Sweeping`); otherwise → the dismissable Sweep gate. The shared `makeSweepCompletionCallback(resumed)`: success → Confirming; resumed-stale → Sweep gate (re-fetch balance, honest "may have already completed" copy); fresh-fail → Error.
+  - **Round 1 (design review, 4 skeptics)** confirmed both safety facts (no fund loss — adopt gate + never-deleted `.bak` untouched; no hang) and caught 3 real resume-UX traps, all fixed: a missing **connectivity gate** (would trap the user in the buttonless `Sweeping` spinner while offline), a **missing balance re-fetch** on the stale fallback (permanent "Checking balance…"), and honest messaging since a daemon restart makes even a *successful* sweep read "stale".
+  - **Round 2 (implementation review, 3 reviewers)** caught one regression — clearing the old txid at sweep *entry* would forget an already-mined first sweep if a remainder re-sweep's submit failed; fixed by the atomic-on-success swap above. All other fixes verified present + correct.
+  - **⚑ Remaining gate — live mainnet run (user):** per CLAUDE.md this fund-moving path must be exercised once on mainnet before it ships. The self-verifiable parts (build, unit test, both review rounds) are green; a real interrupted-sweep resume on mainnet is the human gate I cannot perform.
+- **P1-B / W1-1 (+ W1-4) · W1-2 (wallet-file safety)** — ☑ landed:
+  - **W1-1 (High):** `switchToWallet` never checked the target wallet file exists, so a moved/deleted file "opened" as a fresh empty wallet (dragonxd auto-creates for a missing `-wallet=`), looking exactly like fund loss. It now `std::filesystem::exists`-checks `datadir + "/" + walletFile` before switching and blocks with a "not found (moved or deleted?)" warning. Placed before the daemon-stop prompt, and — since the check runs no matter how `switchToWallet` is invoked — it also **closes W1-4** (the stale-switcher-row TOCTOU).
+  - **W1-2 (Med):** `walletOutputLooksCorrupt` matched the generic "Error loading wallet" string, so a `DB_TOO_NEW` (newer-version) wallet was offered a `-salvagewallet` repair that can't fix it. Now the generic match is excluded when the output also contains "newer version".
+  Build-clean; `ctest` 1/1. **Remaining P1-B:** W1-3 (defer the `syncedHere` stamp to a verified readback) + the startup-path existence check (`app.cpp` hands `getActiveWalletFile()` to the daemon with no `exists()` check — same silent-empty-wallet risk as W1-1 but at launch).
+- **P1-A / W3-1 · W3-2 · W3-4 (migrate-to-seed correctness)** — ☑ landed (fund-adjacent — reviewed carefully):
+  - **W3-1 (High):** `beginAdoptSeedWallet` hardcoded `datadir + "/wallet.dat"` as the file to swap. With a non-default active wallet (e.g. `wallet-2.dat`), that installed the swept seed wallet into an unloaded `wallet.dat` and left the daemon reloading the emptied legacy — funds only recoverable via the seed phrase. Now swaps `datadir + "/" + getActiveWalletFile()` (captured on the main thread; switching is blocked during migration so it can't race).
+  - **W3-2 (High):** `SeedWalletCreator::create` did `remove_all(<config>/seed-migrate)` unconditionally at the start. A prior migration that swept funds into the temp wallet but was abandoned/crashed before adopting would have that fund-bearing wallet destroyed. It now refuses (with a clear message) when `DRAGONX/wallet.dat` already exists — a completed migration removes the dir on adopt, so a leftover means an unfinished one.
+  - **W3-4 (Med):** `switchToWallet` only blocked switching while the migration *dialog* was open; closing it via "Later" mid-migration dropped the guard. Now also blocks while `getSeedMigrationPending()`.
+  Build-clean; `ctest` 1/1. **Remaining P1-A:** W3-3 (persist the sweep opid so an app-close mid-sweep can resume/re-poll instead of silently dropping the txid).
+
+- **P0-B / W2-2 (deferred encryption silently lost) + W2-4 (auto-lock silent-fail)** — ☑ landed:
+  - **W2-2:** the wizard's deferred encryption was stored only in memory, so a quit/crash or a failed daemon connect before it applied left the wallet unencrypted with **no record it was ever requested** — the user believing it was encrypted. Now a persisted `encryption_pending` settings flag is set the moment encryption is requested (**never the passphrase** — only the fact). `refreshWalletEncryptionState()` reconciles it on every connect: wallet observed **encrypted** → clear the flag; wallet **not** encrypted while the flag is set and no deferred encryption is pending/in-flight → a once-per-session **"your wallet is NOT encrypted — open Settings to finish"** warning (the flag stays set, so it recurs each launch until resolved). We deliberately don't persist the passphrase to auto-complete — surfacing it is the secure choice.
+  - **W2-4:** `lockWallet()`'s continuation only handled success — a failed `walletlock` silently left the wallet **unlocked** (an unfulfilled auto-lock). It now logs and warns once (reset on the next successful lock), so a failing auto-lock is visible instead of leaving the wallet exposed.
+  Touches `settings.{h,cpp}`, `app_wizard.cpp`, `app_security.cpp`, `app.h`. Not unit-testable at this layer (RPC/connect-driven state machine); build-clean, `ctest` 1/1.
+
+- **P0-A / W5-3 (lite create-time passphrase)** — ☑ landed (chose option **(b) wire it up**). The lite create/open/restore passphrase was collected but never consumed by the backend — a "passphrase" field that did nothing. It now has a real meaning for all three operations, in `LiteWalletController`: **create/restore** → `encryptWallet(passphrase)` (the backend encrypts + locks + saves the brand-new wallet); **open** → `unlockWallet(passphrase)`, but only when `encryptionStatus()` reports the existing wallet is actually encrypted+locked (skips a spurious unlock otherwise). Encrypt/unlock take their own copy and wipe it; a post-create encrypt failure is `liteLog`'d (the wallet still exists — the create isn't failed). Six existing lite-controller tests carried an incidental `hunter2` create passphrase from the dead-field era; removed (they test non-encryption flows and want an unencrypted wallet), and added `testLiteWalletControllerCreateEncryptsWithPassphrase` to prove the new behavior. Build-clean; `ctest` 1/1. *(Follow-up UX polish: `settings_page` could show the passphrase field's meaning per operation — "encrypt" for create/restore vs "unlock" for open.)*
+- **P0-A / W4-5 (seed-backup file)** — ☑ landed (proportionate): the seed "Save" already wrote 0600 + zeroed the in-memory buffer, but the success message was a bare "Saved to <path>". It now reads "**Saved an UNENCRYPTED seed file — move it to secure offline storage and delete this copy**: <path>", so the plaintext-on-disk risk is called out. `i18n.cpp` (English source; `res/lang` back-fill of this changed key is deferred to the batch i18n pass). A stronger fix (pre-save confirmation, or dropping the file-save in favor of on-screen + Copy) is a follow-up UX decision.
+- **P0-A / W4-1 · W4-3 · W2-3 (memzero cluster)** — ☑ landed, using the file's established `sodium_memzero` pattern (matching the existing lambda-capture scrub at app_network.cpp:2885 and JSON scrub at :4025) rather than a new type, since this is fund-moving code:
+  - **W4-1** `importPrivateKey`/`sweepPrivateKey`: the spending/viewing key is now scrubbed on all paths — the calling-frame copy (after the worker post), the worker-lambda's captured copy (lambda made `mutable`, zeroed after the request is sent), and the JSON request `params` copy.
+  - **W4-3** `exportAllKeys`/`backupWallet`: the concatenated all-keys buffer is zeroed after the consumer uses it, and the backup file is now written via `Platform::writeFileAtomically(..., restrictPermissions=true)` (atomic + 0600) instead of a umask-default `ofstream`.
+  - **W2-3** decrypt-wallet passphrase: `std::move`-captured into the worker lambda (so no plaintext copy is left in the calling frame) and `sodium_memzero`'d right after `unlockWallet` (its only use).
+  Not unit-testable (the scrubbing has no observable RPC effect — the key value sent to the daemon is unchanged; only post-use memory zeroing is added). Build-clean; `ctest` 1/1 (no regression). **Remaining in P0-A:** W5-3 (remove the dead lite `passphrase` field), W4-5 (predictable plaintext seed-backup file).
+- **P0-A / W2-1** — ☑ landed: the decrypt-wallet flow now scrubs (best-effort in-place zero-overwrite) and removes the plaintext key export (`obsidiandecryptexport…`) as soon as the `z_importwallet` attempt resolves — success or failure — so a full cleartext dump of every private key is no longer left on disk forever. Recovery remains the encrypted backup (`wallet.dat.encrypted.bak`). `app_security.cpp` (after the import call). Not unit-testable (fs I/O in a deep lambda); build-clean, `ctest` 1/1 (no regression).
+- **P0-A / W7-1** — ☑ landed: `RedactConsoleCommand`/`ConsoleCommandCarriesSecret` in `console_tab_helpers` redact secret-bearing commands (an allowlist of 13 first-tokens: `walletpassphrase`, `encryptwallet`, `z_importkey`, …) to `> walletpassphrase ****` before they hit the console echo AND the recall history; the real command still executes unredacted. Wired into `submitConsoleCommand` (`console_tab.cpp`). New `testConsoleSecretRedaction` (11 assertions). Clean build; `ctest` 1/1. (Output-secret commands like `z_exportkey` — result redaction — remain a follow-up.)

res/lang/de.json

@@ -48,6 +48,10 @@
     "advanced": "ERWEITERT",
     "advanced_effects": "Erweiterte Effekte...",
     "ago": "her",
+    "alerts_clear": "Meldungsverlauf löschen",
+    "alerts_history_tooltip": "Letzte Meldungen",
+    "alerts_none": "Noch keine Meldungen",
+    "alerts_recent": "LETZTE MELDUNGEN",
     "all_filter": "Alle",
     "allow_custom_fees": "Benutzerdefinierte Gebühren erlauben",
     "amount": "Betrag",
@@ -451,6 +455,8 @@
     "daemon_update_version": "Version:",
     "daemon_version": "Daemon",
     "dark": "Dunkel",
+    "data_stale_prefix": "Aktualisiert",
+    "data_stale_tooltip": "Der Kontostand ist möglicherweise veraltet – die Wallet hat kürzlich keine Aktualisierung erhalten. Überprüfe deine Node-Verbindung.",
     "date": "Datum",
     "date_label": "Datum:",
     "debug_logging": "FEHLERPROTOKOLLIERUNG",
@@ -734,6 +740,9 @@
     "lite_working": "In Arbeit…",
     "loading": "Laden...",
     "loading_addresses": "Adressen werden geladen...",
+    "loading_stall_body": "Der Daemon initialisiert seit %.0f s. Das kann nach einem Update oder beim ersten Start normal sein (Laden des Blockindex oder erneutes Scannen) – die Verbindung wird automatisch hergestellt, sobald er bereit ist.",
+    "loading_stall_hint": "Hängt es noch? Öffne die Einstellungen und nutze „Daemon neu starten“ oder sieh in der Konsole nach Details.",
+    "loading_stall_title": "Dauert länger als erwartet",
     "loading_transactions": "Transaktionen werden geladen",
     "local_hashrate": "Lokale Hashrate",
     "low_spec_mode": "Energiesparmodus",
@@ -953,6 +962,11 @@
     "no_transactions": "Keine Transaktionen gefunden",
     "no_transactions_yet": "Noch keine Transaktionen",
     "node": "KNOTEN",
+    "node_banner_crashed_title": "Der Node wurde unerwartet beendet",
+    "node_banner_lite_open_failed": "Wallet konnte nicht geöffnet werden",
+    "node_banner_offline_title": "Nicht mit dem DragonX-Node verbunden",
+    "node_banner_reconnect": "Erneut verbinden",
+    "node_banner_restart": "Node neu starten",
     "node_security": "KNOTEN & SICHERHEIT",
     "noise": "Rauschen",
     "not_connected": "Nicht mit Daemon verbunden...",
@@ -1154,6 +1168,8 @@
     "sb_connecting_external": "Verbindung zu externem Daemon...",
     "sb_connecting_generic": "Verbindung zum Daemon...",
     "sb_daemon_crashed": "Daemon ist %d mal abgestürzt",
+    "sb_daemon_extract_failed": "Daemon-Dateien konnten nicht geschrieben werden – prüfe freien Speicherplatz und Berechtigungen.",
+    "sb_daemon_files_failed": "Daemon-Dateien konnten nicht nach %s geschrieben werden – prüfe freien Speicherplatz und Berechtigungen.",
     "sb_daemon_not_found": "Daemon nicht gefunden",
     "sb_daemon_start_failed": "dragonxd konnte nicht gestartet werden",
     "sb_dragonxd_running": "dragonxd läuft",
@@ -1169,6 +1185,7 @@
     "sb_net_mhs": "Netz: %.2f MH/s",
     "sb_no_conf": "DRAGONX.conf nicht gefunden",
     "sb_peers": "Peers: %zu",
+    "sb_plaintext_remote_blocked": "RPC-Anmeldedaten werden nicht im Klartext an einen entfernten Host gesendet. Füge rpcallowplaintext=1 zu DRAGONX.conf hinzu, um dies zu erlauben, oder aktiviere TLS mit rpctls=1.",
     "sb_rescanning": "Neuscan",
     "sb_rescanning_pct": "Neuscan %.0f%%",
     "sb_restarting_daemon": "Daemon wird neu gestartet...",
@@ -1285,12 +1302,14 @@
     "settings_configure_explorer": "Externe Block-Explorer-Links konfigurieren",
     "settings_configure_rpc": "Verbindung zum dragonxd-Daemon konfigurieren",
     "settings_connection": "Verbindung",
+    "settings_copy_diagnostics": "Diagnose kopieren",
     "settings_copyright": "Copyright 2024-2026 DragonX-Entwickler  |  GPLv3-Lizenz",
     "settings_custom": "Benutzerdefiniert",
     "settings_data_dir": "Datenverzeichnis:",
     "settings_debug_changed": "Debug-Kategorien geändert — Daemon neu starten zum Anwenden",
     "settings_debug_restart_note": "Änderungen werden nach einem Neustart des Daemons wirksam.",
     "settings_debug_select": "Kategorien auswählen, um Daemon-Fehlerprotokollierung zu aktivieren (-debug= Flags).",
+    "settings_diagnostics_copied": "Diagnose in die Zwischenablage kopiert",
     "settings_encrypt_first_pin": "Verschlüsseln Sie zuerst die Wallet, um PIN zu aktivieren",
     "settings_encrypt_wallet": "Wallet verschlüsseln",
     "settings_explorer_hint": "URLs sollten einen abschließenden Schrägstrich enthalten. Die txid/Adresse wird angehängt.",
@@ -1311,6 +1330,7 @@
     "settings_not_found": "Nicht gefunden",
     "settings_open_app_dir": "App-Ordner öffnen",
     "settings_open_data_dir": "Datenordner öffnen",
+    "settings_open_log_folder": "Log-Ordner öffnen",
     "settings_other": "Sonstiges",
     "settings_pin_active": "PIN",
     "settings_privacy": "Datenschutz",
@@ -1470,6 +1490,7 @@
     "tt_chat_timestamp": "Zeitstempelformat nur für diesen Tab: der app-weiten Uhr folgen oder 24-hour bzw. 12-hour erzwingen",
     "tt_clear_ztx": "Lokal zwischengespeicherten Z-Transaktionsverlauf löschen",
     "tt_clock_format": "24- oder 12-Stunden-Uhr, app-weit. Der Chat-Tab kann sie überschreiben.",
+    "tt_copy_diagnostics": "Kopiert eine Support-Übersicht (Version, Daemon-/Wallet-/Log-Status – keine Geheimnisse) in die Zwischenablage",
     "tt_custom_fees": "Manuelle Gebühreneingabe beim Senden von Transaktionen aktivieren",
     "tt_custom_theme": "Benutzerdefiniertes Theme aktiv",
     "tt_daemon_install_bundled": "Node stoppen, den installierten dragonxd mit der in diesem Wallet-Build enthaltenen Version überschreiben und dann neu starten",
@@ -1523,6 +1544,7 @@
     "tt_open_app_dir": "Den ObsidianDragon-Ordner (Einstellungen, Themes, Logs) im Dateimanager öffnen",
     "tt_open_data_dir": "Den Ordner mit Ihren Wallet- und Blockchain-Daten im Dateimanager öffnen",
     "tt_open_dir": "Klicken, um im Dateimanager zu öffnen",
+    "tt_open_log_folder": "Öffnet den Ordner mit den Debug- und Absturzprotokollen",
     "tt_reduce_motion": "Animierte Übergänge und Saldo-Lerp für Barrierefreiheit deaktivieren",
     "tt_remove_encrypt": "Verschlüsselung entfernen und Wallet ungeschützt speichern",
     "tt_remove_pin": "PIN entfernen und Passphrase zum Entsperren erfordern",

res/lang/es.json

@@ -48,6 +48,10 @@
     "advanced": "AVANZADO",
     "advanced_effects": "Efectos Avanzados...",
     "ago": "atrás",
+    "alerts_clear": "Borrar historial de alertas",
+    "alerts_history_tooltip": "Alertas recientes",
+    "alerts_none": "Aún no hay alertas",
+    "alerts_recent": "ALERTAS RECIENTES",
     "all_filter": "Todos",
     "allow_custom_fees": "Permitir comisiones personalizadas",
     "amount": "Cantidad",
@@ -451,6 +455,8 @@
     "daemon_update_version": "Versión:",
     "daemon_version": "Daemon",
     "dark": "Oscuro",
+    "data_stale_prefix": "Actualizado",
+    "data_stale_tooltip": "El saldo puede estar desactualizado: la cartera no ha recibido una actualización reciente. Comprueba la conexión con tu nodo.",
     "date": "Fecha",
     "date_label": "Fecha:",
     "debug_logging": "REGISTRO DE DEPURACIÓN",
@@ -734,6 +740,9 @@
     "lite_working": "Trabajando…",
     "loading": "Cargando...",
     "loading_addresses": "Cargando direcciones...",
+    "loading_stall_body": "El daemon lleva %.0f s inicializándose. Esto puede ser normal tras una actualización o en el primer inicio (cargando el índice de bloques o reescaneando); se conectará automáticamente cuando esté listo.",
+    "loading_stall_hint": "¿Sigue bloqueado? Abre Ajustes y usa Reiniciar daemon, o revisa la Consola para más detalles.",
+    "loading_stall_title": "Está tardando más de lo esperado",
     "loading_transactions": "Cargando transacciones",
     "local_hashrate": "Tasa Hash Local",
     "low_spec_mode": "Modo bajo rendimiento",
@@ -953,6 +962,11 @@
     "no_transactions": "No se encontraron transacciones",
     "no_transactions_yet": "Aún no hay transacciones",
     "node": "NODO",
+    "node_banner_crashed_title": "El nodo se detuvo inesperadamente",
+    "node_banner_lite_open_failed": "No se pudo abrir tu monedero",
+    "node_banner_offline_title": "No conectado al nodo DragonX",
+    "node_banner_reconnect": "Reconectar",
+    "node_banner_restart": "Reiniciar nodo",
     "node_security": "NODO Y SEGURIDAD",
     "noise": "Ruido",
     "not_connected": "No conectado al daemon...",
@@ -1154,6 +1168,8 @@
     "sb_connecting_external": "Conectando a daemon externo...",
     "sb_connecting_generic": "Conectando al daemon...",
     "sb_daemon_crashed": "El daemon se bloqueó %d veces",
+    "sb_daemon_extract_failed": "No se pudieron escribir los archivos del daemon: comprueba el espacio libre en disco y los permisos.",
+    "sb_daemon_files_failed": "No se pudieron escribir los archivos del daemon en %s: comprueba el espacio libre en disco y los permisos.",
     "sb_daemon_not_found": "Daemon no encontrado",
     "sb_daemon_start_failed": "No se pudo iniciar dragonxd",
     "sb_dragonxd_running": "dragonxd ejecutándose",
@@ -1169,6 +1185,7 @@
     "sb_net_mhs": "Red: %.2f MH/s",
     "sb_no_conf": "DRAGONX.conf no encontrado",
     "sb_peers": "Pares: %zu",
+    "sb_plaintext_remote_blocked": "Se rechaza enviar credenciales RPC en texto plano a un host remoto. Añade rpcallowplaintext=1 a DRAGONX.conf para permitirlo, o habilita TLS con rpctls=1.",
     "sb_rescanning": "Reescaneando",
     "sb_rescanning_pct": "Reescaneando %.0f%%",
     "sb_restarting_daemon": "Reiniciando daemon...",
@@ -1285,12 +1302,14 @@
     "settings_configure_explorer": "Configurar enlaces de explorador de bloques externo",
     "settings_configure_rpc": "Configurar conexión al daemon dragonxd",
     "settings_connection": "Conexión",
+    "settings_copy_diagnostics": "Copiar diagnósticos",
     "settings_copyright": "Copyright 2024-2026 Desarrolladores de DragonX  |  Licencia GPLv3",
     "settings_custom": "Personalizado",
     "settings_data_dir": "Dir. de datos:",
     "settings_debug_changed": "Categorías de depuración cambiadas — reinicie el daemon para aplicar",
     "settings_debug_restart_note": "Los cambios surten efecto después de reiniciar el daemon.",
     "settings_debug_select": "Seleccione categorías para habilitar el registro de depuración del daemon (flags -debug=).",
+    "settings_diagnostics_copied": "Diagnósticos copiados al portapapeles",
     "settings_encrypt_first_pin": "Primero cifre la billetera para habilitar el PIN",
     "settings_encrypt_wallet": "Cifrar billetera",
     "settings_explorer_hint": "Las URLs deben incluir una barra final. Se añadirá el txid/dirección.",
@@ -1311,6 +1330,7 @@
     "settings_not_found": "No encontrado",
     "settings_open_app_dir": "Abrir carpeta de la aplicación",
     "settings_open_data_dir": "Abrir carpeta de datos",
+    "settings_open_log_folder": "Abrir carpeta de registros",
     "settings_other": "Otros",
     "settings_pin_active": "PIN",
     "settings_privacy": "Privacidad",
@@ -1470,6 +1490,7 @@
     "tt_chat_timestamp": "Formato de marca de tiempo solo para esta pestaña: seguir el reloj de toda la app, o forzar 24-hour o 12-hour",
     "tt_clear_ztx": "Eliminar historial de z-transacciones en caché local",
     "tt_clock_format": "Reloj de 24 o 12 horas, en toda la app. El chat puede anularlo.",
+    "tt_copy_diagnostics": "Copia al portapapeles un resumen para soporte (versión, estado de daemon/cartera/registros, sin datos secretos)",
     "tt_custom_fees": "Habilitar entrada manual de comisiones al enviar transacciones",
     "tt_custom_theme": "Tema personalizado activo",
     "tt_daemon_install_bundled": "Detiene el nodo, sobrescribe el dragonxd instalado con la versión incluida en esta compilación de la cartera y luego lo reinicia",
@@ -1523,6 +1544,7 @@
     "tt_open_app_dir": "Abrir la carpeta de ObsidianDragon (configuración, temas, registros) en el explorador de archivos",
     "tt_open_data_dir": "Abre en el gestor de archivos la carpeta con los datos de tu cartera y de la blockchain",
     "tt_open_dir": "Clic para abrir en explorador de archivos",
+    "tt_open_log_folder": "Abre la carpeta que contiene los registros de depuración y de fallos",
     "tt_reduce_motion": "Desactivar transiciones animadas y lerp de saldo para accesibilidad",
     "tt_remove_encrypt": "Quitar cifrado y almacenar la billetera sin protección",
     "tt_remove_pin": "Quitar PIN y requerir contraseña para desbloquear",

res/lang/fr.json

@@ -48,6 +48,10 @@
     "advanced": "AVANCÉ",
     "advanced_effects": "Effets avancés...",
     "ago": "passé",
+    "alerts_clear": "Effacer l'historique des alertes",
+    "alerts_history_tooltip": "Alertes récentes",
+    "alerts_none": "Aucune alerte pour l'instant",
+    "alerts_recent": "ALERTES RÉCENTES",
     "all_filter": "Tout",
     "allow_custom_fees": "Autoriser les frais personnalisés",
     "amount": "Montant",
@@ -451,6 +455,8 @@
     "daemon_update_version": "Version :",
     "daemon_version": "Daemon",
     "dark": "Sombre",
+    "data_stale_prefix": "Mis à jour",
+    "data_stale_tooltip": "Le solde est peut-être obsolète — le portefeuille n'a pas reçu de mise à jour récente. Vérifiez la connexion à votre nœud.",
     "date": "Date",
     "date_label": "Date :",
     "debug_logging": "JOURNALISATION DE DÉBOGAGE",
@@ -734,6 +740,9 @@
     "lite_working": "En cours…",
     "loading": "Chargement...",
     "loading_addresses": "Chargement des adresses...",
+    "loading_stall_body": "Le démon s'initialise depuis %.0f s. Cela peut être normal après une mise à jour ou au premier lancement (chargement de l'index des blocs ou nouvelle analyse) — la connexion se fera automatiquement une fois prêt.",
+    "loading_stall_hint": "Toujours bloqué ? Ouvrez les Paramètres et utilisez Redémarrer le démon, ou consultez la Console pour plus de détails.",
+    "loading_stall_title": "Cela prend plus de temps que prévu",
     "loading_transactions": "Chargement des transactions",
     "local_hashrate": "Hashrate local",
     "low_spec_mode": "Mode économie",
@@ -953,6 +962,11 @@
     "no_transactions": "Aucune transaction trouvée",
     "no_transactions_yet": "Aucune transaction pour le moment",
     "node": "NŒUD",
+    "node_banner_crashed_title": "Le nœud s'est arrêté de façon inattendue",
+    "node_banner_lite_open_failed": "Impossible d'ouvrir votre portefeuille",
+    "node_banner_offline_title": "Non connecté au nœud DragonX",
+    "node_banner_reconnect": "Reconnecter",
+    "node_banner_restart": "Redémarrer le nœud",
     "node_security": "NŒUD & SÉCURITÉ",
     "noise": "Bruit",
     "not_connected": "Non connecté au daemon...",
@@ -1154,6 +1168,8 @@
     "sb_connecting_external": "Connexion au daemon externe...",
     "sb_connecting_generic": "Connexion au daemon...",
     "sb_daemon_crashed": "Le daemon a planté %d fois",
+    "sb_daemon_extract_failed": "Échec de l'écriture des fichiers du démon — vérifiez l'espace disque libre et les permissions.",
+    "sb_daemon_files_failed": "Échec de l'écriture des fichiers du démon dans %s — vérifiez l'espace disque libre et les permissions.",
     "sb_daemon_not_found": "Daemon introuvable",
     "sb_daemon_start_failed": "Impossible de démarrer dragonxd",
     "sb_dragonxd_running": "dragonxd en cours",
@@ -1169,6 +1185,7 @@
     "sb_net_mhs": "Rés: %.2f MH/s",
     "sb_no_conf": "DRAGONX.conf introuvable",
     "sb_peers": "Pairs : %zu",
+    "sb_plaintext_remote_blocked": "Refus d'envoyer les identifiants RPC en clair vers un hôte distant. Ajoutez rpcallowplaintext=1 à DRAGONX.conf pour l'autoriser, ou activez TLS avec rpctls=1.",
     "sb_rescanning": "Rescan",
     "sb_rescanning_pct": "Rescan %.0f%%",
     "sb_restarting_daemon": "Redémarrage du daemon...",
@@ -1285,12 +1302,14 @@
     "settings_configure_explorer": "Configurer les liens vers l'explorateur de blocs externe",
     "settings_configure_rpc": "Configurer la connexion au daemon dragonxd",
     "settings_connection": "Connexion",
+    "settings_copy_diagnostics": "Copier les diagnostics",
     "settings_copyright": "Copyright 2024-2026 Développeurs DragonX  |  Licence GPLv3",
     "settings_custom": "Personnalisé",
     "settings_data_dir": "Rép. de données :",
     "settings_debug_changed": "Catégories de débogage modifiées — redémarrez le daemon pour appliquer",
     "settings_debug_restart_note": "Les modifications prennent effet après le redémarrage du daemon.",
     "settings_debug_select": "Sélectionnez les catégories pour activer la journalisation de débogage du daemon (flags -debug=).",
+    "settings_diagnostics_copied": "Diagnostics copiés dans le presse-papiers",
     "settings_encrypt_first_pin": "Chiffrez d'abord le portefeuille pour activer le PIN",
     "settings_encrypt_wallet": "Chiffrer le portefeuille",
     "settings_explorer_hint": "Les URLs doivent inclure une barre oblique finale. Le txid/adresse sera ajouté.",
@@ -1311,6 +1330,7 @@
     "settings_not_found": "Non trouvé",
     "settings_open_app_dir": "Ouvrir le dossier de l'application",
     "settings_open_data_dir": "Ouvrir le dossier de données",
+    "settings_open_log_folder": "Ouvrir le dossier des journaux",
     "settings_other": "Autres",
     "settings_pin_active": "PIN",
     "settings_privacy": "Confidentialité",
@@ -1470,6 +1490,7 @@
     "tt_chat_timestamp": "Format d'horodatage pour cet onglet uniquement : suivre l'horloge de l'application, ou forcer 24-hour ou 12-hour",
     "tt_clear_ztx": "Supprimer l'historique des z-transactions mis en cache localement",
     "tt_clock_format": "Horloge 24 h ou 12 h, dans toute l'app. Le chat peut la remplacer.",
+    "tt_copy_diagnostics": "Copie un récapitulatif de support (version, état daemon/portefeuille/journaux — sans données secrètes) dans le presse-papiers",
     "tt_custom_fees": "Activer la saisie manuelle des frais lors de l'envoi de transactions",
     "tt_custom_theme": "Thème personnalisé actif",
     "tt_daemon_install_bundled": "Arrêter le nœud, remplacer le dragonxd installé par la version intégrée dans cette version du portefeuille, puis redémarrer",
@@ -1523,6 +1544,7 @@
     "tt_open_app_dir": "Ouvrir le dossier ObsidianDragon (paramètres, thèmes, journaux) dans le gestionnaire de fichiers",
     "tt_open_data_dir": "Ouvrir le dossier contenant les données de votre portefeuille et de la blockchain dans le gestionnaire de fichiers",
     "tt_open_dir": "Cliquer pour ouvrir dans l'explorateur de fichiers",
+    "tt_open_log_folder": "Ouvre le dossier contenant les journaux de débogage et de plantage",
     "tt_reduce_motion": "Désactiver les transitions animées et le lerp de solde pour l'accessibilité",
     "tt_remove_encrypt": "Supprimer le chiffrement et stocker le portefeuille sans protection",
     "tt_remove_pin": "Supprimer le PIN et exiger la phrase secrète pour déverrouiller",

res/lang/ja.json

@@ -48,6 +48,10 @@
     "advanced": "詳細設定",
     "advanced_effects": "高度なエフェクト...",
     "ago": "前",
+    "alerts_clear": "通知履歴を消去",
+    "alerts_history_tooltip": "最近の通知",
+    "alerts_none": "通知はまだありません",
+    "alerts_recent": "最近の通知",
     "all_filter": "すべて",
     "allow_custom_fees": "カスタム手数料を許可",
     "amount": "金額",
@@ -451,6 +455,8 @@
     "daemon_update_version": "バージョン：",
     "daemon_version": "デーモン",
     "dark": "ダーク",
+    "data_stale_prefix": "更新",
+    "data_stale_tooltip": "残高が最新でない可能性があります。ウォレットは最近更新を受信していません。ノード接続を確認してください。",
     "date": "日付",
     "date_label": "日付：",
     "debug_logging": "デバッグログ",
@@ -734,6 +740,9 @@
     "lite_working": "処理中…",
     "loading": "読み込み中...",
     "loading_addresses": "アドレスを読み込み中...",
+    "loading_stall_body": "デーモンは %.0f 秒間初期化しています。アップデート後や初回起動時（ブロックインデックスの読み込みや再スキャン）は正常な場合があります。準備ができ次第、自動的に接続します。",
+    "loading_stall_hint": "まだ動かない場合は、設定を開いて「デーモンを再起動」を使うか、コンソールで詳細を確認してください。",
+    "loading_stall_title": "予想より時間がかかっています",
     "loading_transactions": "トランザクションを読み込み中",
     "local_hashrate": "ローカルハッシュレート",
     "low_spec_mode": "省電力モード",
@@ -953,6 +962,11 @@
     "no_transactions": "取引が見つかりません",
     "no_transactions_yet": "まだ取引がありません",
     "node": "ノード",
+    "node_banner_crashed_title": "ノードが予期せず停止しました",
+    "node_banner_lite_open_failed": "ウォレットを開けませんでした",
+    "node_banner_offline_title": "DragonX ノードに接続されていません",
+    "node_banner_reconnect": "再接続",
+    "node_banner_restart": "ノードを再起動",
     "node_security": "ノードとセキュリティ",
     "noise": "ノイズ",
     "not_connected": "デーモンに未接続...",
@@ -1285,12 +1299,14 @@
     "settings_configure_explorer": "外部ブロックエクスプローラーリンクを設定",
     "settings_configure_rpc": "dragonxd デーモンへの接続を設定",
     "settings_connection": "接続",
+    "settings_copy_diagnostics": "診断情報をコピー",
     "settings_copyright": "Copyright 2024-2026 DragonX 開発者  |  GPLv3 ライセンス",
     "settings_custom": "カスタム",
     "settings_data_dir": "データディレクトリ：",
     "settings_debug_changed": "デバッグカテゴリが変更されました — デーモンを再起動して適用",
     "settings_debug_restart_note": "変更はデーモンの再起動後に有効になります。",
     "settings_debug_select": "デーモンのデバッグログを有効にするカテゴリを選択（-debug= フラグ）。",
+    "settings_diagnostics_copied": "診断情報をクリップボードにコピーしました",
     "settings_encrypt_first_pin": "PIN を有効にするには、まずウォレットを暗号化してください",
     "settings_encrypt_wallet": "ウォレットを暗号化",
     "settings_explorer_hint": "URLには末尾のスラッシュを含めてください。txid/アドレスが追加されます。",
@@ -1311,6 +1327,7 @@
     "settings_not_found": "見つかりません",
     "settings_open_app_dir": "アプリフォルダを開く",
     "settings_open_data_dir": "データフォルダを開く",
+    "settings_open_log_folder": "ログフォルダを開く",
     "settings_other": "その他",
     "settings_pin_active": "PIN",
     "settings_privacy": "プライバシー",
@@ -1470,6 +1487,7 @@
     "tt_chat_timestamp": "このタブのみのタイムスタンプ形式：アプリ全体の時計に従うか、24-hourまたは12-hourを強制します",
     "tt_clear_ztx": "ローカルにキャッシュされた z-トランザクション履歴を削除",
     "tt_clock_format": "24時間または12時間表示（アプリ全体）。チャットで上書きできます。",
+    "tt_copy_diagnostics": "サポート用の概要(バージョン、デーモン/ウォレット/ログの状態 — 秘密情報なし)をクリップボードにコピーします",
     "tt_custom_fees": "トランザクション送信時に手動手数料入力を有効化",
     "tt_custom_theme": "カスタムテーマがアクティブ",
     "tt_daemon_install_bundled": "ノードを停止し、インストール済みの dragonxd をこのウォレットビルドにバンドルされたバージョンで上書きしてから再起動します",
@@ -1523,6 +1541,7 @@
     "tt_open_app_dir": "ObsidianDragon フォルダ（設定、テーマ、ログ）をファイルマネージャーで開く",
     "tt_open_data_dir": "ファイルマネージャーでウォレットとブロックチェーンデータのフォルダを開きます",
     "tt_open_dir": "クリックしてファイルエクスプローラーで開く",
+    "tt_open_log_folder": "デバッグログとクラッシュログが入ったフォルダを開きます",
     "tt_reduce_motion": "アクセシビリティのためにアニメーション遷移と残高補間を無効にする",
     "tt_remove_encrypt": "暗号化を解除してウォレットを保護なしで保存",
     "tt_remove_pin": "PIN を削除しアンロックにパスフレーズを要求",

res/lang/ko.json

@@ -48,6 +48,10 @@
     "advanced": "고급 설정",
     "advanced_effects": "고급 효과...",
     "ago": "전",
+    "alerts_clear": "알림 기록 지우기",
+    "alerts_history_tooltip": "최근 알림",
+    "alerts_none": "아직 알림이 없습니다",
+    "alerts_recent": "최근 알림",
     "all_filter": "전체",
     "allow_custom_fees": "사용자 정의 수수료 허용",
     "amount": "금액",
@@ -451,6 +455,8 @@
     "daemon_update_version": "버전:",
     "daemon_version": "데몬",
     "dark": "다크",
+    "data_stale_prefix": "업데이트",
+    "data_stale_tooltip": "잔액이 오래되었을 수 있습니다 — 지갑이 최근에 업데이트를 받지 못했습니다. 노드 연결을 확인하세요.",
     "date": "날짜",
     "date_label": "날짜:",
     "debug_logging": "디버그 로깅",
@@ -734,6 +740,8 @@
     "lite_working": "작업 중…",
     "loading": "로딩 중...",
     "loading_addresses": "주소 로딩 중...",
+    "loading_stall_body": "데몬이 %.0f초 동안 초기화 중입니다. 업데이트 후나 첫 실행 시(블록 인덱스 로드 또는 재스캔)에는 정상일 수 있습니다. 준비되면 자동으로 연결됩니다.",
+    "loading_stall_title": "예상보다 오래 걸리고 있습니다",
     "loading_transactions": "거래를 불러오는 중",
     "local_hashrate": "로컬 해시레이트",
     "low_spec_mode": "저사양 모드",
@@ -953,6 +961,11 @@
     "no_transactions": "거래 내역이 없습니다",
     "no_transactions_yet": "아직 거래 내역이 없습니다",
     "node": "노드",
+    "node_banner_crashed_title": "노드가 예기치 않게 중지되었습니다",
+    "node_banner_lite_open_failed": "지갑을 열 수 없습니다",
+    "node_banner_offline_title": "DragonX 노드에 연결되지 않음",
+    "node_banner_reconnect": "재연결",
+    "node_banner_restart": "노드 재시작",
     "node_security": "노드 및 보안",
     "noise": "노이즈",
     "not_connected": "데몬에 연결되지 않음...",
@@ -1154,6 +1167,8 @@
     "sb_connecting_external": "외부 데몬에 연결 중...",
     "sb_connecting_generic": "데몬에 연결 중...",
     "sb_daemon_crashed": "데몬이 %d회 충돌함",
+    "sb_daemon_extract_failed": "데몬 파일을 쓰지 못했습니다. 디스크 여유 공간과 권한을 확인하세요.",
+    "sb_daemon_files_failed": "%s에 데몬 파일을 쓰지 못했습니다. 디스크 여유 공간과 권한을 확인하세요.",
     "sb_daemon_not_found": "데몬을 찾을 수 없음",
     "sb_daemon_start_failed": "dragonxd를 시작할 수 없습니다",
     "sb_dragonxd_running": "dragonxd 실행 중",
@@ -1169,6 +1184,7 @@
     "sb_net_mhs": "네트: %.2f MH/s",
     "sb_no_conf": "DRAGONX.conf를 찾을 수 없음",
     "sb_peers": "피어: %zu",
+    "sb_plaintext_remote_blocked": "원격 호스트로 RPC 자격 증명을 평문으로 보내는 것을 거부했습니다. 허용하려면 DRAGONX.conf에 rpcallowplaintext=1을 추가하거나 rpctls=1로 TLS를 활성화하세요.",
     "sb_rescanning": "재스캔",
     "sb_rescanning_pct": "재스캔 %.0f%%",
     "sb_restarting_daemon": "데몬 재시작 중...",
@@ -1285,12 +1301,14 @@
     "settings_configure_explorer": "외부 블록 탐색기 링크 구성",
     "settings_configure_rpc": "dragonxd 데몬 연결 구성",
     "settings_connection": "연결",
+    "settings_copy_diagnostics": "진단 정보 복사",
     "settings_copyright": "Copyright 2024-2026 DragonX 개발자  |  GPLv3 라이선스",
     "settings_custom": "사용자 지정",
     "settings_data_dir": "데이터 디렉터리:",
     "settings_debug_changed": "디버그 카테고리가 변경되었습니다 — 데몬을 재시작하여 적용",
     "settings_debug_restart_note": "변경 사항은 데몬을 다시 시작한 후에 적용됩니다.",
     "settings_debug_select": "데몬 디버그 로깅을 활성화할 카테고리를 선택하세요 (-debug= 플래그).",
+    "settings_diagnostics_copied": "진단 정보를 클립보드에 복사했습니다",
     "settings_encrypt_first_pin": "PIN을 활성화하려면 먼저 지갑을 암호화하세요",
     "settings_encrypt_wallet": "지갑 암호화",
     "settings_explorer_hint": "URL에 후행 슬래시를 포함해야 합니다. txid/주소가 추가됩니다.",
@@ -1311,6 +1329,7 @@
     "settings_not_found": "찾을 수 없음",
     "settings_open_app_dir": "앱 폴더 열기",
     "settings_open_data_dir": "데이터 폴더 열기",
+    "settings_open_log_folder": "로그 폴더 열기",
     "settings_other": "기타",
     "settings_pin_active": "PIN",
     "settings_privacy": "개인 정보",
@@ -1470,6 +1489,7 @@
     "tt_chat_timestamp": "이 탭에만 적용되는 타임스탬프 형식: 앱 전체 시계를 따르거나 24-hour 또는 12-hour로 강제합니다",
     "tt_clear_ztx": "로컬에 캐시된 z-트랜잭션 기록 삭제",
     "tt_clock_format": "24시간 또는 12시간 형식(앱 전체). 채팅에서 재정의할 수 있습니다.",
+    "tt_copy_diagnostics": "지원용 요약(버전, 데몬/지갑/로그 상태 — 비밀 정보 없음)을 클립보드에 복사합니다",
     "tt_custom_fees": "거래 전송 시 수동 수수료 입력 활성화",
     "tt_custom_theme": "사용자 지정 테마 활성화됨",
     "tt_daemon_install_bundled": "노드를 중지하고 설치된 dragonxd를 이 지갑 빌드에 번들된 버전으로 덮어쓴 다음 재시작합니다",
@@ -1523,6 +1543,7 @@
     "tt_open_app_dir": "파일 관리자에서 ObsidianDragon 폴더(설정, 테마, 로그)를 엽니다",
     "tt_open_data_dir": "지갑 및 블록체인 데이터가 있는 폴더를 파일 탐색기에서 엽니다",
     "tt_open_dir": "파일 탐색기에서 열려면 클릭",
+    "tt_open_log_folder": "디버그 및 충돌 로그가 있는 폴더를 엽니다",
     "tt_reduce_motion": "접근성을 위해 애니메이션 전환 및 잔액 보간 비활성화",
     "tt_remove_encrypt": "암호화를 제거하고 지갑을 보호 없이 저장",
     "tt_remove_pin": "PIN을 제거하고 잠금 해제 시 비밀번호 요구",

res/lang/pt.json

@@ -48,6 +48,10 @@
     "advanced": "AVANÇADO",
     "advanced_effects": "Efeitos Avançados...",
     "ago": "atrás",
+    "alerts_clear": "Limpar histórico de alertas",
+    "alerts_history_tooltip": "Alertas recentes",
+    "alerts_none": "Ainda não há alertas",
+    "alerts_recent": "ALERTAS RECENTES",
     "all_filter": "Todos",
     "allow_custom_fees": "Permitir taxas personalizadas",
     "amount": "Valor",
@@ -451,6 +455,8 @@
     "daemon_update_version": "Versão:",
     "daemon_version": "Daemon",
     "dark": "Escuro",
+    "data_stale_prefix": "Atualizado",
+    "data_stale_tooltip": "O saldo pode estar desatualizado — a carteira não recebeu uma atualização recente. Verifique a conexão com o seu nó.",
     "date": "Data",
     "date_label": "Data:",
     "debug_logging": "REGISTRO DE DEPURAÇÃO",
@@ -734,6 +740,9 @@
     "lite_working": "Processando…",
     "loading": "Carregando...",
     "loading_addresses": "Carregando endereços...",
+    "loading_stall_body": "O daemon está inicializando há %.0f s. Isso pode ser normal após uma atualização ou no primeiro início (carregando o índice de blocos ou reescaneando) — ele se conectará automaticamente quando estiver pronto.",
+    "loading_stall_hint": "Ainda travado? Abra as Configurações e use Reiniciar daemon, ou verifique o Console para mais detalhes.",
+    "loading_stall_title": "Está demorando mais do que o esperado",
     "loading_transactions": "Carregando transações",
     "local_hashrate": "Hashrate Local",
     "low_spec_mode": "Modo econômico",
@@ -953,6 +962,11 @@
     "no_transactions": "Nenhuma transação encontrada",
     "no_transactions_yet": "Nenhuma transação ainda",
     "node": "NÓ",
+    "node_banner_crashed_title": "O nó parou inesperadamente",
+    "node_banner_lite_open_failed": "Não foi possível abrir sua carteira",
+    "node_banner_offline_title": "Não conectado ao nó DragonX",
+    "node_banner_reconnect": "Reconectar",
+    "node_banner_restart": "Reiniciar nó",
     "node_security": "NÓ & SEGURANÇA",
     "noise": "Ruído",
     "not_connected": "Não conectado ao daemon...",
@@ -1154,6 +1168,8 @@
     "sb_connecting_external": "Conectando ao daemon externo...",
     "sb_connecting_generic": "Conectando ao daemon...",
     "sb_daemon_crashed": "O daemon travou %d vezes",
+    "sb_daemon_extract_failed": "Falha ao gravar os arquivos do daemon — verifique o espaço livre em disco e as permissões.",
+    "sb_daemon_files_failed": "Falha ao gravar os arquivos do daemon em %s — verifique o espaço livre em disco e as permissões.",
     "sb_daemon_not_found": "Daemon não encontrado",
     "sb_daemon_start_failed": "Não foi possível iniciar o dragonxd",
     "sb_dragonxd_running": "dragonxd em execução",
@@ -1169,6 +1185,7 @@
     "sb_net_mhs": "Rede: %.2f MH/s",
     "sb_no_conf": "DRAGONX.conf não encontrado",
     "sb_peers": "Pares: %zu",
+    "sb_plaintext_remote_blocked": "Recusando enviar credenciais RPC em texto simples para um host remoto. Adicione rpcallowplaintext=1 ao DRAGONX.conf para permitir, ou habilite TLS com rpctls=1.",
     "sb_rescanning": "Reescaneando",
     "sb_rescanning_pct": "Reescaneando %.0f%%",
     "sb_restarting_daemon": "Reiniciando daemon...",
@@ -1285,12 +1302,14 @@
     "settings_configure_explorer": "Configurar links do explorador de blocos externo",
     "settings_configure_rpc": "Configurar conexão ao daemon dragonxd",
     "settings_connection": "Conexão",
+    "settings_copy_diagnostics": "Copiar diagnósticos",
     "settings_copyright": "Copyright 2024-2026 Desenvolvedores DragonX  |  Licença GPLv3",
     "settings_custom": "Personalizado",
     "settings_data_dir": "Dir. de dados:",
     "settings_debug_changed": "Categorias de depuração alteradas — reinicie o daemon para aplicar",
     "settings_debug_restart_note": "As alterações entram em vigor após reiniciar o daemon.",
     "settings_debug_select": "Selecione categorias para ativar o registro de depuração do daemon (flags -debug=).",
+    "settings_diagnostics_copied": "Diagnósticos copiados para a área de transferência",
     "settings_encrypt_first_pin": "Encripte a carteira primeiro para ativar o PIN",
     "settings_encrypt_wallet": "Encriptar carteira",
     "settings_explorer_hint": "As URLs devem incluir uma barra final. O txid/endereço será adicionado.",
@@ -1311,6 +1330,7 @@
     "settings_not_found": "Não encontrado",
     "settings_open_app_dir": "Abrir pasta do aplicativo",
     "settings_open_data_dir": "Abrir pasta de dados",
+    "settings_open_log_folder": "Abrir pasta de logs",
     "settings_other": "Outros",
     "settings_pin_active": "PIN",
     "settings_privacy": "Privacidade",
@@ -1470,6 +1490,7 @@
     "tt_chat_timestamp": "Formato de horário apenas para esta aba: seguir o relógio geral do aplicativo, ou forçar 24-hour ou 12-hour",
     "tt_clear_ztx": "Excluir histórico de z-transações em cache local",
     "tt_clock_format": "Relógio de 24 ou 12 horas, em todo o app. O chat pode substituí-lo.",
+    "tt_copy_diagnostics": "Copia um resumo para suporte (versão, estado do daemon/carteira/logs — sem segredos) para a área de transferência",
     "tt_custom_fees": "Ativar entrada manual de taxas ao enviar transações",
     "tt_custom_theme": "Tema personalizado ativo",
     "tt_daemon_install_bundled": "Parar o nó, sobrescrever o dragonxd instalado com a versão incluída nesta compilação da carteira e reiniciar",
@@ -1523,6 +1544,7 @@
     "tt_open_app_dir": "Abrir a pasta ObsidianDragon (configurações, temas, logs) no gerenciador de arquivos",
     "tt_open_data_dir": "Abrir a pasta com os dados da sua carteira e da blockchain no gerenciador de arquivos",
     "tt_open_dir": "Clique para abrir no explorador de arquivos",
+    "tt_open_log_folder": "Abre a pasta que contém os logs de depuração e de falhas",
     "tt_reduce_motion": "Desativar transições animadas e lerp de saldo para acessibilidade",
     "tt_remove_encrypt": "Remover encriptação e armazenar a carteira desprotegida",
     "tt_remove_pin": "Remover PIN e exigir frase secreta para desbloquear",

res/lang/ru.json

@@ -48,6 +48,10 @@
     "advanced": "ПРОЧЕЕ",
     "advanced_effects": "Расширенные эффекты...",
     "ago": "назад",
+    "alerts_clear": "Очистить историю оповещений",
+    "alerts_history_tooltip": "Недавние оповещения",
+    "alerts_none": "Пока нет оповещений",
+    "alerts_recent": "НЕДАВНИЕ ОПОВЕЩЕНИЯ",
     "all_filter": "Все",
     "allow_custom_fees": "Разрешить пользовательские комиссии",
     "amount": "Сумма",
@@ -451,6 +455,8 @@
     "daemon_update_version": "Версия:",
     "daemon_version": "Демон",
     "dark": "Тёмная",
+    "data_stale_prefix": "Обновлено",
+    "data_stale_tooltip": "Баланс может быть устаревшим — кошелёк давно не получал обновлений. Проверьте подключение к узлу.",
     "date": "Дата",
     "date_label": "Дата:",
     "debug_logging": "ЖУРНАЛ ОТЛАДКИ",
@@ -734,6 +740,9 @@
     "lite_working": "Обработка…",
     "loading": "Загрузка...",
     "loading_addresses": "Загрузка адресов...",
+    "loading_stall_body": "Демон инициализируется уже %.0f с. Это может быть нормально после обновления или при первом запуске (загрузка индекса блоков или повторное сканирование) — соединение установится автоматически, когда он будет готов.",
+    "loading_stall_hint": "Всё ещё не отвечает? Откройте Настройки и нажмите «Перезапустить демон» или посмотрите подробности в Консоли.",
+    "loading_stall_title": "Занимает больше времени, чем ожидалось",
     "loading_transactions": "Загрузка транзакций",
     "local_hashrate": "Локальный хешрейт",
     "low_spec_mode": "Режим экономии",
@@ -953,6 +962,11 @@
     "no_transactions": "Транзакции не найдены",
     "no_transactions_yet": "Транзакций пока нет",
     "node": "УЗЕЛ",
+    "node_banner_crashed_title": "Узел неожиданно остановился",
+    "node_banner_lite_open_failed": "Не удалось открыть кошелёк",
+    "node_banner_offline_title": "Нет подключения к узлу DragonX",
+    "node_banner_reconnect": "Переподключить",
+    "node_banner_restart": "Перезапустить узел",
     "node_security": "УЗЕЛ И БЕЗОПАСНОСТЬ",
     "noise": "Шум",
     "not_connected": "Не подключено к daemon...",
@@ -1154,6 +1168,8 @@
     "sb_connecting_external": "Подключение к внешнему демону...",
     "sb_connecting_generic": "Подключение к демону...",
     "sb_daemon_crashed": "Демон упал %d раз",
+    "sb_daemon_extract_failed": "Не удалось записать файлы демона — проверьте свободное место на диске и права доступа.",
+    "sb_daemon_files_failed": "Не удалось записать файлы демона в %s — проверьте свободное место на диске и права доступа.",
     "sb_daemon_not_found": "Демон не найден",
     "sb_daemon_start_failed": "Не удалось запустить dragonxd",
     "sb_dragonxd_running": "dragonxd запущен",
@@ -1169,6 +1185,7 @@
     "sb_net_mhs": "Сеть: %.2f MH/s",
     "sb_no_conf": "DRAGONX.conf не найден",
     "sb_peers": "Пиры: %zu",
+    "sb_plaintext_remote_blocked": "Отправка учётных данных RPC открытым текстом на удалённый узел запрещена. Добавьте rpcallowplaintext=1 в DRAGONX.conf, чтобы разрешить, или включите TLS с помощью rpctls=1.",
     "sb_rescanning": "Пересканирование",
     "sb_rescanning_pct": "Пересканирование %.0f%%",
     "sb_restarting_daemon": "Перезапуск демона...",
@@ -1285,12 +1302,14 @@
     "settings_configure_explorer": "Настроить ссылки внешнего обозревателя блоков",
     "settings_configure_rpc": "Настроить подключение к демону dragonxd",
     "settings_connection": "Подключение",
+    "settings_copy_diagnostics": "Копировать диагностику",
     "settings_copyright": "Copyright 2024-2026 Разработчики DragonX  |  Лицензия GPLv3",
     "settings_custom": "Пользовательские",
     "settings_data_dir": "Каталог данных:",
     "settings_debug_changed": "Категории отладки изменены — перезапустите демон для применения",
     "settings_debug_restart_note": "Изменения вступают в силу после перезапуска демона.",
     "settings_debug_select": "Выберите категории для включения журнала отладки демона (флаги -debug=).",
+    "settings_diagnostics_copied": "Диагностика скопирована в буфер обмена",
     "settings_encrypt_first_pin": "Сначала зашифруйте кошелёк, чтобы включить PIN",
     "settings_encrypt_wallet": "Зашифровать кошелёк",
     "settings_explorer_hint": "URL-адреса должны заканчиваться косой чертой. Txid/адрес будет добавлен.",
@@ -1311,6 +1330,7 @@
     "settings_not_found": "Не найден",
     "settings_open_app_dir": "Открыть папку приложения",
     "settings_open_data_dir": "Открыть папку данных",
+    "settings_open_log_folder": "Открыть папку журналов",
     "settings_other": "Прочее",
     "settings_pin_active": "PIN",
     "settings_privacy": "Конфиденциальность",
@@ -1470,6 +1490,7 @@
     "tt_chat_timestamp": "Формат времени только для этой вкладки: следовать общим настройкам часов приложения либо принудительно 24-hour или 12-hour",
     "tt_clear_ztx": "Удалить локально кешированную историю z-транзакций",
     "tt_clock_format": "24- или 12-часовой формат для всего приложения. Чат может переопределить.",
+    "tt_copy_diagnostics": "Копирует сводку для поддержки (версия, состояние демона/кошелька/журналов — без секретов) в буфер обмена",
     "tt_custom_fees": "Включить ручной ввод комиссий при отправке транзакций",
     "tt_custom_theme": "Пользовательская тема активна",
     "tt_daemon_install_bundled": "Остановить узел, перезаписать установленный dragonxd версией, встроенной в эту сборку кошелька, затем перезапустить",
@@ -1523,6 +1544,7 @@
     "tt_open_app_dir": "Открыть папку ObsidianDragon (настройки, темы, логи) в файловом менеджере",
     "tt_open_data_dir": "Открыть в файловом менеджере папку с данными кошелька и блокчейна",
     "tt_open_dir": "Нажмите, чтобы открыть в проводнике",
+    "tt_open_log_folder": "Открывает папку с журналами отладки и сбоев",
     "tt_reduce_motion": "Отключить анимированные переходы и плавное изменение баланса для доступности",
     "tt_remove_encrypt": "Удалить шифрование и хранить кошелёк без защиты",
     "tt_remove_pin": "Удалить PIN и требовать пароль для разблокировки",

res/lang/zh.json

@@ -48,6 +48,10 @@
     "advanced": "高级",
     "advanced_effects": "高级特效...",
     "ago": "前",
+    "alerts_clear": "清除通知历史",
+    "alerts_history_tooltip": "最近通知",
+    "alerts_none": "暂无通知",
+    "alerts_recent": "最近通知",
     "all_filter": "全部",
     "allow_custom_fees": "允许自定义手续费",
     "amount": "金额",
@@ -451,6 +455,8 @@
     "daemon_update_version": "版本：",
     "daemon_version": "守护进程",
     "dark": "深色",
+    "data_stale_prefix": "更新于",
+    "data_stale_tooltip": "余额可能已过时 — 钱包最近未收到更新。请检查您的节点连接。",
     "date": "日期",
     "date_label": "日期：",
     "debug_logging": "调试日志",
@@ -734,6 +740,8 @@
     "lite_working": "处理中…",
     "loading": "加载中...",
     "loading_addresses": "正在加载地址...",
+    "loading_stall_body": "守护进程已初始化 %.0f 秒。更新后或首次启动时（加载区块索引或重新扫描）这可能是正常现象——就绪后会自动连接。",
+    "loading_stall_title": "耗时超出预期",
     "loading_transactions": "正在加载交易",
     "local_hashrate": "本地算力",
     "low_spec_mode": "低配模式",
@@ -953,6 +961,11 @@
     "no_transactions": "未找到交易",
     "no_transactions_yet": "尚无交易",
     "node": "节点",
+    "node_banner_crashed_title": "节点意外停止",
+    "node_banner_lite_open_failed": "无法打开您的钱包",
+    "node_banner_offline_title": "未连接到 DragonX 节点",
+    "node_banner_reconnect": "重新连接",
+    "node_banner_restart": "重启节点",
     "node_security": "节点与安全",
     "noise": "噪点",
     "not_connected": "未连接到守护进程...",
@@ -1154,6 +1167,8 @@
     "sb_connecting_external": "正在连接外部守护进程...",
     "sb_connecting_generic": "正在连接守护进程...",
     "sb_daemon_crashed": "守护进程崩溃 %d 次",
+    "sb_daemon_extract_failed": "无法写入守护进程文件——请检查磁盘剩余空间和权限。",
+    "sb_daemon_files_failed": "无法将守护进程文件写入 %s——请检查磁盘剩余空间和权限。",
     "sb_daemon_not_found": "未找到守护进程",
     "sb_daemon_start_failed": "无法启动 dragonxd",
     "sb_dragonxd_running": "dragonxd 运行中",
@@ -1285,12 +1300,14 @@
     "settings_configure_explorer": "配置外部区块浏览器链接",
     "settings_configure_rpc": "配置 dragonxd 守护进程连接",
     "settings_connection": "连接",
+    "settings_copy_diagnostics": "复制诊断信息",
     "settings_copyright": "版权所有 2024-2026 DragonX 开发者  |  GPLv3 许可证",
     "settings_custom": "自定义",
     "settings_data_dir": "数据目录：",
     "settings_debug_changed": "调试类别已更改——重启守护进程以应用",
     "settings_debug_restart_note": "更改将在重启守护进程后生效。",
     "settings_debug_select": "选择要启用的守护进程调试日志类别（-debug= 标志）。",
+    "settings_diagnostics_copied": "诊断信息已复制到剪贴板",
     "settings_encrypt_first_pin": "请先加密钱包以启用 PIN",
     "settings_encrypt_wallet": "加密钱包",
     "settings_explorer_hint": "URL 应包含尾部斜杠。将自动附加 txid/地址。",
@@ -1311,6 +1328,7 @@
     "settings_not_found": "未找到",
     "settings_open_app_dir": "打开应用文件夹",
     "settings_open_data_dir": "打开数据文件夹",
+    "settings_open_log_folder": "打开日志文件夹",
     "settings_other": "其他",
     "settings_pin_active": "PIN",
     "settings_privacy": "隐私",
@@ -1470,6 +1488,7 @@
     "tt_chat_timestamp": "仅此标签页的时间戳格式：跟随全应用时钟，或强制使用 24-hour 或 12-hour",
     "tt_clear_ztx": "删除本地缓存的 z-交易历史",
     "tt_clock_format": "24 或 12 小时制，应用全局。聊天可覆盖。",
+    "tt_copy_diagnostics": "将支持诊断摘要(版本、守护进程/钱包/日志状态 — 不含机密)复制到剪贴板",
     "tt_custom_fees": "发送交易时启用手动费用输入",
     "tt_custom_theme": "自定义主题已激活",
     "tt_daemon_install_bundled": "停止节点，用此钱包版本内置的 dragonxd 覆盖已安装的版本，然后重启",
@@ -1523,6 +1542,7 @@
     "tt_open_app_dir": "在文件管理器中打开 ObsidianDragon 文件夹（设置、主题、日志）",
     "tt_open_data_dir": "在文件管理器中打开包含您钱包和区块链数据的文件夹",
     "tt_open_dir": "点击在文件管理器中打开",
+    "tt_open_log_folder": "打开包含调试和崩溃日志的文件夹",
     "tt_reduce_motion": "禁用动画过渡和余额渐变以提高无障碍性",
     "tt_remove_encrypt": "移除加密并以未受保护状态存储钱包",
     "tt_remove_pin": "移除 PIN 并要求密码解锁",

res/themes/ui.toml

@@ -700,6 +700,12 @@ status-pill-bg-alpha = { size = 30 }
 status-pill-y-offset = { size = 1 }
 confirmed-threshold = { size = 10 }
 
+# Persistent node/RPC error strip at the top of the content column (see App::renderNodeStatusBanner).
+# Slightly taller than the per-tab sync banner so it comfortably holds the Reconnect/Restart action.
+[banners.node-status]
+min-height = { size = 26.0 }
+height = { size = 30.0 }
+
 [tabs.transactions]
 search-max-width = 300.0
 search-width-ratio = 0.3
@@ -1503,6 +1509,7 @@ progress-bar      = { height = 6.0, radius = 3.0 }
 progress-width    = { size = 260.0 }
 backdrop-alpha    = { opacity = 0.80 }
 vertical-gap      = { size = 8.0 }
+stall-timeout-sec = { size = 45.0 }
 
 # ---------------------------------------------------------------------------
 # First-Run Wizard Screens

src/app.h

@@ -147,6 +147,10 @@ public:
     bool isLiteBuild() const { return wallet::isLiteBuild(walletCapabilities()); }
     bool supportsEmbeddedDaemon() const { return wallet::supportsEmbeddedDaemon(walletCapabilities()); }
     bool supportsFullNodeLifecycleActions() const { return wallet::supportsFullNodeLifecycleActions(walletCapabilities()); }
+
+    // W7 QoL: a plaintext support-diagnostics snapshot (version, variant, daemon/RPC/wallet/log state)
+    // for the "Copy diagnostics" action. Contains no secrets.
+    std::string buildDiagnosticsReport();
     bool supportsSoloMining() const { return wallet::supportsSoloMining(walletCapabilities()); }
     bool supportsPoolMining() const { return wallet::supportsPoolMining(walletCapabilities()); }
     bool supportsLiteBackend() const { return wallet::supportsLiteBackend(walletCapabilities()); }
@@ -800,6 +804,10 @@ private:
     void pumpSeedMigration();      // main thread: pick up background progress/result each frame
     // Phase 2: sweep all legacy funds into the new wallet, then adopt it as the primary wallet.
     void refreshSeedMigrationBalance();  // query the legacy total (shown on the Sweep step)
+    // W3-3: the terminal callback for the sweep opid, shared by the initial submit and a resume
+    // re-track. `resumed` selects the failure behaviour: a fresh sweep that fails -> Error; a resumed
+    // opid the daemon no longer knows (stale) -> back to the dismissable Sweep gate (re-check balance).
+    std::function<void(bool, const std::string&)> makeSweepCompletionCallback(bool resumed);
     void beginSweepToSeedWallet();       // z_mergetoaddress ["ANY_TADDR","ANY_ZADDR"] -> dest
     void pollSweepStatus();              // Confirming step: poll sweep confirmations + legacy balance
     void beginAdoptSeedWallet();         // stop daemon -> swap wallet.dat -> restart with -rescan
@@ -887,6 +895,37 @@ private:
     // sets these and defers to renderSwitchStopDaemonDialog; confirming re-calls switchToWallet(w, true).
     bool show_switch_stop_daemon_confirm_ = false;
     std::string pending_switch_wallet_file_;
+    // Block-database recovery: set when the embedded node aborts because its block DB is unreadable
+    // (a daemon-vs-chaindata format mismatch after an update, or a corrupt index). While set, the
+    // connect loop STOPS crash-restarting into the same abort and offers a one-click reindex instead.
+    bool block_db_reindex_available_ = false;   // node needs its block DB rebuilt (gates restart loop)
+    bool show_block_db_reindex_confirm_ = false; // auto-shown offer dialog
+    // Wallet auto-recovery: the daemon moved wallet.dat to wallet.<ts>.bak and loaded a salvaged copy
+    // (BDB-verify failure — often a false positive from stale/cross-platform env state). We warn loudly
+    // so a possibly-incomplete salvaged wallet isn't mistaken for fund loss. Warned once per session.
+    bool wallet_auto_recovered_ = false;         // a salvage happened this session
+    bool wallet_auto_recovered_warned_ = false;  // guard: only surface it once per session
+    bool show_wallet_recovered_dialog_ = false;  // auto-shown warning dialog
+    // The recovery dialog is the ONE authoritative surface: it stays open through the async rebuild/
+    // restore, driven Offer → Working → Done/Failed (pumpWalletRestore sets the outcome). Presentation
+    // only — the fund-safety file ops in rebuildWalletDatabase()/restoreOriginalWallet() are unchanged.
+    enum class RecoveryPhase { Offer, Working, Done, Failed };
+    RecoveryPhase recovery_phase_ = RecoveryPhase::Offer;
+    int         recovery_outcome_sev_ = 0;               // 0 ok / 1 warn / 2 error, set at Done/Failed
+    std::string recovery_outcome_msg_;                   // honest result string for the Done/Failed body
+    bool        recovery_last_action_rebuild_ = false;   // which handler ran (for "try the other option")
+    // After a successful repair the daemon restarts with a full rescan — minutes long, and it won't
+    // answer RPC yet. This makes the loading overlay show a calm "finishing your wallet repair" screen
+    // (instead of the generic "daemon stuck / RPC timeout / restart daemon" text) and suppresses the
+    // daemon-crash toast. Set on repair success; cleared on connect (onConnected).
+    bool        post_recovery_rescan_ = false;
+    double      post_recovery_rescan_since_ = 0.0;       // stamped on first overlay frame (ImGui::GetTime)
+    // "Restore original wallet" background op: worker sets these under the mutex, pumpWalletRestore()
+    // (main thread) shows the result. 0 = success, 1 = warning, 2 = error.
+    std::mutex wallet_restore_mutex_;
+    bool wallet_restore_done_ = false;
+    int  wallet_restore_severity_ = 0;
+    std::string wallet_restore_msg_;
     // Live progress for the switch modal: it stays open from confirm through stop → wait-for-exit → start →
     // reconnect and auto-closes when the new node connects (onConnected). Phase is worker-updated;
     // dialog_open_ gates rendering — both atomic since onConnected/the worker may run off the main thread.
@@ -1023,6 +1062,10 @@ private:
     std::uint64_t clipboard_secret_hash_ = 0;
     double clipboard_clear_deadline_ = 0.0;
     float loading_timer_ = 0.0f;  // spinner animation for loading overlay
+    double connect_stall_since_ = 0.0;  // ImGui::GetTime() when the daemon first went "reachable but not ready"; 0 = not stalling (see util/connect_stall.h)
+    bool encryption_incomplete_warned_ = false;  // W2-2: once-per-session guard for the "encryption didn't complete" warning
+    bool lock_failure_warned_ = false;           // W2-4: guard so a repeatedly-failing auto-lock warns once, not every retry
+    std::uint64_t alerts_seen_total_ = 0;        // Notifications::totalPushed() at last alert-panel open; drives the bell's unread dot
 
     // Current page (sidebar navigation)
     ui::NavPage current_page_ = ui::NavPage::Overview;
@@ -1288,6 +1331,13 @@ private:
 
     // Private methods - rendering
     void renderStatusBar();
+    // Persistent node/RPC error strip at the top of the content column when the wallet can't
+    // reach its node (or the embedded daemon gave up crashing). Decision logic is the pure
+    // evaluateNodeStatusBanner() in ui/node_status_banner.h; this draws it and wires the action.
+    void renderNodeStatusBanner();
+    // Body of the status-bar alert-history popup: recent alerts (incl. ones whose toast faded),
+    // newest first, with severity icon + relative age + a Clear action. See src/ui/notifications.h.
+    void renderAlertHistoryPanel();
     void renderLiteFirstRunPrompt();  // lite-only welcome modal when no wallet exists yet
     void renderLiteUnlockPrompt();    // lite-only send-time unlock modal
     void renderImportKeyDialog();
@@ -1305,6 +1355,14 @@ private:
     void renderPinDialogs();
     void renderAntivirusHelpDialog();
     void renderSwitchStopDaemonDialog();  // confirm before stopping an adopted node to switch wallets
+    void renderBlockDbReindexDialog();    // offer to rebuild an unreadable block database (-reindex)
+    void reindexBlockDatabase();          // restart the daemon with -reindex to rebuild the block DB
+    void renderWalletRecoveredDialog();   // warn that the node auto-recovered/salvaged wallet.dat
+    void detectWalletAutoRecovery();      // scan daemon output for a salvage; fire the warning once/session
+    void restoreOriginalWallet();         // swap the wallet.<ts>.bak back over the salvaged copy + restart
+    void pumpWalletRestore();             // main-thread: surface the restore/rebuild op's result
+    void rebuildWalletDatabase();         // rebuild a BDB-inconsistent wallet into a loadable one (helper)
+    bool walletRebuildAvailable() const;  // the dragonx-wallet-rebuild helper is present
     void processDeferredEncryption();
 
     // Private methods - connection

src/app_network.cpp

@@ -35,6 +35,7 @@
 #include "rpc/connection.h"
 #include "chat/chat_identity.h"  // deriveChatIdentityFromSecret for HushChat identity provisioning
 #include "ui/windows/chat_tab.h"  // ui::ResetChatTab — wipe chat UI plaintext on a wallet switch
+#include "ui/windows/mining_pool_panel.h"  // ui::resolveMiningUserAddress
 #include <sodium.h>              // sodium_memzero for wiping the fetched mnemonic
 #include <cctype>
 #include "config/settings.h"
@@ -43,6 +44,7 @@
 #include "wallet/lite_diagnostics.h"        // liteLog — chat note-buffer coordinator diagnostics
 #include "config/version.h"
 #include "daemon/daemon_controller.h"
+#include "daemon/daemon_startup_diagnosis.h"
 #include "daemon/embedded_daemon.h"
 #include "daemon/seed_wallet_creator.h"
 #include "daemon/xmrig_manager.h"
@@ -54,7 +56,11 @@
 #include "util/http_download.h"
 #include "data/exchange_info.h"
 #include "data/exchange_candles.h"
+#include "data/seed_migration_resume.h"
 #include "util/platform.h"
+#include "util/wallet_file_probe.h"   // verify a salvage-backup is a real BDB before restoring it
+#include "resources/embedded_resources.h"   // getDaemonDirectory() — locate the wallet-rebuild helper
+#include <cstdio>                            // popen the rebuild helper
 #include "util/perf_log.h"
 #include "util/i18n.h"
 #include "util/secure_vault.h"
@@ -196,10 +202,14 @@ static WarmupText translateWarmup(const std::string& raw)
 // Used to offer a -salvagewallet repair when a switch fails because the target wallet is corrupt.
 static bool walletOutputLooksCorrupt(const std::string& out)
 {
+    // W1-2: the generic "Error loading wallet" fallback is ALSO printed for DB_TOO_NEW
+    // ("...requires ... newer version..."), which -salvagewallet cannot fix — so don't misclassify a
+    // version mismatch as salvageable corruption and offer a repair that can't help.
+    const bool versionMismatch = out.find("newer version") != std::string::npos;
     return out.find("Failed to rename")     != std::string::npos
         || out.find("salvage failed")       != std::string::npos
         || out.find("wallet.dat corrupt")   != std::string::npos
-        || out.find("Error loading wallet") != std::string::npos;
+        || (out.find("Error loading wallet") != std::string::npos && !versionMismatch);
 }
 
 // Phrases dragonxd prints to its console while initializing, in the order translateWarmup()
@@ -219,6 +229,24 @@ static constexpr int kDaemonWaitWarnAttempts = 4;
 // Connection Management
 // ============================================================================
 
+// dragonxd moves wallet.dat to wallet.<ts>.bak and loads a salvaged copy whenever BDB verify fails —
+// no flag, and often a false positive (stale/cross-platform env) or an inconsistent-but-readable file.
+// The salvage prints to the node's captured output at STARTUP, but the node may then fail to connect
+// (block-index abort, long sync, crash) so we must NOT wait for onConnected — scan the output on every
+// tryConnect tick, early enough that the line hasn't been trimmed from the rolling buffer. Fires once
+// per session; the dialog offers Rebuild (fix the DB) / Restore (swap the .bak back).
+void App::detectWalletAutoRecovery()
+{
+    if (wallet_auto_recovered_warned_) return;
+    if (!isUsingEmbeddedDaemon() || !daemon_controller_ || !daemon_controller_->daemon()) return;
+    if (!daemon::walletAutoRecovered(daemon_controller_->daemon()->getOutput())) return;
+    wallet_auto_recovered_ = true;
+    wallet_auto_recovered_warned_ = true;
+    show_wallet_recovered_dialog_ = true;
+    ui::Notifications::instance().info(TR("wallet_recovered_notify"), 30.0f);   // calm, not red — coins are safe
+    VERBOSE_LOGF("[recovery] Daemon auto-recovered/salvaged wallet.dat — surfacing the recovery dialog\n");
+}
+
 void App::tryConnect()
 {
     // Lite builds have no full node / RPC daemon, so never run the RPC connection state machine
@@ -226,6 +254,10 @@ void App::tryConnect()
     // derived from it each frame in App::update(), which also gates the wallet UI (isConnected()).
     if (isLiteBuild()) return;
 
+    // Catch a startup wallet salvage as soon as it appears in the node's output — independent of whether
+    // the node ever finishes starting or connects (skip only while an orchestrated swap is mid-flight).
+    if (!daemon_restarting_) detectWalletAutoRecovery();
+
     if (connection_in_progress_) return;
 
     // Don't fight an in-progress restart/adopt orchestration: while it stops the daemon, swaps
@@ -240,6 +272,16 @@ void App::tryConnect()
     
     // Auto-detect configuration (file I/O — fast, safe on main thread)
     auto config = rpc::Connection::autoDetectConfig();
+
+    if (!config.dir_error.empty()) {
+        // The data directory could not be created (read-only home, permission denied,
+        // disk full). Retrying won't fix it, so surface it in the status line instead of
+        // mislabelling it as "waiting for config" below.
+        connection_in_progress_ = false;
+        connection_status_ = config.dir_error;
+        VERBOSE_LOGF("[connect #%d] data dir error: %s\n", connect_attempt, config.dir_error.c_str());
+        return;
+    }
     
     if (config.rpcuser.empty() || config.rpcpassword.empty()) {
         connection_in_progress_ = false;
@@ -310,11 +352,21 @@ void App::tryConnect()
     VERBOSE_LOGF("[connect #%d] Connecting to %s:%s (user=%s)\n",
                connect_attempt, config.host.c_str(), config.port.c_str(), config.rpcuser.c_str());
 
-    if (rpc::Connection::usesPlaintextRemote(config) && !remote_rpc_plaintext_warning_shown_) {
-        remote_rpc_plaintext_warning_shown_ = true;
-        ui::Notifications::instance().warning(
-            "Remote RPC is using plaintext HTTP. Add rpctls=1 to DRAGONX.conf if your daemon supports TLS.",
-            10.0f);
+    if (rpc::Connection::usesPlaintextRemote(config) &&
+        !rpc::Connection::allowsPlaintextRemote(config)) {
+        // Refuse to send Basic-auth credentials in cleartext to a remote host — a local-network
+        // MITM would otherwise capture rpcuser:rpcpassword. This is a deliberate behaviour change
+        // from the old warn-and-proceed: opt in explicitly with rpcallowplaintext=1 in
+        // DRAGONX.conf (or enable TLS with rpctls=1) if the plaintext link is intended.
+        connection_in_progress_ = false;
+        connection_status_ = TR("sb_plaintext_remote_blocked");
+        if (!remote_rpc_plaintext_warning_shown_) {
+            remote_rpc_plaintext_warning_shown_ = true;
+            ui::Notifications::instance().warning(TR("sb_plaintext_remote_blocked"), 20.0f);
+        }
+        VERBOSE_LOGF("[connect #%d] refusing plaintext-remote RPC to %s:%s (set rpcallowplaintext=1 to override)\n",
+                   connect_attempt, config.host.c_str(), config.port.c_str());
+        return;
     }
     
     // Run the blocking rpc_->connect() on the worker thread so the UI
@@ -356,9 +408,12 @@ void App::tryConnect()
         // "stuck connecting" while the node silently died-and-respawned. Surface each new crash once.
         const int crashes = daemon_controller_->crashCount();
         if (crashes > daemon_last_seen_crashes_) {
-            daemon_last_seen_crashes_ = crashes;
+            daemon_last_seen_crashes_ = crashes;   // consume it either way, so it can't toast later
             const std::string detail = daemon_controller_->lastError();
-            if (!detail.empty()) {
+            // Suppress the scary "dragonxd exited unexpectedly" toast during recovery: the stop after a
+            // salvage, and the intentional restart-with-rescan after a repair, are both EXPECTED here and
+            // owned by the recovery UI (dialog / calm rescan overlay).
+            if (!detail.empty() && !wallet_auto_recovered_ && !post_recovery_rescan_) {
                 connection_status_ = TR("sb_daemon_start_failed");
                 ui::Notifications::instance().error(detail, 30.0f);
             }
@@ -385,6 +440,7 @@ void App::tryConnect()
                     // fail until warmup completes.  Set the warmup state so
                     // the UI shows status instead of a blocking overlay.
                     state_.warming_up = true;
+                    if (connect_stall_since_ <= 0.0) connect_stall_since_ = ImGui::GetTime();  // start the "taking too long" clock
                     auto wt = translateWarmup(warmupStatus);
                     state_.warmup_status = wt.title;
                     state_.warmup_description = wt.description;
@@ -474,8 +530,34 @@ void App::tryConnect()
                     VERBOSE_LOGF("[connect #%d] RPC connection failed — no daemon starting, no external detected\n", attempt);
                     
                     if (isUsingEmbeddedDaemon() && !isEmbeddedDaemonRunning()) {
+                        // A repair completed and we restarted with a full rescan, but the fresh daemon has
+                        // now EXITED — a fault distinct from the wallet file (corrupt block index, disk full,
+                        // OOM). Drop out of the calm "finishing repair" state so this surfaces as a normal
+                        // daemon failure (reindex offer / crash toast / restart) instead of silently freezing
+                        // the reconnect loop on a reassuring "don't restart" screen with no way forward.
+                        if (post_recovery_rescan_) {
+                            post_recovery_rescan_ = false;
+                            wallet_auto_recovered_ = false;   // repair done; the original-salvage hold is over
+                        }
+                        // If the node aborted because its BLOCK DATABASE is unreadable (a daemon-vs-chaindata
+                        // format mismatch after an update, or a corrupt index), crash-restarting just repeats
+                        // the same abort — and each attempt reloads the whole index (wasteful). Detect it once
+                        // and offer a one-click reindex instead of silently looping into a zero-balance node.
+                        if (!block_db_reindex_available_ && daemon_controller_ && daemon_controller_->daemon() &&
+                            daemon::blockDbOutputLooksBroken(daemon_controller_->daemon()->getOutput())) {
+                            block_db_reindex_available_ = true;
+                            show_block_db_reindex_confirm_ = true;
+                            ui::Notifications::instance().error(TR("block_db_reindex_notify"), 20.0f);
+                            VERBOSE_LOGF("[connect #%d] Block database unreadable — offering a one-click reindex\n", attempt);
+                        }
                         // Prevent infinite crash-restart loop
-                        if (daemon_controller_ && daemon_controller_->crashCount() >= 3) {
+                        if (block_db_reindex_available_) {
+                            connection_status_ = TR("sb_block_db_unreadable");   // hold; awaiting the rebuild choice
+                        } else if (wallet_auto_recovered_) {
+                            // A salvage is happening — DON'T restart into another one (each round can shrink
+                            // the wallet further). Hold while the recovery dialog (Rebuild/Restore) is up.
+                            connection_status_ = TR("sb_wallet_needs_recovery");
+                        } else if (daemon_controller_ && daemon_controller_->crashCount() >= 3) {
                             if (wallet_switch_pending_confirm_.load()) {
                                 // The just-switched-to wallet's daemon keeps crashing (e.g. a wallet that
                                 // fails LATE in init, past the fast start grace) — revert to the previous
@@ -526,10 +608,18 @@ void App::onConnected()
     }
     state_.daemon_initializing = false;  // RPC is answering now; clear the "initializing" overlay
     daemon_wait_attempts_ = 0;           // re-arm the port-busy / start-failure notifications
+    connect_stall_since_ = 0.0;          // connected — clear the "taking too long" clock
+    // A repair's rescan finished and connected — retire the recovery session so its crash-toast/error-card
+    // suppression and status-chip hold can't persist forever. (Only when we were mid-post-repair-rescan;
+    // a pre-repair salvaged-daemon connect keeps the flag so the recovery dialog/chip stay available.)
+    if (post_recovery_rescan_) wallet_auto_recovered_ = false;
+    post_recovery_rescan_ = false;       // repair's post-restart rescan is past the RPC-less phase now
     daemon_start_error_shown_ = false;
     daemon_last_seen_crashes_ = 0;       // (onConnected resets the daemon's crash count too)
     connection_status_ = TR("connected");
 
+    detectWalletAutoRecovery();   // also runs every tryConnect tick — catches a salvage even if we never connect
+
     // Stamp the active wallet as opened in the index (last-opened + size + synced-here). Balance +
     // address count fill in on the first address refresh (addresses aren't loaded yet here).
     updateWalletIndexForActiveWallet(/*markOpened=*/true);
@@ -606,6 +696,7 @@ void App::onDisconnected(const std::string& reason)
     state_.connected = false;
     state_.warming_up = false;
     state_.warmup_status.clear();
+    connect_stall_since_ = 0.0;  // reset the "taking too long" clock (App member, untouched by state_.clear())
     state_.clear();
     connection_status_ = reason;
 
@@ -660,6 +751,7 @@ void App::onDisconnected(const std::string& reason)
 std::string App::applyDaemonInitStatus(bool reachableButBusy)
 {
     state_.daemon_initializing = true;
+    if (connect_stall_since_ <= 0.0) connect_stall_since_ = ImGui::GetTime();  // start the "taking too long" clock
 
     // Find the most recent console line that names an init phase, so we can tell the user exactly
     // what the node is doing (loading the block index, verifying, activating best chain, …).
@@ -920,10 +1012,13 @@ void App::applyPendingSendDelta(const std::string& fromAddress, double signedAmo
     // For a debit (signedAmount < 0) this clamps at >=0 exactly as the debit sites did. For a
     // restore (signedAmount > 0) the clamp is a no-op — max(0, bal+amt) == bal+amt when bal,amt>=0 —
     // so the single clamped form reproduces the original restore's unclamped bal += amt.
+    // Debit/restore the SPENDABLE view ONLY. The DISPLAY balances now come from an honest minconf=0 RPC
+    // that already reflects the outgoing spend AND the incoming 0-conf change, so debiting them here too
+    // would re-crater the display. This delta only lowers what can be re-spent before the change confirms.
     auto applyToAddress = [&](std::vector<AddressInfo>& addresses) {
         for (auto& address : addresses) {
             if (address.address == fromAddress) {
-                address.balance = std::max(0.0, address.balance + signedAmount);
+                address.spendableBalance = std::max(0.0, address.spendableBalance + signedAmount);
                 return true;
             }
         }
@@ -932,11 +1027,12 @@ void App::applyPendingSendDelta(const std::string& fromAddress, double signedAmo
     if (!applyToAddress(state_.z_addresses)) applyToAddress(state_.t_addresses);
     if (includeAggregates) {
         if (!fromAddress.empty() && fromAddress[0] == 'z') {
-            state_.privateBalance = std::max(0.0, state_.privateBalance + signedAmount);
+            state_.spendablePrivateBalance = std::max(0.0, state_.spendablePrivateBalance + signedAmount);
         } else {
-            state_.transparentBalance = std::max(0.0, state_.transparentBalance + signedAmount);
+            state_.spendableTransparentBalance = std::max(0.0, state_.spendableTransparentBalance + signedAmount);
         }
-        state_.totalBalance = std::max(0.0, state_.totalBalance + signedAmount);
+        state_.spendableTotalBalance = std::max(0.0, state_.spendableTotalBalance + signedAmount);
+        state_.unconfirmedBalance = std::max(0.0, state_.totalBalance - state_.spendableTotalBalance);
     }
 }
 
@@ -1067,9 +1163,16 @@ void App::updateWalletIndexForActiveWallet(bool markOpened)
         if (!ec) e.sizeBytesAtLastOpen = static_cast<long long>(sz);
     }
 
+    // W1-3: record "synced here" only once the wallet's identity is actually verified (its addresses are
+    // known -> idHash non-empty). Stamping it on the bare connect (before any address readback) would let
+    // a freshly-restored wallet skip its needed rescan. It's idempotent, so the post-refresh update
+    // (updateWalletIndexForActiveWallet after addresses load) sets it once; lastOpenedEpoch is still
+    // recorded at open time here.
+    if (!idHash.empty()) {
+        e.syncedHere = true;  // loaded + identity-verified in this datadir -> catch-up (no full rescan)
+    }
     if (markOpened) {
         e.lastOpenedEpoch = static_cast<long long>(std::time(nullptr));
-        e.syncedHere = true;  // we've loaded it in this datadir -> catch-up (no full rescan) on switch
     }
 
     if (wallet_index_.upsert(e)) wallet_index_.save();
@@ -1096,7 +1199,9 @@ void App::switchToWallet(const std::string& walletFile, bool stopDaemonConfirmed
         ui::Notifications::instance().warning("A rescan or repair is in progress — try again once it finishes.");
         return;
     }
-    if (show_seed_migration_) {
+    // W3-4: block switching while a migration is PENDING, not only while its dialog is open — closing
+    // the dialog via "Later" mid-migration leaves the pending state but previously dropped this guard.
+    if (show_seed_migration_ || (settings_ && settings_->getSeedMigrationPending())) {
         ui::Notifications::instance().warning("Finish or cancel the seed migration before switching wallets.");
         return;
     }
@@ -1108,6 +1213,19 @@ void App::switchToWallet(const std::string& walletFile, bool stopDaemonConfirmed
         ui::Notifications::instance().warning("Finish or cancel the pending send before switching wallets.");
         return;
     }
+    // W1-1: verify the target wallet file actually exists before switching. dragonxd auto-CREATES a
+    // fresh empty wallet for a missing -wallet=<name>, so without this a moved/deleted wallet file would
+    // silently "open" as a brand-new empty wallet with a zero balance — looking exactly like fund loss.
+    // (Also closes the W1-4 stale-switcher-row race: the check runs no matter how switchToWallet is called.)
+    {
+        std::error_code existEc;
+        const std::string walletPath = util::Platform::getDragonXDataDir() + "/" + walletFile;
+        if (!std::filesystem::exists(walletPath, existEc)) {
+            ui::Notifications::instance().warning(
+                "Wallet file not found (moved or deleted?): " + walletFile + " — it was not opened.", 15.0f);
+            return;
+        }
+    }
     // If we're connected to a node this session did NOT spawn (no live process handle — it was left
     // running by "keep node running", started by the user, or we just direct-connected to a config-provided
     // one), confirm before stopping it: switching must stop+restart it on the new wallet, but the user may
@@ -1488,6 +1606,7 @@ void App::refreshCoreData()
                     state_.warming_up = false;
                     state_.warmup_status.clear();
                     state_.warmup_description.clear();
+                    connect_stall_since_ = 0.0;  // warmup finished — clear the "taking too long" clock
                     connection_status_ = TR("connected");
                     VERBOSE_LOGF("[warmup] Daemon ready, warmup complete\n");
 
@@ -1570,7 +1689,7 @@ void App::refreshCoreData()
 
                 // Auto-shield transparent funds if enabled
                 if (result.balanceOk && settings_ && settings_->getAutoShield() &&
-                    state_.transparent_balance > 0.0001 && !state_.sync.syncing &&
+                    state_.spendableTransparentBalance > 0.0001 && !state_.sync.syncing &&
                     !auto_shield_pending_.exchange(true)) {
                     std::string targetZAddr;
                     for (const auto& addr : state_.addresses) {
@@ -1581,7 +1700,7 @@ void App::refreshCoreData()
                     }
                     if (!targetZAddr.empty() && worker_) {
                         DEBUG_LOGF("[AutoShield] Shielding %.8f DRGX to %s\n",
-                               state_.transparent_balance, targetZAddr.c_str());
+                               state_.spendableTransparentBalance, targetZAddr.c_str());
                         // Use the user-configured fee, formatted fixed-decimal so the daemon's
                         // ParseFixedPoint accepts it (a small double would serialize to "5e-05").
                         const std::string feeStr =
@@ -2288,27 +2407,23 @@ void App::startPoolMining(int threads)
     cfg.tls            = settings_->getPoolTls();
     cfg.hugepages      = settings_->getPoolHugepages();
 
-    // Use first shielded address as the mining wallet address, fall back to transparent
+    // xmrig "user" is the pool login the block rewards are credited to. The user's
+    // "Payout Address" field (cfg.worker_name = getPoolWorker) is exactly that, so it
+    // takes priority — otherwise a payout address that differs from the wallet's own
+    // first z-address is silently ignored and rewards go to the wrong address. Only when
+    // no payout address is set do we fall back to the wallet's own first shielded, then
+    // transparent, address (available even before the daemon is connected/synced).
+    std::string firstShielded, firstTransparent;
     for (const auto& addr : state_.z_addresses) {
-        if (!addr.address.empty()) {
-            cfg.wallet_address = addr.address;
+        if (!addr.address.empty()) { firstShielded = addr.address; break; }
+    }
+    for (const auto& addr : state_.addresses) {
+        if (addr.type == "transparent" && !addr.address.empty()) {
+            firstTransparent = addr.address;
             break;
         }
     }
-    if (cfg.wallet_address.empty()) {
-        for (const auto& addr : state_.addresses) {
-            if (addr.type == "transparent" && !addr.address.empty()) {
-                cfg.wallet_address = addr.address;
-                break;
-            }
-        }
-    }
-
-    // Fallback: use pool worker address from settings (available even before
-    // the daemon is connected or the blockchain is synced).
-    if (cfg.wallet_address.empty() && !cfg.worker_name.empty()) {
-        cfg.wallet_address = cfg.worker_name;
-    }
+    cfg.wallet_address = ui::resolveMiningUserAddress(cfg.worker_name, firstShielded, firstTransparent);
 
     if (cfg.wallet_address.empty()) {
         DEBUG_LOGF("[ERROR] Pool mining: No wallet address available\n");
@@ -2935,14 +3050,14 @@ std::string App::chatPayFromZaddr(double fee) const
     std::string reply;
     if (settings_) reply = settings_->getChatReplyZaddr();
     for (const auto& a : state_.z_addresses)
-        if (a.address == reply && a.has_spending_key && a.balance >= fee) return reply;
+        if (a.address == reply && a.has_spending_key && a.spendableBalance >= fee) return reply;
 
     std::string best;
     double bestBal = -1.0;
     for (const auto& a : state_.z_addresses)
-        if (a.has_spending_key && !a.address.empty() && a.balance >= fee && a.balance > bestBal) {
+        if (a.has_spending_key && !a.address.empty() && a.spendableBalance >= fee && a.spendableBalance > bestBal) {
             best = a.address;
-            bestBal = a.balance;
+            bestBal = a.spendableBalance;
         }
     return best;   // empty → no z-address can cover the fee
 }
@@ -3761,6 +3876,8 @@ void App::exportAllKeys(std::function<void(const std::string&, int, int)> callba
             (*pending)--;
             if (*pending == 0 && callback) {
                 callback(*keys_result, *exported, *total);
+                // Scrub the concatenated all-keys buffer once the consumer (backup writer) has used it.
+                if (!keys_result->empty()) sodium_memzero(&(*keys_result)[0], keys_result->size());
             }
         });
     }
@@ -3783,7 +3900,9 @@ void App::importPrivateKey(const std::string& rawKey, int startHeight,
     // Reject anything that isn't a recognized Z/T private key or shielded viewing key before handing
     // it to the daemon (the dialog's indicator and this guard share isRecognizedImportKey).
     if (!services::WalletSecurityController::isRecognizedImportKey(key)) {
-        if (callback) callback(false, "Unrecognized key format.", "");
+        if (callback) callback(false,
+            "Not a recognized DragonX private key or viewing key. Check for missing or "
+            "mistyped characters, and that this is a DragonX key (not another coin).", "");
         return;
     }
 
@@ -3792,7 +3911,7 @@ void App::importPrivateKey(const std::string& rawKey, int startHeight,
                           == services::WalletSecurityController::KeyKind::Shielded;
     // Run on the worker thread — import requests a full rescan (rescan=true), so the
     // synchronous curl call can take many seconds; never block the UI thread on it.
-    worker_->post([this, key, viewing, shielded, startHeight, callback]() -> rpc::RPCWorker::MainCb {
+    worker_->post([this, key, viewing, shielded, startHeight, callback]() mutable -> rpc::RPCWorker::MainCb {
         std::string err, addr;
         try {
             rpc::RPCClient::TraceScope trace("Settings / Import key");
@@ -3804,6 +3923,11 @@ void App::importPrivateKey(const std::string& rawKey, int startHeight,
             // A start height (shielded RPCs only) rescans from that block instead of genesis.
             if (startHeight > 0 && (viewing || shielded)) params.push_back(startHeight);
             nlohmann::json r = rpc_->call(method, params);
+            // Scrub the key out of the request params (the json holds its own copy of it).
+            if (params.is_array() && !params.empty() && params[0].is_string()) {
+                std::string& pk = params[0].get_ref<std::string&>();
+                if (!pk.empty()) sodium_memzero(&pk[0], pk.size());
+            }
             // z_import* return {type,address}; importprivkey returns the t-address string.
             if (r.is_object() && r.contains("address") && r["address"].is_string())
                 addr = r["address"].get<std::string>();
@@ -3816,6 +3940,16 @@ void App::importPrivateKey(const std::string& rawKey, int startHeight,
             // below would never run, leaving a stuck "Importing…" spinner.
             err = "Import failed (unknown error)";
         }
+        // Scrub the worker's copy of the key now that the request has been sent (all paths).
+        if (!key.empty()) sodium_memzero(&key[0], key.size());
+        // A checksum-valid key the daemon still rejects is almost always the right *format* but the
+        // wrong network/coin (Komodo-family chains share version bytes) or a corrupted paste — say so,
+        // since the bare "Invalid …" text reads like a wallet bug (F5).
+        if (!err.empty() && err.find("Invalid") != std::string::npos &&
+            err.find("DragonX") == std::string::npos) {
+            err += " — check the key is for DragonX (not another coin or network) and has no missing "
+                   "or altered characters.";
+        }
         return [this, err, addr, callback]() {
             if (!err.empty()) {
                 if (callback) callback(false, err, "");
@@ -3826,6 +3960,7 @@ void App::importPrivateKey(const std::string& rawKey, int startHeight,
             if (callback) callback(true, "", addr);
         };
     });
+    if (!key.empty()) sodium_memzero(&key[0], key.size());  // scrub the calling-frame copy
 }
 
 // Sweep a spending key: import it (a full rescan populates its UTXOs/notes — the stock node has no
@@ -3863,7 +3998,7 @@ void App::sweepPrivateKey(const std::string& rawKey, int startHeight, int destMo
     const bool shielded = services::WalletSecurityController::classifyPrivateKey(key)
                           == services::WalletSecurityController::KeyKind::Shielded;
     const double fee = DRAGONX_DEFAULT_FEE;
-    worker_->post([this, key, startHeight, destMode, destExisting, shielded, fee]() -> rpc::RPCWorker::MainCb {
+    worker_->post([this, key, startHeight, destMode, destExisting, shielded, fee]() mutable -> rpc::RPCWorker::MainCb {
         std::string err, dest, sourceAddr, amountStr;
         double amount = 0.0;
         try {
@@ -3887,6 +4022,11 @@ void App::sweepPrivateKey(const std::string& rawKey, int startHeight, int destMo
             else          { method = "importprivkey"; params = {key, "", true}; }
             if (startHeight > 0 && shielded) params.push_back(startHeight);
             nlohmann::json r = rpc_->call(method, params);
+            // Scrub the key out of the request params (the json holds its own copy of it).
+            if (params.is_array() && !params.empty() && params[0].is_string()) {
+                std::string& pk = params[0].get_ref<std::string&>();
+                if (!pk.empty()) sodium_memzero(&pk[0], pk.size());
+            }
 
             // 2. Determine the swept address. importprivkey returns the t-address string; z_importkey
             //    returns null, so diff the z-address list to find the one the key just added.
@@ -3945,6 +4085,8 @@ void App::sweepPrivateKey(const std::string& rawKey, int startHeight, int destMo
         } catch (...) {
             err = "Sweep failed (unknown error)";
         }
+        // Scrub the worker's copy of the spending key now that the request has been sent (all paths).
+        if (!key.empty()) sodium_memzero(&key[0], key.size());
         return [this, err, sourceAddr, dest, amount, amountStr, fee]() {
             invalidateAddressValidationCache();
             refreshAddresses();
@@ -3981,6 +4123,7 @@ void App::sweepPrivateKey(const std::string& rawKey, int startHeight, int destMo
             });
         };
     });
+    if (!key.empty()) sodium_memzero(&key[0], key.size());  // scrub the calling-frame copy
 }
 
 void App::exportSeedPhrase(std::function<void(bool, bool, const std::string&, const std::string&)> callback)
@@ -4111,27 +4254,56 @@ void App::showSeedMigrationDialog()
     // Resume a pending migration. If a sweep was already submitted (txid persisted), resume at the
     // confirm/adopt stage — re-derived from the chain — rather than sweeping again; otherwise start
     // at the Sweep step. With no pending migration, start fresh at the intro.
-    if (settings_ && settings_->getSeedMigrationPending() && !settings_->getSeedMigrationDest().empty()) {
-        seed_migration_dest_ = settings_->getSeedMigrationDest();
+    const bool pending  = settings_ && settings_->getSeedMigrationPending();
+    const bool haveDest = settings_ && !settings_->getSeedMigrationDest().empty();
+    const std::string sweepTxid = settings_ ? settings_->getSeedMigrationSweepTxid() : std::string();
+    const std::string sweepOpid = settings_ ? settings_->getSeedMigrationSweepOpid() : std::string();
+    const bool connected = state_.connected && rpc_ && worker_;
+
+    switch (decideSeedMigrationResume(pending, haveDest, sweepTxid, sweepOpid, connected)) {
+    case MigrationResume::Confirming:
+        seed_migration_dest_       = settings_->getSeedMigrationDest();
+        seed_migration_temp_dir_   = settings_->getSeedMigrationTempDir();
+        seed_migration_sweep_txid_ = sweepTxid;
+        seed_migration_sweep_confs_ = 0;
+        seed_migration_legacy_remaining_ = -1.0;
+        seed_migration_poll_timer_ = 0.0f;  // poll immediately
+        seed_migration_step_ = SeedMigrationStep::Confirming;
+        break;
+    case MigrationResume::RetrackOpid:
+        // W3-3: a sweep opid was submitted but its txid was never persisted (app closed mid-Sweeping).
+        // Re-track it to recover the txid. If the daemon forgot it (restart), the opid poller flags it
+        // stale and makeSweepCompletionCallback(resumed) falls back to the Sweep gate — never a hang.
+        // Only reached when connected (decideSeedMigrationResume), so the poller can actually run and
+        // the buttonless "Sweeping" spinner is guaranteed an exit.
+        seed_migration_dest_       = settings_->getSeedMigrationDest();
+        seed_migration_temp_dir_   = settings_->getSeedMigrationTempDir();
+        seed_migration_sweep_txid_.clear();
+        pending_send_callbacks_[sweepOpid] = makeSweepCompletionCallback(/*resumed=*/true);
+        trackOperation(sweepOpid);
+        seed_migration_step_ = SeedMigrationStep::Sweeping;
+        seed_migration_status_ = "Checking on the previous sweep…";
+        break;
+    case MigrationResume::SweepGate:
+        // No txid, and either no opid or not connected to re-track it (a persisted opid is left in
+        // place so a later reconnect+reopen can re-track it). The Sweep step is dismissable and
+        // reloads the balance, so the user is never trapped while offline.
+        seed_migration_dest_     = settings_->getSeedMigrationDest();
         seed_migration_temp_dir_ = settings_->getSeedMigrationTempDir();
-        seed_migration_sweep_txid_ = settings_->getSeedMigrationSweepTxid();
-        if (!seed_migration_sweep_txid_.empty()) {
-            seed_migration_sweep_confs_ = 0;
-            seed_migration_legacy_remaining_ = -1.0;
-            seed_migration_poll_timer_ = 0.0f;  // poll immediately
-            seed_migration_step_ = SeedMigrationStep::Confirming;
-        } else {
-            seed_migration_step_ = SeedMigrationStep::Sweep;
-            seed_migration_balance_loaded_ = false;
-            seed_migration_nofunds_confirmed_ = false;
-            refreshSeedMigrationBalance();
-        }
-    } else {
+        seed_migration_sweep_txid_.clear();
+        seed_migration_step_ = SeedMigrationStep::Sweep;
+        seed_migration_balance_loaded_ = false;
+        seed_migration_nofunds_confirmed_ = false;
+        refreshSeedMigrationBalance();
+        break;
+    case MigrationResume::Intro:
+    default:
         seed_migration_step_ = SeedMigrationStep::Intro;
         // Fresh start: the Intro step will pre-flight the wallet (legacy vs already-seeded vs old
         // daemon) before offering to create anything.
         seed_migration_precheck_ = SeedMigrationPrecheck::Pending;
         seed_migration_precheck_started_ = false;
+        break;
     }
 }
 
@@ -4206,29 +4378,71 @@ void App::beginSweepToSeedWallet()
                 seed_migration_step_ = SeedMigrationStep::Error;
                 return;
             }
-            pending_send_callbacks_[opid] = [this](bool ok, const std::string& result) {
-                if (ok) {
-                    seed_migration_sweep_txid_ = result;
-                    // Persist the txid so a restart resumes at the confirm/adopt stage and never
-                    // re-sweeps from scratch. The Confirming step gates adopt on this tx being mined
-                    // (>= 1 confirmation) AND the legacy balance dropping to ~0.
-                    if (settings_) { settings_->setSeedMigrationSweepTxid(result); settings_->save(); }
-                    seed_migration_sweep_confs_ = 0;
-                    seed_migration_legacy_remaining_ = -1.0;
-                    seed_migration_poll_timer_ = 0.0f;
-                    seed_migration_status_.clear();
-                    seed_migration_step_ = SeedMigrationStep::Confirming;
-                } else {
-                    seed_migration_status_ = result.empty() ? "The sweep transaction failed." : result;
-                    seed_migration_step_ = SeedMigrationStep::Error;
-                }
-            };
+            // W3-3: adopt this new opid atomically — persist it AND clear any prior sweep txid in the
+            // SAME settings write. Persisting the opid lets an app-close during Sweeping (opid
+            // submitted, not yet resolved to a txid) re-poll it on resume instead of dropping it. Doing
+            // the swap HERE — only once the new submit has succeeded — rather than speculatively at
+            // function entry means a FAILED "Sweep remaining" remainder re-sweep leaves the
+            // already-mined first sweep's txid intact and resumable to Confirming; and the txid and
+            // opid are never both authoritative at once (torn-write safe; resume checks txid first).
+            seed_migration_sweep_txid_.clear();
+            if (settings_) {
+                settings_->setSeedMigrationSweepTxid("");
+                settings_->setSeedMigrationSweepOpid(opid);
+                settings_->save();
+            }
+            pending_send_callbacks_[opid] = makeSweepCompletionCallback(/*resumed=*/false);
             trackOperation(opid);
             seed_migration_status_ = "Waiting for the sweep transaction to be accepted…";
         };
     });
 }
 
+// W3-3: terminal handling for the sweep operation, shared by the initial submit (resumed=false) and
+// a resume re-track (resumed=true). On success it persists the txid and clears the opid in the SAME
+// settings write, so the txid always outranks the opid on a later resume (torn-write safe).
+std::function<void(bool, const std::string&)> App::makeSweepCompletionCallback(bool resumed)
+{
+    return [this, resumed](bool ok, const std::string& result) {
+        if (ok) {
+            seed_migration_sweep_txid_ = result;
+            // Persist the txid (and drop the now-redundant opid) so a restart resumes at the
+            // confirm/adopt stage and never re-sweeps from scratch. The Confirming step gates adopt on
+            // this tx being mined (>= 1 confirmation) AND the legacy balance dropping to ~0.
+            if (settings_) {
+                settings_->setSeedMigrationSweepTxid(result);
+                settings_->setSeedMigrationSweepOpid("");
+                settings_->save();
+            }
+            seed_migration_sweep_confs_ = 0;
+            seed_migration_legacy_remaining_ = -1.0;
+            seed_migration_poll_timer_ = 0.0f;
+            seed_migration_status_.clear();
+            seed_migration_step_ = SeedMigrationStep::Confirming;
+        } else if (resumed) {
+            // A resumed opid the daemon no longer knows (it restarted — the op queue is in-memory
+            // only). "Stale" can't be told apart from "failed", and the earlier sweep may in fact have
+            // already broadcast/mined, so DON'T dead-end at Error: drop the stale opid and return to
+            // the Sweep gate, re-fetching the legacy balance. If that sweep did complete, the balance
+            // reads ~0 and the Sweep step short-circuits to adopt; otherwise the user can sweep again.
+            if (settings_) { settings_->setSeedMigrationSweepOpid(""); settings_->save(); }
+            seed_migration_sweep_txid_.clear();
+            seed_migration_balance_loaded_ = false;
+            seed_migration_nofunds_confirmed_ = false;
+            seed_migration_status_ =
+                "Couldn't confirm the earlier sweep — it may have already completed. "
+                "Check your balance below before sweeping again.";
+            seed_migration_step_ = SeedMigrationStep::Sweep;
+            refreshSeedMigrationBalance();  // else the Sweep step sits on a permanent "Checking balance…"
+        } else {
+            // A fresh sweep that genuinely failed. Clear the persisted opid so it can't mis-resume.
+            if (settings_) { settings_->setSeedMigrationSweepOpid(""); settings_->save(); }
+            seed_migration_status_ = result.empty() ? "The sweep transaction failed." : result;
+            seed_migration_step_ = SeedMigrationStep::Error;
+        }
+    };
+}
+
 // Confirming step: poll the sweep tx's confirmations + the legacy wallet's remaining balance. The
 // adopt step is gated on the tx being mined (confs >= 1) AND the legacy balance being ~0, so we
 // never swap wallet.dat while the funds could still bounce back (dropped/reorged tx) or while a
@@ -4282,7 +4496,13 @@ void App::beginAdoptSeedWallet()
     // has its own passphrase; the user can re-enable PIN quick-unlock for it).
     if (vault_) vault_->removeVault();
     const std::string base = seed_migration_temp_dir_;
-    async_tasks_.submit("Adopt seed wallet", [this, base](const util::AsyncTaskManager::Token&) {
+    // W3-1: adopt must swap the ACTIVE wallet file (multi-wallet), not a hardcoded "wallet.dat" —
+    // otherwise a migration run while e.g. wallet-2.dat is active would install the swept seed wallet
+    // into an unloaded wallet.dat and leave the daemon loading the (now-emptied) legacy wallet.
+    // Captured on the main thread; wallet switching is blocked during migration so this can't race.
+    const std::string activeWalletName = (settings_ && !settings_->getActiveWalletFile().empty())
+                                             ? settings_->getActiveWalletFile() : std::string("wallet.dat");
+    async_tasks_.submit("Adopt seed wallet", [this, base, activeWalletName](const util::AsyncTaskManager::Token&) {
         namespace fs = std::filesystem;
         std::string err;       // fatal (swap did not happen; migration incomplete)
         std::string warn;      // non-fatal (swap done but the daemon did not restart)
@@ -4302,7 +4522,7 @@ void App::beginAdoptSeedWallet()
                 // 2. Swap wallet.dat. Move the legacy one aside to a timestamped backup (NEVER
                 //    delete), then copy the new seed wallet in. On any failure, restore the legacy.
                 const std::string datadir = util::Platform::getDragonXDataDir();
-                const std::string legacy = datadir + "/wallet.dat";
+                const std::string legacy = datadir + "/" + activeWalletName;
                 const std::string newWallet = base + "/DRAGONX/wallet.dat";
                 std::time_t t = std::time(nullptr);
                 std::tm tmv{};  // thread-safe local time (the UI thread also uses localtime)
@@ -4363,6 +4583,310 @@ void App::beginAdoptSeedWallet()
     });
 }
 
+// Undo a daemon wallet auto-recovery: swap the untouched original (wallet.<ts>.bak) back over the
+// salvaged copy and clear the stale BDB env that triggered the false recovery, then restart. Modeled on
+// beginAdoptSeedWallet — stop daemon → file ops (copy/rename only, NEVER delete user data) → restart.
+void App::restoreOriginalWallet()
+{
+    if (!supportsFullNodeLifecycleActions()) {
+        ui::Notifications::instance().warning("Full-node lifecycle actions are unavailable in lite build");
+        return;
+    }
+    if (daemon_restarting_) {
+        ui::Notifications::instance().warning(TR("wallet_restore_busy"));
+        return;
+    }
+    // Keep the recovery dialog OPEN and drive it into the Working phase — it shows progress and the
+    // honest outcome in place (pumpWalletRestore flips it to Done/Failed). Presentation only; every
+    // file-safety step below is unchanged.
+    show_wallet_recovered_dialog_ = true;
+    recovery_phase_ = RecoveryPhase::Working;
+    recovery_last_action_rebuild_ = false;
+    { std::lock_guard<std::mutex> lk(wallet_restore_mutex_); wallet_restore_done_ = false; }
+    daemon_restarting_ = true;                 // gate the reconnect loop while we swap files
+    connection_status_ = TR("sb_restarting_daemon");
+    if (rpc_ && rpc_->isConnected()) rpc_->disconnect();
+    onDisconnected("Restoring original wallet");
+    ui::Notifications::instance().info(TR("wallet_restore_started"), 12.0f);
+
+    const std::string activeWalletName = (settings_ && !settings_->getActiveWalletFile().empty())
+                                             ? settings_->getActiveWalletFile() : std::string("wallet.dat");
+
+    async_tasks_.submit("Restore original wallet", [this, activeWalletName](const util::AsyncTaskManager::Token&) {
+        namespace fs = std::filesystem;
+        std::string err, warn;
+        try {
+            const std::string datadir = util::Platform::getDragonXDataDir();
+            // 1. Find the LARGEST salvage backup (offline — no daemon needed). Largest = least-salvaged =
+            //    the original: a salvage cascade shrinks the wallet each round, so the newest .bak can be
+            //    empty ("Salvage found no records") while the original is untouched and huge.
+            std::vector<std::pair<std::string, unsigned long long>> files;
+            {
+                std::error_code lec;
+                for (const auto& e : fs::directory_iterator(datadir, lec)) {
+                    if (lec) break;
+                    std::error_code se;
+                    const auto sz = fs::is_regular_file(e, se) ? fs::file_size(e, se) : 0;
+                    files.emplace_back(e.path().filename().string(),
+                                       se ? 0ull : static_cast<unsigned long long>(sz));
+                }
+            }
+            const std::string bak = daemon::largestWalletSalvageBak(files);
+            if (bak.empty()) {
+                err = TR("wallet_restore_no_backup");
+            } else if (!util::probeWalletFile(datadir + "/" + bak).isBerkeleyDB) {
+                err = TR("wallet_restore_bad_backup");   // don't overwrite a working wallet with a bad .bak
+            } else if (!stopDaemonForWalletSwitch()) {   // 2. Release wallet.dat + the RPC port first.
+                err = TR("wallet_restore_stop_failed");
+            } else {
+                std::error_code ec;
+                std::time_t t = std::time(nullptr);
+                std::tm tmv{};
+#ifdef _WIN32
+                localtime_s(&tmv, &t);
+#else
+                localtime_r(&t, &tmv);
+#endif
+                char ts[32]; std::strftime(ts, sizeof(ts), "%Y%m%d-%H%M%S", &tmv);
+                const std::string active = datadir + "/" + activeWalletName;
+                const std::string salvagedAside = active + ".salvaged-" + ts + ".dat";
+                // 3. Move the salvaged copy aside (NEVER delete), then copy the original .bak into place
+                //    (copy, so the .bak itself stays as a backup). Roll back the move if the copy fails.
+                bool movedSalvaged = false;
+                if (fs::exists(active)) {
+                    fs::rename(active, salvagedAside, ec);
+                    if (ec) err = TR("wallet_restore_move_failed");
+                    else movedSalvaged = true;
+                }
+                if (err.empty()) {
+                    fs::copy_file(datadir + "/" + bak, active, fs::copy_options::overwrite_existing, ec);
+                    if (ec) {
+                        if (movedSalvaged) { std::error_code e2; fs::rename(salvagedAside, active, e2); }
+                        err = TR("wallet_restore_copy_failed");
+                    }
+                }
+                // 4. Clear the stale BDB environment that triggered the false recovery — otherwise the
+                //    daemon would just re-salvage the restored wallet on the next start. Move database/
+                //    aside (keeps its logs) and drop the transient __db.* region files.
+                if (err.empty()) {
+                    std::error_code e2;
+                    if (fs::exists(datadir + "/database"))
+                        fs::rename(datadir + "/database", datadir + "/database.pre-restore-" + ts + ".bak", e2);
+                    for (const auto& e : fs::directory_iterator(datadir, e2)) {
+                        if (e.path().filename().string().rfind("__db.", 0) == 0) {
+                            std::error_code e3; fs::remove(e.path(), e3);
+                        }
+                    }
+                }
+            }
+
+            // 5. Bring the daemon back up (unless quitting). Even on a restore failure we relaunch so the
+            //    node isn't left down; the connect loop reconnects and onConnected clears the gate.
+            if (!shutting_down_) {
+                if (daemon_controller_) daemon_controller_->clearExternalDaemonDetected();
+                if (!startEmbeddedDaemon() && err.empty())
+                    warn = TR("wallet_restore_no_restart");
+            }
+        } catch (const std::exception& e) {
+            err = std::string("Restore failed: ") + e.what();
+        } catch (...) {
+            err = "Restore failed due to an unexpected error.";
+        }
+        daemon_restarting_ = false;   // ALWAYS re-arm the reconnect gate
+
+        std::lock_guard<std::mutex> lk(wallet_restore_mutex_);
+        wallet_restore_severity_ = !err.empty() ? 2 : (!warn.empty() ? 1 : 0);
+        wallet_restore_msg_ = !err.empty() ? err : warn;
+        wallet_restore_done_ = true;
+    });
+}
+
+void App::pumpWalletRestore()
+{
+    if (capture_mode_) return;
+    bool done = false; int sev = 0; std::string msg;
+    {
+        std::lock_guard<std::mutex> lk(wallet_restore_mutex_);
+        if (wallet_restore_done_) { done = true; sev = wallet_restore_severity_; msg = wallet_restore_msg_; wallet_restore_done_ = false; }
+    }
+    if (!done) return;
+    // Primary outcome channel: if the recovery dialog is still up (Working), flip it to Done/Failed in
+    // place with the real result. The toast below stays as the secondary echo for a dismissed/alt-tabbed
+    // user. sev 2 = failed (op discarded, nothing changed); sev 0/1 = done (1 carries a warning message).
+    if (show_wallet_recovered_dialog_ && recovery_phase_ == RecoveryPhase::Working) {
+        recovery_outcome_sev_ = sev;
+        recovery_outcome_msg_ = msg;
+        recovery_phase_ = (sev == 2) ? RecoveryPhase::Failed : RecoveryPhase::Done;
+        // Clean success (sev 0) → the daemon is now restarting with a full rescan. Flag it so the loading
+        // overlay shows a calm "finishing repair" screen (not the scary generic stall) until it connects.
+        // NOT for sev 1 (a warning like "node didn't restart") — nothing is rescanning then, and the Done
+        // dialog already shows that message. Timestamp is stamped on the first overlay frame.
+        if (sev == 0) { post_recovery_rescan_ = true; post_recovery_rescan_since_ = 0.0; }
+    }
+    if (sev == 2)      ui::Notifications::instance().error(msg, 25.0f);
+    else if (sev == 1) ui::Notifications::instance().warning(msg, 20.0f);
+    else               ui::Notifications::instance().success(msg.empty() ? TR("wallet_restore_ok") : msg, 12.0f);
+}
+
+// Locate the bundled dragonx-wallet-rebuild helper (exe dir → daemon dir). "" if not present.
+static std::string findWalletRebuildHelper()
+{
+    namespace fs = std::filesystem;
+#ifdef _WIN32
+    const char* exe = "dragonx-wallet-rebuild.exe";
+#else
+    const char* exe = "dragonx-wallet-rebuild";
+#endif
+    for (const std::string& d : { util::Platform::getExecutableDirectory(),
+                                  dragonx::resources::getDaemonDirectory() }) {
+        if (d.empty()) continue;
+        std::error_code ec;
+        const std::string p = d + "/" + exe;
+        if (fs::exists(p, ec)) return p;
+    }
+    // Not sitting next to the app/daemon — but a self-contained exe carries it embedded. Extract it on
+    // demand (first-run param extraction is gated on needsParamsExtraction(), so it may never have run
+    // on a machine that already had the Sapling params). Returns "" on non-embedded builds.
+    return dragonx::resources::ensureWalletRebuildHelperExtracted();
+}
+
+bool App::walletRebuildAvailable() const { return !findWalletRebuildHelper().empty(); }
+
+// Rebuild a BDB-inconsistent wallet into a fresh, daemon-loadable one via the offline helper (see
+// tools/wallet_rebuild). This is the real fix for the salvage cascade: plain "Restore original" just
+// hands the same broken file back and the daemon re-salvages it. Modeled on restoreOriginalWallet:
+// stop daemon → run helper → verify → safe swap (copy/rename only, never delete) → rescan → restart.
+void App::rebuildWalletDatabase()
+{
+    if (!supportsFullNodeLifecycleActions()) {
+        ui::Notifications::instance().warning("Full-node lifecycle actions are unavailable in lite build");
+        return;
+    }
+    if (daemon_restarting_) { ui::Notifications::instance().warning(TR("wallet_restore_busy")); return; }
+    const std::string helper = findWalletRebuildHelper();
+    if (helper.empty()) { ui::Notifications::instance().error(TR("wallet_rebuild_no_helper"), 15.0f); return; }
+
+    // Keep the recovery dialog OPEN through the rebuild (Working → Done/Failed in place). Presentation
+    // only; the run-helper → verify-before-swap → copy/rename-never-delete steps below are unchanged.
+    show_wallet_recovered_dialog_ = true;
+    recovery_phase_ = RecoveryPhase::Working;
+    recovery_last_action_rebuild_ = true;
+    { std::lock_guard<std::mutex> lk(wallet_restore_mutex_); wallet_restore_done_ = false; }
+    daemon_restarting_ = true;
+    connection_status_ = TR("sb_restarting_daemon");
+    if (rpc_ && rpc_->isConnected()) rpc_->disconnect();
+    onDisconnected("Rebuilding wallet database");
+    ui::Notifications::instance().info(TR("wallet_rebuild_started"), 15.0f);
+
+    const std::string activeWalletName = (settings_ && !settings_->getActiveWalletFile().empty())
+                                             ? settings_->getActiveWalletFile() : std::string("wallet.dat");
+
+    async_tasks_.submit("Rebuild wallet database", [this, helper, activeWalletName](const util::AsyncTaskManager::Token&) {
+        namespace fs = std::filesystem;
+        std::string err, warn;
+        try {
+            const std::string datadir = util::Platform::getDragonXDataDir();
+            const std::string active = datadir + "/" + activeWalletName;
+            // 1. Rebuild SOURCE = the largest readable wallet file (the active wallet or any salvage .bak).
+            //    Largest = most records = the original / least-salvaged (a salvaged copy is tiny).
+            std::string src; unsigned long long best = 0;
+            {
+                std::error_code ec;
+                for (const auto& e : fs::directory_iterator(datadir, ec)) {
+                    if (ec) break;
+                    const std::string n = e.path().filename().string();
+                    if (n != activeWalletName && daemon::parseWalletSalvageBakTs(n) < 0) continue;
+                    std::error_code se;
+                    const auto sz = fs::is_regular_file(e, se) ? fs::file_size(e, se) : 0;
+                    const auto usz = se ? 0ull : static_cast<unsigned long long>(sz);
+                    if (usz > best && util::probeWalletFile(e.path().string()).isBerkeleyDB) {
+                        best = usz; src = e.path().string();
+                    }
+                }
+            }
+            if (src.empty()) {
+                err = TR("wallet_rebuild_no_source");
+            } else if (!stopDaemonForWalletSwitch()) {   // 2. release wallet.dat + the port
+                err = TR("wallet_restore_stop_failed");
+            } else {
+                std::time_t t = std::time(nullptr);
+                std::tm tmv{};
+#ifdef _WIN32
+                localtime_s(&tmv, &t);
+#else
+                localtime_r(&t, &tmv);
+#endif
+                char ts[32]; std::strftime(ts, sizeof(ts), "%Y%m%d-%H%M%S", &tmv);
+                const std::string tmpOut = datadir + "/wallet.rebuilt-" + std::string(ts) + ".tmp";
+                { std::error_code ec; fs::remove(tmpOut, ec); }   // helper uses DB_EXCL — path must be fresh
+
+                // 3. Run the helper (src -> tmpOut). Quote both paths; capture its JSON line.
+                std::string cmd = "\"" + helper + "\" \"" + src + "\" \"" + tmpOut + "\"";
+#ifdef _WIN32
+                cmd = "\"" + cmd + "\"";                          // cmd.exe strips the outermost quotes
+                FILE* fp = _popen(cmd.c_str(), "r");
+#else
+                FILE* fp = popen(cmd.c_str(), "r");
+#endif
+                std::string jout;
+                if (fp) { char b[512]; while (std::fgets(b, sizeof b, fp)) jout += b; }
+#ifdef _WIN32
+                const int rc = fp ? _pclose(fp) : -1;
+#else
+                const int rc = fp ? pclose(fp) : -1;
+#endif
+                DEBUG_LOGF("[App] wallet-rebuild helper rc=%d out=%s\n", rc, jout.c_str());
+
+                // 4. Verify-before-swap: the output must be a readable BDB with the fund-critical keys.
+                const auto probe = util::parseWalletBtree(tmpOut);
+                if (rc != 0 || !probe.parsed || probe.addresses() == 0) {
+                    std::error_code ec; fs::remove(tmpOut, ec);
+                    err = TR("wallet_rebuild_failed");
+                } else {
+                    // 5. Swap: set the current wallet aside (kept), install the rebuilt one, clear stale env.
+                    std::error_code ec;
+                    const std::string aside = active + ".prerebuild-" + std::string(ts) + ".dat";
+                    bool moved = false;
+                    if (fs::exists(active)) {
+                        fs::rename(active, aside, ec);
+                        if (ec) err = TR("wallet_restore_move_failed"); else moved = true;
+                    }
+                    if (err.empty()) {
+                        fs::rename(tmpOut, active, ec);
+                        if (ec) {
+                            if (moved) { std::error_code e2; fs::rename(aside, active, e2); }
+                            err = TR("wallet_rebuild_install_failed");
+                        }
+                    }
+                    if (err.empty()) {
+                        std::error_code e2;
+                        if (fs::exists(datadir + "/database"))
+                            fs::rename(datadir + "/database", datadir + "/database.prerebuild-" + std::string(ts) + ".bak", e2);
+                        for (const auto& e : fs::directory_iterator(datadir, e2))
+                            if (e.path().filename().string().rfind("__db.", 0) == 0) { std::error_code e3; fs::remove(e.path(), e3); }
+                        if (daemon_controller_) daemon_controller_->setRescanOnNextStart(true);
+                    }
+                }
+            }
+
+            if (!shutting_down_) {
+                if (daemon_controller_) daemon_controller_->clearExternalDaemonDetected();
+                if (!startEmbeddedDaemon() && err.empty()) warn = TR("wallet_restore_no_restart");
+            }
+        } catch (const std::exception& e) {
+            err = std::string("Rebuild failed: ") + e.what();
+        } catch (...) {
+            err = "Rebuild failed due to an unexpected error.";
+        }
+        daemon_restarting_ = false;
+
+        std::lock_guard<std::mutex> lk(wallet_restore_mutex_);
+        wallet_restore_severity_ = !err.empty() ? 2 : (!warn.empty() ? 1 : 0);
+        wallet_restore_msg_ = !err.empty() ? err : (!warn.empty() ? warn : std::string(TR("wallet_rebuild_ok")));
+        wallet_restore_done_ = true;
+    });
+}
+
 void App::pumpSeedMigration()
 {
     if (capture_mode_) return;  // no live ops during a UI sweep (steps are set directly)
@@ -4386,6 +4910,7 @@ void App::pumpSeedMigration()
                     settings_->setSeedMigrationDest("");
                     settings_->setSeedMigrationTempDir("");
                     settings_->setSeedMigrationSweepTxid("");
+                    settings_->setSeedMigrationSweepOpid("");  // W3-3
                     settings_->save();
                 }
                 seed_migration_status_ = err;  // a non-empty warning here (e.g. restart hiccup) is shown on Done
@@ -4428,6 +4953,11 @@ void App::pumpSeedMigration()
             settings_->setSeedMigrationPending(true);
             settings_->setSeedMigrationDest(seed_migration_dest_);
             settings_->setSeedMigrationTempDir(seed_migration_temp_dir_);
+            // W3-3: a brand-new migration has done no sweep yet — clear any sweep artifacts left over
+            // from a prior aborted run so reopening this fresh migration can't mis-resume on a stale
+            // txid/opid (the resume block reads these whenever the migration is pending).
+            settings_->setSeedMigrationSweepTxid("");
+            settings_->setSeedMigrationSweepOpid("");
             settings_->save();
         }
     } else {
@@ -4456,13 +4986,12 @@ void App::backupWallet(const std::string& destination, std::function<void(bool,
             return;
         }
 
-        std::ofstream file(destination);
-        if (!file.is_open()) {
-            if (callback) callback(false, "Could not open file: " + destination);
+        // Write the key backup atomically and owner-only (0600) — it must never be even briefly
+        // world-readable, and the previous std::ofstream left it at the umask default.
+        if (!util::Platform::writeFileAtomically(destination, keys, /*restrictPermissions=*/true)) {
+            if (callback) callback(false, "Could not write file: " + destination);
             return;
         }
-        file << keys;
-        file.close();
 
         std::string msg = "Wallet backup saved to " + destination + " — "
                         + std::to_string(exported) + " of " + std::to_string(total) + " keys.";
@@ -4537,7 +5066,10 @@ void App::sendTransaction(const std::string& from, const std::string& to,
     recipient["address"] = to;
     recipient["amount"] = util::formatAmountFixed(amount);
     if (!memo.empty()) {
-        recipient["memo"] = memo;
+        // The daemon rejects a raw memo — it wants hex or a "utf8:" prefix. Prefix the user's plain-text
+        // memo so it's UTF-8-encoded into the note (same as the chat path). The unprefixed `memo` is still
+        // passed to submitZSendMany below for the tx-history display.
+        recipient["memo"] = "utf8:" + memo;
     }
     recipients.push_back(recipient);
     
@@ -4681,7 +5213,7 @@ void App::resendWithFeeGapWorkaround(const std::string& from, const std::string&
     nlohmann::json primary;
     primary["address"] = to;
     primary["amount"] = util::formatAmountFixed(amount);
-    if (!memo.empty()) primary["memo"] = memo;
+    if (!memo.empty()) primary["memo"] = "utf8:" + memo;   // daemon needs hex or a "utf8:" prefix (see submit)
     recipients.push_back(primary);
     nlohmann::json selfOut;
     selfOut["address"] = from;

src/app_security.cpp

@@ -33,6 +33,10 @@
 #include <ctime>
 #include <cstdint>
 #include <filesystem>
+#include <fstream>
+#include <vector>
+#include <utility>
+#include <sodium.h>
 #include <functional>
 #include <memory>
 #include <utility>
@@ -483,7 +487,17 @@ void App::lockWallet() {
                 state_.locked = true;
                 state_.unlocked_until = 0;
                 resetTransactionHistoryCacheSession();
+                lock_failure_warned_ = false;
                 DEBUG_LOGF("[App] Wallet locked\n");
+            } else {
+                // The walletlock RPC failed — the wallet is still UNLOCKED. Surface it (once) rather
+                // than silently leaving an auto-lock unfulfilled and the wallet exposed (W2-4).
+                DEBUG_LOGF("[App] walletlock failed — wallet remains unlocked\n");
+                if (!lock_failure_warned_) {
+                    lock_failure_warned_ = true;
+                    ui::Notifications::instance().warning(
+                        "Couldn't lock the wallet — it is still unlocked. Check the daemon connection.", 12.0f);
+                }
             }
         };
     });
@@ -560,6 +574,12 @@ void App::refreshWalletEncryptionState() {
                     state_.unlocked_until = until;
                     state_.locked = (until == 0);
                     state_.encryption_state_known = true;
+                    // Wallet is encrypted — any pending deferred-encryption request has now been
+                    // satisfied (however it completed). Clear the persisted flag (W2-2).
+                    if (settings_ && settings_->getEncryptionPending()) {
+                        settings_->setEncryptionPending(false);
+                        settings_->save();
+                    }
                     if (state_.locked) {
                         resetTransactionHistoryCacheSession();
                     } else if (state_.transactions.empty()) {
@@ -572,6 +592,19 @@ void App::refreshWalletEncryptionState() {
                     state_.locked = false;
                     state_.unlocked_until = 0;
                     state_.encryption_state_known = true;
+                    // W2-2: encryption was requested (persisted flag) but the wallet is NOT encrypted,
+                    // and no deferred encryption is pending/in-flight — it was lost to a quit/crash or a
+                    // failed connect before it applied. Warn (once/session) instead of silently leaving
+                    // an unencrypted wallet the user believes is protected. The flag stays set until the
+                    // wallet is actually encrypted, so the warning recurs each launch until resolved.
+                    if (settings_ && settings_->getEncryptionPending() &&
+                        !wallet_security_.hasDeferredEncryption() && !encrypt_in_progress_ &&
+                        !encryption_incomplete_warned_) {
+                        encryption_incomplete_warned_ = true;
+                        ui::Notifications::instance().warning(
+                            "Wallet encryption did not complete — your wallet is NOT encrypted. "
+                            "Open Settings to finish encrypting it.", 30.0f);
+                    }
                     if (state_.transactions.empty()) {
                         loadTransactionHistoryCacheIfAvailable();
                     } else {
@@ -1478,12 +1511,14 @@ void App::renderDecryptWalletDialog() {
 
                 // Run entire decrypt flow on worker thread
                 if (worker_) {
-                    worker_->post([this, passphrase]() -> rpc::RPCWorker::MainCb {
+                    worker_->post([this, passphrase = std::move(passphrase)]() mutable -> rpc::RPCWorker::MainCb {
                         WalletSecurityDecryptRpcAdapter decryptRpc(rpc_.get(),
                             [this](rpc::RPCClient& client, const char* context) {
                                 return sendStopCommandSafely(client, context);
                             });
                         auto unlock = services::WalletSecurityWorkflowExecutor::unlockWallet(passphrase, decryptRpc);
+                        // Scrub the passphrase — unlock is its only use in this flow.
+                        if (!passphrase.empty()) sodium_memzero(&passphrase[0], passphrase.size());
                         if (!unlock.ok) {
                                 return [this]() {
                                 wallet_security_workflow_.failEntry("Incorrect passphrase");
@@ -1606,6 +1641,27 @@ void App::renderDecryptWalletDialog() {
                                                         WalletSecurityImportRpcAdapter importAdapter(rpc_.get(), saved_config_);
                                                         auto importResult = services::WalletSecurityWorkflowExecutor::importWallet(
                                                             importAdapter, exportPath);
+
+                                                        // The plaintext key export (obsidiandecryptexport…) has served its purpose now
+                                                        // that the import attempt has resolved — scrub and remove it so a full cleartext
+                                                        // dump of every private key isn't left on disk forever. Recovery, if ever needed,
+                                                        // is the encrypted backup (wallet.dat.encrypted.bak), never this file.
+                                                        {
+                                                            std::error_code delEc;
+                                                            const auto sz = std::filesystem::file_size(exportPath, delEc);
+                                                            if (!delEc && sz > 0) {
+                                                                std::fstream scrub(exportPath,
+                                                                    std::ios::binary | std::ios::in | std::ios::out);
+                                                                if (scrub) {
+                                                                    const std::vector<char> zeros(static_cast<size_t>(sz), 0);
+                                                                    scrub.write(zeros.data(), static_cast<std::streamsize>(sz));
+                                                                    scrub.flush();
+                                                                }
+                                                            }
+                                                            std::filesystem::remove(exportPath, delEc);
+                                                            DEBUG_LOGF("[decrypt] removed plaintext key export after import\n");
+                                                        }
+
                                                         if (!importResult.ok) {
                                                             std::string err = importResult.error;
                                                             if (worker_) {

src/app_sweep.cpp

@@ -170,10 +170,10 @@ void App::installDemoWalletData()
     }
 
     auto zaddr = [](const char* a, double bal, const char* label) {
-        AddressInfo i; i.address = a; i.balance = bal; i.type = "shielded"; i.label = label; return i;
+        AddressInfo i; i.address = a; i.balance = bal; i.spendableBalance = bal; i.type = "shielded"; i.label = label; return i;
     };
     auto taddr = [](const char* a, double bal, const char* label) {
-        AddressInfo i; i.address = a; i.balance = bal; i.type = "transparent"; i.label = label; return i;
+        AddressInfo i; i.address = a; i.balance = bal; i.spendableBalance = bal; i.type = "transparent"; i.label = label; return i;
     };
     state_.z_addresses = {
         zaddr("zs1demoprimaryshieldedaddressforuisweep000000000000000000000000000", 12.0, "Savings"),

src/app_wizard.cpp

@@ -1338,6 +1338,10 @@ void App::renderFirstRunWizard() {
                     wallet_security_.beginDeferredEncryption(
                         std::string(encrypt_pass_buf_),
                         (pinEntered && pinOk) ? pinStr : std::string());
+                    // Persist that encryption was requested (never the passphrase) so a quit/crash or
+                    // failed daemon connect before it applies isn't silent — reconciled on the next
+                    // connect in refreshWalletEncryptionState (W2-2). Saved with the wizard state below.
+                    settings_->setEncryptionPending(true);
 
                     // Clear sensitive buffers
                     memset(encrypt_pass_buf_, 0, sizeof(encrypt_pass_buf_));

src/config/settings.cpp

@@ -231,12 +231,14 @@ bool Settings::load(const std::string& path)
         }
         loadScalar(j, "wizard_completed", wizard_completed_);
         loadScalar(j, "seed_backup_reminded", seed_backup_reminded_);
+        loadScalar(j, "encryption_pending", encryption_pending_);
         loadScalar(j, "daemon_update_prompted_size", daemon_update_prompted_size_);
         loadScalar(j, "active_wallet_file", active_wallet_file_);
         loadScalar(j, "seed_migration_pending", seed_migration_pending_);
         loadScalar(j, "seed_migration_dest", seed_migration_dest_);
         loadScalar(j, "seed_migration_temp_dir", seed_migration_temp_dir_);
         loadScalar(j, "seed_migration_sweep_txid", seed_migration_sweep_txid_);
+        loadScalar(j, "seed_migration_sweep_opid", seed_migration_sweep_opid_);
         loadScalar(j, "auto_lock_timeout", auto_lock_timeout_);
         loadScalar(j, "unlock_duration", unlock_duration_);
         loadScalar(j, "pin_enabled", pin_enabled_);
@@ -497,12 +499,14 @@ bool Settings::save(const std::string& path)
     }
     j["wizard_completed"] = wizard_completed_;
     j["seed_backup_reminded"] = seed_backup_reminded_;
+    j["encryption_pending"] = encryption_pending_;
     j["daemon_update_prompted_size"] = daemon_update_prompted_size_;
     j["active_wallet_file"] = active_wallet_file_;
     j["seed_migration_pending"] = seed_migration_pending_;
     j["seed_migration_dest"] = seed_migration_dest_;
     j["seed_migration_temp_dir"] = seed_migration_temp_dir_;
     j["seed_migration_sweep_txid"] = seed_migration_sweep_txid_;
+    j["seed_migration_sweep_opid"] = seed_migration_sweep_opid_;
     j["auto_lock_timeout"] = auto_lock_timeout_;
     j["unlock_duration"] = unlock_duration_;
     j["pin_enabled"] = pin_enabled_;

src/config/settings.h

@@ -327,6 +327,12 @@ public:
     bool getSeedBackupReminded() const { return seed_backup_reminded_; }
     void setSeedBackupReminded(bool v) { seed_backup_reminded_ = v; }
 
+    // Persisted the moment deferred (wizard) encryption is requested; cleared only once the wallet is
+    // observed to be actually encrypted. Lets a quit/crash/failed-connect before it applies be detected
+    // and surfaced (W2-2). NEVER stores the passphrase — only the fact that encryption was requested.
+    bool getEncryptionPending() const { return encryption_pending_; }
+    void setEncryptionPending(bool v) { encryption_pending_ = v; }
+
     // Bundled-daemon size we last prompted to install (see App::renderDaemonUpdatePrompt). Lets the
     // "a newer node is bundled — update?" prompt fire once per wallet version, never re-nagging.
     long long getDaemonUpdatePromptedSize() const { return daemon_update_prompted_size_; }
@@ -350,6 +356,11 @@ public:
     // migration is past the sweep, so a resume goes to the confirm/adopt stage (not sweep again).
     std::string getSeedMigrationSweepTxid() const { return seed_migration_sweep_txid_; }
     void setSeedMigrationSweepTxid(const std::string& v) { seed_migration_sweep_txid_ = v; }
+    // W3-3: the async sweep operation id, persisted while the sweep is in flight (before it resolves
+    // to a txid). Lets a resume re-poll a mid-sweep interruption instead of dropping the txid. Cleared
+    // in the same write that persists the txid, so the txid always outranks it (see [[decideSeedMigrationResume]]).
+    std::string getSeedMigrationSweepOpid() const { return seed_migration_sweep_opid_; }
+    void setSeedMigrationSweepOpid(const std::string& v) { seed_migration_sweep_opid_ = v; }
 
     // Security — auto-lock timeout (seconds; 0 = disabled)
     int getAutoLockTimeout() const { return auto_lock_timeout_; }
@@ -574,12 +585,14 @@ private:
     std::map<std::string, AddressMeta> address_meta_;
     bool wizard_completed_ = false;
     bool seed_backup_reminded_ = false;
+    bool encryption_pending_ = false;
     long long daemon_update_prompted_size_ = 0;  // bundled daemon size last offered via the update prompt
     std::string active_wallet_file_ = "wallet.dat";  // -wallet=<name> the daemon loads (multi-wallet)
     bool seed_migration_pending_ = false;
     std::string seed_migration_dest_;
     std::string seed_migration_temp_dir_;
     std::string seed_migration_sweep_txid_;
+    std::string seed_migration_sweep_opid_;
     int auto_lock_timeout_ = 900;   // 15 minutes
     int unlock_duration_ = 600;     // 10 minutes
     bool pin_enabled_ = false;

src/daemon/daemon_controller.cpp

@@ -126,6 +126,11 @@ void DaemonController::setSalvageOnNextStart(bool enabled)
     daemon_->setSalvageOnNextStart(enabled);
 }
 
+void DaemonController::setReindexOnNextStart(bool enabled)
+{
+    daemon_->setReindexOnNextStart(enabled);
+}
+
 bool DaemonController::zapOnNextStart() const
 {
     return daemon_->zapOnNextStart();

src/daemon/daemon_controller.h

@@ -108,6 +108,7 @@ public:
     void setZapOnNextStart(bool enabled);
     bool zapOnNextStart() const;
     void setSalvageOnNextStart(bool enabled);
+    void setReindexOnNextStart(bool enabled);   // -reindex: rebuild the block DB from raw blocks on next start
 
     static ShutdownDecision evaluateShutdownPolicy(bool hasDaemon,
                                                    bool externalDaemonDetected,

src/daemon/daemon_startup_diagnosis.h

@@ -0,0 +1,97 @@
+// DragonX Wallet - ImGui Edition
+// Copyright 2024-2026 The Hush Developers
+// Released under the GPLv3
+//
+// daemon_startup_diagnosis.h — pure classifiers over a crashed daemon's captured console output,
+// so the app can offer a targeted one-click fix instead of a bare "daemon crashed" / silent no-funds.
+
+#pragma once
+
+#include <string>
+#include <utility>
+#include <vector>
+
+namespace dragonx {
+namespace daemon {
+
+// True when dragonxd aborted because its BLOCK DATABASE could not be loaded — either a
+// daemon-vs-chaindata serialization-format mismatch after a daemon update (the deterministic
+// "non-canonical optional discriminant" → "Error loading block database" → "Aborted block database
+// rebuild. Exiting." sequence) or a genuinely corrupt/incomplete block index. In BOTH cases the fix
+// is the same: `-reindex` rebuilds the index + chainstate from the intact raw blocks (blk*.dat).
+// This is what otherwise silently presents as a wallet with zero balance — the node never starts.
+inline bool blockDbOutputLooksBroken(const std::string& out)
+{
+    return out.find("Error loading block database")        != std::string::npos
+        || out.find("non-canonical optional discriminant") != std::string::npos
+        || out.find("Aborted block database rebuild")      != std::string::npos
+        || out.find("LoadBlockIndex()")                    != std::string::npos;  // "... : failed to read value"
+}
+
+// True when dragonxd AUTO-RECOVERED the wallet on startup: on any BDB-verify failure it moves the
+// original wallet.dat to "wallet.{timestamp}.bak", salvages readable keys into a fresh wallet.dat, and
+// keeps running — no flag required (CWallet::Verify → CDBEnv::Verify(walletFile, CWalletDB::Recover)).
+// The salvage can be incomplete (or a false positive from stale/cross-platform BDB env state), so the
+// node silently comes up on a possibly-empty wallet — which reads as fund loss unless we surface it.
+inline bool walletAutoRecovered(const std::string& out)
+{
+    // Cover BOTH salvage outcomes. A successful salvage prints the "data salvaged"/"saved as wallet.<ts>.bak"
+    // warning; a FAILED one (e.g. an inconsistent-but-readable file where aggressive salvage finds no
+    // records) prints "salvage failed"/"found no records". In every case CWalletDB::Recover first logs
+    // "Renamed <wallet> to wallet.<ts>.bak" and CDBEnv::Salvage logs its own banner — those two fire the
+    // instant a salvage begins, before the daemon may abort, so they're the earliest reliable signal.
+    return out.find("CDBEnv::Salvage")                     != std::string::npos   // salvage is running
+        || out.find("wallet.dat corrupt, data salvaged")   != std::string::npos   // RECOVER_OK
+        || out.find("Original wallet.dat saved as wallet.") != std::string::npos
+        || out.find("wallet.dat corrupt, salvage failed")  != std::string::npos   // RECOVER_FAIL
+        || out.find("found no records in wallet")           != std::string::npos   // aggressive salvage empty
+        || (out.find("Renamed ") != std::string::npos && out.find(" to wallet.") != std::string::npos
+            && out.find(".bak") != std::string::npos);                             // Recover moved wallet.dat aside
+}
+
+// If `name` is a daemon salvage backup "wallet.<unixtime>.bak", return its timestamp; else -1.
+inline long long parseWalletSalvageBakTs(const std::string& name)
+{
+    if (name.rfind("wallet.", 0) != 0) return -1;                                   // must start "wallet."
+    if (name.size() < 12 || name.compare(name.size() - 4, 4, ".bak") != 0) return -1;  // ...and end ".bak"
+    const std::string mid = name.substr(7, name.size() - 7 - 4);                    // digits between the dots
+    if (mid.empty() || mid.size() > 18) return -1;
+    for (char c : mid) if (c < '0' || c > '9') return -1;
+    long long ts = 0;
+    for (char c : mid) ts = ts * 10 + (c - '0');
+    return ts;
+}
+
+// Most RECENT salvage backup (highest timestamp). Pure, testable.
+inline std::string newestWalletSalvageBak(const std::vector<std::string>& filenames)
+{
+    long long best = -1;
+    std::string bestName;
+    for (const auto& f : filenames) {
+        const long long ts = parseWalletSalvageBakTs(f);
+        if (ts > best) { best = ts; bestName = f; }
+    }
+    return bestName;
+}
+
+// LARGEST salvage backup, from (filename, fileSize) pairs — the least-salvaged one, i.e. the original.
+// This is what "Restore original wallet" should use: a salvage CASCADE shrinks the wallet each round, so
+// the newest .bak is the WORST and the largest is the pristine pre-salvage original (an emptied salvage
+// is tiny; a real wallet is large). Ties break toward the newest timestamp. Returns "" if none present.
+inline std::string largestWalletSalvageBak(const std::vector<std::pair<std::string, unsigned long long>>& files)
+{
+    std::string bestName;
+    unsigned long long bestSize = 0;
+    long long bestTs = -1;
+    for (const auto& fp : files) {
+        const long long ts = parseWalletSalvageBakTs(fp.first);
+        if (ts < 0) continue;
+        if (fp.second > bestSize || (fp.second == bestSize && ts > bestTs)) {
+            bestSize = fp.second; bestTs = ts; bestName = fp.first;
+        }
+    }
+    return bestName;
+}
+
+}  // namespace daemon
+}  // namespace dragonx

src/daemon/embedded_daemon.cpp

@@ -488,6 +488,34 @@ bool EmbeddedDaemon::start(const std::string& binary_path)
         return false;
     }
     external_daemon_detected_ = false;
+
+    // A previous dragonxd can release the RPC port well before it releases the datadir
+    // .lock — a graceful shutdown can take up to ~90s (see isDaemonProcessRunning). Starting
+    // into a still-held lock spawns a process that dies instantly with "Cannot obtain a lock
+    // on data directory"; the crash monitor reports that generically and, three times in
+    // ~12s, that is enough to trip the 3-strike restart cap before the lock's ~90s life
+    // elapses. Gate on the process actually still being alive, with a SHORT bounded wait
+    // (not the full ~90s — start() runs on the UI thread). Isolated starts (migrate-to-seed:
+    // skip_port_check_ / -datadir override) are exempt; they run their own datadir+port.
+    {
+        constexpr int kDatadirLockWaitPollMs   = 100;
+        constexpr int kDatadirLockWaitMaxPolls = 3;   // ~300ms total, breaks early on exit
+        bool stillRunning = false;
+        if (!skip_port_check_ && override_datadir_.empty()) {
+            stillRunning = isDaemonProcessRunning();
+            for (int i = 0; stillRunning && i < kDatadirLockWaitMaxPolls; ++i) {
+                std::this_thread::sleep_for(std::chrono::milliseconds(kDatadirLockWaitPollMs));
+                stillRunning = isDaemonProcessRunning();
+            }
+        }
+        const StartLockGateDecision gate =
+            evaluateDatadirLockGate(skip_port_check_, !override_datadir_.empty(), stillRunning);
+        if (!gate.proceed) {
+            VERBOSE_LOGF("[INFO] %s\n", gate.errorMessage);
+            setState(State::Error, gate.errorMessage);
+            return false;
+        }
+    }
     
     setState(State::Starting, "Looking for dragonxd binary...");
     
@@ -543,6 +571,14 @@ bool EmbeddedDaemon::start(const std::string& binary_path)
         args.push_back("-rescan");
     }
 
+    // -reindex rebuilds the block index + chainstate from the raw blocks (fixes an unreadable/format-
+    // mismatched block DB). It's about the CHAIN, not the wallet, so it's independent of the wallet-repair
+    // chain above (and implies its own wallet rescan). One-shot, consumed here.
+    if (reindex_on_next_start_.exchange(false)) {
+        DEBUG_LOGF("[INFO] Adding -reindex flag to rebuild the block database from raw blocks\n");
+        args.push_back("-reindex");
+    }
+
     // One-shot isolated-datadir override (migrate-to-seed flow): run this start against a
     // throwaway datadir, plus any extra args (e.g. -connect=0). Consumed here so later starts
     // revert to the normal datadir. The datadir's basename MUST be the assetchain name (DRAGONX)
@@ -557,8 +593,14 @@ bool EmbeddedDaemon::start(const std::string& binary_path)
     override_extra_args_.clear();
 
     if (!startProcess(daemon_path, args)) {
-        DEBUG_LOGF("[ERROR] Failed to start dragonxd process: %s\\n", last_error_.c_str());
-        setState(State::Error, "Failed to start dragonxd process");
+        // startProcess() sets a precise last_error_ (e.g. "dragonxd could not be executed:
+        // ... not executable or wrong architecture"). Surface THAT via setState — which also
+        // stores the Error message into last_error_ — instead of clobbering it with a generic
+        // string that would then be all getLastError()/the UI ever sees.
+        std::string detail = last_error_.empty() ? std::string("Failed to start dragonxd process")
+                                                  : last_error_;
+        DEBUG_LOGF("[ERROR] %s\n", detail.c_str());
+        setState(State::Error, detail);
         return false;
     }
     
@@ -962,18 +1004,38 @@ bool EmbeddedDaemon::startProcess(const std::string& binary_path, const std::vec
         last_error_ = "Failed to create pipe: " + std::string(strerror(errno));
         return false;
     }
+
+    // Self-pipe used purely as an exec-success/failure handshake, separate from
+    // the stdout pipe above. Both ends are close-on-exec, so a successful execv()
+    // closes the write end for free (parent reads EOF); on execv() failure the
+    // child writes errno here, so the parent learns synchronously instead of
+    // reporting State::Running for a child that never became dragonxd. We use
+    // pipe()+FD_CLOEXEC (not pipe2) because this POSIX branch is shared with
+    // macOS, which has no pipe2().
+    int execpipe[2];
+    if (pipe(execpipe) == -1) {
+        last_error_ = "Failed to create exec-status pipe: " + std::string(strerror(errno));
+        close(pipefd[0]);
+        close(pipefd[1]);
+        return false;
+    }
+    fcntl(execpipe[0], F_SETFD, FD_CLOEXEC);
+    fcntl(execpipe[1], F_SETFD, FD_CLOEXEC);
     
     pid_t pid = fork();
     if (pid == -1) {
         last_error_ = "Fork failed: " + std::string(strerror(errno));
         close(pipefd[0]);
         close(pipefd[1]);
+        close(execpipe[0]);
+        close(execpipe[1]);
         return false;
     }
     
     if (pid == 0) {
         // Child process
-        close(pipefd[0]);  // Close read end
+        close(pipefd[0]);   // Close read end of the stdout pipe
+        close(execpipe[0]); // Child only writes the exec-status pipe
         
         // Put child in its own process group so we can kill the entire
         // group later (including dragonxd spawned by a wrapper script).
@@ -1040,22 +1102,61 @@ bool EmbeddedDaemon::startProcess(const std::string& binary_path, const std::vec
             execv(binary_path.c_str(), argv.data());
         }
         
-        // If we get here, exec failed
-        fprintf(stderr, "execv failed: %s\n", strerror(errno));
+        // If we get here, execv() failed — the child never became dragonxd.
+        // Capture errno before fprintf/strerror can clobber it, report it to
+        // the parent over the exec-status pipe (EINTR-safe), then exit.
+        int exec_errno = errno;
+        fprintf(stderr, "execv failed: %s\n", strerror(exec_errno));
+        ssize_t w;
+        do {
+            w = write(execpipe[1], &exec_errno, sizeof(exec_errno));
+        } while (w < 0 && errno == EINTR);
         _exit(127);
     }
     
     // Parent process
-    close(pipefd[1]);  // Close write end
+    close(pipefd[1]);   // Close our copy of the stdout write end
+    close(execpipe[1]); // Must close our copy, or the read() below never sees EOF
+
+    // Exec-status handshake: EOF => execv() succeeded (its write end was closed
+    // on exec); a full sizeof(int) => execv() failed and the child sent errno.
+    int child_errno = 0;
+    size_t got = 0;
+    char* ep = reinterpret_cast<char*>(&child_errno);
+    for (;;) {
+        ssize_t n = read(execpipe[0], ep + got, sizeof(child_errno) - got);
+        if (n == 0) break;                                   // EOF: exec succeeded
+        if (n < 0) { if (errno == EINTR) continue; break; }  // other error: assume success
+        got += static_cast<size_t>(n);
+        if (got >= sizeof(child_errno)) break;               // full errno: exec failed
+    }
+    close(execpipe[0]);
+
+    if (got >= sizeof(child_errno)) {
+        // execv() never replaced the child; it fprintf'd and _exit(127)'d. Reap
+        // the already-dead zombie here — monitorProcess() is only started after
+        // this function returns true, so there is no competing reaper.
+        close(pipefd[0]);
+        int status;
+        waitpid(pid, &status, 0);
+        last_error_ = "dragonxd could not be executed: " + std::string(strerror(child_errno)) +
+                      " — not executable or wrong architecture";
+        return false;
+    }
+
     stdout_fd_ = pipefd[0];
-    
-    // Also set process group from parent side (race with child's setpgid)
-    setpgid(pid, pid);
-    
+
+    // Best-effort: the child already calls setpgid(0, 0); this parent-side call
+    // just closes the fork/exec race window. A failure here is not fatal to
+    // startup, so we log rather than abort.
+    if (setpgid(pid, pid) != 0) {
+        DEBUG_LOGF("[WARN] setpgid(%d) from parent failed: %s\n", (int)pid, strerror(errno));
+    }
+
     // Set non-blocking
     int flags = fcntl(stdout_fd_, F_GETFL, 0);
     fcntl(stdout_fd_, F_SETFL, flags | O_NONBLOCK);
-    
+
     process_pid_ = pid;
     return true;
 }
@@ -1135,17 +1236,21 @@ double EmbeddedDaemon::getMemoryUsageMB() const
 
 bool EmbeddedDaemon::isRunning() const
 {
+    // Read the atomic state_ instead of calling waitpid() here. monitorProcess()
+    // is the sole thread allowed to waitpid() process_pid_ during normal operation.
+    // Calling waitpid() from this method too (as it used to, and this is invoked
+    // from the UI thread nearly every frame) meant whichever thread reaped the
+    // child's exit first consumed the status; if isRunning() won that race,
+    // monitorProcess() never saw the exit, so crash_count_ / the decoded exit
+    // code / the State::Error transition were all silently lost. Mirrors the
+    // fix already in XmrigManager::isRunning().
     if (process_pid_ <= 0) return false;
-    
-    int status;
-    pid_t result = waitpid(process_pid_, &status, WNOHANG);
-    
-    if (result == 0) {
-        // Still running
-        return true;
-    }
-    
-    return false;
+
+    const State s = state_.load(std::memory_order_relaxed);
+    // State::Stopping is included: stop()'s graceful/SIGTERM wait loops poll
+    // isRunning() while state_ == Stopping — before the process has actually
+    // terminated — and must keep seeing "alive" to wait/escalate correctly.
+    return (s == State::Running || s == State::Stopping);
 }
 
 void EmbeddedDaemon::drainOutput()

src/daemon/embedded_daemon.h

@@ -206,6 +206,13 @@ public:
     void setSalvageOnNextStart(bool v) { salvage_on_next_start_ = v; }
     bool salvageOnNextStart() const { return salvage_on_next_start_.load(); }
 
+    // -reindex: rebuild the block index + chainstate from the raw blocks (blk*.dat) on startup. One-shot,
+    // consumed on the next start. Offered when the node aborts on an unreadable block database (a
+    // daemon-vs-chaindata format mismatch after an update, or a corrupt index). It implies a wallet
+    // rescan, so it's the block-DB analogue of -salvagewallet and coexists with the wallet-repair flags.
+    void setReindexOnNextStart(bool v) { reindex_on_next_start_ = v; }
+    bool reindexOnNextStart() const { return reindex_on_next_start_.load(); }
+
     /**
      * @brief One-shot isolated-datadir override for the NEXT start(): run the daemon against a
      *        different datadir (with its own DRAGONX.conf) plus the given extra args. Used by the
@@ -235,6 +242,32 @@ public:
      */
     static bool isDaemonProcessRunning();
 
+    /** Decision returned by evaluateDatadirLockGate(): whether start() may spawn now. */
+    struct StartLockGateDecision {
+        bool proceed = true;             // false => bail before spawning
+        const char* errorMessage = "";   // set (a string literal) when proceed == false
+    };
+
+    /**
+     * @brief Pure decision for start(): bail because a previous dragonxd still holds the
+     *        shared datadir lock? Isolated instances (skip_port_check_ / an active -datadir
+     *        override) are exempt — they run their own throwaway datadir+port and can coexist
+     *        with the main daemon. Does no process/fs I/O itself (the caller does the probing),
+     *        so it is directly unit-testable; defined inline so tests need only this header.
+     */
+    static StartLockGateDecision evaluateDatadirLockGate(bool skipPortCheck,
+                                                         bool isolatedOverride,
+                                                         bool stillRunningAfterWait)
+    {
+        if (skipPortCheck || isolatedOverride) return {true, ""};
+        if (stillRunningAfterWait) {
+            return {false,
+                    "A previous dragonxd is still shutting down and holding the data "
+                    "directory lock. Retrying shortly…"};
+        }
+        return {true, ""};
+    }
+
     /** @brief Is an arbitrary TCP port currently in use on localhost? (used to pick a free port) */
     static bool tcpPortInUse(int port);
 
@@ -280,6 +313,7 @@ private:
     std::atomic<bool> rescan_on_next_start_{false};  // -rescan flag for next start
     std::atomic<bool> zap_on_next_start_{false};     // -zapwallettxes=2 flag for next start
     std::atomic<bool> salvage_on_next_start_{false}; // -salvagewallet flag for next start
+    std::atomic<bool> reindex_on_next_start_{false}; // -reindex flag for next start (rebuild block DB)
     std::string override_datadir_;                   // one-shot: -datadir for the next start
     std::vector<std::string> override_extra_args_;   // one-shot: extra args for the next start
     bool skip_port_check_ = false;                   // isolated instance on a non-default port

src/daemon/seed_wallet_creator.cpp

@@ -54,6 +54,16 @@ SeedWalletResult SeedWalletCreator::create(bool keepDatadir,
     //    RPC port. So the wallet lives in <base>/DRAGONX; `base` is the migration root we clean up.
     const std::string base = util::Platform::getConfigDir() + "/seed-migrate";
     const std::string dataDir = base + "/DRAGONX";
+    // W3-2: never blindly wipe a pre-existing temp seed wallet. A prior migration that swept funds into
+    // it but was abandoned or crashed before adopting would otherwise have its (fund-bearing) wallet
+    // destroyed here. A completed migration removes this dir on adopt, so a leftover means an unfinished
+    // one — refuse and point the user at it rather than silently destroying it.
+    if (fs::exists(dataDir + "/wallet.dat")) {
+        r.error = "A previous seed migration looks unfinished — its temporary wallet is still at\n" + base +
+                  "\nResume or cancel it first. If you are certain its funds are already in your main "
+                  "wallet, delete that folder and try again.";
+        return r;
+    }
     fs::remove_all(base, ec);
     fs::create_directories(dataDir, ec);
     if (ec) { r.error = "Could not create the temporary wallet directory."; return r; }

src/data/address_book.cpp

@@ -46,20 +46,25 @@ bool AddressBook::load()
         entries_.clear();
         
         if (j.contains("entries") && j["entries"].is_array()) {
+            size_t skipped = 0;
             for (const auto& entry : j["entries"]) {
-                AddressBookEntry e;
-                e.label = entry.value("label", "");
-                e.address = entry.value("address", "");
-                e.notes = entry.value("notes", "");
-                // Legacy entries (no "scope") migrate to "global" so nothing disappears when
-                // multi-wallet scoping lands — a contact you already had stays visible everywhere.
-                e.scope = entry.value("scope", "global");
-                e.avatar = entry.value("avatar", "");
-
-                if (!e.address.empty()) {
-                    entries_.push_back(e);
-                }
+                // W6-3: skip (and count) a malformed element rather than letting one bad entry throw and
+                // abort the whole load — which would discard EVERY contact (entries_ was already cleared).
+                if (!entry.is_object()) { ++skipped; continue; }
+                try {
+                    AddressBookEntry e;
+                    e.label = entry.value("label", "");
+                    e.address = entry.value("address", "");
+                    e.notes = entry.value("notes", "");
+                    // Legacy entries (no "scope") migrate to "global" so nothing disappears when
+                    // multi-wallet scoping lands — a contact you already had stays visible everywhere.
+                    e.scope = entry.value("scope", "global");
+                    e.avatar = entry.value("avatar", "");
+                    if (!e.address.empty()) entries_.push_back(e);
+                } catch (const std::exception&) { ++skipped; }
             }
+            if (skipped > 0)
+                DEBUG_LOGF("Address book: skipped %zu malformed entr%s\n", skipped, skipped == 1 ? "y" : "ies");
         }
         
         DEBUG_LOGF("Address book loaded: %zu entries\n", entries_.size());

src/data/seed_migration_resume.h

@@ -0,0 +1,37 @@
+#pragma once
+
+#include <string>
+
+// Pure routing decision for resuming a pending migrate-to-seed flow (finding W3-3). Kept free of
+// App/UI/RPC state so the highest-risk branch — where a reopened migration lands — is unit-testable
+// and reviewable in isolation. App::showSeedMigrationDialog feeds it the persisted state + live
+// connectivity and switches on the result. See src/app_network.cpp.
+namespace dragonx {
+
+enum class MigrationResume {
+    Intro,        // no pending migration → start fresh at the intro
+    Confirming,   // a sweep txid is persisted → resume at the confirm/adopt gate (re-derived from chain)
+    RetrackOpid,  // a sweep opid (but no txid yet) is persisted AND we're connected → re-poll it
+    SweepGate,    // otherwise → the dismissable Sweep step (reload balance, offer re-sweep)
+};
+
+// Decide where reopening the migration dialog lands.
+//
+// Invariant: the txid outranks the opid — once a sweep resolves to a txid the opid is cleared in the
+// same settings write, so a persisted txid always means "past the sweep". A persisted opid is only
+// re-tracked when connected, because the buttonless "Sweeping" spinner relies on the opid poller
+// (which needs an RPC connection) to ever exit; disconnected, we fall back to the dismissable Sweep
+// gate (which reloads the balance and, if the earlier sweep already drained it, short-circuits to
+// adopt) — never trapping the user.
+inline MigrationResume decideSeedMigrationResume(bool pending,
+                                                 bool haveDest,
+                                                 const std::string& sweepTxid,
+                                                 const std::string& sweepOpid,
+                                                 bool connected) {
+    if (!pending || !haveDest)  return MigrationResume::Intro;
+    if (!sweepTxid.empty())     return MigrationResume::Confirming;
+    if (!sweepOpid.empty() && connected) return MigrationResume::RetrackOpid;
+    return MigrationResume::SweepGate;
+}
+
+}  // namespace dragonx

src/data/wallet_state.cpp

@@ -19,12 +19,13 @@ std::vector<size_t> sortedSpendableAddressIndices(const std::vector<AddressInfo>
     for (size_t i = 0; i < addresses.size(); ++i) {
         const auto& address = addresses[i];
         if (!address.isSpendable()) continue;
-        if (requirePositiveBalance && address.balance <= 0.0) continue;
+        // Rank/filter by the CONFIRMED balance — an address holding only 0-conf change can't be sent from.
+        if (requirePositiveBalance && address.spendableBalance <= 0.0) continue;
         indices.push_back(i);
     }
 
     std::sort(indices.begin(), indices.end(), [&](size_t lhs, size_t rhs) {
-        return addresses[lhs].balance > addresses[rhs].balance;
+        return addresses[lhs].spendableBalance > addresses[rhs].spendableBalance;
     });
     return indices;
 }
@@ -34,8 +35,8 @@ int bestSpendableAddressIndex(const std::vector<AddressInfo>& addresses)
     int bestIndex = -1;
     double bestBalance = 0.0;
     for (size_t i = 0; i < addresses.size(); ++i) {
-        if (addresses[i].isSpendable() && addresses[i].balance > bestBalance) {
-            bestBalance = addresses[i].balance;
+        if (addresses[i].isSpendable() && addresses[i].spendableBalance > bestBalance) {
+            bestBalance = addresses[i].spendableBalance;
             bestIndex = static_cast<int>(i);
         }
     }

src/data/wallet_state.h

@@ -21,13 +21,17 @@ namespace dragonx {
  */
 struct AddressInfo {
     std::string address;
-    double balance = 0.0;
+    double balance = 0.0;            // DISPLAY total incl. pending 0-conf change (minconf=0)
     std::string type;  // "shielded" or "transparent"
     bool has_spending_key = true;  // false for view-only (imported via z_importviewingkey)
     
     // For display
     std::string label;
-    
+
+    // CONFIRMED balance (minconf>=1) — what z_sendmany can actually spend now. Kept last so positional
+    // brace-init of the leading fields (used in tests) still compiles.
+    double spendableBalance = 0.0;
+
     // Derived
     bool isZAddr() const { return !address.empty() && address[0] == 'z'; }
     bool isShielded() const { return type == "shielded"; }
@@ -252,12 +256,18 @@ struct WalletState {
     // Sync status
     SyncInfo sync;
     
-    // Balances (named to match UI usage)
-    double privateBalance = 0.0;     // shielded balance
+    // Balances (named to match UI usage). These are the DISPLAY totals — minconf=0, so they include the
+    // user's own pending change and don't crater during an unconfirmed send.
+    double privateBalance = 0.0;     // shielded balance (display, incl. pending change)
     double transparentBalance = 0.0;
     double totalBalance = 0.0;
-    double unconfirmedBalance = 0.0;
-    
+    double unconfirmedBalance = 0.0; // = totalBalance - spendableTotalBalance (the pending portion)
+    // CONFIRMED / spendable totals (minconf>=1) — what can actually be sent right now. z_sendmany runs at
+    // minconf=1, so the Send form / Max / spend validation must size off these, never the display totals.
+    double spendablePrivateBalance = 0.0;
+    double spendableTransparentBalance = 0.0;
+    double spendableTotalBalance = 0.0;
+
     // Aliases for backward compatibility
     double& shielded_balance = privateBalance;
     double& transparent_balance = transparentBalance;
@@ -325,6 +335,7 @@ struct WalletState {
         sync = SyncInfo{};
         privateBalance = transparentBalance = totalBalance = 0.0;
         unconfirmedBalance = 0.0;
+        spendablePrivateBalance = spendableTransparentBalance = spendableTotalBalance = 0.0;
         encrypted = false;
         locked = false;
         unlocked_until = 0;
@@ -335,6 +346,15 @@ struct WalletState {
         transactions.clear();
         peers.clear();
         bannedPeers.clear();
+        // W6-1: reset node-level mining state too — the daemon restarts on a wallet switch (mining
+        // stops), so leaving the previous wallet's hashrate/blocks would show stale mining stats.
+        mining = MiningInfo{};
+        pool_mining = PoolMiningState{};
+        // After a disconnect / wallet switch nothing is freshly known, so drop the "last successful
+        // refresh" stamps. Otherwise the pre-teardown time survives and, on reconnect, the staleness
+        // badge (and any "updated X ago" reader) briefly reports it as current until the first refresh
+        // re-stamps it. All readers treat 0 as "never" (formatTimeAgoShort/timeAgo return "").
+        last_balance_update = last_tx_update = last_peer_update = last_mining_update = 0;
     }
     
     // Rebuild combined addresses list from z/t lists

src/main.cpp

@@ -721,20 +721,105 @@ static void handleDisplayScaleChange(SDL_Window* window, float newScale,
     }
 }
 
+#if !defined(_WIN32)
+#include <csignal>
+#include <cstring>
+#include <unistd.h>
+#include <fcntl.h>
+#if defined(__has_include)
+#  if __has_include(<execinfo.h>)
+#    include <execinfo.h>
+#    define DRAGONX_HAVE_BACKTRACE 1
+#  endif
+#endif
+
+// Absolute path to the crash log, filled at install time so the async-signal handler needs no
+// allocation. (POSIX counterpart of the Windows SEH CrashHandler above — W7-3.)
+static char g_crashLogPath[1024] = {0};
+
+// Async-signal-safe crash handler: only open()/write()/backtrace_symbols_fd()/raise() are used —
+// no stdio, std::filesystem or malloc (all unsafe inside a signal handler).
+static void PosixCrashHandler(int sig)
+{
+    int fd = g_crashLogPath[0] ? open(g_crashLogPath, O_WRONLY | O_CREAT | O_APPEND, 0600) : -1;
+    if (fd >= 0) {
+        auto put = [fd](const char* s) { ssize_t n = write(fd, s, std::strlen(s)); (void)n; };
+        put("\n=== CRASH: signal ");
+        char num[16]; int i = 0, v = sig;                        // signal number -> decimal, no stdio
+        if (v == 0) { num[i++] = '0'; }
+        else { char tmp[16]; int t = 0; while (v > 0) { tmp[t++] = char('0' + v % 10); v /= 10; }
+               while (t > 0) num[i++] = tmp[--t]; }
+        num[i] = '\n';
+        ssize_t nn = write(fd, num, i + 1); (void)nn;
+#ifdef DRAGONX_HAVE_BACKTRACE
+        void* frames[64];
+        int nframes = backtrace(frames, 64);
+        backtrace_symbols_fd(frames, nframes, fd);               // async-signal-safe
+#endif
+        put("=== END CRASH ===\n");
+        close(fd);
+    }
+    // Restore the default disposition and re-raise so we still get a core dump / normal termination.
+    signal(sig, SIG_DFL);
+    raise(sig);
+}
+
+static void installPosixCrashHandler(const std::string& crashLogPath)
+{
+    std::snprintf(g_crashLogPath, sizeof(g_crashLogPath), "%s", crashLogPath.c_str());
+    struct sigaction sa;
+    std::memset(&sa, 0, sizeof(sa));
+    sa.sa_handler = PosixCrashHandler;
+    sigemptyset(&sa.sa_mask);
+    sa.sa_flags = 0;
+    for (int sig : {SIGSEGV, SIGABRT, SIGBUS, SIGFPE, SIGILL}) {
+        sigaction(sig, &sa, nullptr);
+    }
+}
+#endif  // !_WIN32
+
 int main(int argc, char* argv[])
 {
     // Ensure ObsidianDragon config directory exists early (before any file I/O)
     {
         std::string odDir = dragonx::util::Platform::getObsidianDragonDir();
-        std::error_code ec;
-        std::filesystem::create_directories(odDir, ec);
+        std::string odErr;
+        if (!dragonx::util::Platform::ensureDirectory(odDir, &odErr)) {
+            // Pre-App-init: nothing (ini, logs, config) can persist if this fails, and the
+            // Windows log redirect below isn't set up yet — report loudly before any setup.
+            std::fprintf(stderr, "%s\n", odErr.c_str());
+#ifdef _WIN32
+            MessageBoxA(nullptr, odErr.c_str(), DRAGONX_APP_NAME, MB_OK | MB_ICONERROR);
+#endif
+            return 1;
+        }
     }
 
-#ifdef _WIN32
-    // Redirect stdout/stderr to a log file so diagnostic output is visible
-    // even when built as a GUI app (WIN32_EXECUTABLE hides the console).
+    // W7-2: initialize the app-level Logger's file sink on ALL platforms so LOG/LOGF/VERBOSE_LOGF are
+    // actually persisted to dragonx-debug.log. Previously init() was never called, so on Linux/macOS the
+    // file never existed at all (the Windows-only stdout freopen below is a separate mechanism).
     {
-        std::string logPath = (std::filesystem::path(dragonx::util::Platform::getObsidianDragonDir()) / "dragonx-debug.log").string();
+        const std::string logPath =
+            (std::filesystem::path(dragonx::util::Platform::getObsidianDragonDir()) / "dragonx-debug.log").string();
+        dragonx::util::Logger::instance().init(logPath);
+    }
+
+#if !defined(_WIN32)
+    // W7-3: install the POSIX crash handler (the Windows SEH filter is installed below). A segfault or
+    // abort now leaves a backtrace in dragonx-crash.log instead of vanishing silently on Linux/macOS.
+    {
+        const std::string crashPath =
+            (std::filesystem::path(dragonx::util::Platform::getObsidianDragonDir()) / "dragonx-crash.log").string();
+        installPosixCrashHandler(crashPath);
+    }
+#endif
+
+#ifdef _WIN32
+    // Redirect raw stdout/stderr (library / daemon-pipe writes) to a log file so it's visible even when
+    // built as a GUI app (WIN32_EXECUTABLE hides the console). Separate file from the structured Logger
+    // above so the two writers don't interleave/contend on one file.
+    {
+        std::string logPath = (std::filesystem::path(dragonx::util::Platform::getObsidianDragonDir()) / "dragonx-stdout.log").string();
         freopen(logPath.c_str(), "w", stdout);
         freopen(logPath.c_str(), "a", stderr);
     }

src/resources/embedded_resources.cpp

@@ -40,6 +40,9 @@ static const EmbeddedResource s_resources[] = {
     { g_dragonx_cli_exe_data,       g_dragonx_cli_exe_size,       RESOURCE_DRAGONX_CLI },
     { g_dragonx_tx_exe_data,        g_dragonx_tx_exe_size,        RESOURCE_DRAGONX_TX },
 #endif
+#ifdef HAS_EMBEDDED_WALLET_REBUILD
+    { g_dragonx_wallet_rebuild_exe_data, g_dragonx_wallet_rebuild_exe_size, RESOURCE_DRAGONX_WALLET_REBUILD },
+#endif
 #ifdef HAS_EMBEDDED_XMRIG
     { g_xmrig_exe_data,             g_xmrig_exe_size,             RESOURCE_XMRIG },
 #endif
@@ -436,6 +439,24 @@ bool extractEmbeddedResources()
     }
 #endif
 
+#ifdef HAS_EMBEDDED_WALLET_REBUILD
+    // Offline wallet-rebuild recovery helper — extracted next to the daemon so a bare, self-extracting
+    // ObsidianDragon.exe still offers "Repair automatically" (findWalletRebuildHelper() checks this dir).
+    const EmbeddedResource* rebuildRes = getEmbeddedResource(RESOURCE_DRAGONX_WALLET_REBUILD);
+    if (rebuildRes) {
+        std::string dest = daemonDir + pathSep + RESOURCE_DRAGONX_WALLET_REBUILD;
+        if (!std::filesystem::exists(dest)) {
+            DEBUG_LOGF("[INFO] Extracting dragonx-wallet-rebuild (%zu MB)...\n", rebuildRes->size / (1024*1024));
+            if (!extractResource(rebuildRes, dest)) {
+                success = false;
+            }
+#ifndef _WIN32
+            else { chmod(dest.c_str(), 0755); }
+#endif
+        }
+    }
+#endif
+
     // Best-effort cleanup of any ".old" binaries left behind by a previous in-use replacement.
     // Once the old daemon/xmrig process has exited, the file is no longer locked and removes cleanly;
     // if it's still running, the remove fails harmlessly and we retry on the next startup.
@@ -450,6 +471,32 @@ bool extractEmbeddedResources()
     return success;
 }
 
+std::string ensureWalletRebuildHelperExtracted()
+{
+#ifdef HAS_EMBEDDED_WALLET_REBUILD
+    const EmbeddedResource* res = getEmbeddedResource(RESOURCE_DRAGONX_WALLET_REBUILD);
+    if (!res || res->size == 0) return {};
+#ifdef _WIN32
+    const char sep = '\\';
+#else
+    const char sep = '/';
+#endif
+    const std::string dir  = getDaemonDirectory();
+    const std::string dest = dir + sep + RESOURCE_DRAGONX_WALLET_REBUILD;
+    std::error_code ec;
+    if (std::filesystem::exists(dest, ec)) return dest;   // already extracted
+    std::filesystem::create_directories(dir, ec);
+    if (!extractResource(res, dest)) return {};
+#ifndef _WIN32
+    chmod(dest.c_str(), 0755);
+#endif
+    DEBUG_LOGF("[INFO] Extracted wallet-rebuild helper on demand: %s\n", dest.c_str());
+    return dest;
+#else
+    return {};
+#endif
+}
+
 std::string getDaemonDirectory()
 {
     // Daemon binaries live in %APPDATA%/ObsidianDragon/dragonx/ (Windows) or

src/resources/embedded_resources.h

@@ -55,6 +55,12 @@ BundledDaemonInfo getBundledDaemonInfo();
 // caller should stop the daemon first. Returns true if all present resources were written.
 bool reextractBundledDaemon();
 
+// Ensure the embedded offline wallet-rebuild recovery helper is extracted to the daemon dir, and
+// return its path ("" if not embedded in this build or extraction failed). Idempotent — extracts only
+// when missing. Unlike the first-run extractEmbeddedResources() (gated on needsParamsExtraction()),
+// this runs on demand so recovery works from a self-contained exe on ANY run, not just the first.
+std::string ensureWalletRebuildHelperExtracted();
+
 // Resource names
 constexpr const char* RESOURCE_SAPLING_SPEND = "sapling-spend.params";
 constexpr const char* RESOURCE_SAPLING_OUTPUT = "sapling-output.params";
@@ -62,6 +68,7 @@ constexpr const char* RESOURCE_ASMAP = "asmap.dat";
 constexpr const char* RESOURCE_DRAGONXD = "dragonxd.exe";
 constexpr const char* RESOURCE_DRAGONX_CLI = "dragonx-cli.exe";
 constexpr const char* RESOURCE_DRAGONX_TX = "dragonx-tx.exe";
+constexpr const char* RESOURCE_DRAGONX_WALLET_REBUILD = "dragonx-wallet-rebuild.exe";
 constexpr const char* RESOURCE_XMRIG = "xmrig.exe";
 constexpr const char* RESOURCE_DARK_GRADIENT = "dark_gradient.png";
 constexpr const char* RESOURCE_LOGO = "logo_ObsidianDragon_dark.png";

src/rpc/connection.cpp

@@ -14,8 +14,12 @@
 #include <filesystem>
 #include <algorithm>
 #include <cctype>
+#include <vector>
+#include <chrono>
 
 #include "../util/logger.h"
+#include "../util/platform.h"
+#include "../util/xmrig_updater.h"  // util::sha256Hex
 
 #ifdef _WIN32
 #include <shlobj.h>
@@ -120,30 +124,121 @@ std::string Connection::getSaplingParamsDir()
     return resources::getDaemonDirectory();
 }
 
-bool Connection::verifySaplingParams()
+namespace {
+
+std::string joinParamPath(const std::string& dir, const std::string& file) {
+#ifdef _WIN32
+    return dir + "\\" + file;
+#else
+    return dir + "/" + file;
+#endif
+}
+
+// "<size>:<mtime>" fingerprint used to skip re-hashing an unchanged file. Empty on error.
+std::string paramStatLine(const std::string& path) {
+    std::error_code ec;
+    auto sz = fs::file_size(path, ec);
+    if (ec) return {};
+    auto mtime = fs::last_write_time(path, ec);
+    long long ticks = ec ? 0 :
+        std::chrono::duration_cast<std::chrono::seconds>(mtime.time_since_epoch()).count();
+    return std::to_string(static_cast<unsigned long long>(sz)) + ":" + std::to_string(ticks);
+}
+
+bool paramHashMatches(const std::string& path, const std::string& expectedHex) {
+    std::ifstream f(path, std::ios::binary | std::ios::ate);
+    if (!f) return false;
+    std::streamsize sz = f.tellg();
+    if (sz <= 0) return false;
+    f.seekg(0, std::ios::beg);
+    std::vector<char> buf(static_cast<size_t>(sz));
+    if (!f.read(buf.data(), sz)) return false;
+    std::string got = util::sha256Hex(buf.data(), buf.size());
+    return !got.empty() && got == expectedHex;
+}
+
+// The verification cache: <params_dir>/.sapling_verified holds one paramStatLine per param,
+// in list order, from the last successful hash check.
+bool saplingMarkerMatches(const std::string& markerPath, const std::vector<std::string>& expected) {
+    for (const auto& s : expected) if (s.empty()) return false;   // couldn't stat -> don't trust
+    std::ifstream f(markerPath);
+    if (!f) return false;
+    std::vector<std::string> lines;
+    std::string l;
+    while (std::getline(f, l)) lines.push_back(l);
+    return lines == expected;
+}
+
+void writeSaplingMarker(const std::string& markerPath, const std::vector<std::string>& lines) {
+    std::ofstream f(markerPath, std::ios::trunc);
+    if (!f) return;
+    for (const auto& l : lines) f << l << "\n";
+}
+
+// Canonical Zcash-family Sapling trusted-setup param digests — identical bytes across every
+// fork/platform. Source of truth: scripts/build-lite-backend-artifact.sh ensure_sapling_params().
+// Keep in sync if the params are ever rotated.
+const std::pair<std::string, std::string> kSaplingParamDigests[] = {
+    { "sapling-spend.params",  "8e48ffd23abb3a5fd9c5589204f32d9c31285a04b78096ba40a79b75677efc13" },
+    { "sapling-output.params", "2f0ebbcbb9bb0bcffe95a397e7eba89c29eb4dde6191c339db88570e3f3fb0e4" },
+};
+
+} // namespace
+
+bool Connection::verifySaplingParamsIn(
+    const std::string& dir,
+    const std::vector<std::pair<std::string, std::string>>& digests)
 {
-    std::string params_dir = getSaplingParamsDir();
-    if (params_dir.empty()) {
+    if (dir.empty()) {
         DEBUG_LOGF("verifySaplingParams: params dir is empty\n");
         return false;
     }
-    
-#ifdef _WIN32
-    std::string spend_path = params_dir + "\\sapling-spend.params";
-    std::string output_path = params_dir + "\\sapling-output.params";
-#else
-    std::string spend_path = params_dir + "/sapling-spend.params";
-    std::string output_path = params_dir + "/sapling-output.params";
-#endif
-    
-    bool spend_exists = fs::exists(spend_path);
-    bool output_exists = fs::exists(output_path);
-    
-    DEBUG_LOGF("verifySaplingParams: dir=%s\n", params_dir.c_str());
-    DEBUG_LOGF("  spend: %s -> %s\n", spend_path.c_str(), spend_exists ? "found" : "MISSING");
-    DEBUG_LOGF("  output: %s -> %s\n", output_path.c_str(), output_exists ? "found" : "MISSING");
-    
-    return spend_exists && output_exists;
+    if (digests.empty()) return false;
+
+    // 1) Every param must exist.
+    std::vector<std::string> paths;
+    paths.reserve(digests.size());
+    for (const auto& d : digests) {
+        std::string p = joinParamPath(dir, d.first);
+        if (!fs::exists(p)) {
+            DEBUG_LOGF("verifySaplingParams: %s MISSING\n", p.c_str());
+            return false;
+        }
+        paths.push_back(std::move(p));
+    }
+
+    // 2) Fast path: if the cached marker matches the current size:mtime of every param, trust
+    //    the previous successful hash instead of re-hashing ~48MB on every startup.
+    const std::string markerPath = joinParamPath(dir, ".sapling_verified");
+    std::vector<std::string> current;
+    current.reserve(paths.size());
+    for (const auto& p : paths) current.push_back(paramStatLine(p));
+    if (saplingMarkerMatches(markerPath, current)) {
+        return true;
+    }
+
+    // 3) Integrity-check each param against its pinned SHA-256. A truncated or corrupt param
+    //    (a partial extraction, or a Linux bundle where the file merely *exists*) is rejected
+    //    here instead of being handed to the daemon and failing later on a shielded operation.
+    for (size_t i = 0; i < paths.size(); ++i) {
+        if (!paramHashMatches(paths[i], digests[i].second)) {
+            DEBUG_LOGF("verifySaplingParams: %s FAILED integrity check (truncated or corrupt)\n",
+                       paths[i].c_str());
+            return false;
+        }
+    }
+
+    // 4) Record the verified state so later startups take the fast path.
+    writeSaplingMarker(markerPath, current);
+    DEBUG_LOGF("verifySaplingParams: %zu params verified (sha256)\n", paths.size());
+    return true;
+}
+
+bool Connection::verifySaplingParams()
+{
+    std::vector<std::pair<std::string, std::string>> digests;
+    for (const auto& d : kSaplingParamDigests) digests.emplace_back(d.first, d.second);
+    return verifySaplingParamsIn(getSaplingParamsDir(), digests);
 }
 
 ConnectionConfig Connection::parseConfFile(const std::string& path)
@@ -195,6 +290,8 @@ ConnectionConfig Connection::parseConfFile(const std::string& path)
             config.proxy = value;
         } else if (key == "rpctls" || key == "rpcssl" || key == "use_tls" || key == "rpcuse_tls") {
             config.use_tls = parseBoolValue(value);
+        } else if (key == "rpcallowplaintext") {
+            config.allow_plaintext_remote = parseBoolValue(value);
         }
     }
 
@@ -209,11 +306,14 @@ ConnectionConfig Connection::autoDetectConfig()
 {
     ConnectionConfig config;
     
-    // Ensure data directory exists
+    // Ensure the data directory exists. Use the non-throwing helper and report any failure
+    // via config.dir_error so callers can surface it — the old throwing create_directories()
+    // overload could raise an uncaught filesystem_error straight through autoDetectConfig()'s
+    // callers (read-only home, permission denied, etc.).
     std::string data_dir = getDefaultDataDir();
-    if (!fs::exists(data_dir)) {
-        DEBUG_LOGF("Creating data directory: %s\n", data_dir.c_str());
-        fs::create_directories(data_dir);
+    if (!util::Platform::ensureDirectory(data_dir, &config.dir_error)) {
+        DEBUG_LOGF("[ERROR] autoDetectConfig: %s\n", config.dir_error.c_str());
+        return config;  // data dir unusable — bail early with dir_error set
     }
     
     // Try to find DRAGONX.conf
@@ -268,6 +368,31 @@ bool Connection::buildCookieAuthConfig(const ConnectionConfig& base, ConnectionC
     return true;
 }
 
+// True only for a well-formed IPv4 loopback literal (127.0.0.0/8): exactly four dot-separated
+// 0-255 octets with the first == 127. Rejects "127.evil.com", "127.0.0.1.attacker",
+// "127.300.0.1", "1270.0.0.1", etc. — the old rfind("127.",0)==0 prefix matched all of those.
+static bool isExactIPv4Loopback(const std::string& host)
+{
+    int octets = 0, value = 0, digits = 0;
+    bool firstIs127 = false;
+    for (size_t i = 0; i <= host.size(); ++i) {
+        const char c = (i < host.size()) ? host[i] : '.';   // trailing sentinel flushes the last octet
+        if (c == '.') {
+            if (digits == 0 || digits > 3 || value > 255) return false;
+            if (octets == 0) firstIs127 = (value == 127);
+            ++octets;
+            value = 0;
+            digits = 0;
+        } else if (c >= '0' && c <= '9') {
+            value = value * 10 + (c - '0');
+            ++digits;
+        } else {
+            return false;
+        }
+    }
+    return octets == 4 && firstIs127;
+}
+
 bool Connection::isLocalHost(const std::string& host)
 {
     std::string lowered = lowercase(host);
@@ -277,7 +402,7 @@ bool Connection::isLocalHost(const std::string& host)
 
     return lowered == "localhost" || lowered == "localhost." ||
            lowered == "::1" || lowered == "0:0:0:0:0:0:0:1" ||
-           lowered == "127.0.0.1" || lowered.rfind("127.", 0) == 0;
+           isExactIPv4Loopback(lowered);
 }
 
 bool Connection::usesPlaintextRemote(const ConnectionConfig& config)
@@ -285,6 +410,13 @@ bool Connection::usesPlaintextRemote(const ConnectionConfig& config)
     return !config.use_tls && !isLocalHost(config.host);
 }
 
+bool Connection::allowsPlaintextRemote(const ConnectionConfig& config)
+{
+    // Explicit opt-in (DRAGONX.conf: rpcallowplaintext=1) to send credentials over a plaintext
+    // link to a remote host. Off by default — see usesPlaintextRemote().
+    return config.allow_plaintext_remote;
+}
+
 const char* Connection::authSourceName(AuthSource source)
 {
     switch (source) {

src/rpc/connection.h

@@ -5,6 +5,8 @@
 #pragma once
 
 #include <string>
+#include <vector>
+#include <utility>
 
 namespace dragonx {
 namespace rpc {
@@ -27,7 +29,11 @@ struct ConnectionConfig {
     std::string proxy;  // SOCKS5 proxy for Tor
     bool use_embedded = true;
     bool use_tls = false;
+    bool allow_plaintext_remote = false;  // rpcallowplaintext=1 — opt in to plaintext creds to a remote host
     AuthSource auth_source = AuthSource::Missing;
+    // Non-empty when autoDetectConfig() could not create the data directory; callers
+    // should surface it and abort the connect rather than proceeding blindly.
+    std::string dir_error;
 };
 
 /**
@@ -69,6 +75,14 @@ public:
      */
     static bool verifySaplingParams();
 
+    // Verify the Sapling params in `dir` against a { filename, expected-sha256-hex } list.
+    // Exposed with an injectable dir + digest list so the integrity + marker-cache logic is
+    // unit-testable without the real ~48MB params; verifySaplingParams() calls it with the
+    // pinned production digests and getSaplingParamsDir().
+    static bool verifySaplingParamsIn(
+        const std::string& dir,
+        const std::vector<std::pair<std::string, std::string>>& digests);
+
     /**
      * @brief Get the Sapling params directory
      */
@@ -119,6 +133,11 @@ public:
      */
     static bool usesPlaintextRemote(const ConnectionConfig& config);
 
+    // Whether plaintext credentials to a remote host are explicitly allowed (opt-in via the
+    // DRAGONX.conf rpcallowplaintext key). Off by default: usesPlaintextRemote() && !this
+    // means the connect is refused.
+    static bool allowsPlaintextRemote(const ConnectionConfig& config);
+
     static const char* authSourceName(AuthSource source);
 
 private:

src/services/network_refresh_service.cpp

@@ -37,16 +37,27 @@ void applyBalancesFromUnspent(std::vector<AddressInfo>& addresses, const json& u
 {
     if (!unspent.is_array()) return;
 
-    std::map<std::string, double> balances;
+    // Partition each note/utxo by its per-entry "confirmations": `total` (minconf=0 — DISPLAY, includes
+    // the user's own pending 0-conf change) vs `spendable` (confirmations>=1 — what z_sendmany, run at
+    // minconf=1, can actually spend). This lets a single z_listunspent(0)/listunspent(0) feed both.
+    std::map<std::string, double> total;
+    std::map<std::string, double> spendable;
     for (const auto& output : unspent) {
         auto address = readOptional<std::string>(output, "address");
-        auto amount = readOptional<double>(output, "amount");
-        if (address && amount) balances[*address] += *amount;
+        auto amount  = readOptional<double>(output, "amount");
+        if (!address || !amount) continue;
+        total[*address] += *amount;
+        auto conf = readOptional<int>(output, "confirmations");
+        if (conf && *conf >= 1) spendable[*address] += *amount;
     }
 
+    // The address lists are rebuilt fresh (default 0) each refresh, so hard-set both — an address with no
+    // notes in this set is 0, and spendableBalance is always a subset sum of balance.
     for (auto& info : addresses) {
-        auto balance = balances.find(info.address);
-        if (balance != balances.end()) info.balance = balance->second;
+        auto t = total.find(info.address);
+        auto s = spendable.find(info.address);
+        info.balance          = (t != total.end())    ? t->second : 0.0;
+        info.spendableBalance = (s != spendable.end()) ? s->second : 0.0;
     }
 }
 
@@ -249,7 +260,7 @@ NetworkRefreshService::ConnectionInitResult NetworkRefreshService::collectConnec
 }
 
 NetworkRefreshService::CoreRefreshResult NetworkRefreshService::parseCoreRefreshResult(
-    const json& totalBalance, bool balanceOk, const json& blockInfo, bool blockOk)
+    const json& totalBalance, const json& spendableBalance, bool balanceOk, const json& blockInfo, bool blockOk)
 {
     CoreRefreshResult result;
     result.balanceOk = balanceOk && totalBalance.is_object();
@@ -258,6 +269,11 @@ NetworkRefreshService::CoreRefreshResult NetworkRefreshService::parseCoreRefresh
         result.transparentBalance = readBalanceString(totalBalance, "transparent");
         result.totalBalance = readBalanceString(totalBalance, "total");
     }
+    if (spendableBalance.is_object()) {   // confirmed totals (minconf=1); left unset on old daemons
+        result.spendableShieldedBalance = readBalanceString(spendableBalance, "private");
+        result.spendableTransparentBalance = readBalanceString(spendableBalance, "transparent");
+        result.spendableTotalBalance = readBalanceString(spendableBalance, "total");
+    }
 
     result.blockchainOk = blockOk && blockInfo.is_object();
     if (result.blockchainOk) {
@@ -274,17 +290,21 @@ NetworkRefreshService::CoreRefreshResult NetworkRefreshService::parseCoreRefresh
 NetworkRefreshService::CoreRefreshResult NetworkRefreshService::collectCoreRefreshResult(RefreshRpcGateway& rpc, bool includeBalance)
 {
     json totalBalance;
+    json spendableBalance;
     json blockInfo;
     bool balanceOk = false;
     bool blockOk = false;
 
     if (includeBalance) {
-        try {
-            totalBalance = rpc.call("z_gettotalbalance", json::array());
+        try {   // DISPLAY total: minconf=0 — includes the user's own pending change so it doesn't crater
+            totalBalance = rpc.call("z_gettotalbalance", json::array({0}));
             balanceOk = true;
         } catch (const std::exception& e) {
             DEBUG_LOGF("Balance error: %s\n", e.what());
         }
+        try {   // SPENDABLE total: minconf=1 (confirmed). If absent, spendable degrades to display in apply.
+            spendableBalance = rpc.call("z_gettotalbalance", json::array({1}));
+        } catch (...) {}
     }
 
     try {
@@ -294,7 +314,7 @@ NetworkRefreshService::CoreRefreshResult NetworkRefreshService::collectCoreRefre
         DEBUG_LOGF("BlockchainInfo error: %s\n", e.what());
     }
 
-    return parseCoreRefreshResult(totalBalance, balanceOk, blockInfo, blockOk);
+    return parseCoreRefreshResult(totalBalance, spendableBalance, balanceOk, blockInfo, blockOk);
 }
 
 NetworkRefreshService::MiningRefreshResult NetworkRefreshService::parseMiningRefreshResult(
@@ -426,12 +446,21 @@ std::optional<NetworkRefreshService::PriceRefreshResult> NetworkRefreshService::
         if (!parsed.contains("dragonx-2")) return std::nullopt;
 
         const auto& data = parsed["dragonx-2"];
+        // CoinGecko emits JSON null (not an omitted key) for fields it can't currently compute —
+        // commonly usd_24h_change on illiquid/newly-listed tokens — while still returning a valid
+        // spot price in the same object. .value(key, default) throws type_error on a PRESENT null,
+        // which the outer catch turns into "no price update at all", so read null-tolerantly and
+        // keep the valid usd/btc rather than discarding the whole refresh.
+        auto num = [&data](const char* key, double def) {
+            auto it = data.find(key);
+            return (it != data.end() && it->is_number()) ? it->get<double>() : def;
+        };
         PriceRefreshResult result;
-        result.market.price_usd = data.value("usd", 0.0);
-        result.market.price_btc = data.value("btc", 0.0);
-        result.market.change_24h = data.value("usd_24h_change", 0.0);
-        result.market.volume_24h = data.value("usd_24h_vol", 0.0);
-        result.market.market_cap = data.value("usd_market_cap", 0.0);
+        result.market.price_usd = num("usd", 0.0);
+        result.market.price_btc = num("btc", 0.0);
+        result.market.change_24h = num("usd_24h_change", 0.0);
+        result.market.volume_24h = num("usd_24h_vol", 0.0);
+        result.market.market_cap = num("usd_market_cap", 0.0);
 
         char buf[64];
         // Runs on the RPC worker thread — std::localtime shares a process-wide static tm, so use the
@@ -602,15 +631,19 @@ NetworkRefreshService::AddressRefreshResult NetworkRefreshService::collectAddres
     }
 
     try {
-        json unspent = rpc.call("z_listunspent", json::array());
+        json unspent = rpc.call("z_listunspent", json::array({0, 9999999, false}));  // minconf=0 → include 0-conf change
         applyShieldedBalancesFromUnspent(result.shieldedAddresses, unspent);
     } catch (const std::exception& e) {
         DEBUG_LOGF("z_listunspent unavailable (%s), falling back to z_getbalance\n", e.what());
         for (auto& info : result.shieldedAddresses) {
-            try {
-                json balance = rpc.call("z_getbalance", json::array({info.address}));
-                if (!balance.is_null()) info.balance = balance.get<double>();
+            try {   // display total (minconf=0, includes pending change)
+                json total = rpc.call("z_getbalance", json::array({info.address, 0}));
+                if (!total.is_null()) info.balance = total.get<double>();
             } catch (...) {}
+            try {   // spendable (minconf=1); degrade to the display value on old daemons
+                json conf = rpc.call("z_getbalance", json::array({info.address, 1}));
+                info.spendableBalance = (!conf.is_null()) ? conf.get<double>() : info.balance;
+            } catch (...) { info.spendableBalance = info.balance; }
         }
     }
 
@@ -622,7 +655,7 @@ NetworkRefreshService::AddressRefreshResult NetworkRefreshService::collectAddres
     }
 
     try {
-        json unspent = rpc.call("listunspent", json::array());
+        json unspent = rpc.call("listunspent", json::array({0}));  // minconf=0 → include 0-conf change
         applyTransparentBalancesFromUnspent(result.transparentAddresses, unspent);
     } catch (const std::exception& e) {
         DEBUG_LOGF("listunspent error: %s\n", e.what());
@@ -1101,12 +1134,16 @@ NetworkRefreshService::OperationStatusPollResult NetworkRefreshService::parseOpe
     std::set<std::string> reported;
     for (const auto& op : result) {
         if (!op.is_object()) continue;
-        std::string opid = op.value("id", std::string());
+        // Type-checked reads: .value(key, default) throws if the key is PRESENT with a non-string
+        // type, which would abort the whole poll (and wedge it for the session — see the call site).
+        if (!op.contains("id") || !op["id"].is_string()) continue;
+        std::string opid = op["id"].get<std::string>();
         if (opid.empty()) continue;
         if (requested.find(opid) == requested.end()) continue;  // not one of ours — ignore
         reported.insert(opid);
 
-        std::string status = op.value("status", std::string());
+        std::string status = (op.contains("status") && op["status"].is_string())
+                                 ? op["status"].get<std::string>() : std::string();
         if (status == "success") {
             parsed.doneOpids.push_back(opid);
             parsed.anySuccess = true;
@@ -1184,6 +1221,12 @@ void NetworkRefreshService::applyCoreRefreshResult(WalletState& state,
         if (result.shieldedBalance) state.shielded_balance = *result.shieldedBalance;
         if (result.transparentBalance) state.transparent_balance = *result.transparentBalance;
         if (result.totalBalance) state.total_balance = *result.totalBalance;
+        // Confirmed/spendable totals; if the minconf=1 call was unavailable (old daemon) degrade to the
+        // display value so nothing is *over*-reported as spendable (z_sendmany stays the final gate).
+        state.spendablePrivateBalance     = result.spendableShieldedBalance.value_or(state.privateBalance);
+        state.spendableTransparentBalance = result.spendableTransparentBalance.value_or(state.transparentBalance);
+        state.spendableTotalBalance       = result.spendableTotalBalance.value_or(state.totalBalance);
+        state.unconfirmedBalance = std::max(0.0, state.totalBalance - state.spendableTotalBalance);
         state.last_balance_update = updatedAt;
     }
 

src/services/network_refresh_service.h

@@ -98,9 +98,12 @@ public:
 
     struct CoreRefreshResult {
         bool balanceOk = false;
-        std::optional<double> shieldedBalance;
+        std::optional<double> shieldedBalance;               // display (minconf=0, incl. pending change)
         std::optional<double> transparentBalance;
         std::optional<double> totalBalance;
+        std::optional<double> spendableShieldedBalance;      // confirmed (minconf=1)
+        std::optional<double> spendableTransparentBalance;
+        std::optional<double> spendableTotalBalance;
         bool blockchainOk = false;
         std::optional<int> blocks;
         std::optional<int> headers;
@@ -227,6 +230,7 @@ public:
         RefreshRpcGateway& rpc,
         const std::optional<ConnectionInfoResult>& prefetchedInfo = std::nullopt);
     static CoreRefreshResult parseCoreRefreshResult(const nlohmann::json& totalBalance,
+                                                    const nlohmann::json& spendableBalance,
                                                     bool balanceOk,
                                                     const nlohmann::json& blockInfo,
                                                     bool blockOk);

src/services/wallet_security_controller.cpp

@@ -1,9 +1,12 @@
 #include "wallet_security_controller.h"
 #include "../util/secure_vault.h"
+#include "../util/address_validation.h"
 
 #include <cctype>
+#include <cstdint>
 #include <cstdio>
 #include <utility>
+#include <vector>
 
 namespace dragonx {
 namespace services {
@@ -108,18 +111,35 @@ WalletSecurityController::KeyKind WalletSecurityController::classifyPrivateKey(c
 
 bool WalletSecurityController::isViewingKey(const std::string& key)
 {
-    // Sapling extended full viewing key (mainnet HRP "zxviews"; "zxview" also matches the prefix the
-    // lite backend recognizes). Watch-only: reveals the address's funds but cannot spend them.
-    return key.rfind("zxview", 0) == 0;
+    // DragonX's z_exportviewingkey returns a Sapling *incoming* viewing key (mainnet HRP "zivks");
+    // z_importviewingkey only decodes that form. Recognize it structurally — a valid Bech32 checksum
+    // plus a known HRP — instead of a bare prefix, and cover testnet/regtest too. (The old check
+    // looked for Zcash's "zxview" extended-FVK HRP, which DragonX never emits, so every real viewing
+    // key was rejected client-side.) Watch-only: reveals the address's funds but cannot spend them.
+    const std::string hrp = util::bech32Hrp(key);
+    return hrp == "zivks"                 // mainnet
+        || hrp == "zivktestsapling"       // testnet
+        || hrp == "zivkregtestsapling";   // regtest
 }
 
 bool WalletSecurityController::isRecognizedPrivateKey(const std::string& key)
 {
+    // Sapling z spending key (HRP "secret-extended-key-{main,test,regtest}"). These run ~300 chars,
+    // past the Bech32 length cap, so match by HRP prefix and let the daemon vet the payload.
     if (key.rfind("secret-extended-key-", 0) == 0) return true;               // Sapling z spending key
     if (key.size() >= 2 && key[0] == 'S' && key[1] == 'K') return true;       // Sprout z spending key
-    // Transparent WIF: base58, ~51-52 chars, common version prefixes.
-    if (key.size() >= 51 && key.size() <= 52 &&
-        (key[0] == '5' || key[0] == 'K' || key[0] == 'L' || key[0] == 'U')) return true;
+    // Transparent WIF: decode Base58Check and confirm it is actually a secret key — version byte plus
+    // a 32-byte key, optionally a compression flag (payload 33 or 34 bytes). This accepts BOTH the
+    // compressed ("U…") and uncompressed ("7…") mainnet forms and the testnet form, and rejects
+    // addresses / typos via the real checksum — the old length+first-char heuristic dropped the
+    // uncompressed mainnet key (which starts with '7', not one of 5/K/L/U).
+    std::vector<std::uint8_t> payload;
+    if (util::decodeBase58Check(key, payload) &&
+        (payload.size() == 33 || payload.size() == 34) &&
+        (payload[0] == 188 /* DragonX main/regtest SECRET_KEY */ ||
+         payload[0] == 128 /* DragonX testnet SECRET_KEY */)) {
+        return true;
+    }
     return false;
 }
 

src/services/wallet_security_controller.h

@@ -74,7 +74,7 @@ public:
                                                 std::size_t minLength = 4);
     static KeyKind classifyAddress(const std::string& address);
     static KeyKind classifyPrivateKey(const std::string& key);
-    // True if `key` is a shielded viewing key (extended full viewing key, "zxview…" — watch-only).
+    // True if `key` is a shielded viewing key (Sapling incoming viewing key, "zivks…" — watch-only).
     static bool isViewingKey(const std::string& key);
     // True if `key` looks like a recognized Z (Sapling/Sprout spending) or T (WIF) private key.
     static bool isRecognizedPrivateKey(const std::string& key);

src/ui/node_status_banner.h

@@ -0,0 +1,111 @@
+#pragma once
+
+#include <string>
+
+// Persistent node-connectivity banner shown at the top of the content column when the wallet
+// cannot reach its node. Distinct from the transient toast notifications: it stays visible for
+// as long as the fault persists, so an offline wallet is never silently mistaken for a working
+// one. The decision (whether to show, how severe, which action) is a pure function of a state
+// snapshot so it can be unit-tested; App::renderNodeStatusBanner() feeds it the live state and
+// draws the strip. See src/app.cpp.
+namespace dragonx::ui {
+
+// Visual weight. Warning (amber) = recoverable / a reconnect is offered; Error (red) = a hard
+// fault the user must act on (the daemon gave up crashing, or a lite wallet failed to open).
+enum class NodeBannerSeverity {
+    Warning,
+    Error,
+};
+
+// What the banner's action button does. App maps this to the concrete call.
+enum class NodeBannerAction {
+    None,         // no button — nothing the user can usefully do from here
+    Reconnect,    // full node: re-run the RPC connect state machine (App::tryConnect)
+    RestartNode,  // full node: the embedded daemon crashed & auto-restart gave up (App::restartDaemon)
+};
+
+// Why the banner is up. App maps this to a translated headline; `detail` carries the live,
+// already-human-readable status text (connection_status_ / daemon lastError / lite open error).
+enum class NodeBannerReason {
+    None,
+    FullNodeOffline,  // a reachable node was lost, or never came up; reconnect offered
+    DaemonCrashed,    // the embedded daemon crashed repeatedly and auto-restart stopped
+    LiteOpenFailed,   // lite build: the wallet failed to open
+};
+
+struct NodeBannerState {
+    bool               show     = false;
+    NodeBannerSeverity severity = NodeBannerSeverity::Warning;
+    NodeBannerReason   reason   = NodeBannerReason::None;
+    NodeBannerAction   action   = NodeBannerAction::None;
+    std::string        detail;  // passthrough status/error text (may be empty)
+};
+
+// Snapshot of the connection state the banner reads. Plain values so the decision is testable
+// without an App instance.
+struct NodeBannerInputs {
+    bool lite                 = false;  // lite build (no embedded daemon / RPC)
+    bool connected            = false;  // state_.connected — the master "online" flag
+    bool warming_up           = false;  // daemon reachable, RPC warmup (code -28)
+    bool daemon_initializing  = false;  // daemon launching / block index loading
+    bool connection_in_progress = false;  // a connect attempt is actively running
+
+    // Full-node embedded-daemon crash signal.
+    bool using_embedded_daemon = false;
+    bool has_daemon_controller = false;
+    bool daemon_running        = false;
+    int  daemon_crash_count    = 0;
+
+    std::string connection_status;  // human-readable status line (already translated)
+    std::string daemon_last_error;  // DaemonController::lastError() (may be empty)
+    std::string lite_open_error;    // lite: last wallet-open failure reason
+};
+
+// Auto-restart give-up threshold — mirrors the crash cap in app_network.cpp's connect loop.
+inline constexpr int kNodeBannerCrashGiveUpCount = 3;
+
+inline NodeBannerState evaluateNodeStatusBanner(const NodeBannerInputs& in) {
+    NodeBannerState s;
+
+    if (in.lite) {
+        // Lite has no daemon/RPC; "online" == wallet open. Only a genuine open failure is a
+        // fault worth a persistent banner (a not-yet-created wallet is handled by the normal
+        // "No wallet open" prompt, and leaves lite_open_error empty).
+        if (!in.connected && !in.lite_open_error.empty()) {
+            s.show     = true;
+            s.severity = NodeBannerSeverity::Error;
+            s.reason   = NodeBannerReason::LiteOpenFailed;
+            s.action   = NodeBannerAction::None;
+            s.detail   = in.lite_open_error;
+        }
+        return s;
+    }
+
+    // Full node. Connected, or in an expected startup phase → the loading/warmup overlay owns
+    // the screen, so no banner. An active connect attempt likewise shows progress, not an
+    // error — don't flicker a banner over it.
+    if (in.connected) return s;
+    if (in.warming_up || in.daemon_initializing) return s;
+    if (in.connection_in_progress) return s;
+
+    // Genuinely offline. Distinguish "the embedded daemon crashed and we stopped retrying" (a
+    // hard fault needing a manual restart) from an ordinary lost/failed connection (retryable).
+    if (in.using_embedded_daemon && in.has_daemon_controller && !in.daemon_running &&
+        in.daemon_crash_count >= kNodeBannerCrashGiveUpCount) {
+        s.show     = true;
+        s.severity = NodeBannerSeverity::Error;
+        s.reason   = NodeBannerReason::DaemonCrashed;
+        s.action   = NodeBannerAction::RestartNode;
+        s.detail   = !in.daemon_last_error.empty() ? in.daemon_last_error : in.connection_status;
+        return s;
+    }
+
+    s.show     = true;
+    s.severity = NodeBannerSeverity::Warning;
+    s.reason   = NodeBannerReason::FullNodeOffline;
+    s.action   = NodeBannerAction::Reconnect;
+    s.detail   = in.connection_status;
+    return s;
+}
+
+}  // namespace dragonx::ui

src/ui/notifications.cpp

@@ -32,19 +32,22 @@ void Notifications::render()
         return v >= 0 ? v : fb;
     };
 
-    // Status bar geometry
-    float sbHeight = S.window("components.status-bar").height;
-    if (sbHeight <= 0.0f) sbHeight = 30.0f;
+    // Status bar geometry. These are logical-px schema values; the icon/text drawn into the pill
+    // are DPI-baked, so scale the box by dpiScale to match the (also DPI-scaled) rendered status bar
+    // and keep the icon/text inside the pill at HiDPI.
+    const float dp = Layout::dpiScale();
+    float sbHeight = S.window("components.status-bar").height * dp;
+    if (sbHeight <= 0.0f) sbHeight = 30.0f * dp;
 
     ImGuiViewport* viewport = ImGui::GetMainViewport();
     float viewBottom = viewport->WorkPos.y + viewport->WorkSize.y;
     float viewCenterX = viewport->WorkPos.x + viewport->WorkSize.x * 0.5f;
 
     // Toast pill sizing — fit inside status bar with margin
-    float pillMarginY = nde("pill-margin-y", 3.0f);
+    float pillMarginY = nde("pill-margin-y", 3.0f) * dp;
     float pillHeight = sbHeight - pillMarginY * 2.0f;
-    float pillPadX = nde("padding-x", 12.0f);
-    float pillRounding = nde("pill-rounding", 12.0f);
+    float pillPadX = nde("padding-x", 12.0f) * dp;
+    float pillRounding = nde("pill-rounding", 12.0f) * dp;
 
     // Get accent color based on type — resolved from theme palette
     ImVec4 accent_color, text_color;
@@ -89,7 +92,7 @@ void Notifications::render()
     ImFont* textFont = material::Type().caption();
     ImFont* iconFont = material::Type().iconSmall();
     float iconW = iconFont ? iconFont->CalcTextSizeA(iconFont->LegacySize, FLT_MAX, 0.0f, icon).x : 0.0f;
-    float iconGap = 4.0f;
+    float iconGap = 4.0f * dp;
     float msgW = textFont ? textFont->CalcTextSizeA(textFont->LegacySize, FLT_MAX, 0.0f, notif.message.c_str()).x : 100.0f;
     float pillWidth = pillPadX + iconW + iconGap + msgW + pillPadX;
     // Clamp to reasonable bounds
@@ -122,7 +125,7 @@ void Notifications::render()
     // Progress bar at bottom of pill (accent-colored), clipped to pill rounded
     // corners.  Draw a full-pill-size rounded rect and clip it to just the
     // bottom-left progress strip so both bottom corners are respected.
-    float progH = nde("progress-bar-height", 2.0f);
+    float progH = nde("progress-bar-height", 2.0f) * dp;
     float progW = pillWidth * (1.0f - progress);
     if (progW > 0.0f) {
         ImVec2 clipMin(pillX, pMax.y - progH);

src/ui/notifications.h

@@ -9,6 +9,8 @@
 #include <chrono>
 #include <functional>
 #include <cstdio>
+#include <cstdint>
+#include <ctime>
 #include "../util/logger.h"
 #include "schema/ui_schema.h"
 
@@ -22,6 +24,15 @@ enum class NotificationType {
     Error
 };
 
+// A retained alert for the persistent history panel. Unlike a live Notification (which fades and is
+// erased within seconds), this keeps a wall-clock epoch so its age can be shown as "3m ago" long
+// after the toast is gone. See App::renderAlertHistoryPanel.
+struct AlertRecord {
+    std::string      message;
+    NotificationType type;
+    std::int64_t     epoch;  // std::time(nullptr) at push — wall-clock, for relative-age display
+};
+
 struct Notification {
     std::string message;
     NotificationType type;
@@ -84,20 +95,30 @@ public:
     
     void push(const std::string& message, NotificationType type, float duration = 5.0f) {
         notifications_.emplace_back(message, type, duration);
-        
+
+        // Retain a copy in the persistent history (the toast above will fade in seconds; this
+        // survives so the user can review what happened). Thread note: every push is on the UI
+        // thread (RPC results run as main-thread MainCb callbacks), so this container needs no lock,
+        // consistent with the rest of this class. Do NOT push from a raw worker thread.
+        history_.push_back(AlertRecord{message, type, static_cast<std::int64_t>(std::time(nullptr))});
+        ++total_pushed_;
+        while (history_.size() > kMaxHistory) {
+            history_.pop_front();
+        }
+
         // Log errors and warnings (debug-only output)
         if (type == NotificationType::Error) {
             DEBUG_LOGF("[ERROR] Notification: %s\n", message.c_str());
         } else if (type == NotificationType::Warning) {
             DEBUG_LOGF("[WARN] Notification: %s\n", message.c_str());
         }
-        
+
         // Forward errors and warnings to console callback
         if (console_callback_ && (type == NotificationType::Error || type == NotificationType::Warning)) {
             const char* prefix = (type == NotificationType::Error) ? "[ERROR] " : "[WARN] ";
             console_callback_(prefix + message, type == NotificationType::Error);
         }
-        
+
         // Limit max notifications
         while (notifications_.size() > max_notifications_) {
             notifications_.pop_front();
@@ -122,21 +143,34 @@ public:
     void clear() {
         notifications_.clear();
     }
-    
+
     void setMaxNotifications(size_t max) {
         max_notifications_ = max;
     }
-    
+
+    // ── Persistent alert history (for the status-bar bell panel) ──
+    /// Retained alerts, oldest first (capped at kMaxHistory; the toast deque is separate).
+    const std::deque<AlertRecord>& history() const { return history_; }
+    bool hasHistory() const { return !history_.empty(); }
+    void clearHistory() { history_.clear(); }
+    /// Monotonic count of every alert ever pushed this session — survives capping/clearing, so it is
+    /// the correct basis for an "unseen since last opened" count (deque size is not).
+    std::uint64_t totalPushed() const { return total_pushed_; }
+
 private:
     Notifications() = default;
     ~Notifications() = default;
     Notifications(const Notifications&) = delete;
     Notifications& operator=(const Notifications&) = delete;
-    
+
     std::deque<Notification> notifications_;
     size_t max_notifications_ = 5;
     std::function<void(const std::string&, bool)> console_callback_;
 
+    std::deque<AlertRecord> history_;
+    std::uint64_t total_pushed_ = 0;
+    static constexpr size_t kMaxHistory = 100;
+
     static float schemaDuration(const char* key, float fallback) {
         float v = schema::UI().drawElement("components.notifications", key).size;
         return v > 0.0f ? v : fallback;

src/ui/pages/settings_page.cpp

@@ -16,6 +16,7 @@
 #include "../windows/console_tab.h"
 #include "../../util/i18n.h"
 #include "../../util/platform.h"
+#include "../../util/seed_phrase.h"
 #include "../../resources/embedded_resources.h"
 #include <ctime>
 #include "../../rpc/rpc_client.h"
@@ -231,16 +232,12 @@ static void exitLowSpec(bool applyEffects) {
     s_settingsState.low_spec_snapshot.valid = false;
 }
 
-// Count whitespace-separated words in a (seed) buffer — used to validate/guide restore input.
+// Count words in a (seed) buffer — used to validate/guide restore input. Normalizes exotic Unicode
+// whitespace (NBSP etc.) first so the count matches the phrase actually submitted (shared with the
+// first-run restore gate via util::seed_phrase).
 static int liteSeedWordCount(const char* s) {
-    int words = 0;
-    bool inWord = false;
-    for (; s && *s; ++s) {
-        const bool space = std::isspace(static_cast<unsigned char>(*s)) != 0;
-        if (space) inWord = false;
-        else if (!inWord) { inWord = true; ++words; }
-    }
-    return words;
+    return dragonx::util::seedPhraseWordCount(
+        dragonx::util::normalizeSeedPhrase(s ? std::string(s) : std::string()));
 }
 
 static wallet::LiteWalletLifecycleOperation liteLifecycleOperationFromPageState() {
@@ -277,7 +274,9 @@ static void evaluateLiteLifecycleRequestFromPageState(App* app) {
             break;
         case wallet::LiteWalletLifecycleOperation::RestoreFromSeed:
             input.request.restoreRequest.walletPath = s_settingsState.lite_wallet_path;
-            input.request.restoreRequest.seedPhrase = s_settingsState.lite_restore_seed;
+            // Normalize (fold NBSP/exotic whitespace to plain spaces) so an NBSP-pasted phrase the
+            // gate counted as 24 words also restores correctly at the backend.
+            input.request.restoreRequest.seedPhrase = dragonx::util::normalizeSeedPhrase(s_settingsState.lite_restore_seed);
             input.request.restoreRequest.passphrase = s_settingsState.lite_lifecycle_passphrase;
             input.request.restoreRequest.birthday = static_cast<unsigned long long>(std::max(0, s_settingsState.lite_restore_birthday));
             input.request.restoreRequest.account = static_cast<unsigned long long>(std::max(0, s_settingsState.lite_restore_account));
@@ -320,7 +319,7 @@ static void evaluateLiteLifecycleRequestFromPageState(App* app) {
     // entered secret on this return path).
     if (input.request.operation == wallet::LiteWalletLifecycleOperation::RestoreFromSeed) {
         const int words = liteSeedWordCount(s_settingsState.lite_restore_seed);
-        if (words != 24) {
+        if (!dragonx::util::isCompleteRecoveryPhrase(words)) {
             s_settingsState.lite_lifecycle_status =
                 "Enter all 24 seed words to restore (got " + std::to_string(words) + ")";
             s_settingsState.lite_lifecycle_summary.clear();
@@ -1351,6 +1350,21 @@ void RenderSettingsPage(App* app) {
             if (ImGui::IsItemHovered()) material::Tooltip("%s", TR("tt_verbose"));
         }
 
+        // W7 QoL: quick diagnostics actions — open the log folder, and copy a plaintext support bundle
+        // (version, variant, daemon/RPC/wallet/log state) to the clipboard.
+        {
+            const float diagBtnW = (contentW - Layout::spacingMd()) * 0.5f;
+            if (TactileButton(TR("settings_open_log_folder"), ImVec2(diagBtnW, 0), S.resolveFont("button")))
+                dragonx::util::Platform::openFolder(dragonx::util::Platform::getObsidianDragonDir());
+            if (ImGui::IsItemHovered()) material::Tooltip("%s", TR("tt_open_log_folder"));
+            ImGui::SameLine(0, Layout::spacingMd());
+            if (TactileButton(TR("settings_copy_diagnostics"), ImVec2(diagBtnW, 0), S.resolveFont("button"))) {
+                ImGui::SetClipboardText(app->buildDiagnosticsReport().c_str());
+                ui::Notifications::instance().info(TR("settings_diagnostics_copied"), 4.0f);
+            }
+            if (ImGui::IsItemHovered()) material::Tooltip("%s", TR("tt_copy_diagnostics"));
+        }
+
         ImGui::Dummy(ImVec2(0, Layout::spacingSm()));
 
         // --- Collapsible: Tools & Actions... ---
@@ -2067,12 +2081,22 @@ void RenderSettingsPage(App* app) {
                     ImGui::SameLine(0, 0);
                     ImGui::SetCursorPosX(leftX + labelW);
                     ImGui::AlignTextToFramePadding();
-                    ImGui::TextColored(ImGui::ColorConvertU32ToFloat4(Primary()), "%s", dirPath.c_str());
+                    // In the two-column layout this shares one draw list with the Daemon-binary
+                    // column (no clip rect between them), so a long OS data-dir path (Windows
+                    // AppData / macOS Application Support) would overrun into it. Middle-ellipsize
+                    // to the remaining column width (room left for the copy button); the full path
+                    // stays available via the tooltip, click-to-open, and the copy button.
+                    ImFont* pathFont = ImGui::GetFont();
+                    const float pathAvailW = contentW - labelW - Layout::spacingSm()
+                                             - ImGui::GetFrameHeight() - Layout::spacingXs();
+                    const std::string dirShown =
+                        material::TruncateToWidth(dirPath, pathFont, pathFont->LegacySize, pathAvailW);
+                    ImGui::TextColored(ImGui::ColorConvertU32ToFloat4(Primary()), "%s", dirShown.c_str());
                     if (ImGui::IsItemHovered()) {
                         const ImVec2 tmn = ImGui::GetItemRectMin(), tmx = ImGui::GetItemRectMax();
                         dl->AddLine(ImVec2(tmn.x, tmx.y), ImVec2(tmx.x, tmx.y), Primary());
                         ImGui::SetMouseCursor(ImGuiMouseCursor_Hand);
-                        material::Tooltip("%s", TR("tt_open_dir"));
+                        material::Tooltip("%s\n%s", dirPath.c_str(), TR("tt_open_dir"));
                     }
                     if (ImGui::IsItemClicked()) util::Platform::openFolder(dirPath);
                     ImGui::SameLine(0, Layout::spacingSm());

src/ui/staleness_badge.h

@@ -0,0 +1,48 @@
+#pragma once
+
+#include <cstdint>
+
+// Refresh-staleness badge (finding W6-2). The wallet stamps WalletState::last_balance_update only on
+// a *successful* balance fetch (see services/network_refresh_service.cpp), so a busy daemon that fails
+// z_gettotalbalance without dropping the whole connection leaves the old balance on screen with a
+// frozen timestamp — and the node-status banner (which only fires on a full disconnect) stays hidden.
+// This badge is the surface that reflects that "connected but the number may be out of date" state.
+//
+// The decision is a pure function of (last-success timestamp, now, connected) so it is unit-testable;
+// balance_tab.cpp draws the pill. Both use the same std::time(nullptr) wall-clock the refresh path
+// stamps with, so age = now - last_update is consistent.
+namespace dragonx::ui {
+
+enum class StalenessSeverity {
+    Warning,  // amber — noticeably behind
+    Error,    // red — very stale, something is likely wrong
+};
+
+struct StalenessBadge {
+    bool              show        = false;
+    StalenessSeverity severity    = StalenessSeverity::Warning;
+    std::int64_t      seconds_old = 0;
+};
+
+// Balance refreshes every ~2s on the Overview profile (and ~10s while syncing), so tens of seconds
+// with no successful update means refreshes are failing, not merely slow.
+inline constexpr std::int64_t kStaleAfterSeconds     = 45;
+inline constexpr std::int64_t kVeryStaleAfterSeconds = 180;
+
+inline StalenessBadge evaluateStalenessBadge(std::int64_t last_update, std::int64_t now, bool connected) {
+    StalenessBadge b;
+    // Offline is the node-status banner's job; don't double up. A zero stamp means "never updated
+    // this session" (fresh start) or "reset on disconnect" — nothing to be stale about yet.
+    if (!connected || last_update <= 0) return b;
+
+    std::int64_t age = now - last_update;
+    if (age < 0) age = 0;  // clock skew guard
+    if (age < kStaleAfterSeconds) return b;
+
+    b.show        = true;
+    b.seconds_old = age;
+    b.severity    = (age >= kVeryStaleAfterSeconds) ? StalenessSeverity::Error : StalenessSeverity::Warning;
+    return b;
+}
+
+}  // namespace dragonx::ui

src/ui/windows/balance_components.cpp

@@ -324,12 +324,12 @@ void RenderSharedAddressList(App* app, float listH, float availW,
                     s_dragIdx < (int)rows.size()) {
                     const auto& srcRow = rows[s_dragIdx];
                     const auto& dstRow = rows[s_dropTargetIdx];
-                    if (srcRow.info->balance > 1e-9) {
+                    if (srcRow.info->spendableBalance > 1e-9) {   // only offer a transfer of CONFIRMED funds
                         AddressTransferDialog::TransferInfo ti;
                         ti.fromAddr = srcRow.info->address;
                         ti.toAddr = dstRow.info->address;
-                        ti.fromBalance = srcRow.info->balance;
-                        ti.toBalance = dstRow.info->balance;
+                        ti.fromBalance = srcRow.info->spendableBalance;   // spend cap — z_sendmany runs at minconf=1
+                        ti.toBalance = dstRow.info->balance;              // destination display only
                         ti.fromIsZ = srcRow.isZ;
                         ti.toIsZ = dstRow.isZ;
                         AddressTransferDialog::show(app, ti);
@@ -820,7 +820,7 @@ void RenderSharedRecentTx(App* app, float recentH, float availW, float hs, float
             dl->AddText(capFont, capFont->LegacySize,
                         ImVec2(tx_x, rowPos.y + 2 * dp), OnSurfaceMedium(), display.typeText.c_str());
 
-            float addrX = tx_x + S.drawElement("tabs.balance", "recent-tx-addr-offset").sizeOr(65.0f);
+            float addrX = tx_x + S.drawElement("tabs.balance", "recent-tx-addr-offset").sizeOr(65.0f) * hs;
             dl->AddText(capFont, capFont->LegacySize,
                         ImVec2(addrX, rowPos.y + 2 * dp), OnSurfaceDisabled(), display.addressText.c_str());
 

src/ui/windows/balance_tab.cpp

@@ -26,6 +26,7 @@
 #include "../effects/imgui_acrylic.h"
 #include "../sidebar.h"
 #include "../notifications.h"
+#include "../staleness_badge.h"
 #include "../../embedded/IconsMaterialDesign.h"
 #include "imgui.h"
 #include <toml++/toml.hpp>
@@ -421,6 +422,25 @@ static void RenderBalanceClassic(App* app)
                 dl->AddText(capFont, capFont->LegacySize,
                             ImVec2(cx + 12 * dp, cy),
                             WithAlpha(Success(), 200), buf);
+            } else {
+                // Refresh-staleness badge (W6-2): connected, not syncing/mining, but the balance
+                // hasn't refreshed in a while (a busy daemon can fail z_gettotalbalance without
+                // dropping the whole connection). The node banner only covers full disconnects, so
+                // this pill is the sole signal that the shown number may be out of date.
+                StalenessBadge badge = evaluateStalenessBadge(
+                    state.last_balance_update, std::time(nullptr), state.connected);
+                if (badge.show) {
+                    const bool err = (badge.severity == StalenessSeverity::Error);
+                    ImU32 fg = err ? Error() : Warning();
+                    ImU32 bg = WithAlpha(fg, 38);
+                    ImU32 bd = WithAlpha(fg, 90);
+                    snprintf(buf, sizeof(buf), "%s %s",
+                             TR("data_stale_prefix"), timeAgo(state.last_balance_update).c_str());
+                    ImVec2 pillSz = DrawPill(dl, ImVec2(cx, cy), buf, capFont, fg, bg, bd);
+                    // Hover → explain what stale means and how old the data actually is.
+                    if (material::IsRectHovered(ImVec2(cx, cy), ImVec2(cx + pillSz.x, cy + pillSz.y)))
+                        Tooltip("%s", TR("data_stale_tooltip"));
+                }
             }
 
             // Hover glow

src/ui/windows/console_tab.cpp

@@ -1416,8 +1416,11 @@ bool ConsoleTab::submitConsoleCommand(ConsoleCommandExecutor& exec, const std::s
 {
     if (cmd.empty()) return false;
 
-    addLine("> " + cmd, ConsoleChannel::Command);
-    AppendConsoleHistory(command_history_, cmd, 100);
+    // Redact secret-bearing commands (walletpassphrase, z_importkey, …) before they reach the visible
+    // log and the recall history. The real `cmd` below is still executed unredacted.
+    const std::string display = RedactConsoleCommand(cmd);
+    addLine("> " + display, ConsoleChannel::Command);
+    AppendConsoleHistory(command_history_, display, 100);
     history_index_ = -1;
 
     // First token, lowercased, for built-in interception.

src/ui/windows/console_tab_helpers.cpp

@@ -1,10 +1,34 @@
 #include "console_tab_helpers.h"
 
 #include <algorithm>
+#include <cctype>
 
 namespace dragonx {
 namespace ui {
 
+namespace {
+// First tokens (lowercase) of console/RPC commands that carry a secret argument on the command line.
+// Output-secret commands (dumpprivkey / z_exportkey / z_exportmnemonic) are deliberately absent —
+// their secret is in the RESULT, which is a separate redaction concern.
+const char* const kSecretConsoleCommands[] = {
+    "walletpassphrase", "walletpassphrasechange", "encryptwallet",
+    "importprivkey", "importwallet", "importmulti",
+    "z_importkey", "z_importviewingkey", "z_importwallet",
+    "signrawtransaction", "magicrecoverkey", "sethdseed", "importmnemonic",
+};
+
+std::string firstConsoleTokenLower(const std::string& cmd, size_t& tokenEnd) {
+    size_t b = cmd.find_first_not_of(" \t");
+    if (b == std::string::npos) { tokenEnd = cmd.size(); return {}; }
+    size_t e = cmd.find_first_of(" \t", b);
+    tokenEnd = (e == std::string::npos) ? cmd.size() : e;
+    std::string t = cmd.substr(b, tokenEnd - b);
+    std::transform(t.begin(), t.end(), t.begin(),
+                   [](unsigned char c) { return static_cast<char>(std::tolower(c)); });
+    return t;
+}
+} // namespace
+
 float ComputeConsoleInputHeight(float frameHeightWithSpacing,
                                 float itemSpacingY,
                                 float spacingSm,
@@ -27,5 +51,27 @@ float ClampConsoleWrapWidth(float contentWidth, float paddingX)
     return std::max(50.0f, contentWidth - paddingX * 2.0f);
 }
 
+bool ConsoleCommandCarriesSecret(const std::string& cmd)
+{
+    size_t end = 0;
+    const std::string name = firstConsoleTokenLower(cmd, end);
+    if (name.empty()) return false;
+    for (const char* s : kSecretConsoleCommands) if (name == s) return true;
+    return false;
+}
+
+std::string RedactConsoleCommand(const std::string& cmd)
+{
+    size_t end = 0;
+    const std::string name = firstConsoleTokenLower(cmd, end);
+    if (name.empty()) return cmd;
+    bool secret = false;
+    for (const char* s : kSecretConsoleCommands) if (name == s) { secret = true; break; }
+    if (!secret) return cmd;
+    // Only redact if there are actually arguments after the command name.
+    if (cmd.find_first_not_of(" \t", end) == std::string::npos) return cmd;
+    return cmd.substr(0, end) + " ****";
+}
+
 } // namespace ui
 } // namespace dragonx

src/ui/windows/console_tab_helpers.h

@@ -1,5 +1,7 @@
 #pragma once
 
+#include <string>
+
 namespace dragonx {
 namespace ui {
 
@@ -14,5 +16,14 @@ float ComputeConsoleOutputHeight(float availableHeight,
                                  float minHeightRatio);
 float ClampConsoleWrapWidth(float contentWidth, float paddingX);
 
+// True if `cmd`'s first token names a console/RPC command that carries a SECRET on its command line
+// (passphrase, private/spending/viewing key, mnemonic). Output-secret commands (dumpprivkey,
+// z_exportkey, z_exportmnemonic) are NOT covered — their secret is in the result, a separate concern.
+bool ConsoleCommandCarriesSecret(const std::string& cmd);
+
+// A display/history-safe copy of `cmd`: the command name with its arguments replaced by "****" when
+// it carries a secret, else `cmd` unchanged. The real command is still executed unredacted.
+std::string RedactConsoleCommand(const std::string& cmd);
+
 } // namespace ui
 } // namespace dragonx

src/ui/windows/mining_pool_panel.cpp

@@ -20,6 +20,17 @@ std::string defaultPoolWorkerAddress(const std::vector<AddressInfo>& addresses)
     return {};
 }
 
+std::string resolveMiningUserAddress(const std::string& payoutAddress,
+                                     const std::string& firstShieldedAddress,
+                                     const std::string& firstTransparentAddress)
+{
+    // The configured payout address is the pool login rewards go to, so it wins over
+    // the wallet's own addresses. "x" is the placeholder for an unset field.
+    if (!payoutAddress.empty() && payoutAddress != "x") return payoutAddress;
+    if (!firstShieldedAddress.empty()) return firstShieldedAddress;
+    return firstTransparentAddress;  // may be empty -> caller reports "no address"
+}
+
 bool miningValueAlreadySaved(const std::vector<std::string>& savedValues,
                              const std::string& value)
 {

src/ui/windows/mining_pool_panel.h

@@ -10,6 +10,14 @@ namespace ui {
 
 bool shouldDefaultPoolWorker(const std::string& currentWorker, bool alreadyDefaulted);
 std::string defaultPoolWorkerAddress(const std::vector<AddressInfo>& addresses);
+
+// The xmrig "user" — the pool login block rewards are credited to. The user-entered
+// payout address wins; otherwise fall back to the wallet's own first shielded, then
+// transparent, address. "x" is the empty-field placeholder and counts as unset. The
+// result may be empty (no address anywhere), which the caller treats as an error.
+std::string resolveMiningUserAddress(const std::string& payoutAddress,
+                                     const std::string& firstShieldedAddress,
+                                     const std::string& firstTransparentAddress);
 bool miningValueAlreadySaved(const std::vector<std::string>& savedValues,
 							 const std::string& value);
 const char* defaultPoolUrl();

src/ui/windows/mining_stats.cpp

@@ -251,11 +251,15 @@ static void RenderLeftPoolCard(App* app, const WalletState& state, ImDrawList* d
     }
     y += gap * 0.5f;
 
+    // The pool list = official pools ∪ user-saved favorites ∪ the current custom pool.
+    const auto effective = util::effectivePools(app->settings()->getPoolUrl(),
+                                                app->settings()->getSavedPoolUrls());
+
     // --- POOLS (N) header + Refresh ---
     {
         char hdr[48];
         snprintf(hdr, sizeof(hdr), "%s (%d)", TR("mining_pools_header"),
-                 (int)util::knownPools().size());
+                 (int)effective.size());
         dl->AddText(ovFont, ovFont->LegacySize, ImVec2(x, y), OnSurfaceMedium(), hdr);
 
         float btnS = ovFont->LegacySize + 6 * dp;
@@ -278,11 +282,11 @@ static void RenderLeftPoolCard(App* app, const WalletState& state, ImDrawList* d
     {
         ImDrawList* cdl = ImGui::GetWindowDrawList();
         const auto snap = app->poolStatsSnapshot();
-        const util::KnownPool* current = util::findKnownPoolByUrl(app->settings()->getPoolUrl());
+        const util::KnownPool* current = util::findPoolByUrl(effective, app->settings()->getPoolUrl());
         const float childW = ImGui::GetContentRegionAvail().x;
         const float listRowH = capFont->LegacySize + 10 * dp;
 
-        for (const auto& kp : util::knownPools()) {
+        for (const auto& kp : effective) {
             ImGui::PushID(kp.id.c_str());
             const bool isCurrent = current && current->id == kp.id;
             const auto it = snap.byId.find(kp.id);
@@ -315,7 +319,17 @@ static void RenderLeftPoolCard(App* app, const WalletState& state, ImDrawList* d
 
             char right[64];
             std::string hrStr = haveHr ? FormatHashrate(it->second.hashrateHs) : std::string("—");
-            snprintf(right, sizeof(right), "%s  %.0f%% fee", hrStr.c_str(), kp.feePercent);
+            // Prefer the live fee the pool reports; fall back to the compile-time
+            // KnownPool.feePercent. A synthetic user pool has an unknown (<0) fee, so
+            // we show just its hashrate placeholder for it.
+            double feePct = (it != snap.byId.end() && it->second.feePercent >= 0.0)
+                                ? it->second.feePercent
+                                : kp.feePercent;
+            if (feePct >= 0.0)
+                snprintf(right, sizeof(right), "%s  %s%% fee", hrStr.c_str(),
+                         FormatFeePercent(feePct).c_str());
+            else
+                snprintf(right, sizeof(right), "%s", hrStr.c_str());
             ImVec2 rSz = capFont->CalcTextSizeA(capFont->LegacySize, FLT_MAX, 0, right);
             cdl->AddText(capFont, capFont->LegacySize,
                          ImVec2(rMax.x - rSz.x - 6 * dp, textY), OnSurfaceMedium(), right);

src/ui/windows/mining_tab_helpers.cpp

@@ -41,6 +41,21 @@ std::string FormatHashrate(double hashrate)
     return std::string(buffer);
 }
 
+std::string FormatFeePercent(double feePercent)
+{
+    // Whole fees read "1"; fractional ones keep only their significant decimals
+    // ("1.5", "0.9", "1.25") with no trailing zeros. Capped at 2 dp — finer than
+    // any pool advertises, and the caller appends the "%".
+    char buffer[32];
+    snprintf(buffer, sizeof(buffer), "%.2f", feePercent);
+    std::string s(buffer);
+    if (s.find('.') != std::string::npos) {
+        s.erase(s.find_last_not_of('0') + 1);
+        if (!s.empty() && s.back() == '.') s.pop_back();
+    }
+    return s;
+}
+
 double EstimateHoursToBlock(double localHashrate, double networkHashrate, double difficulty)
 {
     (void)difficulty;

src/ui/windows/mining_tab_helpers.h

@@ -9,6 +9,7 @@ int GetMaxMiningThreads();
 int ClampMiningThreads(int requestedThreads, int maxThreads);
 bool IsPoolMiningActive(bool poolMode, bool xmrigRunning, bool soloMiningRunning);
 std::string FormatHashrate(double hashrate);
+std::string FormatFeePercent(double feePercent);
 double EstimateHoursToBlock(double localHashrate, double networkHashrate, double difficulty);
 std::string FormatEstTime(double estimatedHours);
 

src/ui/windows/send_tab.cpp

@@ -137,25 +137,27 @@ static double GetAvailableBalance(App* app) {
     // not a stored list index. The index desyncs from s_from_address after an address-list
     // refresh, and is left at -1 when the source is chosen from another tab ("Send from this
     // address") — which previously made the sufficiency check see 0 and block a valid send.
+    // CONFIRMED balance only — this is the spend ceiling (Max button, slider, validation, pre-broadcast
+    // re-check). z_sendmany runs at minconf=1, so offering 0-conf change here would just make the send fail.
     if (s_from_address[0] != '\0') {
         for (const auto& a : state.addresses) {
-            if (a.address == s_from_address) return a.balance;
+            if (a.address == s_from_address) return a.spendableBalance;
         }
     }
     if (s_selected_from_idx >= 0 && s_selected_from_idx < static_cast<int>(state.addresses.size())) {
-        return state.addresses[s_selected_from_idx].balance;
+        return state.addresses[s_selected_from_idx].spendableBalance;
     }
     return 0.0;
 }
 
-// Recipient validity = prefix/length pre-filter AND a real encoding-checksum check, so a
-// transcription error that still matches the prefix/length is no longer labelled "Valid".
-// The checksum verifiers are version-agnostic, so they never reject a genuine address.
+// Recipient validity via the shared, structure-based recognizers: a real encoding-checksum check
+// plus the actual DragonX address types — so a transcription error is never "Valid", and a valid
+// P2SH/multisig ('b…') recipient is no longer dropped by a hardcoded 'R'-only prefix filter.
 static bool IsValidShieldedAddr(const char* a) {
-    return a[0] == 'z' && a[1] == 's' && strlen(a) > 60 && dragonx::util::isValidBech32(a);
+    return a && dragonx::util::isShieldedAddress(a);
 }
 static bool IsValidTransparentAddr(const char* a) {
-    return a[0] == 'R' && strlen(a) >= 34 && dragonx::util::isValidBase58Check(a);
+    return a && dragonx::util::isTransparentAddress(a);
 }
 
 static std::string timeAgo(int64_t timestamp) {
@@ -252,7 +254,7 @@ static void RenderSourceDropdown(App* app, float width) {
         std::string trunc = util::truncateMiddle(addr.address,
             static_cast<int>(std::max(S.drawElement("tabs.send", "addr-preview-trunc-min").size, width / S.drawElement("tabs.send", "addr-preview-trunc-divisor").size)));
         snprintf(buf, sizeof(buf), "%s %s  —  %.8f %s",
-                 tag, trunc.c_str(), addr.balance, DRAGONX_TICKER);
+                 tag, trunc.c_str(), addr.spendableBalance, DRAGONX_TICKER);
         s_source_preview = buf;
     } else {
         s_source_preview = TR("send_select_source");
@@ -282,7 +284,7 @@ static void RenderSourceDropdown(App* app, float width) {
 
                     std::string trunc = util::truncateMiddle(addr.address, (int)addrTruncLen);
                     snprintf(buf, sizeof(buf), "%s %s  —  %.8f %s",
-                             tag, trunc.c_str(), addr.balance, DRAGONX_TICKER);
+                             tag, trunc.c_str(), addr.spendableBalance, DRAGONX_TICKER);
 
                     ImGui::PushID(static_cast<int>(i));
                     if (ImGui::Selectable(buf, isCurrent)) {
@@ -292,7 +294,7 @@ static void RenderSourceDropdown(App* app, float width) {
                     }
                     if (ImGui::IsItemHovered()) {
                         material::Tooltip("%s\nBalance: %.8f %s",
-                            addr.address.c_str(), addr.balance, DRAGONX_TICKER);
+                            addr.address.c_str(), addr.spendableBalance, DRAGONX_TICKER);
                     }
                     ImGui::PopID();
                 }
@@ -822,7 +824,17 @@ void RenderSendConfirmPopup(App* app) {
         if (s_sending) {
             Type().text(TypeStyle::Body2, TR("sending"));
         } else {
-            if (TactileButton(TR("confirm_and_send"), ImVec2(S.button("tabs.send", "confirm-button").width * Layout::dpiScale(), std::max(schema::UI().drawElement("tabs.send", "confirm-btn-min-height").size, schema::UI().drawElement("tabs.send", "confirm-btn-base-height").size * popVs)), S.resolveFont(S.button("tabs.send", "confirm-button").font))) {
+            // Size to max(schema width, measured label + padding) so a longer translation (e.g. the
+            // Russian "Подтвердить и отправить") isn't clipped on this pre-broadcast confirm button.
+            ImFont* confirmFont = S.resolveFont(S.button("tabs.send", "confirm-button").font);
+            if (!confirmFont) confirmFont = Type().button();
+            const float confirmW = std::max(
+                S.button("tabs.send", "confirm-button").width * Layout::dpiScale(),
+                confirmFont->CalcTextSizeA(confirmFont->LegacySize, FLT_MAX, 0, TR("confirm_and_send")).x
+                + ImGui::GetStyle().FramePadding.x * 2.0f + 16.0f * Layout::dpiScale());
+            const float confirmH = std::max(schema::UI().drawElement("tabs.send", "confirm-btn-min-height").size,
+                                            schema::UI().drawElement("tabs.send", "confirm-btn-base-height").size * popVs);
+            if (TactileButton(TR("confirm_and_send"), ImVec2(confirmW, confirmH), confirmFont)) {
               // Re-validate against LIVE state — the confirm dialog persists across frames, so the
               // balance could have dropped or sync (re)started (or the fee bumped total over available)
               // since Review. Don't broadcast a now-invalid transaction.
@@ -1318,8 +1330,7 @@ void RenderSendTab(App* app)
                         trimmed.erase(trimmed.begin());
                     while (!trimmed.empty() && (trimmed.back() == ' ' || trimmed.back() == '\n' || trimmed.back() == '\r' || trimmed.back() == '\t'))
                         trimmed.pop_back();
-                    bool looksValid = (trimmed.size() > 30 &&
-                        ((trimmed[0] == 'z' && trimmed[1] == 's') || trimmed[0] == 'R'));
+                    bool looksValid = dragonx::util::isValidRecipientAddress(trimmed);
                     if (looksValid && s_to_address[0] == '\0') {
                         s_preview_text = trimmed;
                         s_paste_previewing = true;

src/ui/windows/wallets_dialog.h

@@ -288,17 +288,21 @@ public:
                 // encryption — so absence of a lock never falsely reads as "unencrypted" on a huge wallet.
                 const ProbeResult pres = probeAt(i);   // from the frame-consistent snapshot above
                 const bool bLock    = pres.probed && pres.encrypted;
-                // Seed-phrase vs legacy. Runtime status (z_exportmnemonic → activeWalletSeedBadge) is
-                // authoritative for the ACTIVE wallet; otherwise the offline probe reads the hdchain
-                // record's fMnemonicSeed flag directly (pres.mnemonic: 1 = BIP39 seed phrase, 2 = HD/legacy
-                // with no phrase, 0 = couldn't tell) — which, unlike bare HD-record presence, actually
-                // distinguishes the two. seed uses the same 1/2/0 encoding.
-                const int activeBadge = rowActive[i] ? app->activeWalletSeedBadge() : 0;
-                int seed = activeBadge;
-                if (seed == 0 && pres.probed) {
-                    if (pres.mnemonic != 0)                 seed = pres.mnemonic;   // read the flag off disk
-                    else if (pres.complete && !pres.hdSeed) seed = 2;              // no HD records at all → no phrase
-                }
+                // Seed-phrase vs legacy. The offline probe reads the hdchain record's fMnemonicSeed flag
+                // straight off disk (pres.mnemonic: 1 = BIP39 seed phrase, 2 = HD/legacy with no phrase,
+                // 0 = couldn't tell). That is the SAME flag the daemon's IsMnemonicSeed()/z_exportmnemonic
+                // consult, so a definitive read is authoritative and takes precedence. The runtime badge
+                // (activeWalletSeedBadge, reset only on disconnect) is used ONLY when the offline probe
+                // couldn't decide — it must NEVER override a definitive on-disk read, or a stale
+                // HasMnemonic carried from a previously-active mnemonic wallet mislabels a legacy wallet as
+                // a seed-phrase wallet. seed uses the same 1/2/0 encoding.
+                int seed = 0;
+                if (pres.probed && pres.mnemonic != 0)
+                    seed = pres.mnemonic;                                          // definitive on-disk flag wins
+                else if (rowActive[i] && app->activeWalletSeedBadge() != 0)
+                    seed = app->activeWalletSeedBadge();                           // runtime fallback (active row only)
+                else if (pres.probed && pres.complete && !pres.hdSeed)
+                    seed = 2;                                                      // no HD records at all → no phrase
                 const bool bSeed    = (seed == 1);
                 const bool bLegacy  = (seed == 2);
                 // seed==0 splits by what the probe DID learn: if it saw HD records we know it's an HD
@@ -792,6 +796,14 @@ private:
                     } else {
                         const auto pr = util::probeWalletFile(t.first, std::min(budget, kPerFile));
                         res = ProbeResult{ pr.isBerkeleyDB, pr.scanComplete, pr.encrypted, pr.hdSeed };
+                        // A cap-truncated btree walk still yields DEFINITIVE positives (a found marker is
+                        // authoritative even when the scan didn't finish), so carry what it read — notably
+                        // the fMnemonicSeed flag. Otherwise a large wallet probed after the shared budget is
+                        // spent loses its seed/legacy classification and the row falls back to the (possibly
+                        // stale) runtime badge, mislabelling a legacy wallet as a seed-phrase wallet.
+                        if (bt.mnemonicSeed != 0) res.mnemonic  = bt.mnemonicSeed;
+                        if (bt.hdSeed)            res.hdSeed    = true;
+                        if (bt.encrypted)         res.encrypted = true;
                         budget -= std::min(budget, std::max(bt.bytesRead, pr.bytesRead));
                     }
                 }

src/util/address_validation.cpp

@@ -76,7 +76,7 @@ std::vector<int> bech32HrpExpand(const std::string& hrp)
 
 }  // namespace
 
-bool isValidBase58Check(const std::string& s)
+bool decodeBase58Check(const std::string& s, std::vector<std::uint8_t>& payloadOut)
 {
     if (s.size() < 5 || s.size() > 256) return false;
     std::vector<std::uint8_t> data;
@@ -88,7 +88,15 @@ bool isValidBase58Check(const std::string& s)
     unsigned char h2[crypto_hash_sha256_BYTES];
     crypto_hash_sha256(h1, data.data(), payloadLen);
     crypto_hash_sha256(h2, h1, sizeof(h1));
-    return std::memcmp(h2, data.data() + payloadLen, 4) == 0;
+    if (std::memcmp(h2, data.data() + payloadLen, 4) != 0) return false;
+    payloadOut.assign(data.begin(), data.begin() + payloadLen);
+    return true;
+}
+
+bool isValidBase58Check(const std::string& s)
+{
+    std::vector<std::uint8_t> payload;
+    return decodeBase58Check(s, payload);
 }
 
 bool isValidBech32(const std::string& s)
@@ -127,5 +135,39 @@ bool isValidBech32(const std::string& s)
     return bech32Polymod(combined) == 1;  // original Bech32 constant (Sapling, not Bech32m)
 }
 
+std::string bech32Hrp(const std::string& s)
+{
+    if (!isValidBech32(s)) return {};
+    // isValidBech32 already rejected mixed case and guaranteed a non-empty HRP before the
+    // final '1' separator, so lower-casing and splitting there recovers the HRP verbatim.
+    std::string lower(s);
+    std::transform(lower.begin(), lower.end(), lower.begin(),
+                   [](unsigned char c) { return static_cast<char>(std::tolower(c)); });
+    const std::size_t sep = lower.rfind('1');
+    if (sep == std::string::npos) return {};
+    return lower.substr(0, sep);
+}
+
+bool isTransparentAddress(const std::string& s)
+{
+    std::vector<std::uint8_t> payload;
+    // version byte (1) + hash160 (20) = 21 bytes, checksum stripped. Covers P2PKH ('R', v60) and
+    // P2SH/multisig ('b', v85); the daemon vets the exact version byte for the active network.
+    return decodeBase58Check(s, payload) && payload.size() == 21;
+}
+
+bool isShieldedAddress(const std::string& s)
+{
+    const std::string hrp = bech32Hrp(s);
+    return hrp == "zs"                 // mainnet Sapling payment address
+        || hrp == "ztestsapling"       // testnet
+        || hrp == "zregtestsapling";   // regtest
+}
+
+bool isValidRecipientAddress(const std::string& s)
+{
+    return isTransparentAddress(s) || isShieldedAddress(s);
+}
+
 }  // namespace util
 }  // namespace dragonx

src/util/address_validation.h

@@ -11,7 +11,9 @@
 
 #pragma once
 
+#include <cstdint>
 #include <string>
+#include <vector>
 
 namespace dragonx {
 namespace util {
@@ -20,9 +22,31 @@ namespace util {
 // (transparent R-addresses). Version-byte agnostic by design.
 bool isValidBase58Check(const std::string& s);
 
+// Decodes `s` as Base58Check; on success returns true and fills `payloadOut` with the
+// decoded bytes EXCLUDING the trailing 4-byte checksum (i.e. version byte + data). Lets
+// callers inspect the version byte / payload length (e.g. to tell a WIF from an address).
+bool decodeBase58Check(const std::string& s, std::vector<std::uint8_t>& payloadOut);
+
 // True if `s` is a valid Bech32 string (Sapling zs-addresses). The HRP is taken
 // from the string itself and folded into the checksum, so no HRP is hardcoded.
 bool isValidBech32(const std::string& s);
 
+// Returns the (lower-cased) human-readable prefix of a valid Bech32 string, or "" if
+// `s` is not valid Bech32. The HRP identifies the key/address type (e.g. "zivks").
+std::string bech32Hrp(const std::string& s);
+
+// True if `s` is a transparent (Base58Check) address — P2PKH *or* P2SH/multisig. Accepts any
+// address whose payload is a 21-byte version+hash160, so it covers both the 'R…' (v60) and 'b…'
+// (v85 script) forms on every DragonX network and rejects WIF keys / typos by checksum. Version-byte
+// agnostic by design — a bare prefix check ('R' only) silently drops valid P2SH recipients.
+bool isTransparentAddress(const std::string& s);
+
+// True if `s` is a shielded Sapling payment address (HRP "zs" / "ztestsapling" / "zregtestsapling"),
+// with a valid Bech32 checksum. Distinguishes a payment address from a viewing key (e.g. "zivks…").
+bool isShieldedAddress(const std::string& s);
+
+// True if `s` is any address a payment can be sent to (transparent or shielded).
+bool isValidRecipientAddress(const std::string& s);
+
 }  // namespace util
 }  // namespace dragonx

src/util/connect_stall.h

@@ -0,0 +1,27 @@
+// DragonX Wallet - ImGui Edition
+// Copyright 2024-2026 The Hush Developers
+// Released under the GPLv3
+
+#pragma once
+
+namespace dragonx {
+namespace util {
+
+// Default "taking longer than expected" threshold (seconds) for the daemon connect loop,
+// overridable via ui.toml [screens.loading].stall-timeout-sec. Kept as a free function with
+// no ImGui/App dependency so it is directly unit-testable from tests/test_phase4.cpp.
+constexpr float kConnectStallDefaultSeconds = 45.0f;
+
+// True once a daemon that is reachable-but-not-ready has stayed that way past the threshold.
+//   stallSince : timestamp (same clock as `now`) when the stall began; <= 0 means "not stalling".
+//   now        : current time in the same units as stallSince.
+//   thresholdSec: how long to wait before considering it stalled; <= 0 disables the feature.
+inline bool connectHasStalled(double stallSince, double now, float thresholdSec)
+{
+    if (stallSince <= 0.0) return false;        // not currently in a stall-tracked state
+    if (thresholdSec <= 0.0f) return false;     // 0/negative disables the notice defensively
+    return (now - stallSince) >= static_cast<double>(thresholdSec);
+}
+
+} // namespace util
+} // namespace dragonx

src/util/daemon_updater_core.cpp

@@ -140,15 +140,16 @@ std::map<std::string, std::string> parseDaemonChecksums(const std::string& body)
     //   | File | SHA-256 |
     //   |------|---------|
     //   | dragonx-1.0.2-linux-amd64.zip | `85f1dd…16` |
-    // Per line: blank out the table/code delimiters ('|' and '`'), then find the 64-hex token (the
-    // hash) and a token ending in ".zip" (the archive name). Header/separator/prose rows lack one
-    // or the other and are skipped, so this is robust to surrounding text and column order.
+    // Per line: blank out the table/code/emphasis delimiters ('|', '`', and markdown '*'/'_' so a
+    // bolded **archive.zip** still tokenizes), then find the 64-hex token (the hash) and a token
+    // ending in ".zip" (the archive name). Header/separator/prose rows lack one or the other and are
+    // skipped, so this is robust to surrounding text and column order.
     std::map<std::string, std::string> out;
     std::istringstream in(body);
     std::string line;
     while (std::getline(in, line)) {
         for (char& c : line)
-            if (c == '|' || c == '`') c = ' ';
+            if (c == '|' || c == '`' || c == '*' || c == '_') c = ' ';
         std::istringstream ls(line);
         std::string tok, hash, name;
         while (ls >> tok) {

src/util/i18n.cpp

@@ -320,7 +320,7 @@ void I18n::loadBuiltinEnglish()
         strings_["seed_backup_load_failed"] = "Could not load the seed phrase.";
         strings_["seed_backup_copy"] = "Copy";
         strings_["seed_backup_save"] = "Save to file…";
-        strings_["seed_backup_saved"] = "Saved to ";
+        strings_["seed_backup_saved"] = "Saved an UNENCRYPTED seed file — move it to secure offline storage and delete this copy: ";
         strings_["seed_backup_save_failed"] = "Could not write ";
         strings_["seed_backup_close"] = "Close";
         strings_["seed_backup_reminder"] = "Your wallet has a 24-word recovery seed phrase. Back it up now in Settings → Node & Security.";
@@ -1185,6 +1185,77 @@ void I18n::loadBuiltinEnglish()
         strings_["switch_corrupt_body"] = "This wallet appears corrupt — the node couldn't open it. Restore it from a backup, re-create it, or try to repair it.";
         strings_["switch_corrupt_repair"] = "Try to repair (salvage)";
 
+        // Block-database recovery (offered when the node aborts on an unreadable/format-mismatched block DB).
+        strings_["block_db_reindex_title"] = "Rebuild block database?";
+        strings_["block_db_reindex_warn"] = "The node can't read its block database.";
+        strings_["block_db_reindex_body"] = "This usually happens after a daemon update changes the on-disk format, or if the block index is damaged. Your wallet and coins are safe — the node just can't load the chain, so balances show as zero.\n\nRebuilding re-reads your existing block files and can take a while (it also rescans your wallet). Nothing is downloaded.";
+        strings_["block_db_reindex_confirm"] = "Rebuild block database";
+        strings_["block_db_reindex_notify"] = "The node can't read its block database (often after a daemon update). Rebuild it to restore your balance — see the prompt, or Settings › Node.";
+        strings_["block_db_reindex_started"] = "Rebuilding the block database from your blocks — this can take a while.";
+
+        // Wallet auto-recovery warning (the node moved wallet.dat aside and loaded a salvaged copy).
+        strings_["wallet_recovered_title"] = "Your wallet file needs a quick repair";
+        strings_["wallet_recovered_safety"] = "Your coins are safe.";
+        strings_["wallet_recovered_warn"] = "When the app started, it found that your wallet file didn't pass its consistency check — this usually happens after an app update or an unclean shutdown. The app already protected your data: it set the old file aside and loaded a repaired copy so you're not stuck.";
+        strings_["wallet_recovered_body"] = "Nothing has been deleted. Your original wallet is still saved on your computer as a dated backup file, and every option below only copies or renames files — it never erases one. Your keys are never regenerated, only re-read.\n\nThe repaired copy that's loaded now may be missing a few recent transactions, so your balance can look a little low until you finish below and it re-scans.";
+        strings_["wallet_recovered_open_folder"] = "Show me the files";
+        strings_["wallet_recovered_open_folder_sub"] = "Opens the wallet data folder so you can inspect the backup files yourself — nothing is changed.";
+        strings_["wallet_recovered_dismiss"] = "Not now — keep the repaired copy";
+        strings_["wallet_recovered_dismiss_sub"] = "No files change. You can reopen this anytime from the status bar; your original stays safely backed up either way.";
+        strings_["wallet_recovered_restore"] = "Restore the original file instead";
+        strings_["wallet_recovered_restore_sub"] = "Puts your largest untouched backup back in place, verbatim, then re-scans — slightly faster, but only as complete as that one file was. Your current file is kept as a dated backup either way.";
+        strings_["wallet_recovered_notify"] = "Your wallet file needed a repair — your original was safely backed up. Open the app to review your options.";
+        // In-dialog recovery lifecycle (Offer → Working → Done/Failed) + disclosures.
+        strings_["wallet_recovery_working_label"] = "Working";
+        strings_["wallet_recovery_done"] = "Done";
+        strings_["wallet_recovery_other_options"] = "Other options";
+        strings_["wallet_recovery_details_label"] = "Show technical details";
+        strings_["wallet_recovery_try_other"] = "Try the other option";
+        strings_["wallet_recovery_success_body"] = "The app loaded your repaired wallet and is re-scanning to total your balance — this can take a few minutes. It reads every record it can, but on rare damaged files it may recover slightly fewer — or occasionally more — addresses than before. Once the re-scan finishes, check your balance and history look right.";
+        strings_["wallet_recovery_success_restore"] = "Your largest backup file is back in place and loading now, and the app is re-scanning. It's restored verbatim, so it's exactly as complete as that file was — check your balance once the re-scan finishes.";
+        strings_["wallet_recovery_failure_title"] = "The repair didn't go through";
+        strings_["wallet_recovery_failure_body"] = "The repair ran, but its result didn't pass verification (it couldn't be read, or had no addresses), so it was discarded automatically before it ever replaced anything. Your wallet is exactly as it was before you clicked — nothing on disk changed.";
+        strings_["wallet_recovery_whats_happened"] = "What happened?";
+        // Choice-card layout: two side-by-side cards (recommended one highlighted) + quiet footer links.
+        strings_["wallet_recovery_rebuild_card"] = "Repair automatically";
+        strings_["wallet_recovery_restore_card"] = "Restore original";
+        strings_["wallet_recovery_rebuild_card_desc"] = "Reads every recoverable record into a clean file, then restarts. The most thorough option.";
+        strings_["wallet_recovery_restore_card_desc"] = "Puts your largest untouched backup back, verbatim \xE2\x80\x94 only as complete as that file was.";
+        strings_["wallet_recovery_recommended"] = "RECOMMENDED";
+        strings_["wallet_recovery_repair_go"] = "Repair";
+        strings_["wallet_recovery_restore_go"] = "Restore";
+        strings_["wallet_recovery_notnow_short"] = "Not now";
+        strings_["wallet_recovery_decide_later"] = "Decide later";
+        strings_["wallet_recovery_decide_later_tip"] = "Closes this and keeps the copy that's loaded now. Nothing is changed, and you can repair anytime \xE2\x80\x94 the status bar keeps a \xE2\x80\x9CWallet repair available\xE2\x80\x9D link.";
+        strings_["wallet_recovery_files_label"] = "What happens to my files?";
+        strings_["wallet_recovery_files_detail"] = "Your original wallet is still here \xE2\x80\x94 the app renamed it to a dated backup (wallet.<numbers>.bak) in your data folder and hasn't deleted anything. \xE2\x80\x9CRepair\xE2\x80\x9D reads every record from your fullest wallet into a brand-new clean file. \xE2\x80\x9CRestore\xE2\x80\x9D copies your largest backup back exactly as it is. The copy loaded right now is kept as a backup too.";
+        // Post-repair rescan screen (shown while the node restarts + re-scans, before it answers RPC).
+        strings_["wallet_recovery_rescan_title"] = "Finishing your wallet repair";
+        strings_["wallet_recovery_rescan_body"] = "Re-scanning the blockchain to rebuild your balance and transaction history. This can take several minutes — you don't need to do anything, and please don't restart the node while it's running.";
+        strings_["wallet_recovery_rescan_elapsed"] = "Working for %s";
+        strings_["wallet_recovery_rescan_size"] = "Rebuilt wallet is now %s and still filling in";
+        strings_["wallet_recovery_rescan_slow"] = "This is taking longer than usual, which is normal for a large wallet. It's safe to leave it running — you can watch progress under Advanced \xE2\x96\xB8 Console.";
+        strings_["sb_finishing_repair"] = "Finishing wallet repair — re-scanning…";
+        // One-click "Restore original wallet" flow.
+        strings_["wallet_restore_started"] = "Restoring your original file — please don't close this window.";
+        strings_["wallet_restore_busy"] = "The node is busy restarting — try again in a moment.";
+        strings_["wallet_restore_ok"] = "Original wallet restored. The node is loading it now.";
+        strings_["wallet_restore_no_backup"] = "Couldn't find a wallet.<timestamp>.bak to restore. Nothing was changed.";
+        strings_["wallet_restore_bad_backup"] = "The backup wallet file looks unreadable, so it was NOT restored — your current wallet is unchanged. Restore from your own backup instead.";
+        strings_["wallet_restore_stop_failed"] = "The node didn't stop in time, so nothing was changed. Try again.";
+        strings_["wallet_restore_move_failed"] = "Couldn't set the current wallet aside — nothing was changed.";
+        strings_["wallet_restore_copy_failed"] = "Couldn't install the backup wallet; your current wallet was left in place.";
+        strings_["wallet_restore_no_restart"] = "Your original wallet was restored, but the node didn't restart — start it from Settings.";
+        // One-click "Rebuild wallet database" flow (fixes a BDB-inconsistent wallet that keeps getting salvaged).
+        strings_["wallet_recovered_rebuild"] = "Repair automatically (recommended)";
+        strings_["wallet_recovered_rebuild_sub"] = "Re-reads every recoverable record from your fullest wallet file and writes a clean new one, then restarts. The most thorough option — your current file is kept as a dated backup either way.";
+        strings_["wallet_rebuild_started"] = "Repairing your wallet file — please don't close this window.";
+        strings_["wallet_rebuild_ok"] = "Wallet database rebuilt — the node is loading it and rescanning for your balance.";
+        strings_["wallet_rebuild_no_helper"] = "The wallet-rebuild helper isn't available in this build. Use Restore, or rebuild manually.";
+        strings_["wallet_rebuild_no_source"] = "Couldn't find a readable wallet to rebuild. Nothing was changed.";
+        strings_["wallet_rebuild_failed"] = "The rebuild didn't produce a valid wallet, so nothing was changed. Your wallet is untouched.";
+        strings_["wallet_rebuild_install_failed"] = "Couldn't install the rebuilt wallet; your current wallet was left in place.";
+
         // Receive Tab
         strings_["receiving_addresses"] = "Your Receiving Addresses";
         strings_["new_z_shielded"] = "New z-Address (Shielded)";
@@ -1309,6 +1380,24 @@ void I18n::loadBuiltinEnglish()
         strings_["sb_connecting_err"] = "Connecting to daemon — %s";
         strings_["sb_daemon_crashed"] = "Daemon crashed %d times";
         strings_["sb_daemon_start_failed"] = "Couldn't start dragonxd";
+        strings_["sb_block_db_unreadable"] = "Block database unreadable — rebuild required";
+        strings_["sb_wallet_needs_recovery"] = "Wallet repair available";
+        // Persistent node-status banner (App::renderNodeStatusBanner).
+        strings_["node_banner_offline_title"] = "Not connected to the DragonX node";
+        strings_["node_banner_crashed_title"] = "The node stopped unexpectedly";
+        strings_["node_banner_lite_open_failed"] = "Couldn't open your wallet";
+        strings_["node_banner_reconnect"] = "Reconnect";
+        strings_["node_banner_restart"] = "Restart node";
+        // Refresh-staleness badge (W6-2) on the Total Balance card.
+        strings_["data_stale_prefix"] = "Updated";
+        strings_["data_stale_tooltip"] =
+            "Balance may be out of date — the wallet hasn't received a fresh update recently. "
+            "Check your node connection.";
+        // Persistent alert-history panel (status-bar bell).
+        strings_["alerts_history_tooltip"] = "Recent alerts";
+        strings_["alerts_recent"] = "RECENT ALERTS";
+        strings_["alerts_none"] = "No alerts yet";
+        strings_["alerts_clear"] = "Clear alert history";
         strings_["daemon_port_busy_warn"] =
             "Port " DRAGONX_DEFAULT_RPC_PORT " is in use but isn't responding as a DragonX node. "
             "Close the program using it (or free the port), then restart — the wallet can't start "
@@ -1316,6 +1405,17 @@ void I18n::loadBuiltinEnglish()
         strings_["sb_extracting_sapling"] = "Extracting Sapling parameters...";
         strings_["sb_sapling_failed"] = "Failed to extract Sapling parameters.";
         strings_["sb_sapling_not_found"] = "Sapling parameters not found.";
+        strings_["sb_daemon_extract_failed"] = "Failed to write daemon files — check free disk space and permissions.";
+        strings_["sb_daemon_files_failed"] = "Failed to write daemon files to %s — check free disk space and permissions.";
+        strings_["loading_stall_title"] = "Taking longer than expected";
+        strings_["loading_stall_body"] = "The daemon has been initializing for %.0fs. This can be normal after an update or on first launch (loading the block index or rescanning) — it will connect automatically once ready.";
+        strings_["loading_stall_hint"] = "Still stuck? Open Settings and use Restart Daemon, or check the Console for details.";
+        strings_["sb_plaintext_remote_blocked"] = "Refusing to send RPC credentials over plaintext to a remote host. Add rpcallowplaintext=1 to DRAGONX.conf to allow it, or enable TLS with rpctls=1.";
+        strings_["settings_open_log_folder"] = "Open log folder";
+        strings_["settings_copy_diagnostics"] = "Copy diagnostics";
+        strings_["settings_diagnostics_copied"] = "Diagnostics copied to clipboard";
+        strings_["tt_open_log_folder"] = "Open the folder containing the debug and crash logs";
+        strings_["tt_copy_diagnostics"] = "Copy a support snapshot (version, daemon/wallet/log state — no secrets) to the clipboard";
         strings_["sb_dragonxd_running"] = "dragonxd running";
         strings_["sb_dragonxd_stopping"] = "Stopping dragonxd...";
         strings_["sb_dragonxd_stopped"] = "dragonxd stopped";

src/util/logger.cpp

@@ -5,10 +5,12 @@
 #include "logger.h"
 
 #include <cstdarg>
+#include <cstdint>
 #include <ctime>
 #include <chrono>
 #include <iomanip>
 #include <sstream>
+#include <filesystem>
 
 namespace dragonx {
 namespace util {
@@ -35,14 +37,30 @@ bool Logger::init(const std::string& path)
     if (file_.is_open()) {
         file_.close();
     }
-    
+
+    // W7-4: cap the log's growth — if the existing file is already large, rotate it to a single .1
+    // backup before reopening in append mode, so a long-lived or verbose session can't grow it
+    // without bound.
+    {
+        std::error_code ec;
+        const auto sz = std::filesystem::file_size(path, ec);
+        constexpr std::uintmax_t kMaxLogBytes = 10ull * 1024ull * 1024ull;  // 10 MB
+        if (!ec && sz > kMaxLogBytes) {
+            std::filesystem::rename(path, path + ".1", ec);  // replaces any previous .1 backup
+            if (ec) std::filesystem::remove(path, ec);       // fall back to truncation if rename fails
+        }
+    }
+
     file_.open(path, std::ios::out | std::ios::app);
     initialized_ = file_.is_open();
-    
+
     if (initialized_) {
-        write("=== Logger initialized ===");
+        // Write the banner directly, NOT via write(): write() re-locks the non-recursive mutex_ we
+        // already hold here, which would deadlock (latent — init() was previously never called, W7-2).
+        file_ << "=== Logger initialized ===" << std::endl;
+        file_.flush();
     }
-    
+
     return initialized_;
 }
 

src/util/payment_uri.cpp

@@ -3,6 +3,7 @@
 // Released under the GPLv3
 
 #include "payment_uri.h"
+#include "address_validation.h"
 
 #include <sstream>
 #include <iomanip>
@@ -161,20 +162,11 @@ PaymentURI parsePaymentURI(const std::string& uri)
         return result;
     }
     
-    // Basic address format check. NOTE: this is format-only by design — the send flow
-    // checksum-validates the recipient (isValidBase58Check / shielded check) before broadcasting,
-    // so an invalid-checksum address parsed here can never actually be sent to.
-    bool validFormat = false;
-
-    // z-address: starts with 'zs' and is 78+ chars
-    if (result.address[0] == 'z' && result.address.size() >= 78) {
-        validFormat = true;
-    }
-    // t-address: starts with 'R' (DragonX) or 't' (HUSH) and is ~34 chars
-    else if ((result.address[0] == 'R' || result.address[0] == 't') &&
-             result.address.size() >= 26 && result.address.size() <= 36) {
-        validFormat = true;
-    }
+    // Address format check via the shared, structure-based recognizers (checksum + real DragonX
+    // address types). This accepts shielded ("zs…"), P2PKH ("R…") and P2SH/multisig ("b…") forms —
+    // the old prefix/length heuristic rejected P2SH and hardcoded a 't' prefix DragonX never emits.
+    const bool validFormat = isShieldedAddress(result.address) ||
+                             isTransparentAddress(result.address);
 
     if (!validFormat) {
         result.error = "Invalid address format";

src/util/platform.cpp

@@ -126,6 +126,27 @@ bool Platform::openUrl(const std::string& url)
 #endif
 }
 
+bool Platform::ensureDirectory(const std::string& dir, std::string* outError)
+{
+    if (dir.empty()) {
+        if (outError) *outError = "Cannot create directory: empty path.";
+        return false;
+    }
+    std::error_code ec;
+    if (std::filesystem::is_directory(dir, ec)) return true;
+    ec.clear();
+    std::filesystem::create_directories(dir, ec);
+    if (ec) {
+        if (outError) {
+            *outError = "Cannot create " + dir + ": " + ec.message() +
+                        ". Check permissions / free space.";
+        }
+        DEBUG_LOGF("[ERROR] ensureDirectory failed for %s: %s\n", dir.c_str(), ec.message().c_str());
+        return false;
+    }
+    return true;
+}
+
 bool Platform::openFolder(const std::string& path, bool createIfMissing)
 {
     if (path.empty()) return false;

src/util/platform.h

@@ -128,6 +128,17 @@ public:
      */
     static void ensureObsidianDragonSetup();
 
+    /**
+     * @brief Create a directory (and parents) if missing, with a clear error on failure.
+     *
+     * Uses the non-throwing std::error_code overload internally. On failure sets *outError
+     * (when non-null) to one consistent, user-facing message:
+     *   "Cannot create <dir>: <reason>. Check permissions / free space."
+     *
+     * @return true if the directory exists (already did, or was just created).
+     */
+    static bool ensureDirectory(const std::string& dir, std::string* outError = nullptr);
+
     /**
      * @brief Get total system RAM in megabytes
      * @return Total physical RAM in MB, or 0 on failure

src/util/pool_registry.h

@@ -45,16 +45,30 @@ struct PoolHashrate {
     std::string id;
     double      hashrateHs = 0.0;
     bool        ok = false;
+    // Live pool fee (%) read from the same stats JSON. <0 means "not available" —
+    // callers fall back to the compile-time KnownPool.feePercent.
+    double      feePercent = -1.0;
 };
 
 // The built-in official pools (PPLNS only — never a SOLO pool, whose hashrate is
 // meaningless to balance against). Stable order.
 const std::vector<KnownPool>& knownPools();
 
-// The known pool whose stratum matches `url` (host, and port when both specify one),
-// or nullptr. `url` may be a bare host, host:port, or carry a scheme/userinfo/path.
+// The pool in `pools` whose stratum matches `url` (host, and port when both specify
+// one), or nullptr. `url` may be a bare host, host:port, or carry a scheme/path.
+const KnownPool* findPoolByUrl(const std::vector<KnownPool>& pools, const std::string& url);
+
+// Same, over the built-in official pools only.
 const KnownPool* findKnownPoolByUrl(const std::string& url);
 
+// The full list the UI should show: the official knownPools(), plus a row for every
+// user-saved pool URL and for `currentPoolUrl` when it isn't one of those — so a
+// custom/bookmarked pool is a first-class, selectable row. Synthetic (user) rows are
+// official=false and carry no statsUrl (feePercent<0, no live hashrate), and endpoints
+// are de-duplicated so a saved URL that equals an official pool isn't listed twice.
+std::vector<KnownPool> effectivePools(const std::string& currentPoolUrl,
+                                      const std::vector<std::string>& savedPoolUrls);
+
 // The algo xmrig must use for `url`: the matching known pool's algo, else `fallback`.
 std::string resolvePoolAlgo(const std::string& url, const std::string& fallback);
 
@@ -64,6 +78,13 @@ std::string resolvePoolAlgo(const std::string& url, const std::string& fallback)
 double parsePoolHashrate(PoolStatsSchema schema, const std::string& json,
                          const std::string& miningcorePoolId, bool& ok);
 
+// Parse a pool's advertised fee (%) out of the same stats JSON (DragonXIs:
+// pools.<name>.poolFee; Miningcore: pools[id].poolFeePercent). Selects the same
+// pool entry as parsePoolHashrate. Sets ok=false and returns 0 when the field is
+// absent / malformed, so the caller keeps the compile-time fallback.
+double parsePoolFee(PoolStatsSchema schema, const std::string& json,
+                    const std::string& miningcorePoolId, bool& ok);
+
 // Weighted-random pick among the usable (ok==true) pools: probability is inversely
 // proportional to hashrate (smaller pools favored), so miners spread out instead of
 // all stampeding to the single lowest pool. The current pool (`currentId`, may be

src/util/pool_registry_core.cpp

@@ -28,7 +28,7 @@ const std::vector<KnownPool>& knownPools()
         KnownPool{
             "dragonx-is", "pool.dragonx.is", "pool.dragonx.is:3433", "rx/hush",
             "https://pool.dragonx.is/api/stats", PoolStatsSchema::DragonXIs,
-            /*miningcorePoolId=*/"", /*feePercent=*/0.0, /*official=*/true,
+            /*miningcorePoolId=*/"", /*feePercent=*/1.0, /*official=*/true,
         },
     };
     return pools;
@@ -83,13 +83,62 @@ bool sameEndpoint(const std::string& a, const std::string& b)
     return pa == pb;
 }
 
+// Build a synthetic, selectable pool row for a user-supplied URL (a saved favorite
+// or the current custom pool). We don't know its stats API, so it carries no
+// statsUrl / live hashrate and an unknown (<0) fee — the UI falls back to "—".
+KnownPool makeUserPool(const std::string& url)
+{
+    KnownPool p;
+    const std::string hp = hostPortOf(url);
+    std::string host, port;
+    splitHostPort(hp, host, port);
+    p.id       = "user:" + trimmed(url);  // stable + unique (used as the ImGui id)
+    p.label    = host.empty() ? hp : host;
+    p.stratum  = trimmed(url);            // what the miner connects to / a row-click restores
+    p.algo     = "";                      // unknown; xmrig resolves via resolvePoolAlgo's fallback
+    p.statsUrl = "";                      // no known stats endpoint -> no live hashrate/fee
+    p.schema   = PoolStatsSchema::DragonXIs;
+    p.miningcorePoolId = "";
+    p.feePercent = -1.0;                  // unknown fee
+    p.official = false;
+    return p;
+}
+
 } // namespace
 
+const KnownPool* findPoolByUrl(const std::vector<KnownPool>& pools, const std::string& url)
+{
+    for (const auto& p : pools)
+        if (sameEndpoint(p.stratum, url)) return &p;
+    return nullptr;
+}
+
 const KnownPool* findKnownPoolByUrl(const std::string& url)
 {
-    for (const auto& p : knownPools())
-        if (sameEndpoint(p.stratum, url)) return &p;
-    return nullptr;
+    return findPoolByUrl(knownPools(), url);
+}
+
+std::vector<KnownPool> effectivePools(const std::string& currentPoolUrl,
+                                      const std::vector<std::string>& savedPoolUrls)
+{
+    std::vector<KnownPool> pools = knownPools();
+
+    // Skip anything whose endpoint already appears (official or an earlier user row).
+    auto listed = [&](const std::string& url) {
+        return findPoolByUrl(pools, url) != nullptr;
+    };
+
+    for (const auto& url : savedPoolUrls) {
+        if (trimmed(url).empty() || listed(url)) continue;
+        pools.push_back(makeUserPool(url));
+    }
+
+    // The pool currently being mined, if not already shown, so the active pool is
+    // always visible even before it's bookmarked.
+    if (!trimmed(currentPoolUrl).empty() && !listed(currentPoolUrl))
+        pools.push_back(makeUserPool(currentPoolUrl));
+
+    return pools;
 }
 
 std::string resolvePoolAlgo(const std::string& url, const std::string& fallback)
@@ -159,6 +208,64 @@ double parsePoolHashrate(PoolStatsSchema schema, const std::string& jsonStr,
     return 0.0;
 }
 
+double parsePoolFee(PoolStatsSchema schema, const std::string& jsonStr,
+                    const std::string& miningcorePoolId, bool& ok)
+{
+    ok = false;
+    try {
+        const json j = json::parse(jsonStr);
+
+        if (schema == PoolStatsSchema::DragonXIs) {
+            // { "pools": { "dragonx": { "poolFee": <num>, ... }, ... } }
+            if (j.contains("pools") && j["pools"].is_object()) {
+                const auto& pools = j["pools"];
+                auto readFee = [&](const json& pool, double& out) -> bool {
+                    if (pool.is_object() && pool.contains("poolFee") &&
+                        pool["poolFee"].is_number()) {
+                        out = pool["poolFee"].get<double>();
+                        return true;
+                    }
+                    return false;
+                };
+                double fee = 0.0;
+                if (pools.contains("dragonx") && readFee(pools["dragonx"], fee)) {
+                    ok = true;
+                    return fee;
+                }
+                for (auto it = pools.begin(); it != pools.end(); ++it) {
+                    if (readFee(it.value(), fee)) {
+                        ok = true;
+                        return fee;
+                    }
+                }
+            }
+        } else {  // Miningcore: pools[id].poolFeePercent
+            if (j.contains("pools") && j["pools"].is_array()) {
+                const json* chosen = nullptr;
+                for (const auto& pool : j["pools"]) {
+                    if (!pool.is_object()) continue;
+                    if (!miningcorePoolId.empty()) {
+                        if (pool.value("id", std::string{}) == miningcorePoolId) {
+                            chosen = &pool;
+                            break;
+                        }
+                    } else if (!chosen) {
+                        chosen = &pool;  // first pool when no id requested
+                    }
+                }
+                if (chosen && chosen->contains("poolFeePercent") &&
+                    (*chosen)["poolFeePercent"].is_number()) {
+                    ok = true;
+                    return (*chosen)["poolFeePercent"].get<double>();
+                }
+            }
+        }
+    } catch (...) {
+        // fall through — ok stays false
+    }
+    return 0.0;
+}
+
 std::string chooseWeightedPool(const std::vector<PoolHashrate>& pools,
                                const std::string& currentId,
                                std::mt19937& rng)

src/util/pool_stats_service.cpp

@@ -94,6 +94,12 @@ void PoolStatsService::run(std::vector<KnownPool> pools)
             const double v = parsePoolHashrate(p.schema, body, p.miningcorePoolId, ok);
             hr.ok = ok;
             hr.hashrateHs = ok ? v : 0.0;
+
+            bool feeOk = false;
+            const double fee = parsePoolFee(p.schema, body, p.miningcorePoolId, feeOk);
+            // Only trust a sane fee; anything else leaves feePercent < 0 so the UI
+            // falls back to the compile-time KnownPool.feePercent.
+            if (feeOk && fee >= 0.0 && fee <= 100.0) hr.feePercent = fee;
         }
         results[p.id] = hr;
     }

src/util/seed_phrase.cpp

@@ -0,0 +1,77 @@
+// DragonX Wallet - ImGui Edition
+// Copyright 2024-2026 The Hush Developers
+// Released under the GPLv3
+
+#include "seed_phrase.h"
+
+#include <cctype>
+
+namespace dragonx {
+namespace util {
+
+std::string normalizeSeedPhrase(const std::string& raw)
+{
+    // Unicode whitespace encoded as UTF-8, each mapped to a single ASCII space; and zero-width marks
+    // to strip. We substitute only these EXACT byte sequences, so ordinary (ASCII) word bytes are
+    // never touched — the common all-ASCII phrase just gets its spacing collapsed and trimmed.
+    static const char* const kSpaces[] = {
+        "\xC2\xA0",                                                            // U+00A0 NBSP
+        "\xC2\x85",                                                            // U+0085 NEL
+        "\xE1\x9A\x80",                                                        // U+1680 ogham space
+        "\xE2\x80\x80", "\xE2\x80\x81", "\xE2\x80\x82", "\xE2\x80\x83",        // U+2000–2003
+        "\xE2\x80\x84", "\xE2\x80\x85", "\xE2\x80\x86", "\xE2\x80\x87",        // U+2004–2007
+        "\xE2\x80\x88", "\xE2\x80\x89", "\xE2\x80\x8A",                        // U+2008–200A
+        "\xE2\x80\xAF",                                                        // U+202F narrow NBSP
+        "\xE2\x81\x9F",                                                        // U+205F math space
+        "\xE3\x80\x80",                                                        // U+3000 ideographic
+    };
+    static const char* const kZeroWidth[] = {
+        "\xE2\x80\x8B", "\xE2\x80\x8C", "\xE2\x80\x8D",                        // U+200B/C/D
+        "\xEF\xBB\xBF",                                                        // U+FEFF BOM / ZWNBSP
+    };
+
+    std::string s = raw;
+    auto replaceAll = [&s](const std::string& from, const std::string& to) {
+        if (from.empty()) return;
+        std::size_t pos = 0;
+        while ((pos = s.find(from, pos)) != std::string::npos) {
+            s.replace(pos, from.size(), to);
+            pos += to.size();
+        }
+    };
+    for (const char* zw : kZeroWidth) replaceAll(zw, "");
+    for (const char* sp : kSpaces)    replaceAll(sp, " ");
+
+    // Collapse ASCII whitespace runs to a single space and trim ends.
+    std::string out;
+    out.reserve(s.size());
+    bool pendingSpace = false;
+    bool sawWord = false;
+    for (unsigned char c : s) {
+        if (std::isspace(c)) { pendingSpace = sawWord; continue; }
+        if (pendingSpace) { out.push_back(' '); pendingSpace = false; }
+        out.push_back(static_cast<char>(c));
+        sawWord = true;
+    }
+    return out;
+}
+
+int seedPhraseWordCount(const std::string& phrase)
+{
+    int words = 0;
+    bool inWord = false;
+    for (unsigned char c : phrase) {
+        const bool space = std::isspace(c) != 0;
+        if (space) inWord = false;
+        else if (!inWord) { inWord = true; ++words; }
+    }
+    return words;
+}
+
+bool isCompleteRecoveryPhrase(int words)
+{
+    return words == 24;
+}
+
+}  // namespace util
+}  // namespace dragonx

src/util/seed_phrase.h

@@ -0,0 +1,38 @@
+// DragonX Wallet - ImGui Edition
+// Copyright 2024-2026 The Hush Developers
+// Released under the GPLv3
+//
+// seed_phrase.h — shared, pure helpers for validating a pasted BIP39 recovery phrase.
+// One source of truth for the seed-length contract so the lite-restore gates (first-run
+// wizard + Settings) cannot drift apart. No I/O, no secrets retained — safe for both variants.
+
+#pragma once
+
+#include <string>
+
+namespace dragonx {
+namespace util {
+
+// Normalize a pasted recovery phrase for consistent word counting AND backend submission:
+//  - every run of Unicode/ASCII whitespace (incl. NBSP U+00A0, en/em spaces U+2000–200A,
+//    U+202F, U+205F, ideographic U+3000, NEL, tab/newline) collapses to a single ASCII space,
+//  - zero-width marks (U+200B/C/D, U+FEFF BOM) are stripped,
+//  - leading/trailing space is trimmed.
+// Word bytes are copied verbatim — only these exact whitespace byte-sequences are substituted.
+// The lite backend (tiny-bip39) splits on the literal ASCII space and does NO Unicode folding, so
+// a phrase pasted with NBSPs (common from PDFs/note apps) is otherwise unrestorable; normalizing
+// before submit makes the words space-separated and recoverable.
+std::string normalizeSeedPhrase(const std::string& raw);
+
+// Count ASCII-whitespace-separated words. Pair with normalizeSeedPhrase so exotic spacing counts right.
+int seedPhraseWordCount(const std::string& phrase);
+
+// True if `words` is a complete recovery phrase the DragonX backends accept. DragonX seeds are
+// 24-word / 256-bit / 32-byte-entropy ONLY: the SDXL lite backend's LightWallet::new copies the
+// phrase entropy into a fixed [u8;32] (a shorter valid-BIP39 phrase — 12/15/18/21 words — makes it
+// panic, uncaught, across the restore FFI), and the full-node daemon likewise generates 24 words.
+// Both lite-restore gates MUST use this so a crash-inducing length is refused client-side.
+bool isCompleteRecoveryPhrase(int words);
+
+}  // namespace util
+}  // namespace dragonx

src/util/wallet_file_probe.h

@@ -339,5 +339,155 @@ inline WalletBtreeStats parseWalletBtree(const std::string& path,
     return st;
 }
 
+// ─────────────────────────────────────────────────────────────────────────────────────────────────
+// Tier 3: collect the raw (key,value) record BYTES — the read half of the offline wallet REBUILD that
+// recovers a BDB-inconsistent wallet.dat (stale extent metadata: our tolerant walk reads records the
+// daemon's Berkeley DB verify rejects and auto-salvages). A helper then writes these verbatim into a
+// fresh, consistent BDB so the daemon loads it cleanly. Records are copied byte-for-byte — encrypted
+// key material (ckey/csapzkey/mkey) passes through as opaque ciphertext, so no passphrase is needed.
+// Values that live in BDB OVERFLOW pages (only large `tx` history records) are NOT captured (skipped +
+// counted); they are irrelevant to funds — a rescan rebuilds transaction history. Same bounds-checked,
+// subdb-aware, visited-set-capped walk as parseWalletBtree.
+struct WalletRawRecords {
+    bool parsed   = false;   ///< the btree walked cleanly
+    bool complete = false;   ///< the whole file was read (not cap-truncated)
+    std::vector<std::pair<std::string, std::string>> records;  ///< inline (key,value) bytes, verbatim
+    int keyRecords   = 0;    ///< fund-critical key-type records captured (key/wkey/ckey/z*/sap*/hdseed)
+    int skippedOverflow = 0; ///< records whose value spilled to overflow pages (tx history) — not captured
+    std::size_t bytesRead = 0;
+};
+
+inline WalletRawRecords extractWalletBtreeRecords(const std::string& path,
+                                                  std::size_t maxBytes = 512u * 1024u * 1024u) {
+    WalletRawRecords out;
+    std::ifstream f(path, std::ios::binary);
+    if (!f) return out;
+    std::string buf;
+    {
+        f.seekg(0, std::ios::end);
+        std::streamoff sz = f.tellg();
+        if (sz < 512) return out;
+        const std::size_t want = std::min<std::size_t>(static_cast<std::size_t>(sz), maxBytes);
+        f.seekg(0, std::ios::beg);
+        buf.resize(want);
+        f.read(&buf[0], static_cast<std::streamsize>(want));
+        buf.resize(static_cast<std::size_t>(std::max<std::streamsize>(0, f.gcount())));
+        if (buf.size() < 512) return out;
+        out.bytesRead = buf.size();
+        out.complete  = (buf.size() == static_cast<std::size_t>(sz));
+    }
+    const unsigned char* B = reinterpret_cast<const unsigned char*>(buf.data());
+    const std::size_t N = buf.size();
+
+    auto rd32at = [&](std::size_t o, bool le) -> uint32_t {
+        return le ? (uint32_t)B[o] | ((uint32_t)B[o+1]<<8) | ((uint32_t)B[o+2]<<16) | ((uint32_t)B[o+3]<<24)
+                  : (uint32_t)B[o+3] | ((uint32_t)B[o+2]<<8) | ((uint32_t)B[o+1]<<16) | ((uint32_t)B[o]<<24);
+    };
+    constexpr uint32_t kBtreeMagic = 0x00053162u;
+    bool le;
+    if      (rd32at(12, true)  == kBtreeMagic) le = true;
+    else if (rd32at(12, false) == kBtreeMagic) le = false;
+    else return out;
+    auto r32 = [&](std::size_t o) { return o + 4 <= N ? rd32at(o, le) : 0u; };
+    auto r16 = [&](std::size_t o) -> uint32_t {
+        if (o + 2 > N) return 0;
+        return le ? (uint32_t)B[o] | ((uint32_t)B[o+1]<<8) : (uint32_t)B[o+1] | ((uint32_t)B[o]<<8);
+    };
+    const uint32_t pagesize = r32(20);
+    if (pagesize < 512 || pagesize > 65536 || (pagesize & (pagesize - 1)) != 0) return out;
+    const uint32_t npages = static_cast<uint32_t>(N / pagesize);
+    const uint32_t root   = r32(88);
+    if (npages == 0 || root == 0 || root >= npages) return out;
+    if (B[24] != 0 || (B[26] & 0x01)) return out;   // page checksum/encryption — offsets shift; bail
+
+    constexpr uint8_t P_IBTREE = 3, P_LBTREE = 5, P_BTREEMETA = 9, B_KEYDATA = 1;
+    constexpr std::size_t kMaxPagesVisited = 600000;
+    constexpr int         kMaxKeys         = 4000000;
+    std::vector<bool> visited(npages, false);
+    std::size_t pagesVisited = 0;
+    int keys = 0;
+    bool aborted = false;
+    auto rdpgno = [&](const unsigned char* p) -> uint32_t {
+        return le ? (uint32_t)p[0] | ((uint32_t)p[1]<<8) | ((uint32_t)p[2]<<16) | ((uint32_t)p[3]<<24)
+                  : (uint32_t)p[3] | ((uint32_t)p[2]<<8) | ((uint32_t)p[1]<<16) | ((uint32_t)p[0]<<24);
+    };
+    auto traverse = [&](uint32_t rootPg, auto&& fn) {
+        std::fill(visited.begin(), visited.end(), false);
+        std::vector<uint32_t> stack;
+        if (rootPg < npages && !visited[rootPg]) { visited[rootPg] = true; stack.push_back(rootPg); }
+        while (!stack.empty()) {
+            const uint32_t pg = stack.back(); stack.pop_back();
+            if (pg >= npages) continue;
+            if (++pagesVisited > kMaxPagesVisited) { aborted = true; return; }
+            const std::size_t base = static_cast<std::size_t>(pg) * pagesize;
+            if (base + 26 > N) continue;
+            const uint8_t  type    = B[base + 25];
+            const uint32_t entries = r16(base + 20);
+            if (26 + static_cast<std::size_t>(entries) * 2 > pagesize) continue;
+            if (type == P_IBTREE) {
+                for (uint32_t i = 0; i < entries; ++i) {
+                    const uint32_t off = r16(base + 26 + i * 2);
+                    if (off + 8 > pagesize) continue;
+                    const uint32_t child = r32(base + off + 4);
+                    if (child > 0 && child < npages && !visited[child]) { visited[child] = true; stack.push_back(child); }
+                }
+            } else if (type == P_LBTREE) {
+                for (uint32_t i = 0; i + 1 < entries; i += 2) {
+                    if (++keys > kMaxKeys) { aborted = true; return; }
+                    const uint32_t ko = r16(base + 26 + i * 2);
+                    const uint32_t dO = r16(base + 26 + (i + 1) * 2);
+                    if (ko + 3 > pagesize || dO + 3 > pagesize) continue;
+                    if (B[base + ko + 2] != B_KEYDATA) continue;   // overflow/dup key — never a record name
+                    const uint32_t kl = r16(base + ko);
+                    if (kl < 1 || ko + 3 + kl > pagesize) continue;
+                    const uint8_t  dtype = B[base + dO + 2];
+                    const uint32_t dl    = r16(base + dO);
+                    const unsigned char* dp = (dO + 3 + dl <= pagesize) ? B + base + dO + 3 : nullptr;
+                    fn(B + base + ko + 3, kl, dp, dl, dtype);
+                }
+            }
+        }
+    };
+
+    // Master DB: subdb-name → subdb meta/root pgno (big-endian value; native fallback), same as parseWalletBtree.
+    std::vector<uint32_t> subRoots;
+    traverse(root, [&](const unsigned char*, uint32_t, const unsigned char* dp, uint32_t dl, uint8_t dtype) {
+        if (dtype != B_KEYDATA || dl != 4 || !dp) return;
+        const uint32_t cand[2] = {
+            (uint32_t)dp[3] | ((uint32_t)dp[2]<<8) | ((uint32_t)dp[1]<<16) | ((uint32_t)dp[0]<<24),
+            rdpgno(dp),
+        };
+        for (const uint32_t pgno : cand) {
+            if (pgno == 0 || pgno >= npages) continue;
+            const uint8_t pt = B[static_cast<std::size_t>(pgno) * pagesize + 25];
+            if (pt == P_BTREEMETA) {
+                const uint32_t sr = r32(static_cast<std::size_t>(pgno) * pagesize + 88);
+                if (sr > 0 && sr < npages) { subRoots.push_back(sr); break; }
+            } else if (pt == P_LBTREE || pt == P_IBTREE) { subRoots.push_back(pgno); break; }
+        }
+    });
+    if (aborted) return out;
+    if (subRoots.empty()) subRoots.push_back(root);
+
+    auto isKeyType = [](const char* nm, uint32_t nl) {
+        auto is = [&](const char* s) { return std::strlen(s) == nl && std::memcmp(nm, s, nl) == 0; };
+        return is("key") || is("wkey") || is("ckey") || is("zkey") || is("czkey")
+            || is("sapzkey") || is("csapzkey") || is("hdseed") || is("chdseed");
+    };
+    for (const uint32_t sr : subRoots) {
+        traverse(sr, [&](const unsigned char* kp, uint32_t kl, const unsigned char* dp, uint32_t dl, uint8_t dt) {
+            if (dt != B_KEYDATA || !dp) { out.skippedOverflow++; return; }   // overflow value (tx history) — skip
+            out.records.emplace_back(std::string(reinterpret_cast<const char*>(kp), kl),
+                                     std::string(reinterpret_cast<const char*>(dp), dl));
+            const uint32_t nlen = kp[0];
+            if (nlen >= 2 && nlen <= 20 && 1u + nlen <= kl && isKeyType(reinterpret_cast<const char*>(kp + 1), nlen))
+                out.keyRecords++;
+        });
+        if (aborted) return out;
+    }
+    out.parsed = true;
+    return out;
+}
+
 }  // namespace util
 }  // namespace dragonx

src/wallet/lite_wallet_controller.cpp

@@ -80,8 +80,10 @@ bool persistAfterBroadcast(LiteClientBridge& bridge)
     for (int attempt = 0; attempt < 2; ++attempt) {
         if (bridge.execute("save", "").ok) return true;
     }
-    // Persistent failure: the spent note will be re-derived from the chain on the next sync,
-    // so this is a robustness gap, not fund loss. (Retry handles the common transient case.)
+    // Persistent failure: the spent note will be re-derived from the chain on the next sync, so this
+    // is a robustness gap, not fund loss. Log it (W5-1) — both callers discard this return, so the
+    // failure was previously completely silent.
+    liteLog("save failed after send/shield — the wallet will re-derive it on the next sync");
     return false;
 }
 
@@ -137,6 +139,12 @@ void applyLiteRefreshModelToWalletState(const LiteWalletAppRefreshModel& model,
         state.transparentBalance = static_cast<double>(model.balance.transparentZatoshis) / kZatoshisPerCoin;
         state.totalBalance = static_cast<double>(model.balance.totalZatoshis) / kZatoshisPerCoin;
         state.unconfirmedBalance = static_cast<double>(model.balance.unconfirmedZatoshis) / kZatoshisPerCoin;
+        // Lite already tracks confirmed/unconfirmed itself and its per-address balances are confirmed
+        // (spendable outputs only). Mirror the aggregate spendable fields so full-node-shaped spend
+        // validation isn't zeroed on lite (the actual lite spend gate is per-address, set below).
+        state.spendablePrivateBalance = state.privateBalance;
+        state.spendableTransparentBalance = state.transparentBalance;
+        state.spendableTotalBalance = state.totalBalance;
     }
 
     if (model.hasAddresses) {
@@ -176,6 +184,7 @@ void applyLiteRefreshModelToWalletState(const LiteWalletAppRefreshModel& model,
             } else {
                 info.balance = 0.0;  // notes succeeded and address has no spendable outputs
             }
+            info.spendableBalance = info.balance;  // lite per-address balance is already confirmed/spendable
             info.type = (addr.kind == LiteWalletAppAddressKind::Shielded) ? "shielded" : "transparent";
             info.has_spending_key = addr.spendabilityKnown ? addr.spendable : true;
             if (addr.kind == LiteWalletAppAddressKind::Shielded) {
@@ -600,7 +609,8 @@ void LiteWalletController::startSync()
             // The backend does NOT auto-save after a sync, so persist the freshly-scanned wallet;
             // otherwise the next launch re-scans from the checkpoint (~30 min). Set `done` only
             // after the save so a syncComplete() observer sees a fully-persisted wallet.
-            bridge->execute("save", "");
+            if (!bridge->execute("save", "").ok)   // W5-2: don't leave a failed post-sync save silent
+                liteLog("save failed after sync — the next launch will re-scan from the checkpoint");
         }
         done->store(true);
     });
@@ -631,7 +641,8 @@ bool LiteWalletController::startRescan()
             // `rescan` clears the wallet's synced block cache and re-downloads/re-scans from the
             // birthday height — a blocking, uninterruptible full scan, same as `sync`.
             bridge->execute("rescan", "");
-            bridge->execute("save", "");  // backend doesn't auto-save after a rescan
+            if (!bridge->execute("save", "").ok)   // W5-2: don't leave a failed post-rescan save silent
+                liteLog("save failed after rescan — the next launch will re-scan from the checkpoint");
         }
         done->store(true);
     });
@@ -883,6 +894,11 @@ LiteImportResult LiteWalletController::importKey(std::string spendingOrViewingKe
     }
     // Transparent WIFs begin with U/5/K/L (TImportCommand); shielded keys begin with
     // "secret-..." / viewing keys "zxview...", so this prefix check usually won't collide.
+    // NB: the lite/SDXL backend's viewing key is an *extended full* viewing key ("zxviews…",
+    // hrp_sapling_viewing_key), which is genuinely correct here — do NOT "harmonize" this with the
+    // full node, whose z_importviewingkey takes an *incoming* viewing key ("zivks…") instead. The
+    // two variants accept different viewing-key forms; a VK is not portable between them. Regardless,
+    // the two-command fallback below means a mis-guessed prefix never rejects an otherwise-valid key.
     const char first = spendingOrViewingKey[0];
     const bool transparentFirst = (first == 'U' || first == '5' || first == 'K' || first == 'L');
 
@@ -1172,25 +1188,47 @@ void LiteWalletController::workerLoop()
 LiteWalletLifecycleResult LiteWalletController::createWallet(LiteWalletCreateRequest request)
 {
     auto result = lifecycle_.createWallet(request);
-    secureWipeLiteSecret(request.passphrase);
     onLifecycleResult(result);
+    // If the user supplied a passphrase, encrypt the brand-new wallet with it now that it's open
+    // (the backend encrypts + locks + saves). Previously this passphrase was collected but never
+    // used (W5-3) — a passphrase field that silently did nothing. encryptWallet() takes its own
+    // copy and wipes it.
+    if (walletOpen_.load() && !request.passphrase.empty()) {
+        const auto enc = encryptWallet(request.passphrase);
+        if (!enc.ok) liteLog("wallet created but encryption failed: " + enc.error);
+    }
+    secureWipeLiteSecret(request.passphrase);
     return result;
 }
 
 LiteWalletLifecycleResult LiteWalletController::openWallet(LiteWalletOpenRequest request)
 {
     auto result = lifecycle_.openWallet(request);
-    secureWipeLiteSecret(request.passphrase);
     onLifecycleResult(result);
+    // An existing wallet may be encrypted + locked — use the supplied passphrase to unlock it so it
+    // opens ready to use. Only meaningful when the wallet is actually locked (W5-3).
+    if (walletOpen_.load() && !request.passphrase.empty()) {
+        const auto encStatus = encryptionStatus();
+        if (encStatus.ok && encStatus.encrypted && encStatus.locked) {
+            if (!unlockWallet(request.passphrase))
+                liteLog("wallet opened but unlock failed (wrong passphrase?)");
+        }
+    }
+    secureWipeLiteSecret(request.passphrase);
     return result;
 }
 
 LiteWalletLifecycleResult LiteWalletController::restoreWallet(LiteWalletRestoreRequest request)
 {
     auto result = lifecycle_.restoreWallet(request);
+    onLifecycleResult(result);
+    // If the user supplied a passphrase, encrypt the restored wallet with it now that it's open (W5-3).
+    if (walletOpen_.load() && !request.passphrase.empty()) {
+        const auto enc = encryptWallet(request.passphrase);
+        if (!enc.ok) liteLog("wallet restored but encryption failed: " + enc.error);
+    }
     secureWipeLiteSecret(request.seedPhrase);
     secureWipeLiteSecret(request.passphrase);
-    onLifecycleResult(result);
     return result;
 }
 

tools/wallet_rebuild/main.cpp

@@ -0,0 +1,90 @@
+// dragonx-wallet-rebuild — offline recovery helper for a BDB-inconsistent wallet.dat.
+//
+// Some wallet.dat files are valid Berkeley DB btrees whose EXTENT metadata is stale (the "main"
+// subdatabase metapage records a low last_pgno while its live data spans thousands of pages further
+// in the file). A tolerant page-walk reads every record, but the daemon's Berkeley DB `verify`
+// rejects the file and auto-salvages it — which finds nothing and, on each restart, shrinks the
+// wallet to empty (the "salvage cascade" that looks like fund loss). The keys are intact; only the
+// DB envelope is broken.
+//
+// This tool fixes it the way it must be fixed — offline, on the file, before any daemon touches it:
+//   1) read all (key,value) records with the tolerant walker (util/wallet_file_probe.h), then
+//   2) write them VERBATIM into a fresh, consistent Berkeley DB "main" btree via real libdb put()s,
+//      so libdb computes correct extent/metapage bookkeeping itself (sidestepping the whole defect).
+// Records are copied byte-for-byte: encrypted key material (ckey/csapzkey/mkey) passes through as
+// opaque ciphertext — no passphrase, no decryption, no key material ever interpreted. Only large `tx`
+// history values (which live in BDB overflow pages) are skipped; a wallet rescan rebuilds those.
+//
+// Usage:  dragonx-wallet-rebuild <source-wallet.dat> <output-wallet.dat>
+// Output: a single JSON line on stdout; exit 0 on success, non-zero on failure. Never touches the
+// source (opens it read-only); refuses to overwrite an existing output (DB_EXCL).
+
+#include "util/wallet_file_probe.h"
+
+#include <db.h>
+
+#include <cstdio>
+#include <cstring>
+#include <string>
+
+int main(int argc, char** argv)
+{
+    if (argc < 3) {
+        std::fprintf(stderr, "usage: dragonx-wallet-rebuild <source-wallet.dat> <output-wallet.dat>\n");
+        return 2;
+    }
+    const char* src = argv[1];
+    const char* dst = argv[2];
+
+    // --- 1) tolerant read (no libdb; reads records the daemon's BDB can't) ---
+    const auto rec = dragonx::util::extractWalletBtreeRecords(src);
+    if (!rec.parsed) {
+        std::printf("{\"ok\":false,\"error\":\"source is not a readable Berkeley DB btree wallet\"}\n");
+        return 3;
+    }
+    if (rec.keyRecords == 0) {
+        // Refuse to produce a keyless wallet — nothing to recover, and installing it would look like loss.
+        std::printf("{\"ok\":false,\"error\":\"no key records found in source\",\"read\":%zu}\n",
+                    rec.records.size());
+        return 4;
+    }
+
+    // --- 2) write a fresh, consistent BDB "main" btree (what CWalletDB expects) ---
+    DB* db = nullptr;
+    int r = db_create(&db, nullptr, 0);
+    if (r != 0) {
+        std::printf("{\"ok\":false,\"error\":\"db_create: %s\"}\n", db_strerror(r));
+        return 5;
+    }
+    // DB_EXCL: never clobber an existing file — the caller passes a fresh path.
+    r = db->open(db, nullptr, dst, "main", DB_BTREE, DB_CREATE | DB_EXCL, 0600);
+    if (r != 0) {
+        std::printf("{\"ok\":false,\"error\":\"open output: %s\"}\n", db_strerror(r));
+        db->close(db, 0);
+        return 6;
+    }
+    long wrote = 0;
+    for (const auto& kv : rec.records) {
+        DBT k, v;
+        std::memset(&k, 0, sizeof k);
+        std::memset(&v, 0, sizeof v);
+        k.data = const_cast<char*>(kv.first.data());   k.size = static_cast<u_int32_t>(kv.first.size());
+        v.data = const_cast<char*>(kv.second.data());  v.size = static_cast<u_int32_t>(kv.second.size());
+        r = db->put(db, nullptr, &k, &v, 0);
+        if (r != 0) {
+            std::printf("{\"ok\":false,\"error\":\"put failed: %s\",\"wrote\":%ld}\n", db_strerror(r), wrote);
+            db->close(db, 0);
+            return 7;
+        }
+        ++wrote;
+    }
+    r = db->close(db, 0);   // close flushes correct metadata
+    if (r != 0) {
+        std::printf("{\"ok\":false,\"error\":\"close: %s\",\"wrote\":%ld}\n", db_strerror(r), wrote);
+        return 8;
+    }
+
+    std::printf("{\"ok\":true,\"read\":%zu,\"keyRecords\":%d,\"skippedOverflow\":%d,\"wrote\":%ld,\"complete\":%s}\n",
+                rec.records.size(), rec.keyRecords, rec.skippedOverflow, wrote, rec.complete ? "true" : "false");
+    return 0;
+}