feat(wallet): per-wallet data isolation foundation (P1)

First phase of multi-wallet support: keep each wallet's data separate so loading
a different wallet no longer shows the previous one's data, and lay the metadata
groundwork for the wallet-files list.

- Address book scoped per wallet: AddressBookEntry gains a "scope" ("global" or a
  wallet-identity hash); the Contacts tab shows global + current-wallet contacts
  (App::activeWalletIdentityHash) with a "show in every wallet" toggle + globe
  badge. Legacy entries migrate to "global". Scope-aware de-dup allows the same
  address across different wallets.
- Wallet metadata index (data/wallet_index -> wallets.json): file-keyed cache of
  balance / address count / identity / size / last-opened / synced-here, since
  those can't be read off a wallet.dat without loading it. Populated on connect +
  address refresh (change-detecting upsert). Plus an active_wallet_file setting
  for the -wallet=<name> switch coming in P2.

Unit-tested (testAddressBookScope, testWalletIndex): migration, visibility filter,
scope-aware de-dup, upsert change-detection, save/reload round-trip.

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

src/data/wallet_index.cpp

@@ -0,0 +1,159 @@
+// DragonX Wallet - ImGui Edition
+// Copyright 2024-2026 The Hush Developers
+// Released under the GPLv3
+
+#include "wallet_index.h"
+
+#include <nlohmann/json.hpp>
+#include <algorithm>
+#include <filesystem>
+#include <fstream>
+
+#include "../util/logger.h"
+#include "../util/platform.h"
+
+namespace fs = std::filesystem;
+using json = nlohmann::json;
+
+namespace dragonx {
+namespace data {
+
+namespace {
+// A field-wise "did anything change" check so we only rewrite wallets.json when needed.
+bool sameEntry(const WalletIndexEntry& a, const WalletIndexEntry& b)
+{
+    return a.fileName == b.fileName
+        && a.displayName == b.displayName
+        && a.walletIdentityHash == b.walletIdentityHash
+        && a.cachedBalance == b.cachedBalance
+        && a.cachedAddressCount == b.cachedAddressCount
+        && a.lastOpenedEpoch == b.lastOpenedEpoch
+        && a.sizeBytesAtLastOpen == b.sizeBytesAtLastOpen
+        && a.syncedHere == b.syncedHere;
+}
+}  // namespace
+
+std::string WalletIndex::getDefaultPath()
+{
+    // Co-located with settings.json / addressbook.json in the per-variant config dir.
+    const std::string dir = util::Platform::getConfigDir();
+    fs::create_directories(dir);
+    return (fs::path(dir) / "wallets.json").string();
+}
+
+bool WalletIndex::load()
+{
+    file_path_ = getDefaultPath();
+    entries_.clear();
+    extra_folders_.clear();
+
+    std::ifstream file(file_path_);
+    if (!file.is_open()) return true;  // no file yet is fine
+
+    try {
+        json j;
+        file >> j;
+
+        if (j.contains("entries") && j["entries"].is_array()) {
+            for (const auto& e : j["entries"]) {
+                WalletIndexEntry w;
+                w.fileName = e.value("file", "");
+                if (w.fileName.empty()) continue;
+                w.displayName = e.value("name", w.fileName);
+                w.walletIdentityHash = e.value("identity", "");
+                w.cachedBalance = e.value("balance", -1.0);
+                w.cachedAddressCount = e.value("addresses", (long long)-1);
+                w.lastOpenedEpoch = e.value("lastOpened", (long long)0);
+                w.sizeBytesAtLastOpen = e.value("size", (long long)0);
+                w.syncedHere = e.value("syncedHere", false);
+                entries_.push_back(std::move(w));
+            }
+        }
+        if (j.contains("extraFolders") && j["extraFolders"].is_array()) {
+            for (const auto& d : j["extraFolders"]) {
+                if (d.is_string() && !d.get<std::string>().empty())
+                    extra_folders_.push_back(d.get<std::string>());
+            }
+        }
+        DEBUG_LOGF("Wallet index loaded: %zu wallets, %zu extra folders\n",
+                   entries_.size(), extra_folders_.size());
+        return true;
+    } catch (const std::exception& e) {
+        DEBUG_LOGF("Error loading wallet index: %s\n", e.what());
+        return false;
+    }
+}
+
+bool WalletIndex::save()
+{
+    if (file_path_.empty()) file_path_ = getDefaultPath();
+
+    try {
+        json j;
+        j["entries"] = json::array();
+        for (const auto& w : entries_) {
+            json e;
+            e["file"] = w.fileName;
+            e["name"] = w.displayName;
+            e["identity"] = w.walletIdentityHash;
+            e["balance"] = w.cachedBalance;
+            e["addresses"] = w.cachedAddressCount;
+            e["lastOpened"] = w.lastOpenedEpoch;
+            e["size"] = w.sizeBytesAtLastOpen;
+            e["syncedHere"] = w.syncedHere;
+            j["entries"].push_back(std::move(e));
+        }
+        j["extraFolders"] = extra_folders_;
+
+        // No secrets here (file names + coarse metadata) but keep it owner-only for consistency.
+        if (!util::Platform::writeFileAtomically(file_path_, j.dump(2), /*restrictPermissions=*/true)) {
+            DEBUG_LOGF("Could not write wallet index: %s\n", file_path_.c_str());
+            return false;
+        }
+        return true;
+    } catch (const std::exception& e) {
+        DEBUG_LOGF("Error saving wallet index: %s\n", e.what());
+        return false;
+    }
+}
+
+bool WalletIndex::upsert(const WalletIndexEntry& e)
+{
+    for (auto& w : entries_) {
+        if (w.fileName == e.fileName) {
+            if (sameEntry(w, e)) return false;  // nothing changed -> caller can skip save()
+            w = e;
+            return true;
+        }
+    }
+    entries_.push_back(e);
+    return true;
+}
+
+const WalletIndexEntry* WalletIndex::find(const std::string& fileName) const
+{
+    for (const auto& w : entries_) {
+        if (w.fileName == fileName) return &w;
+    }
+    return nullptr;
+}
+
+bool WalletIndex::addExtraFolder(const std::string& dir)
+{
+    if (dir.empty()) return false;
+    if (std::find(extra_folders_.begin(), extra_folders_.end(), dir) != extra_folders_.end())
+        return false;
+    extra_folders_.push_back(dir);
+    return true;
+}
+
+bool WalletIndex::removeExtraFolder(const std::string& dir)
+{
+    auto it = std::find(extra_folders_.begin(), extra_folders_.end(), dir);
+    if (it == extra_folders_.end()) return false;
+    extra_folders_.erase(it);
+    return true;
+}
+
+} // namespace data
+} // namespace dragonx