From 45b652f514761a704dd7b5b71d4cccb2d49b1d2e Mon Sep 17 00:00:00 2001 From: DanS Date: Sat, 25 Jul 2026 03:48:05 -0500 Subject: [PATCH 01/89] feat(mining): live pool fee, saved/custom pool rows, and payout-address fix Several related mining-tab pool improvements: - Report the default pool fee correctly: pool.dragonx.is is 1%, not 0%. The registry constant was hardcoded to 0. It now also fetches the live poolFee from the pool's /api/stats alongside hashrate (no extra request), so the displayed fee self-corrects and falls back to the compile-time value only when the fetch hasn't landed. - Show fractional fees: new FormatFeePercent trims trailing zeros so whole fees read "1%" and fractional ones keep their decimals ("1.5%"). - Surface saved + custom pools in the pool list card: the list is now the union of the official pools, the user's saved favorites, and the currently-mined pool (effectivePools), each a selectable, endpoint- deduped row. Previously the card only showed the hardcoded knownPools(). - Fix the xmrig "user" field: the "Payout Address" field now drives the pool login rewards are credited to (resolveMiningUserAddress), instead of being written only to "pass" while "user" was auto-derived from the wallet's own first z-address -- which silently ignored a configured payout address and could route rewards to the wrong address. Unit tests cover parsePoolFee, FormatFeePercent, effectivePools, and resolveMiningUserAddress; full app + ObsidianDragonTests build clean. Co-Authored-By: Claude Opus 4.8 --- src/app_network.cpp | 31 ++++--- src/ui/windows/mining_pool_panel.cpp | 11 +++ src/ui/windows/mining_pool_panel.h | 8 ++ src/ui/windows/mining_stats.cpp | 22 ++++- src/ui/windows/mining_tab_helpers.cpp | 15 ++++ src/ui/windows/mining_tab_helpers.h | 1 + src/util/pool_registry.h | 25 +++++- src/util/pool_registry_core.cpp | 115 +++++++++++++++++++++++++- src/util/pool_stats_service.cpp | 6 ++ tests/test_phase4.cpp | 104 +++++++++++++++++++++++ 10 files changed, 311 insertions(+), 27 deletions(-) diff --git a/src/app_network.cpp b/src/app_network.cpp index d331f35..72824e6 100644 --- a/src/app_network.cpp +++ b/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_memzero for wiping the fetched mnemonic #include #include "config/settings.h" @@ -2288,27 +2289,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"); diff --git a/src/ui/windows/mining_pool_panel.cpp b/src/ui/windows/mining_pool_panel.cpp index 2082e9e..9d3b9c8 100644 --- a/src/ui/windows/mining_pool_panel.cpp +++ b/src/ui/windows/mining_pool_panel.cpp @@ -20,6 +20,17 @@ std::string defaultPoolWorkerAddress(const std::vector& 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& savedValues, const std::string& value) { diff --git a/src/ui/windows/mining_pool_panel.h b/src/ui/windows/mining_pool_panel.h index f4e7b73..705606f 100644 --- a/src/ui/windows/mining_pool_panel.h +++ b/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& 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& savedValues, const std::string& value); const char* defaultPoolUrl(); diff --git a/src/ui/windows/mining_stats.cpp b/src/ui/windows/mining_stats.cpp index ae734e8..31fba5a 100644 --- a/src/ui/windows/mining_stats.cpp +++ b/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); diff --git a/src/ui/windows/mining_tab_helpers.cpp b/src/ui/windows/mining_tab_helpers.cpp index 40efe61..d1d8d7b 100644 --- a/src/ui/windows/mining_tab_helpers.cpp +++ b/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; diff --git a/src/ui/windows/mining_tab_helpers.h b/src/ui/windows/mining_tab_helpers.h index 4a7d1cf..60add69 100644 --- a/src/ui/windows/mining_tab_helpers.h +++ b/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); diff --git a/src/util/pool_registry.h b/src/util/pool_registry.h index e86aa63..f5a63f1 100644 --- a/src/util/pool_registry.h +++ b/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& 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& 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 effectivePools(const std::string& currentPoolUrl, + const std::vector& 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..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 diff --git a/src/util/pool_registry_core.cpp b/src/util/pool_registry_core.cpp index 619cd76..2a8271d 100644 --- a/src/util/pool_registry_core.cpp +++ b/src/util/pool_registry_core.cpp @@ -28,7 +28,7 @@ const std::vector& 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& 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 effectivePools(const std::string& currentPoolUrl, + const std::vector& savedPoolUrls) +{ + std::vector 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": , ... }, ... } } + 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(); + 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(); + } + } + } + } catch (...) { + // fall through — ok stays false + } + return 0.0; +} + std::string chooseWeightedPool(const std::vector& pools, const std::string& currentId, std::mt19937& rng) diff --git a/src/util/pool_stats_service.cpp b/src/util/pool_stats_service.cpp index 117751a..7bc479d 100644 --- a/src/util/pool_stats_service.cpp +++ b/src/util/pool_stats_service.cpp @@ -94,6 +94,12 @@ void PoolStatsService::run(std::vector 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; } diff --git a/tests/test_phase4.cpp b/tests/test_phase4.cpp index 6925049..14cf7ed 100644 --- a/tests/test_phase4.cpp +++ b/tests/test_phase4.cpp @@ -3231,6 +3231,19 @@ void testRendererHelpers() EXPECT_EQ(dragonx::ui::defaultPoolWorkerAddress(poolAddresses), std::string("zs-default-worker")); EXPECT_TRUE(dragonx::ui::miningValueAlreadySaved({"pool-a", "pool-b"}, "pool-b")); EXPECT_FALSE(dragonx::ui::miningValueAlreadySaved({"pool-a"}, "")); + + // resolveMiningUserAddress: the configured payout address is the xmrig "user" + // (where rewards go) and must win over the wallet's own addresses. + EXPECT_EQ(dragonx::ui::resolveMiningUserAddress("zs-payout", "zs-own", "R-own"), + std::string("zs-payout")); // explicit payout wins + EXPECT_EQ(dragonx::ui::resolveMiningUserAddress("", "zs-own", "R-own"), + std::string("zs-own")); // unset -> own shielded + EXPECT_EQ(dragonx::ui::resolveMiningUserAddress("x", "zs-own", "R-own"), + std::string("zs-own")); // "x" placeholder counts as unset + EXPECT_EQ(dragonx::ui::resolveMiningUserAddress("x", "", "R-own"), + std::string("R-own")); // no shielded -> transparent + EXPECT_EQ(dragonx::ui::resolveMiningUserAddress("", "", ""), + std::string("")); // nothing anywhere -> caller errors EXPECT_EQ(std::string(dragonx::ui::defaultPoolUrl()), std::string("pool.dragonx.is:3433")); dragonx::TransactionInfo tx; @@ -5828,6 +5841,94 @@ void testPoolHashrateParsing() EXPECT_FALSE(ok); } +// Schema-aware pool fee parsing (fed to the mining-tab "N% fee" display). +void testPoolFeeParsing() +{ + using namespace dragonx::util; + bool ok = false; + + // pool.dragonx.is custom schema: pools.dragonx.poolFee (a whole-percent number). + const std::string isJson = + R"({"pools":{"dragonx":{"hashrate":27670.14,"poolFee":1,"soloFee":3}}})"; + double fee = parsePoolFee(PoolStatsSchema::DragonXIs, isJson, "", ok); + EXPECT_TRUE(ok); + EXPECT_NEAR(fee, 1.0, 0.001); + + // Fractional fees survive (display rounds, but the parse must not). + const std::string isFrac = R"({"pools":{"dragonx":{"poolFee":1.5}}})"; + fee = parsePoolFee(PoolStatsSchema::DragonXIs, isFrac, "", ok); + EXPECT_TRUE(ok); + EXPECT_NEAR(fee, 1.5, 0.001); + + // Miningcore schema: the requested pool id's poolFeePercent. + const std::string ccJson = + R"({"pools":[)" + R"({"id":"dragonx-solo","poolFeePercent":2.0,"poolStats":{"poolHashrate":88780.0}},)" + R"({"id":"dragonx-pplns","poolFeePercent":0.9,"poolStats":{"poolHashrate":1585.9}}]})"; + fee = parsePoolFee(PoolStatsSchema::Miningcore, ccJson, "dragonx-pplns", ok); + EXPECT_TRUE(ok); + EXPECT_NEAR(fee, 0.9, 0.001); + + // Missing field / malformed / wrong-schema input all fail closed (caller keeps + // the compile-time fallback rather than showing a bogus 0%). + parsePoolFee(PoolStatsSchema::DragonXIs, R"({"pools":{"dragonx":{"hashrate":1.0}}})", "", ok); + EXPECT_FALSE(ok); // no poolFee key + parsePoolFee(PoolStatsSchema::DragonXIs, "not json", "", ok); + EXPECT_FALSE(ok); + parsePoolFee(PoolStatsSchema::Miningcore, ccJson, "does-not-exist", ok); + EXPECT_FALSE(ok); + parsePoolFee(PoolStatsSchema::DragonXIs, R"({"pools":{"dragonx":{"poolFee":"1"}}})", "", ok); + EXPECT_FALSE(ok); // string, not number +} + +// The effective pool list = official pools ∪ saved favorites ∪ current custom pool, +// endpoint-deduped, with synthetic user rows flagged official=false. +void testEffectivePools() +{ + using namespace dragonx::util; + const int base = (int)knownPools().size(); + + // Current pool is the official one, nothing saved -> just the official pools. + auto a = effectivePools("pool.dragonx.is:3433", {}); + EXPECT_EQ((int)a.size(), base); + + // A custom current pool (neither official nor saved) appears as an extra row. + auto b = effectivePools("my.pool.example:3333", {}); + EXPECT_EQ((int)b.size(), base + 1); + const KnownPool* custom = findPoolByUrl(b, "my.pool.example:3333"); + EXPECT_TRUE(custom != nullptr); + EXPECT_FALSE(custom->official); + EXPECT_TRUE(custom->feePercent < 0.0); // unknown fee + + // Saved pools are appended; an official one among them and a duplicate collapse. + auto c = effectivePools("pool.dragonx.is:3433", + {"pool.dragonx.is:3433", "alt.pool:1", "alt.pool:1"}); + EXPECT_EQ((int)c.size(), base + 1); + EXPECT_TRUE(findPoolByUrl(c, "alt.pool:1") != nullptr); + + // Current pool equal to a saved one is not listed twice. + auto d = effectivePools("alt.pool:1", {"alt.pool:1"}); + EXPECT_EQ((int)d.size(), base + 1); + + // Blank/whitespace URLs are ignored (no phantom rows). + auto e = effectivePools(" ", {"", " "}); + EXPECT_EQ((int)e.size(), base); +} + +// Fee formatting: whole numbers stay clean, fractional fees keep their decimals. +void testFormatFeePercent() +{ + using dragonx::ui::FormatFeePercent; + EXPECT_TRUE(FormatFeePercent(1.0) == "1"); + EXPECT_TRUE(FormatFeePercent(0.0) == "0"); + EXPECT_TRUE(FormatFeePercent(3.0) == "3"); + EXPECT_TRUE(FormatFeePercent(1.5) == "1.5"); + EXPECT_TRUE(FormatFeePercent(0.9) == "0.9"); + EXPECT_TRUE(FormatFeePercent(1.25) == "1.25"); + EXPECT_TRUE(FormatFeePercent(2.50) == "2.5"); // trailing zero trimmed + EXPECT_TRUE(FormatFeePercent(100.0) == "100"); +} + // Weighted-random pool selection: smaller pools favored, incumbent sticky, fails safe. void testPoolWeightedSelection() { @@ -6590,6 +6691,9 @@ int main() testLiteOfficialServerDetection(); testPoolRegistryLookup(); testPoolHashrateParsing(); + testPoolFeeParsing(); + testEffectivePools(); + testFormatFeePercent(); testPoolWeightedSelection(); testAtomicFileWrite(); testHushChatCrypto(); From b3444e0a896ff73897cad70157d227e8ff3f9e63 Mon Sep 17 00:00:00 2001 From: DanS Date: Sun, 2 Aug 2026 10:32:30 -0500 Subject: [PATCH 02/89] fix(daemon): harden startup process lifecycle (crash race, exec failure, datadir lock) Three verified daemon-startup edge-case fixes in the embedded-daemon process lifecycle (all in embedded_daemon.{cpp,h}): - F1: EmbeddedDaemon::isRunning() (POSIX) now reads the atomic state_ instead of calling waitpid(WNOHANG) from the UI thread, which raced monitorProcess()'s own reap. waitpid is one-shot: whichever thread won consumed the exit status; if isRunning() won, the monitor never saw the crash, so crash_count_/State::Error and the 3-strike restart cap were silently lost. monitorProcess() is now the sole reaper (predicate Running || Stopping keeps stop()'s wait loops correct). Mirrors the existing XmrigManager::isRunning() fix. - F2: startProcess() (POSIX) adds a close-on-exec self-pipe exec handshake. On a non-executable / wrong-arch / corrupt binary, execv fails in the child and the parent now learns synchronously (reads errno vs EOF), reaps the zombie, sets a precise last_error_ ("not executable or wrong architecture"), and returns false -- instead of reporting State::Running for a daemon that never started. Uses pipe()+FD_CLOEXEC (not pipe2) so the branch stays shared with macOS. Parent-side setpgid is now best-effort + logged. - F4: start() gates on a lingering datadir lock after the port check. A graceful shutdown releases the RPC port ~90s before the datadir .lock, so a rapid stop->start spawned a daemon that died on the lock and, three times in ~12s, tripped the 3-strike crash cap before the lock cleared. start() now polls isDaemonProcessRunning() with a bounded ~300ms wait and bails with a distinct non-crash Error (no crash_count_ bump) that the connect loop retries once the lock clears. Isolated migrate-to-seed starts (skip_port_check_ / -datadir override) are exempt. Adds the testDatadirLockGate unit test (pure evaluateDatadirLockGate matrix) to test_phase4.cpp. Plan and progress tracked in docs/daemon-startup-hardening.md. Co-Authored-By: Claude Opus 4.8 --- docs/daemon-startup-hardening.md | 495 +++++++++++++++++++++++++++++++ src/daemon/embedded_daemon.cpp | 129 ++++++-- src/daemon/embedded_daemon.h | 26 ++ tests/test_phase4.cpp | 24 ++ 4 files changed, 655 insertions(+), 19 deletions(-) create mode 100644 docs/daemon-startup-hardening.md diff --git a/docs/daemon-startup-hardening.md b/docs/daemon-startup-hardening.md new file mode 100644 index 0000000..5aa315d --- /dev/null +++ b/docs/daemon-startup-hardening.md @@ -0,0 +1,495 @@ +# 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 + +--- + +## 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_` (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:** ☐ + +### 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:** ☐ + +### 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:** ☐ + +### 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:** ☐ + +### 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:** ☐ + +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** — ☑ 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. +- **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. diff --git a/src/daemon/embedded_daemon.cpp b/src/daemon/embedded_daemon.cpp index 2e67fd6..2add767 100644 --- a/src/daemon/embedded_daemon.cpp +++ b/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..."); @@ -962,18 +990,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 +1088,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(&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(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 +1222,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() diff --git a/src/daemon/embedded_daemon.h b/src/daemon/embedded_daemon.h index 4021cab..bce7513 100644 --- a/src/daemon/embedded_daemon.h +++ b/src/daemon/embedded_daemon.h @@ -235,6 +235,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); diff --git a/tests/test_phase4.cpp b/tests/test_phase4.cpp index 14cf7ed..d868e22 100644 --- a/tests/test_phase4.cpp +++ b/tests/test_phase4.cpp @@ -3,6 +3,7 @@ #include "chat/chat_service.h" #include "chat/chat_database.h" #include "daemon/daemon_controller.h" +#include "daemon/embedded_daemon.h" #include "data/transaction_history_cache.h" #include "data/address_book.h" #include "data/wallet_index.h" @@ -2477,6 +2478,28 @@ void testDaemonShutdownPolicy() EXPECT_TRUE(bootstrap.disconnectRpc); } +void testDatadirLockGate() +{ + using dragonx::daemon::EmbeddedDaemon; + + // Normal start, no lingering daemon after the bounded wait → proceed. + auto clear = EmbeddedDaemon::evaluateDatadirLockGate(false, false, false); + EXPECT_TRUE(clear.proceed); + + // A previous dragonxd still alive after the wait → bail with a distinct, non-crash msg. + auto locked = EmbeddedDaemon::evaluateDatadirLockGate(false, false, true); + EXPECT_TRUE(!locked.proceed); + EXPECT_TRUE(std::string(locked.errorMessage).find("data directory lock") != std::string::npos); + + // Isolated instance via skip_port_check_ is exempt even if a sibling dragonxd is running. + auto skipPort = EmbeddedDaemon::evaluateDatadirLockGate(true, false, true); + EXPECT_TRUE(skipPort.proceed); + + // Isolated instance via -datadir override is exempt even if a sibling is running. + auto isolated = EmbeddedDaemon::evaluateDatadirLockGate(false, true, true); + EXPECT_TRUE(isolated.proceed); +} + void testDaemonLifecycleExecution() { using dragonx::daemon::DaemonController; @@ -6619,6 +6642,7 @@ int main() testWalletSecurityWorkflow(); testWalletSecurityWorkflowExecutor(); testDaemonShutdownPolicy(); + testDatadirLockGate(); testDaemonLifecycleExecution(); testDaemonLifecycleAdapters(); testConsoleTextLayout(); From 2675b8ab931c1b549c3ce79eaf377a5f1900daea Mon Sep 17 00:00:00 2001 From: DanS Date: Sun, 2 Aug 2026 11:07:32 -0500 Subject: [PATCH 03/89] fix(startup): surface filesystem failures and verify Sapling param integrity Three verified daemon-startup edge-case fixes centered on the config/params filesystem path: - F7: new non-throwing Platform::ensureDirectory(dir, outError) with one consistent "Cannot create : . Check permissions / free space." message. Replaces the unchecked/throwing create_directories sites at main.cpp (pre-init: log + Windows MessageBox + return 1), connection.cpp's autoDetectConfig (was the *throwing* overload -- could raise an uncaught filesystem_error through its callers; now sets the new ConnectionConfig::dir_error), and both app.cpp daemon-dir sites (surface via daemon_status_ + return false). The primary connect path (app_network.cpp) checks dir_error and shows it instead of mislabelling it "waiting for config". embedded_resources.cpp already checked its error_code, so it is left as-is. - F6: verifySaplingParams() now hash-verifies each param against its pinned canonical SHA-256 (source of truth: scripts/build-lite-backend-artifact.sh) instead of only checking existence, so a truncated / corrupt-but-present param is rejected up front rather than failing later on a shielded operation. A /.sapling_verified marker keyed on size:mtime avoids re-hashing ~48MB on every startup. Logic extracted to the injectable, unit-testable verifySaplingParamsIn(dir, digests); reuses util::sha256Hex (no new hash impl). - F5: startEmbeddedDaemon() now checks extractEmbeddedResources()'s return and the previously-dropped copy_file error_code in the daemon-binary fallback loop, aborting with a clear status (sb_daemon_extract_failed / sb_daemon_files_failed) instead of failing opaquely at spawn. An absent source file stays non-fatal. Adds testPlatformEnsureDirectory and testVerifySaplingParams to test_phase4.cpp. i18n keys added to i18n.cpp (English source of truth); the res/lang/*.json back-fill via add_missing_translations.py is deferred to a single run at the end of the batch. Progress tracked in docs/daemon-startup-hardening.md. Co-Authored-By: Claude Opus 4.8 --- docs/daemon-startup-hardening.md | 24 +++-- src/app.cpp | 35 +++++++- src/app_network.cpp | 10 +++ src/main.cpp | 12 ++- src/rpc/connection.cpp | 146 ++++++++++++++++++++++++++----- src/rpc/connection.h | 13 +++ src/util/i18n.cpp | 2 + src/util/platform.cpp | 21 +++++ src/util/platform.h | 11 +++ tests/test_phase4.cpp | 101 +++++++++++++++++++++ 10 files changed, 340 insertions(+), 35 deletions(-) diff --git a/docs/daemon-startup-hardening.md b/docs/daemon-startup-hardening.md index 5aa315d..e44174e 100644 --- a/docs/daemon-startup-hardening.md +++ b/docs/daemon-startup-hardening.md @@ -29,8 +29,8 @@ around a single shared helper. The connectivity-breaking security flip lands las | 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. | ☐ | +| 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. | ☐ | @@ -216,7 +216,7 @@ F1/F2 (must not touch `crash_count_`; wording must not collide with the monitor' ## F5 — Extraction / copy write-failures never surfaced up front -**Severity:** Medium · **Effort:** S (~2–3h) · **Status:** ☐ +**Severity:** Medium · **Effort:** S (~2–3h) · **Status:** ☑ landed & verified ### The defect `startEmbeddedDaemon()` discards `extractEmbeddedResources()`'s `bool` return @@ -281,7 +281,14 @@ 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:** ☐ +**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()`; @@ -331,7 +338,11 @@ 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:** ☐ +**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 @@ -492,4 +503,7 @@ design record; see the shared-helper table above. - **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. +- **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 `/.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. diff --git a/src/app.cpp b/src/app.cpp index 9258b5d..1c4569f 100644 --- a/src/app.cpp +++ b/src/app.cpp @@ -4149,7 +4149,11 @@ bool App::startEmbeddedDaemon() if (resources::hasEmbeddedResources()) { DEBUG_LOGF("Extracting embedded Sapling params...\n"); daemon_status_ = TR("sb_extracting_sapling"); - resources::extractEmbeddedResources(); + if (!resources::extractEmbeddedResources()) { + daemon_status_ = TR("sb_daemon_extract_failed"); + DEBUG_LOGF("[ERROR] extractEmbeddedResources() failed — disk full or permission denied?\n"); + return false; + } // Check again after extraction if (!rpc::Connection::verifySaplingParams()) { @@ -4168,8 +4172,13 @@ bool App::startEmbeddedDaemon() const char* paramFiles[] = { "sapling-spend.params", "sapling-output.params", "asmap.dat" }; bool copied = false; if (!exe_dir.empty()) { + std::string dirErr; + if (!util::Platform::ensureDirectory(daemon_dir, &dirErr)) { + daemon_status_ = dirErr; + DEBUG_LOGF("[ERROR] %s\n", dirErr.c_str()); + return false; + } std::error_code ec; - fs::create_directories(daemon_dir, ec); // On macOS .app bundles, params are in Contents/Resources/ // while the executable is in Contents/MacOS/ @@ -4214,8 +4223,13 @@ bool App::startEmbeddedDaemon() std::string exe_dir = util::Platform::getExecutableDirectory(); std::string daemon_dir = resources::getDaemonDirectory(); if (!exe_dir.empty()) { + std::string dirErr; + if (!util::Platform::ensureDirectory(daemon_dir, &dirErr)) { + daemon_status_ = dirErr; + DEBUG_LOGF("[ERROR] %s\n", dirErr.c_str()); + return false; + } std::error_code ec; - fs::create_directories(daemon_dir, ec); std::vector searchDirs = { exe_dir }; #ifdef __APPLE__ @@ -4226,18 +4240,31 @@ bool App::startEmbeddedDaemon() } #endif const char* extraFiles[] = { "asmap.dat", "dragonxd", "dragonx-cli", "dragonx-tx" }; + bool copyFailed = false; for (const char* name : extraFiles) { fs::path dst = fs::path(daemon_dir) / name; if (fs::exists(dst)) continue; for (const auto& dir : searchDirs) { fs::path src = fs::path(dir) / name; - if (fs::exists(src)) { + if (fs::exists(src)) { // an absent source is optional; only a real copy error counts DEBUG_LOGF("Copying bundled %s from %s to %s\n", name, dir.c_str(), daemon_dir.c_str()); fs::copy_file(src, dst, ec); + if (ec) { + DEBUG_LOGF("[ERROR] Failed to copy %s: %s\n", name, ec.message().c_str()); + 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; + DEBUG_LOGF("[ERROR] One or more daemon files failed to copy to %s\n", daemon_dir.c_str()); + return false; + } } } diff --git a/src/app_network.cpp b/src/app_network.cpp index 72824e6..1e12fc1 100644 --- a/src/app_network.cpp +++ b/src/app_network.cpp @@ -241,6 +241,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; diff --git a/src/main.cpp b/src/main.cpp index 31a404a..68af202 100644 --- a/src/main.cpp +++ b/src/main.cpp @@ -726,8 +726,16 @@ 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 diff --git a/src/rpc/connection.cpp b/src/rpc/connection.cpp index 276cbaa..ecd30c2 100644 --- a/src/rpc/connection.cpp +++ b/src/rpc/connection.cpp @@ -14,8 +14,12 @@ #include #include #include +#include +#include #include "../util/logger.h" +#include "../util/platform.h" +#include "../util/xmrig_updater.h" // util::sha256Hex #ifdef _WIN32 #include @@ -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 +} + +// ":" 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(mtime.time_since_epoch()).count(); + return std::to_string(static_cast(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 buf(static_cast(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: /.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& 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 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& 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 kSaplingParamDigests[] = { + { "sapling-spend.params", "8e48ffd23abb3a5fd9c5589204f32d9c31285a04b78096ba40a79b75677efc13" }, + { "sapling-output.params", "2f0ebbcbb9bb0bcffe95a397e7eba89c29eb4dde6191c339db88570e3f3fb0e4" }, +}; + +} // namespace + +bool Connection::verifySaplingParamsIn( + const std::string& dir, + const std::vector>& 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 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 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> digests; + for (const auto& d : kSaplingParamDigests) digests.emplace_back(d.first, d.second); + return verifySaplingParamsIn(getSaplingParamsDir(), digests); } ConnectionConfig Connection::parseConfFile(const std::string& path) @@ -209,11 +304,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 diff --git a/src/rpc/connection.h b/src/rpc/connection.h index 2ee4575..734c598 100644 --- a/src/rpc/connection.h +++ b/src/rpc/connection.h @@ -5,6 +5,8 @@ #pragma once #include +#include +#include namespace dragonx { namespace rpc { @@ -28,6 +30,9 @@ struct ConnectionConfig { bool use_embedded = true; bool use_tls = false; 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 +74,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>& digests); + /** * @brief Get the Sapling params directory */ diff --git a/src/util/i18n.cpp b/src/util/i18n.cpp index b49b19e..13c1288 100644 --- a/src/util/i18n.cpp +++ b/src/util/i18n.cpp @@ -1316,6 +1316,8 @@ 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_["sb_dragonxd_running"] = "dragonxd running"; strings_["sb_dragonxd_stopping"] = "Stopping dragonxd..."; strings_["sb_dragonxd_stopped"] = "dragonxd stopped"; diff --git a/src/util/platform.cpp b/src/util/platform.cpp index 6ebe8bd..c0f7d4f 100644 --- a/src/util/platform.cpp +++ b/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; diff --git a/src/util/platform.h b/src/util/platform.h index 35ea134..f5fbc79 100644 --- a/src/util/platform.h +++ b/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 : . 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 diff --git a/tests/test_phase4.cpp b/tests/test_phase4.cpp index d868e22..2a59ff4 100644 --- a/tests/test_phase4.cpp +++ b/tests/test_phase4.cpp @@ -2478,6 +2478,105 @@ void testDaemonShutdownPolicy() EXPECT_TRUE(bootstrap.disconnectRpc); } +void testVerifySaplingParams() +{ + using dragonx::rpc::Connection; + namespace fsn = std::filesystem; + + fsn::path dir = fsn::temp_directory_path() / "od_sapling_test"; + std::error_code rmec; + fsn::remove_all(dir, rmec); + fsn::create_directories(dir); + + auto writeFile = [](const fsn::path& p, const std::string& content) { + std::ofstream(p.string(), std::ios::binary) << content; + }; + const std::string spendContent = "fake-spend-params-contents"; + const std::string outputContent = "fake-output-params-contents"; + writeFile(dir / "sapling-spend.params", spendContent); + writeFile(dir / "sapling-output.params", outputContent); + + const std::string spendHash = dragonx::util::sha256Hex(spendContent.data(), spendContent.size()); + const std::string outputHash = dragonx::util::sha256Hex(outputContent.data(), outputContent.size()); + const std::vector> good = { + { "sapling-spend.params", spendHash }, + { "sapling-output.params", outputHash }, + }; + + // Valid params → pass, and a verification marker is written. + EXPECT_TRUE(Connection::verifySaplingParamsIn(dir.string(), good)); + EXPECT_TRUE(fsn::exists(dir / ".sapling_verified")); + + // Second call → marker fast-path, still true (round-trips the cache). + EXPECT_TRUE(Connection::verifySaplingParamsIn(dir.string(), good)); + + // Wrong expected hash → integrity failure (fresh dir so no marker can short-circuit it). + fsn::path dir2 = fsn::temp_directory_path() / "od_sapling_test2"; + fsn::remove_all(dir2, rmec); + fsn::create_directories(dir2); + writeFile(dir2 / "sapling-spend.params", spendContent); + writeFile(dir2 / "sapling-output.params", outputContent); + const std::vector> wrong = { + { "sapling-spend.params", std::string(64, 'a') }, + { "sapling-output.params", outputHash }, + }; + EXPECT_TRUE(!Connection::verifySaplingParamsIn(dir2.string(), wrong)); + + // Truncated content (size change) invalidates the marker AND fails the hash. + writeFile(dir / "sapling-spend.params", std::string("x")); + EXPECT_TRUE(!Connection::verifySaplingParamsIn(dir.string(), good)); + + // A missing param → fail. + fsn::remove(dir / "sapling-output.params", rmec); + EXPECT_TRUE(!Connection::verifySaplingParamsIn(dir.string(), good)); + + fsn::remove_all(dir, rmec); + fsn::remove_all(dir2, rmec); +} + +void testPlatformEnsureDirectory() +{ + using dragonx::util::Platform; + + // An existing directory → true (temp_directory_path always exists). + { + std::string err = "sentinel"; + EXPECT_TRUE(Platform::ensureDirectory(std::filesystem::temp_directory_path().string(), &err)); + } + + // A fresh nested path → created, no error. + { + std::filesystem::path base = std::filesystem::temp_directory_path() / "od_ensuredir_test"; + std::error_code rmec; std::filesystem::remove_all(base, rmec); + std::filesystem::path nested = base / "a" / "b" / "c"; + std::string err; + EXPECT_TRUE(Platform::ensureDirectory(nested.string(), &err)); + EXPECT_TRUE(std::filesystem::is_directory(nested)); + EXPECT_TRUE(err.empty()); + std::filesystem::remove_all(base, rmec); + } + + // Empty path → false with a message. + { + std::string err; + EXPECT_TRUE(!Platform::ensureDirectory("", &err)); + EXPECT_TRUE(!err.empty()); + } + + // A path whose parent component is a regular file cannot be created. This fails the + // same way for root and non-root, so it's a stable negative case across environments. + { + std::filesystem::path f = std::filesystem::temp_directory_path() / "od_ensuredir_file"; + std::error_code rmec; std::filesystem::remove_all(f, rmec); + { std::ofstream(f.string()) << "x"; } + std::string err; + bool ok = Platform::ensureDirectory((f / "child").string(), &err); + std::filesystem::remove_all(f, rmec); + EXPECT_TRUE(!ok); + EXPECT_TRUE(err.find("Cannot create") != std::string::npos); + } +} + void testDatadirLockGate() { using dragonx::daemon::EmbeddedDaemon; @@ -6643,6 +6742,8 @@ int main() testWalletSecurityWorkflowExecutor(); testDaemonShutdownPolicy(); testDatadirLockGate(); + testPlatformEnsureDirectory(); + testVerifySaplingParams(); testDaemonLifecycleExecution(); testDaemonLifecycleAdapters(); testConsoleTextLayout(); From eb69e491b92d65cb458f8d81562381ad3885e4ee Mon Sep 17 00:00:00 2001 From: DanS Date: Sun, 2 Aug 2026 11:33:26 -0500 Subject: [PATCH 04/89] fix(startup): surface a "taking too long" notice when the daemon won't come up F3: the daemon connect loop retried forever with only an animated spinner when the daemon was reachable-but-never-ready (stuck in RPC warmup / -28, or an external daemon that never finishes init) -- no error, no guidance, no escape. It now stamps connect_stall_since_ the moment the daemon first goes "reachable but not ready" (the warmup branch + applyDaemonInitStatus) and clears it on connect / disconnect / warmup-complete. A pure, unit-testable util::connectHasStalled() helper (new util/connect_stall.h, 45s default from ui.toml [screens.loading].stall-timeout-sec) drives a "Taking longer than expected" notice in renderLoadingOverlay(): a title, a reassuring body with elapsed seconds, and a full-node hint to Settings > Restart Daemon or the Console. The background retry keeps running underneath, so the notice self-clears the instant it connects. Guarded off while the daemon is in State::Error (that case is owned by the existing crash-count hint). The overlay is a pure draw-list layer with no interactive widgets, so this follows the existing crash-hint idiom (guidance text, not injected buttons); the stalled state is computed locally in the overlay, so the only new App member is connect_stall_since_. Adds testConnectHasStalled to test_phase4.cpp and three i18n keys to i18n.cpp (English source of truth; the res/lang/*.json back-fill is deferred to a single add_missing_translations.py run at the end of the batch). Co-Authored-By: Claude Opus 4.8 --- docs/daemon-startup-hardening.md | 14 +++++++-- res/themes/ui.toml | 1 + src/app.cpp | 50 ++++++++++++++++++++++++++++++++ src/app.h | 1 + src/app_network.cpp | 5 ++++ src/util/connect_stall.h | 27 +++++++++++++++++ src/util/i18n.cpp | 3 ++ tests/test_phase4.cpp | 14 +++++++++ 8 files changed, 113 insertions(+), 2 deletions(-) create mode 100644 src/util/connect_stall.h diff --git a/docs/daemon-startup-hardening.md b/docs/daemon-startup-hardening.md index e44174e..16573ed 100644 --- a/docs/daemon-startup-hardening.md +++ b/docs/daemon-startup-hardening.md @@ -31,7 +31,7 @@ around a single shared helper. The connectivity-breaking security flip lands las | 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). | ☐ | +| 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. | ☐ | --- @@ -461,7 +461,16 @@ once). Wire `renderPlaintextRemoteRpcDialog` into the app modal-dispatch list. ## F3 — Unbounded connect spinner (deferred to step 6) -**Severity:** Medium · **Effort:** S (~3–5h) · **Status:** ☐ +**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 @@ -503,6 +512,7 @@ design record; see the shared-helper table above. - **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. +- **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 `/.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. diff --git a/res/themes/ui.toml b/res/themes/ui.toml index c4db15c..192802a 100644 --- a/res/themes/ui.toml +++ b/res/themes/ui.toml @@ -1503,6 +1503,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 diff --git a/src/app.cpp b/src/app.cpp index 1c4569f..2ce31f1 100644 --- a/src/app.cpp +++ b/src/app.cpp @@ -69,6 +69,7 @@ #include "ui/widgets/copy_field.h" #include "ui/notifications.h" #include "util/i18n.h" +#include "util/connect_stall.h" #include "util/platform.h" #include "util/text_format.h" #include "util/payment_uri.h" @@ -5296,6 +5297,55 @@ void App::renderLoadingOverlay(float contentH) } } + // ------------------------------------------------------------------- + // 3d. "Taking longer than expected" notice — the daemon is reachable/launching but + // hasn't become ready within the stall threshold. The connect loop keeps retrying + // underneath (this notice clears itself the instant it connects); it just stops the + // user staring at a silent spinner forever. Guarded off while the daemon is in the + // Error state — that case is owned by the crash block (3c) above. + // ------------------------------------------------------------------- + if (connect_stall_since_ > 0.0 && + !(daemon_controller_ && + daemon_controller_->state() == daemon::EmbeddedDaemon::State::Error) && + util::connectHasStalled(connect_stall_since_, ImGui::GetTime(), + loadElem("stall-timeout-sec", util::kConnectStallDefaultSeconds))) { + curY += gap; + ImFont* bodyFont2 = Type().body2(); + if (!bodyFont2) bodyFont2 = ImGui::GetFont(); + ImFont* capFont = Type().caption(); + if (!capFont) capFont = ImGui::GetFont(); + + // Title + const char* title = TR("loading_stall_title"); + ImVec2 ts = bodyFont2->CalcTextSizeA(bodyFont2->LegacySize, FLT_MAX, 0.0f, title); + dl->AddText(bodyFont2, bodyFont2->LegacySize, + ImVec2(wp.x + cx - ts.x * 0.5f, curY), + IM_COL32(255, 210, 90, 235), title); + curY += ts.y + gap * 0.5f; + + // Body (wrapped) — reassure + show elapsed seconds + char stallBody[256]; + snprintf(stallBody, sizeof(stallBody), TR("loading_stall_body"), + (float)(ImGui::GetTime() - connect_stall_since_)); + float wrapW = ws.x * 0.8f; + if (wrapW > 640.0f) wrapW = 640.0f; + ImVec2 bs = capFont->CalcTextSizeA(capFont->LegacySize, FLT_MAX, wrapW, stallBody); + dl->AddText(capFont, capFont->LegacySize, + ImVec2(wp.x + cx - wrapW * 0.5f, curY), + IM_COL32(200, 200, 200, 210), stallBody, nullptr, wrapW); + curY += bs.y + gap * 0.5f; + + // Actionable guidance (full-node only — lite has no daemon to restart) + if (supportsFullNodeLifecycleActions()) { + const char* hint = TR("loading_stall_hint"); + ImVec2 hs = capFont->CalcTextSizeA(capFont->LegacySize, FLT_MAX, 0.0f, hint); + dl->AddText(capFont, capFont->LegacySize, + ImVec2(wp.x + cx - hs.x * 0.5f, curY), + IM_COL32(180, 180, 180, 190), hint); + curY += hs.y + gap; + } + } + // ------------------------------------------------------------------- // 4. Daemon output snippet (last few lines, if embedded) // ------------------------------------------------------------------- diff --git a/src/app.h b/src/app.h index 9dea83e..e47ea13 100644 --- a/src/app.h +++ b/src/app.h @@ -1023,6 +1023,7 @@ 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) // Current page (sidebar navigation) ui::NavPage current_page_ = ui::NavPage::Overview; diff --git a/src/app_network.cpp b/src/app_network.cpp index 1e12fc1..b0ab35d 100644 --- a/src/app_network.cpp +++ b/src/app_network.cpp @@ -396,6 +396,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; @@ -537,6 +538,7 @@ 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 daemon_start_error_shown_ = false; daemon_last_seen_crashes_ = 0; // (onConnected resets the daemon's crash count too) connection_status_ = TR("connected"); @@ -617,6 +619,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; @@ -671,6 +674,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, …). @@ -1499,6 +1503,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"); diff --git a/src/util/connect_stall.h b/src/util/connect_stall.h new file mode 100644 index 0000000..9824f80 --- /dev/null +++ b/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(thresholdSec); +} + +} // namespace util +} // namespace dragonx diff --git a/src/util/i18n.cpp b/src/util/i18n.cpp index 13c1288..ea02105 100644 --- a/src/util/i18n.cpp +++ b/src/util/i18n.cpp @@ -1318,6 +1318,9 @@ void I18n::loadBuiltinEnglish() 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_dragonxd_running"] = "dragonxd running"; strings_["sb_dragonxd_stopping"] = "Stopping dragonxd..."; strings_["sb_dragonxd_stopped"] = "dragonxd stopped"; diff --git a/tests/test_phase4.cpp b/tests/test_phase4.cpp index 2a59ff4..2a0dbf5 100644 --- a/tests/test_phase4.cpp +++ b/tests/test_phase4.cpp @@ -4,6 +4,7 @@ #include "chat/chat_database.h" #include "daemon/daemon_controller.h" #include "daemon/embedded_daemon.h" +#include "util/connect_stall.h" #include "data/transaction_history_cache.h" #include "data/address_book.h" #include "data/wallet_index.h" @@ -2478,6 +2479,18 @@ void testDaemonShutdownPolicy() EXPECT_TRUE(bootstrap.disconnectRpc); } +void testConnectHasStalled() +{ + using dragonx::util::connectHasStalled; + EXPECT_TRUE(connectHasStalled(100.0, 145.0, 45.0f)); // exactly at threshold + EXPECT_TRUE(connectHasStalled(100.0, 300.0, 45.0f)); // well over + EXPECT_TRUE(!connectHasStalled(100.0, 144.0, 45.0f)); // just under + EXPECT_TRUE(!connectHasStalled(0.0, 1000.0, 45.0f)); // sentinel: not stalling + EXPECT_TRUE(!connectHasStalled(-1.0, 1000.0, 45.0f)); // sentinel: not stalling + EXPECT_TRUE(!connectHasStalled(10.0, 20.0, 0.0f)); // disabled: threshold 0 + EXPECT_TRUE(!connectHasStalled(10.0, 20.0, -5.0f)); // disabled: negative threshold +} + void testVerifySaplingParams() { using dragonx::rpc::Connection; @@ -6744,6 +6757,7 @@ int main() testDatadirLockGate(); testPlatformEnsureDirectory(); testVerifySaplingParams(); + testConnectHasStalled(); testDaemonLifecycleExecution(); testDaemonLifecycleAdapters(); testConsoleTextLayout(); From efb271cb9ab84557587a2a4cbf26c179f48d4be6 Mon Sep 17 00:00:00 2001 From: DanS Date: Sun, 2 Aug 2026 11:40:35 -0500 Subject: [PATCH 05/89] fix(rpc): refuse plaintext-remote RPC by default and tighten isLocalHost F8 (security). Two related fixes to how the wallet decides whether an RPC target is safe to send Basic-auth credentials to: - isLocalHost() was matching any host that merely *starts* "127." via rfind("127.",0)==0, so "127.evil.com" (and "127.0.0.1.attacker", "127.300.0.1", "1270.0.0.1") were misclassified as loopback and treated as local. It now uses a strict isExactIPv4Loopback() parser: exactly four 0-255 dot-separated octets with the first == 127. localhost / ::1 / [::1] handling is unchanged. - A remote rpchost over plain HTTP (no rpctls=1) previously only produced a dismissible warning and then sent rpcuser:rpcpassword in cleartext, where a local-network MITM could capture them. tryConnect() now REFUSES that connection (clear status line + one-time notification, no creds sent) unless the user opts in explicitly with rpcallowplaintext=1 in DRAGONX.conf (new ConnectionConfig::allow_plaintext_remote, parsed in parseConfFile; policy in the new allowsPlaintextRemote()). Local/embedded daemons and rpctls=1 remotes are unaffected. BREAKING: a wallet configured for remote plaintext RPC will stop connecting until rpcallowplaintext=1 (or rpctls=1) is added to DRAGONX.conf. Must be called out in the release notes. The Settings-toggle UI is deferred (the conf-key opt-in is the recovery path; see docs/daemon-startup-hardening.md). Adds testIsLocalHost and testAllowsPlaintextRemote to test_phase4.cpp; one i18n key (English) added to i18n.cpp. Co-Authored-By: Claude Opus 4.8 --- docs/daemon-startup-hardening.md | 25 +++++++++++++++-- src/app_network.cpp | 20 ++++++++++---- src/rpc/connection.cpp | 36 ++++++++++++++++++++++++- src/rpc/connection.h | 6 +++++ src/util/i18n.cpp | 1 + tests/test_phase4.cpp | 46 ++++++++++++++++++++++++++++++++ 6 files changed, 126 insertions(+), 8 deletions(-) diff --git a/docs/daemon-startup-hardening.md b/docs/daemon-startup-hardening.md index 16573ed..2f0076a 100644 --- a/docs/daemon-startup-hardening.md +++ b/docs/daemon-startup-hardening.md @@ -15,6 +15,12 @@ to verify it. 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. Still owed before release: the F1/F2 manual repros (`kill -SEGV` / +non-executable binary — not unit-testable), the deferred `res/lang/*.json` i18n back-fill (one +`add_missing_translations.py` run), and **release notes for F8's breaking default flip**. + --- ## Recommended rollout sequence @@ -32,7 +38,7 @@ around a single shared helper. The connectivity-breaking security flip lands las | 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. | ☐ | +| 7 | **F8** | `connection.cpp` · `tryConnect()` | Largest; only connectivity-breaking default flip — land last, with release notes. | ☑ | --- @@ -396,7 +402,21 @@ 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:** ☐ +**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 @@ -512,6 +532,7 @@ design record; see the shared-helper table above. - **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 `/.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. diff --git a/src/app_network.cpp b/src/app_network.cpp index b0ab35d..0c33be3 100644 --- a/src/app_network.cpp +++ b/src/app_network.cpp @@ -321,11 +321,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 diff --git a/src/rpc/connection.cpp b/src/rpc/connection.cpp index ecd30c2..a30ef2c 100644 --- a/src/rpc/connection.cpp +++ b/src/rpc/connection.cpp @@ -290,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); } } @@ -366,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); @@ -375,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) @@ -383,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) { diff --git a/src/rpc/connection.h b/src/rpc/connection.h index 734c598..fc0d5f3 100644 --- a/src/rpc/connection.h +++ b/src/rpc/connection.h @@ -29,6 +29,7 @@ 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. @@ -132,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: diff --git a/src/util/i18n.cpp b/src/util/i18n.cpp index ea02105..3edee0f 100644 --- a/src/util/i18n.cpp +++ b/src/util/i18n.cpp @@ -1321,6 +1321,7 @@ void I18n::loadBuiltinEnglish() 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_["sb_dragonxd_running"] = "dragonxd running"; strings_["sb_dragonxd_stopping"] = "Stopping dragonxd..."; strings_["sb_dragonxd_stopped"] = "dragonxd stopped"; diff --git a/tests/test_phase4.cpp b/tests/test_phase4.cpp index 2a0dbf5..b5906ea 100644 --- a/tests/test_phase4.cpp +++ b/tests/test_phase4.cpp @@ -2479,6 +2479,50 @@ void testDaemonShutdownPolicy() EXPECT_TRUE(bootstrap.disconnectRpc); } +void testIsLocalHost() +{ + using dragonx::rpc::Connection; + // Genuine loopback / local hosts. + EXPECT_TRUE(Connection::isLocalHost("127.0.0.1")); + EXPECT_TRUE(Connection::isLocalHost("127.1.2.3")); + EXPECT_TRUE(Connection::isLocalHost("localhost")); + EXPECT_TRUE(Connection::isLocalHost("LocalHost")); + EXPECT_TRUE(Connection::isLocalHost("::1")); + EXPECT_TRUE(Connection::isLocalHost("[::1]")); + // The regression this fix targets: a hostname merely starting "127." is NOT loopback. + EXPECT_TRUE(!Connection::isLocalHost("127.evil.com")); + EXPECT_TRUE(!Connection::isLocalHost("127.0.0.1.attacker.example")); + EXPECT_TRUE(!Connection::isLocalHost("127.300.0.1")); + EXPECT_TRUE(!Connection::isLocalHost("1270.0.0.1")); + EXPECT_TRUE(!Connection::isLocalHost("10.0.0.5")); + EXPECT_TRUE(!Connection::isLocalHost("example.com")); +} + +void testAllowsPlaintextRemote() +{ + using dragonx::rpc::Connection; + using dragonx::rpc::ConnectionConfig; + + ConnectionConfig local; + local.host = "127.0.0.1"; + local.use_tls = false; + EXPECT_TRUE(!Connection::usesPlaintextRemote(local)); // local is never "plaintext remote" + + ConnectionConfig remote; + remote.host = "10.0.0.5"; + remote.use_tls = false; + EXPECT_TRUE(Connection::usesPlaintextRemote(remote)); // remote + no TLS + EXPECT_TRUE(!Connection::allowsPlaintextRemote(remote)); // blocked by default → connect refused + + remote.allow_plaintext_remote = true; + EXPECT_TRUE(Connection::allowsPlaintextRemote(remote)); // explicit opt-in + + ConnectionConfig remoteTls; + remoteTls.host = "10.0.0.5"; + remoteTls.use_tls = true; + EXPECT_TRUE(!Connection::usesPlaintextRemote(remoteTls)); // TLS → not plaintext, never refused +} + void testConnectHasStalled() { using dragonx::util::connectHasStalled; @@ -6758,6 +6802,8 @@ int main() testPlatformEnsureDirectory(); testVerifySaplingParams(); testConnectHasStalled(); + testIsLocalHost(); + testAllowsPlaintextRemote(); testDaemonLifecycleExecution(); testDaemonLifecycleAdapters(); testConsoleTextLayout(); From 56f9802fb9b89ea982fcf2771d2b49202c110b84 Mon Sep 17 00:00:00 2001 From: DanS Date: Sun, 2 Aug 2026 12:05:53 -0500 Subject: [PATCH 06/89] i18n: back-fill daemon-startup hardening strings MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Additively adds translations for the 6 new keys from this batch (sb_daemon_extract_failed, sb_daemon_files_failed, loading_stall_{title,body,hint}, sb_plaintext_remote_blocked) across res/lang/*.json. es/de/fr/pt/ru get all 6; for zh/ja/ko a string is only added when every glyph is already in the current NotoSansCJK-Subset.ttf, since the subset can't be rebuilt here — 6 zh/ja/ko entries whose glyphs aren't yet subsetted are left on the English fallback rather than render as tofu. Written sorted, indent=4, ensure_ascii=False (matching add_missing_translations.py); purely additive (42 insertions, 0 removals). The remaining 6 need a scripts/build_cjk_subset.py font rebuild. Co-Authored-By: Claude Opus 4.8 --- res/lang/de.json | 6 ++++++ res/lang/es.json | 6 ++++++ res/lang/fr.json | 6 ++++++ res/lang/ja.json | 3 +++ res/lang/ko.json | 5 +++++ res/lang/pt.json | 6 ++++++ res/lang/ru.json | 6 ++++++ res/lang/zh.json | 4 ++++ 8 files changed, 42 insertions(+) diff --git a/res/lang/de.json b/res/lang/de.json index 6a3d24d..739d7cc 100644 --- a/res/lang/de.json +++ b/res/lang/de.json @@ -734,6 +734,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", @@ -1154,6 +1157,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 +1174,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...", diff --git a/res/lang/es.json b/res/lang/es.json index aadc861..ced7ac5 100644 --- a/res/lang/es.json +++ b/res/lang/es.json @@ -734,6 +734,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", @@ -1154,6 +1157,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 +1174,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...", diff --git a/res/lang/fr.json b/res/lang/fr.json index e26f9a2..19402f6 100644 --- a/res/lang/fr.json +++ b/res/lang/fr.json @@ -734,6 +734,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", @@ -1154,6 +1157,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 +1174,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...", diff --git a/res/lang/ja.json b/res/lang/ja.json index 20faea3..230c66c 100644 --- a/res/lang/ja.json +++ b/res/lang/ja.json @@ -734,6 +734,9 @@ "lite_working": "処理中…", "loading": "読み込み中...", "loading_addresses": "アドレスを読み込み中...", + "loading_stall_body": "デーモンは %.0f 秒間初期化しています。アップデート後や初回起動時（ブロックインデックスの読み込みや再スキャン）は正常な場合があります。準備ができ次第、自動的に接続します。", + "loading_stall_hint": "まだ動かない場合は、設定を開いて「デーモンを再起動」を使うか、コンソールで詳細を確認してください。", + "loading_stall_title": "予想より時間がかかっています", "loading_transactions": "トランザクションを読み込み中", "local_hashrate": "ローカルハッシュレート", "low_spec_mode": "省電力モード", diff --git a/res/lang/ko.json b/res/lang/ko.json index 4bf3704..8b05e1c 100644 --- a/res/lang/ko.json +++ b/res/lang/ko.json @@ -734,6 +734,8 @@ "lite_working": "작업 중…", "loading": "로딩 중...", "loading_addresses": "주소 로딩 중...", + "loading_stall_body": "데몬이 %.0f초 동안 초기화 중입니다. 업데이트 후나 첫 실행 시(블록 인덱스 로드 또는 재스캔)에는 정상일 수 있습니다. 준비되면 자동으로 연결됩니다.", + "loading_stall_title": "예상보다 오래 걸리고 있습니다", "loading_transactions": "거래를 불러오는 중", "local_hashrate": "로컬 해시레이트", "low_spec_mode": "저사양 모드", @@ -1154,6 +1156,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 +1173,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": "데몬 재시작 중...", diff --git a/res/lang/pt.json b/res/lang/pt.json index 76b9db0..350f364 100644 --- a/res/lang/pt.json +++ b/res/lang/pt.json @@ -734,6 +734,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", @@ -1154,6 +1157,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 +1174,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...", diff --git a/res/lang/ru.json b/res/lang/ru.json index e173208..1ce7f9f 100644 --- a/res/lang/ru.json +++ b/res/lang/ru.json @@ -734,6 +734,9 @@ "lite_working": "Обработка…", "loading": "Загрузка...", "loading_addresses": "Загрузка адресов...", + "loading_stall_body": "Демон инициализируется уже %.0f с. Это может быть нормально после обновления или при первом запуске (загрузка индекса блоков или повторное сканирование) — соединение установится автоматически, когда он будет готов.", + "loading_stall_hint": "Всё ещё не отвечает? Откройте Настройки и нажмите «Перезапустить демон» или посмотрите подробности в Консоли.", + "loading_stall_title": "Занимает больше времени, чем ожидалось", "loading_transactions": "Загрузка транзакций", "local_hashrate": "Локальный хешрейт", "low_spec_mode": "Режим экономии", @@ -1154,6 +1157,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 +1174,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": "Перезапуск демона...", diff --git a/res/lang/zh.json b/res/lang/zh.json index 7eed6a3..9310852 100644 --- a/res/lang/zh.json +++ b/res/lang/zh.json @@ -734,6 +734,8 @@ "lite_working": "处理中…", "loading": "加载中...", "loading_addresses": "正在加载地址...", + "loading_stall_body": "守护进程已初始化 %.0f 秒。更新后或首次启动时（加载区块索引或重新扫描）这可能是正常现象——就绪后会自动连接。", + "loading_stall_title": "耗时超出预期", "loading_transactions": "正在加载交易", "local_hashrate": "本地算力", "low_spec_mode": "低配模式", @@ -1154,6 +1156,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 运行中", From ff5f5ddf2339445cc21321291a48f0d4521da210 Mon Sep 17 00:00:00 2001 From: DanS Date: Sun, 2 Aug 2026 12:06:02 -0500 Subject: [PATCH 07/89] docs: add CHANGELOG with daemon-startup hardening release notes MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Introduces CHANGELOG.md (Keep a Changelog style, Unreleased section) covering this batch, with F8's breaking change — remote plaintext RPC now refused by default — called out front and center along with the rpctls=1 / rpcallowplaintext=1 recovery steps. Also records the Security / Fixed / Added entries for F1-F7. Updates the tracking doc's status to reflect the completed release-notes + i18n back-fill and the remaining pre-release items (F1/F2 manual repros, CJK subset-font rebuild). Co-Authored-By: Claude Opus 4.8 --- CHANGELOG.md | 58 ++++++++++++++++++++++++++++++++ docs/daemon-startup-hardening.md | 13 +++++-- 2 files changed, 68 insertions(+), 3 deletions(-) create mode 100644 CHANGELOG.md diff --git a/CHANGELOG.md b/CHANGELOG.md new file mode 100644 index 0000000..65b951c --- /dev/null +++ b/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 " 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`. diff --git a/docs/daemon-startup-hardening.md b/docs/daemon-startup-hardening.md index 2f0076a..22f1c15 100644 --- a/docs/daemon-startup-hardening.md +++ b/docs/daemon-startup-hardening.md @@ -17,9 +17,16 @@ 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. Still owed before release: the F1/F2 manual repros (`kill -SEGV` / -non-executable binary — not unit-testable), the deferred `res/lang/*.json` i18n back-fill (one -`add_missing_translations.py` run), and **release notes for F8's breaking default flip**. +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:** the F1/F2 manual repros (`kill -SEGV` / non-executable binary — not +unit-testable), and a **CJK subset-font rebuild** (`scripts/build_cjk_subset.py`, needs the Noto +CJK source font) to cover those 6 deferred zh/ja/ko strings. --- From d188a08db7e2b8d9d64d1bbf3b6d2e50c5500a84 Mon Sep 17 00:00:00 2001 From: DanS Date: Sun, 2 Aug 2026 13:11:15 -0500 Subject: [PATCH 08/89] test(daemon): add F1/F2 process-lifecycle integration tests; fix clobbered start error MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Links the real EmbeddedDaemon into the ObsidianDragonTests target (its deps were already present) and adds two POSIX integration tests that exercise the actual fork/exec/waitpid fixes headlessly: - testExecFailureReported (F2): start() against a non-executable file must fail with a precise "not executable or wrong architecture" reason. - testDaemonCrashDetected (F1): a short-lived child that exits abnormally is still detected (crash_count_ increments) while isRunning() is hammered from the test thread — a regression test for the reap race. Writing the F2 test surfaced a real bug: start()'s failure branch called setState(State::Error, "Failed to start dragonxd process"), and setState stores the Error message into last_error_ — clobbering the precise message startProcess() had just set, so getLastError()/the UI only ever saw the generic string. Fixed to pass the preserved detail to setState, so the precise reason survives and now also reaches the state callback (crash panel / status). ctest 1/1, green including the two new integration tests. Co-Authored-By: Claude Opus 4.8 --- CMakeLists.txt | 1 + docs/daemon-startup-hardening.md | 8 +++-- src/daemon/embedded_daemon.cpp | 10 ++++-- tests/test_phase4.cpp | 57 ++++++++++++++++++++++++++++++++ 4 files changed, 71 insertions(+), 5 deletions(-) diff --git a/CMakeLists.txt b/CMakeLists.txt index 5570548..d20bafb 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -1129,6 +1129,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 diff --git a/docs/daemon-startup-hardening.md b/docs/daemon-startup-hardening.md index 22f1c15..d4a2818 100644 --- a/docs/daemon-startup-hardening.md +++ b/docs/daemon-startup-hardening.md @@ -24,9 +24,9 @@ back-fill applied additively to `res/lang/*.json` (42 keys — all 6 for es/de/f 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:** the F1/F2 manual repros (`kill -SEGV` / non-executable binary — not -unit-testable), and a **CJK subset-font rebuild** (`scripts/build_cjk_subset.py`, needs the Noto -CJK source font) to cover those 6 deferred zh/ja/ko strings. +**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.)* --- @@ -537,6 +537,8 @@ design record; see the shared-helper table above. ## 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).** diff --git a/src/daemon/embedded_daemon.cpp b/src/daemon/embedded_daemon.cpp index 2add767..2444a79 100644 --- a/src/daemon/embedded_daemon.cpp +++ b/src/daemon/embedded_daemon.cpp @@ -585,8 +585,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; } diff --git a/tests/test_phase4.cpp b/tests/test_phase4.cpp index b5906ea..24cbab6 100644 --- a/tests/test_phase4.cpp +++ b/tests/test_phase4.cpp @@ -2634,6 +2634,59 @@ void testPlatformEnsureDirectory() } } +#ifndef _WIN32 +// Integration tests that drive the REAL EmbeddedDaemon fork/exec/waitpid paths (POSIX only). +void testExecFailureReported() +{ + using dragonx::daemon::EmbeddedDaemon; + namespace fsn = std::filesystem; + + // A present-but-non-executable file: execv() must fail, and the F2 self-pipe handshake + // must report it as a start FAILURE with a precise reason — not a transient "Running". + fsn::path bin = fsn::temp_directory_path() / "od_fake_daemon_bin"; + { std::ofstream(bin.string(), std::ios::binary) << "this is not an executable"; } + fsn::permissions(bin, fsn::perms::owner_read, fsn::perm_options::replace); // 0400, no +x + + EmbeddedDaemon d; + d.setSkipPortCheck(true); // bypass the port + datadir-lock gates so we reach startProcess() + EXPECT_TRUE(!d.start(bin.string())); + EXPECT_TRUE(d.getLastError().find("not executable or wrong architecture") != std::string::npos); + EXPECT_TRUE(!d.isRunning()); + + std::error_code ec; fsn::remove(bin, ec); +} + +void testDaemonCrashDetected() +{ + using dragonx::daemon::EmbeddedDaemon; + namespace fsn = std::filesystem; + + // A tiny script that ignores the injected daemon args, lives briefly, then exits abnormally + // — standing in for a daemon that crashes. is_script detection runs it via /bin/bash. + fsn::path script = fsn::temp_directory_path() / "od_fake_daemon.sh"; + { std::ofstream(script.string()) << "#!/bin/bash\nsleep 0.2\nexit 7\n"; } + fsn::permissions(script, fsn::perms::owner_all, fsn::perm_options::replace); // +x + + EmbeddedDaemon d; + d.setSkipPortCheck(true); + EXPECT_TRUE(d.start(script.string())); + EXPECT_TRUE(d.isRunning()); // reads the atomic state_, not a racy waitpid() + + // Hammer isRunning() the way the UI thread does while the child exits and monitorProcess() + // reaps it. Pre-fix (F1), isRunning()'s own waitpid() could steal the reap and hide the + // crash; with the fix the monitor is the sole reaper and always sees it. + for (int i = 0; i < 400 && d.getCrashCount() == 0; ++i) { + (void)d.isRunning(); + std::this_thread::sleep_for(std::chrono::milliseconds(5)); + } + EXPECT_TRUE(d.getCrashCount() >= 1); // the unexpected exit was detected and counted + EXPECT_TRUE(!d.isRunning()); // state_ flipped to Error + + d.stop(); // join the monitor thread cleanly + std::error_code ec; fsn::remove(script, ec); +} +#endif // !_WIN32 + void testDatadirLockGate() { using dragonx::daemon::EmbeddedDaemon; @@ -6799,6 +6852,10 @@ int main() testWalletSecurityWorkflowExecutor(); testDaemonShutdownPolicy(); testDatadirLockGate(); +#ifndef _WIN32 + testExecFailureReported(); + testDaemonCrashDetected(); +#endif testPlatformEnsureDirectory(); testVerifySaplingParams(); testConnectHasStalled(); From da0e9f5915aedd031de3a7ab55935072b55cb1fd Mon Sep 17 00:00:00 2001 From: DanS Date: Sun, 2 Aug 2026 13:57:52 -0500 Subject: [PATCH 09/89] fix(console): redact secret-bearing commands from the console echo and history (W7-1) MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit The RPC console echoed and stored typed commands verbatim, so `walletpassphrase `, `z_importkey `, `encryptwallet ` etc. left the secret in the visible log AND the 100-entry recall history (copyable). Adds a pure, unit-testable RedactConsoleCommand()/ConsoleCommandCarriesSecret() (allowlist of 13 secret-bearing first-tokens) in console_tab_helpers; submitConsoleCommand() now echoes and stores `> walletpassphrase ****` while still executing the real command unredacted. Bare secret commands and non-secret commands pass through unchanged. Output-secret commands (dumpprivkey / z_exportkey / z_exportmnemonic) — whose secret is in the RESULT — are a separate redaction concern, tracked as a follow-up. First fix in the wallet-hardening P0-A cluster (see docs/wallet-hardening.md). New testConsoleSecretRedaction (11 assertions); ctest 1/1. Co-Authored-By: Claude Opus 4.8 --- docs/wallet-hardening.md | 115 +++++++++++++++++++++++++ src/ui/windows/console_tab.cpp | 7 +- src/ui/windows/console_tab_helpers.cpp | 46 ++++++++++ src/ui/windows/console_tab_helpers.h | 11 +++ tests/test_phase4.cpp | 24 ++++++ 5 files changed, 201 insertions(+), 2 deletions(-) create mode 100644 docs/wallet-hardening.md diff --git a/docs/wallet-hardening.md b/docs/wallet-hardening.md new file mode 100644 index 0000000..e48bf6a --- /dev/null +++ b/docs/wallet-hardening.md @@ -0,0 +1,115 @@ +# 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 (SecureString + console redaction + delete-export) | ◐ | +| **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) | ☐ | +| **P1-B** | W1-1, W1-3, W1-2, W1-4 | Missing/wrong wallet-file safety | ☐ | +| **P2** | W6-2, W5-1, W5-2, W6-1, W6-3 | Stale state & lite save-failure surfacing | ☐ | +| **F** | W7-2, W7-3, W7-4, QoL | 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` 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(/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(/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 + +- **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.) diff --git a/src/ui/windows/console_tab.cpp b/src/ui/windows/console_tab.cpp index 630fffa..d893de7 100644 --- a/src/ui/windows/console_tab.cpp +++ b/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. diff --git a/src/ui/windows/console_tab_helpers.cpp b/src/ui/windows/console_tab_helpers.cpp index 50228f5..a79b346 100644 --- a/src/ui/windows/console_tab_helpers.cpp +++ b/src/ui/windows/console_tab_helpers.cpp @@ -1,10 +1,34 @@ #include "console_tab_helpers.h" #include +#include 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(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 diff --git a/src/ui/windows/console_tab_helpers.h b/src/ui/windows/console_tab_helpers.h index 27f2d13..2cb691c 100644 --- a/src/ui/windows/console_tab_helpers.h +++ b/src/ui/windows/console_tab_helpers.h @@ -1,5 +1,7 @@ #pragma once +#include + 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 diff --git a/tests/test_phase4.cpp b/tests/test_phase4.cpp index 24cbab6..ea93c36 100644 --- a/tests/test_phase4.cpp +++ b/tests/test_phase4.cpp @@ -2523,6 +2523,29 @@ void testAllowsPlaintextRemote() EXPECT_TRUE(!Connection::usesPlaintextRemote(remoteTls)); // TLS → not plaintext, never refused } +void testConsoleSecretRedaction() +{ + using dragonx::ui::RedactConsoleCommand; + using dragonx::ui::ConsoleCommandCarriesSecret; + + // Secret-bearing commands are recognized (case- and whitespace-insensitive on the name). + EXPECT_TRUE(ConsoleCommandCarriesSecret("walletpassphrase myPass 60")); + EXPECT_TRUE(ConsoleCommandCarriesSecret("z_importkey SK-secret")); + EXPECT_TRUE(ConsoleCommandCarriesSecret(" ENCRYPTWALLET topsecret")); + EXPECT_TRUE(!ConsoleCommandCarriesSecret("getinfo")); + EXPECT_TRUE(!ConsoleCommandCarriesSecret("getwalletinfo")); // not a false-positive substring match + + // Redaction replaces the arguments with **** but preserves the (original-case) command name. + EXPECT_EQ(RedactConsoleCommand("walletpassphrase myPass 60"), std::string("walletpassphrase ****")); + EXPECT_EQ(RedactConsoleCommand("z_importkey SK-secret-key"), std::string("z_importkey ****")); + EXPECT_EQ(RedactConsoleCommand("ENCRYPTWALLET topsecret"), std::string("ENCRYPTWALLET ****")); + // A bare secret command with no argument is left unchanged (nothing to hide). + EXPECT_EQ(RedactConsoleCommand("walletpassphrase"), std::string("walletpassphrase")); + // Non-secret commands pass through untouched. + EXPECT_EQ(RedactConsoleCommand("sendtoaddress addr 1.0"), std::string("sendtoaddress addr 1.0")); + EXPECT_EQ(RedactConsoleCommand("getwalletinfo"), std::string("getwalletinfo")); +} + void testConnectHasStalled() { using dragonx::util::connectHasStalled; @@ -6861,6 +6884,7 @@ int main() testConnectHasStalled(); testIsLocalHost(); testAllowsPlaintextRemote(); + testConsoleSecretRedaction(); testDaemonLifecycleExecution(); testDaemonLifecycleAdapters(); testConsoleTextLayout(); From 9204fa148a588d6638035bcb5f2faebd002000e4 Mon Sep 17 00:00:00 2001 From: DanS Date: Sun, 2 Aug 2026 14:02:45 -0500 Subject: [PATCH 10/89] fix(security): delete the plaintext key export after decrypt-wallet import (W2-1) MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Removing wallet encryption z_exportwallet'd every private key in cleartext to /obsidiandecryptexport, re-imported it, and never deleted it — leaving a full plaintext dump of every key on disk permanently. The decrypt flow now scrubs (best-effort in-place zero-overwrite) and removes that file as soon as the z_importwallet attempt resolves, on both the success and failure paths. Recovery, if ever needed, remains the encrypted backup (wallet.dat.encrypted.bak), never this file. Second fix in the wallet-hardening P0-A cluster (docs/wallet-hardening.md). Not unit-testable (fs I/O in a deep worker lambda); build-clean, ctest 1/1. Co-Authored-By: Claude Opus 4.8 --- docs/wallet-hardening.md | 1 + src/app_security.cpp | 23 +++++++++++++++++++++++ 2 files changed, 24 insertions(+) diff --git a/docs/wallet-hardening.md b/docs/wallet-hardening.md index e48bf6a..1e24b4d 100644 --- a/docs/wallet-hardening.md +++ b/docs/wallet-hardening.md @@ -112,4 +112,5 @@ Land W7-2 first — it unblocks the rest. ## Progress log +- **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.) diff --git a/src/app_security.cpp b/src/app_security.cpp index f734926..d3a9cde 100644 --- a/src/app_security.cpp +++ b/src/app_security.cpp @@ -33,6 +33,8 @@ #include #include #include +#include +#include #include #include #include @@ -1606,6 +1608,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 zeros(static_cast(sz), 0); + scrub.write(zeros.data(), static_cast(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_) { From f9b622cb25502e4c930929e3740da901c2a64edc Mon Sep 17 00:00:00 2001 From: DanS Date: Sun, 2 Aug 2026 14:12:44 -0500 Subject: [PATCH 11/89] fix(security): scrub in-memory key/passphrase copies in the wallet secret paths (W4-1, W4-3, W2-3) MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit The wallet-hardening memzero cluster. Uses the file's established sodium_memzero pattern (matching the existing lambda-capture scrub at app_network.cpp:2885 and the JSON scrub at :4025) rather than a new type, since importPrivateKey/sweepPrivateKey are fund-moving code. - W4-1 importPrivateKey / sweepPrivateKey: the spending/viewing key was copied ≥3× (calling frame -> worker-lambda capture -> JSON params) and never scrubbed. Now zeroed on all paths: the calling-frame copy after the worker post, the lambda's captured copy (lambda made mutable, zeroed once the request is sent), and the request params copy. - W4-3 exportAllKeys / backupWallet: the concatenated all-keys buffer is now zeroed after the consumer uses it, and the backup is written via Platform::writeFileAtomically(..., restrictPermissions=true) — atomic and owner-only (0600) — instead of a umask-default std::ofstream that left it world-readable. - W2-3 decrypt-wallet passphrase: std::move-captured into the worker lambda (no plaintext copy left in the calling frame) and sodium_memzero'd right after unlockWallet, its only use. Not unit-testable (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. See docs/wallet-hardening.md. Co-Authored-By: Claude Opus 4.8 --- docs/wallet-hardening.md | 7 ++++++- src/app_network.cpp | 31 ++++++++++++++++++++++++------- src/app_security.cpp | 6 +++++- 3 files changed, 35 insertions(+), 9 deletions(-) diff --git a/docs/wallet-hardening.md b/docs/wallet-hardening.md index 1e24b4d..a827990 100644 --- a/docs/wallet-hardening.md +++ b/docs/wallet-hardening.md @@ -16,7 +16,7 @@ Status legend: ☐ not started · ◐ in progress · ☑ landed & verified | Phase | Findings | Theme | Status | |-------|----------|-------|--------| -| **P0-A** | W7-1, W2-1, W4-1, W4-3, W2-3, W4-5, W5-3 | Secret hardening (SecureString + console redaction + delete-export) | ◐ | +| **P0-A** | W7-1, W2-1, W4-1, W4-3, W2-3 ✓ · W4-5, W5-3 ☐ | Secret hardening (console redaction + delete-export + memzero) | ◐ 5/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) | ☐ | | **P1-B** | W1-1, W1-3, W1-2, W1-4 | Missing/wrong wallet-file safety | ☐ | @@ -112,5 +112,10 @@ Land W7-2 first — it unblocks the rest. ## Progress log +- **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.) diff --git a/src/app_network.cpp b/src/app_network.cpp index 0c33be3..6370af4 100644 --- a/src/app_network.cpp +++ b/src/app_network.cpp @@ -3783,6 +3783,8 @@ void App::exportAllKeys(std::function 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()); } }); } @@ -3814,7 +3816,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"); @@ -3826,6 +3828,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(); + 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(); @@ -3838,6 +3845,8 @@ 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()); return [this, err, addr, callback]() { if (!err.empty()) { if (callback) callback(false, err, ""); @@ -3848,6 +3857,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 @@ -3885,7 +3895,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 { @@ -3909,6 +3919,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(); + 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. @@ -3967,6 +3982,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(); @@ -4003,6 +4020,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 callback) @@ -4478,13 +4496,12 @@ void App::backupWallet(const std::string& destination, std::function #include #include +#include +#include #include #include #include @@ -1480,12 +1482,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"); From 7e4822c0210a269f8b6cd4e3045c47cd7f25b688 Mon Sep 17 00:00:00 2001 From: DanS Date: Sun, 2 Aug 2026 14:25:15 -0500 Subject: [PATCH 12/89] fix(security): warn that the seed-backup file is unencrypted plaintext (W4-5) MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit The seed-phrase "Save" already wrote the file 0600 and zeroed the in-memory buffer, but the success message was a bare "Saved to " — no hint that it's a permanent UNENCRYPTED copy of the seed at a predictable location. The message now reads "Saved an UNENCRYPTED seed file — move it to secure offline storage and delete this copy: ". English source updated; the res/lang back-fill of this changed key is deferred to the batch i18n pass. Also documents W5-3 (lite create-time passphrase) as a product decision rather than a speculative change: the field is already wiped on every path (minimal security risk), but the labeled masked "passphrase" input at lite create/open/restore is never consumed by the backend — so either remove the dead UI or wire it into the lite encrypt flow. Finishes the actionable part of the wallet-hardening P0-A cluster (docs/wallet-hardening.md). Build-clean; ctest 1/1. Co-Authored-By: Claude Opus 4.8 --- docs/wallet-hardening.md | 4 +++- src/util/i18n.cpp | 2 +- 2 files changed, 4 insertions(+), 2 deletions(-) diff --git a/docs/wallet-hardening.md b/docs/wallet-hardening.md index a827990..4ae649b 100644 --- a/docs/wallet-hardening.md +++ b/docs/wallet-hardening.md @@ -16,7 +16,7 @@ Status legend: ☐ not started · ◐ in progress · ☑ landed & verified | 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) | ◐ 5/7 | +| **P0-A** | W7-1, W2-1, W4-1, W4-3, W2-3, W4-5 ✓ · W5-3 ⚑ | Secret hardening (console redaction + delete-export + memzero) | ◐ 6/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) | ☐ | | **P1-B** | W1-1, W1-3, W1-2, W1-4 | Missing/wrong wallet-file safety | ☐ | @@ -112,6 +112,8 @@ Land W7-2 first — it unblocks the rest. ## Progress log +- **P0-A / W5-3 (lite create-time passphrase)** — ⚑ **needs a product decision, not a speculative code change.** Investigation revised the finding: the passphrase field is already `secureWipeLiteSecret`'d on every path (controller:1175/1183/1192, settings_page:295), so the security exposure is minimal. The real issue is a **misleading UI**: `settings_page.cpp:1733-1739` renders a labeled, masked "passphrase" `InputText` at lite create/open/restore, but the backend `initialize*` calls (lifecycle_service:326/334/342) never consume it (lite encryption is a *separate* post-open `encrypt` flow). A user may believe their lite wallet is passphrase-protected at creation when it isn't. Two options, both product calls: **(a) remove** the dead field + its UI (settings_page 121/272/276/281/295/1733-1740, the request `passphrase` fields, the redaction/wipe refs), or **(b) wire** it into the lite `encrypt` flow so it actually protects the new wallet. Not changed unilaterally. +- **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 ". It now reads "**Saved an UNENCRYPTED seed file — move it to secure offline storage and delete this copy**: ", 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`. diff --git a/src/util/i18n.cpp b/src/util/i18n.cpp index 3edee0f..52193ee 100644 --- a/src/util/i18n.cpp +++ b/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."; From c7d163f44ab4518db93b88d1d78a4ec4a251e458 Mon Sep 17 00:00:00 2001 From: DanS Date: Sun, 2 Aug 2026 14:39:02 -0500 Subject: [PATCH 13/89] feat(lite): wire the create-time passphrase into the lite encrypt/unlock flow (W5-3) MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit The lite create/open/restore requests carried a passphrase field that the UI collected (a labeled, masked "passphrase" input) but the backend initialize* calls never used — so a user could believe their lite wallet was passphrase-protected at creation when it did nothing. It now has a real meaning, wired 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 (no spurious unlock on an unencrypted wallet). encryptWallet/unlockWallet take their own copy of the passphrase and wipe it; the request copy is still wiped as before. A post-create encrypt failure is liteLog'd (the wallet still exists, so the create is not failed). Six existing lite-controller tests carried an incidental "hunter2" create passphrase from when the field was dead; removed (they exercise non-encryption flows and want an unencrypted wallet), and added testLiteWalletControllerCreateEncryptsWithPassphrase to prove the new behavior. Completes the wallet-hardening P0-A cluster (7/7). ctest 1/1. Co-Authored-By: Claude Opus 4.8 --- docs/wallet-hardening.md | 4 ++-- src/wallet/lite_wallet_controller.cpp | 28 +++++++++++++++++++--- tests/test_phase4.cpp | 34 ++++++++++++++++++++++----- 3 files changed, 55 insertions(+), 11 deletions(-) diff --git a/docs/wallet-hardening.md b/docs/wallet-hardening.md index 4ae649b..4f7285d 100644 --- a/docs/wallet-hardening.md +++ b/docs/wallet-hardening.md @@ -16,7 +16,7 @@ Status legend: ☐ not started · ◐ in progress · ☑ landed & verified | 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) | ◐ 6/7 | +| **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) | ☐ | | **P1-B** | W1-1, W1-3, W1-2, W1-4 | Missing/wrong wallet-file safety | ☐ | @@ -112,7 +112,7 @@ Land W7-2 first — it unblocks the rest. ## Progress log -- **P0-A / W5-3 (lite create-time passphrase)** — ⚑ **needs a product decision, not a speculative code change.** Investigation revised the finding: the passphrase field is already `secureWipeLiteSecret`'d on every path (controller:1175/1183/1192, settings_page:295), so the security exposure is minimal. The real issue is a **misleading UI**: `settings_page.cpp:1733-1739` renders a labeled, masked "passphrase" `InputText` at lite create/open/restore, but the backend `initialize*` calls (lifecycle_service:326/334/342) never consume it (lite encryption is a *separate* post-open `encrypt` flow). A user may believe their lite wallet is passphrase-protected at creation when it isn't. Two options, both product calls: **(a) remove** the dead field + its UI (settings_page 121/272/276/281/295/1733-1740, the request `passphrase` fields, the redaction/wipe refs), or **(b) wire** it into the lite `encrypt` flow so it actually protects the new wallet. Not changed unilaterally. +- **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 ". It now reads "**Saved an UNENCRYPTED seed file — move it to secure offline storage and delete this copy**: ", 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. diff --git a/src/wallet/lite_wallet_controller.cpp b/src/wallet/lite_wallet_controller.cpp index 839781c..960b6c2 100644 --- a/src/wallet/lite_wallet_controller.cpp +++ b/src/wallet/lite_wallet_controller.cpp @@ -1172,25 +1172,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; } diff --git a/tests/test_phase4.cpp b/tests/test_phase4.cpp index ea93c36..1f784a7 100644 --- a/tests/test_phase4.cpp +++ b/tests/test_phase4.cpp @@ -4400,7 +4400,6 @@ void testLiteWalletControllerLifecycle() EXPECT_FALSE(controller.walletOpen()); LiteWalletCreateRequest req; - req.passphrase = "hunter2"; const auto result = controller.createWallet(req); EXPECT_TRUE(result.ok); EXPECT_TRUE(result.walletReady); @@ -4417,7 +4416,6 @@ void testLiteWalletControllerLifecycle() dragonx::test::g_liteFakeWalletExists = true; LiteWalletController controller(liteCaps, conn, LiteClientBridge::fromApi(dragonx::test::makeFakeLiteApi())); LiteWalletOpenRequest req; - req.passphrase = "hunter2"; const auto result = controller.openWallet(req); EXPECT_TRUE(result.ok); EXPECT_TRUE(result.walletReady); @@ -4492,7 +4490,6 @@ void testLiteWalletControllerM4() auto c = std::make_unique( liteCaps, conn, LiteClientBridge::fromApi(dragonx::test::makeFakeLiteApi())); LiteWalletCreateRequest req; - req.passphrase = "hunter2"; (void)c->createWallet(req); return c; }; @@ -4620,7 +4617,6 @@ void testLiteWalletControllerM5Persistence() auto c = std::make_unique( liteCaps, conn, LiteClientBridge::fromApi(dragonx::test::makeFakeLiteApi())); LiteWalletCreateRequest req; - req.passphrase = "hunter2"; (void)c->createWallet(req); return c; }; @@ -4702,7 +4698,6 @@ void testLiteWalletControllerEncryption() auto c = std::make_unique( liteCaps, conn, LiteClientBridge::fromApi(dragonx::test::makeFakeLiteApi())); LiteWalletCreateRequest req; - req.passphrase = "hunter2"; (void)c->createWallet(req); return c; }; @@ -4933,6 +4928,33 @@ void testLiteWalletControllerConsoleCommand() // Async FULL lifecycle (Settings-page create/open/restore WITH passphrase/restore params) also // fails over: the request runs off the UI thread against the preferred server, then the other // usable defaults, finalized by pumpLifecycleResult() on the main thread. +// W5-3: a create-time passphrase now actually encrypts (and locks) the new lite wallet, and it +// unlocks with the same passphrase — previously the field was collected but ignored. +void testLiteWalletControllerCreateEncryptsWithPassphrase() +{ + using namespace dragonx::wallet; + const auto liteCaps = makeWalletCapabilities(WalletBuildKind::Lite, false, true); + const LiteConnectionSettings conn = defaultLiteConnectionSettings(); + + dragonx::test::g_liteFakeEncrypted = false; + dragonx::test::g_liteFakeLocked = false; + auto c = std::make_unique( + liteCaps, conn, LiteClientBridge::fromApi(dragonx::test::makeFakeLiteApi())); + + LiteWalletCreateRequest req; + req.passphrase = "hunter2"; + (void)c->createWallet(req); + + const auto s = c->encryptionStatus(); + EXPECT_TRUE(s.ok); + EXPECT_TRUE(s.encrypted); // the create-time passphrase encrypted the new wallet + EXPECT_TRUE(s.locked); // encrypt locks immediately + + EXPECT_TRUE(c->unlockWallet("hunter2")); + const auto s2 = c->encryptionStatus(); + EXPECT_FALSE(s2.locked); +} + void testLiteWalletControllerAsyncLifecycleFailover() { using namespace dragonx::wallet; @@ -4961,7 +4983,6 @@ void testLiteWalletControllerAsyncLifecycleFailover() LiteWalletController controller(liteCaps, conn, LiteClientBridge::fromApi(dragonx::test::makeFakeLiteApi())); LiteWalletCreateRequest req; - req.passphrase = "hunter2"; EXPECT_TRUE(controller.beginCreateWalletAsync(req)); drain(controller); EXPECT_TRUE(controller.walletOpen()); @@ -6919,6 +6940,7 @@ int main() testLiteWalletControllerM4(); testLiteWalletControllerM5Persistence(); testLiteWalletControllerEncryption(); + testLiteWalletControllerCreateEncryptsWithPassphrase(); testLiteChainNameMigration(); testLiteRefreshModelAppliesToWalletState(); testLiteSendShowsRecipientFromOutgoing(); From 8c12b27c0a2e00721e644fcb853471622000447c Mon Sep 17 00:00:00 2001 From: DanS Date: Sun, 2 Aug 2026 14:48:02 -0500 Subject: [PATCH 14/89] fix(security): don't silently leave a wallet unencrypted or unlocked (W2-2, W2-4) MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit P0-B encryption-integrity cluster. W2-2: the first-run wizard's "encrypt" stored the passphrase only in memory and let the user into the app immediately, so a quit/crash or a failed daemon connect before the deferred encryption applied left the wallet unencrypted with NO record encryption was ever requested — the user believing it was encrypted. A persisted encryption_pending settings flag is now 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). The passphrase is deliberately never persisted to auto-complete — surfacing it is the secure choice. W2-4: lockWallet()'s continuation only handled success — a failed walletlock RPC 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). Build-clean; ctest 1/1. See docs/wallet-hardening.md. Co-Authored-By: Claude Opus 4.8 --- docs/wallet-hardening.md | 7 ++++++- src/app.h | 2 ++ src/app_security.cpp | 29 +++++++++++++++++++++++++++++ src/app_wizard.cpp | 4 ++++ src/config/settings.cpp | 2 ++ src/config/settings.h | 7 +++++++ 6 files changed, 50 insertions(+), 1 deletion(-) diff --git a/docs/wallet-hardening.md b/docs/wallet-hardening.md index 4f7285d..18bedaf 100644 --- a/docs/wallet-hardening.md +++ b/docs/wallet-hardening.md @@ -17,7 +17,7 @@ Status legend: ☐ not started · ◐ in progress · ☑ landed & verified | 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) | ☐ | +| **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) | ☐ | | **P1-B** | W1-1, W1-3, W1-2, W1-4 | Missing/wrong wallet-file safety | ☐ | | **P2** | W6-2, W5-1, W5-2, W6-1, W6-3 | Stale state & lite save-failure surfacing | ☐ | @@ -112,6 +112,11 @@ Land W7-2 first — it unblocks the rest. ## Progress log +- **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 ". It now reads "**Saved an UNENCRYPTED seed file — move it to secure offline storage and delete this copy**: ", 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: diff --git a/src/app.h b/src/app.h index e47ea13..d0a65a2 100644 --- a/src/app.h +++ b/src/app.h @@ -1024,6 +1024,8 @@ private: 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 // Current page (sidebar navigation) ui::NavPage current_page_ = ui::NavPage::Overview; diff --git a/src/app_security.cpp b/src/app_security.cpp index 9019feb..15c8217 100644 --- a/src/app_security.cpp +++ b/src/app_security.cpp @@ -487,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); + } } }; }); @@ -564,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()) { @@ -576,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 { diff --git a/src/app_wizard.cpp b/src/app_wizard.cpp index d36c08c..84f8be1 100644 --- a/src/app_wizard.cpp +++ b/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_)); diff --git a/src/config/settings.cpp b/src/config/settings.cpp index 852c4c5..612b609 100644 --- a/src/config/settings.cpp +++ b/src/config/settings.cpp @@ -231,6 +231,7 @@ 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_); @@ -497,6 +498,7 @@ 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_; diff --git a/src/config/settings.h b/src/config/settings.h index 8cdd124..072cb7e 100644 --- a/src/config/settings.h +++ b/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_; } @@ -574,6 +580,7 @@ private: std::map 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= the daemon loads (multi-wallet) bool seed_migration_pending_ = false; From 03c1b63e032a022431aca2655c99b2fbf163902a Mon Sep 17 00:00:00 2001 From: DanS Date: Sun, 2 Aug 2026 14:53:58 -0500 Subject: [PATCH 15/89] fix(migrate): correct fund-adjacent migrate-to-seed bugs (W3-1, W3-2, W3-4) MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Migrate-to-seed (legacy -> mnemonic wallet) moves real funds; three correctness fixes: - W3-1 (High): beginAdoptSeedWallet swapped a hardcoded datadir/wallet.dat instead of the ACTIVE wallet file. With a non-default active wallet (e.g. wallet-2.dat) it installed the swept seed wallet into an unloaded wallet.dat and left the daemon reloading the emptied legacy wallet — swept funds only recoverable via the seed phrase. Now swaps datadir + "/" + getActiveWalletFile(), captured on the main thread (switching is blocked during migration, so no race). - W3-2 (High): SeedWalletCreator::create() ran remove_all(/seed-migrate) unconditionally at the start, so 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 blocked switching only 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). See docs/wallet-hardening.md. Co-Authored-By: Claude Opus 4.8 --- docs/wallet-hardening.md | 8 +++++++- src/app_network.cpp | 14 +++++++++++--- src/daemon/seed_wallet_creator.cpp | 10 ++++++++++ 3 files changed, 28 insertions(+), 4 deletions(-) diff --git a/docs/wallet-hardening.md b/docs/wallet-hardening.md index 18bedaf..8738ec1 100644 --- a/docs/wallet-hardening.md +++ b/docs/wallet-hardening.md @@ -18,7 +18,7 @@ Status legend: ☐ not started · ◐ in progress · ☑ landed & verified |-------|----------|-------|--------| | **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) | ☐ | +| **P1-A** | W3-1, W3-2, W3-4 ✓ · W3-3 ☐ | Migrate-to-seed correctness (fund-adjacent) | ◐ 3/4 | | **P1-B** | W1-1, W1-3, W1-2, W1-4 | Missing/wrong wallet-file safety | ☐ | | **P2** | W6-2, W5-1, W5-2, W6-1, W6-3 | Stale state & lite save-failure surfacing | ☐ | | **F** | W7-2, W7-3, W7-4, QoL | Diagnostics foundation + QoL bundle | ☐ | @@ -112,6 +112,12 @@ Land W7-2 first — it unblocks the rest. ## Progress log +- **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(/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. diff --git a/src/app_network.cpp b/src/app_network.cpp index 6370af4..e5d495b 100644 --- a/src/app_network.cpp +++ b/src/app_network.cpp @@ -1121,7 +1121,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; } @@ -4322,7 +4324,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) @@ -4342,7 +4350,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) diff --git a/src/daemon/seed_wallet_creator.cpp b/src/daemon/seed_wallet_creator.cpp index 8d3349b..504fbb9 100644 --- a/src/daemon/seed_wallet_creator.cpp +++ b/src/daemon/seed_wallet_creator.cpp @@ -54,6 +54,16 @@ SeedWalletResult SeedWalletCreator::create(bool keepDatadir, // RPC port. So the wallet lives in /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; } From de1ae736de8a642a54b258207faaeaf1c4007ac8 Mon Sep 17 00:00:00 2001 From: DanS Date: Sun, 2 Aug 2026 14:56:59 -0500 Subject: [PATCH 16/89] fix(wallet): guard against opening a missing/wrong wallet file (W1-1, W1-2, W1-4) MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit - W1-1 (High): switchToWallet never verified the target wallet file exists before switching. dragonxd auto-creates a fresh empty wallet for a missing -wallet=, so a moved/deleted wallet file silently "opened" as a brand-new empty wallet with a zero balance — looking exactly like fund loss. It now std::filesystem::exists-checks datadir/ before switching (ahead of the daemon-stop prompt) and blocks with a "not found (moved or deleted?)" warning. Because the check runs regardless of 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, which dragonxd also prints for DB_TOO_NEW (a newer-version wallet) — so a version mismatch was offered a -salvagewallet repair that cannot fix it. The generic match is now excluded when the output also contains "newer version". Build-clean; ctest 1/1. Remaining P1-B: W1-3 (syncedHere timing) + the startup-path existence check. See docs/wallet-hardening.md. Co-Authored-By: Claude Opus 4.8 --- docs/wallet-hardening.md | 6 +++++- src/app_network.cpp | 19 ++++++++++++++++++- 2 files changed, 23 insertions(+), 2 deletions(-) diff --git a/docs/wallet-hardening.md b/docs/wallet-hardening.md index 8738ec1..9715808 100644 --- a/docs/wallet-hardening.md +++ b/docs/wallet-hardening.md @@ -19,7 +19,7 @@ Status legend: ☐ not started · ◐ in progress · ☑ landed & verified | **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) | ◐ 3/4 | -| **P1-B** | W1-1, W1-3, W1-2, W1-4 | Missing/wrong wallet-file safety | ☐ | +| **P1-B** | W1-1, W1-2, W1-4 ✓ · W1-3 ☐ | Missing/wrong wallet-file safety | ◐ 3/4 | | **P2** | W6-2, W5-1, W5-2, W6-1, W6-3 | Stale state & lite save-failure surfacing | ☐ | | **F** | W7-2, W7-3, W7-4, QoL | Diagnostics foundation + QoL bundle | ☐ | @@ -112,6 +112,10 @@ Land W7-2 first — it unblocks the rest. ## Progress log +- **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(/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. diff --git a/src/app_network.cpp b/src/app_network.cpp index e5d495b..dd89e7a 100644 --- a/src/app_network.cpp +++ b/src/app_network.cpp @@ -197,10 +197,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() @@ -1135,6 +1139,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=, 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 From f9ddab059efd645e48ad2f535ad61ccdd8cf85ff Mon Sep 17 00:00:00 2001 From: DanS Date: Sun, 2 Aug 2026 15:18:09 -0500 Subject: [PATCH 17/89] fix(wallet): stamp syncedHere only after identity verified + guard the startup wallet file (W1-3) MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit - W1-3 (Med): updateWalletIndexForActiveWallet stamped syncedHere in the markOpened block at bare connect (idHash still empty), letting a freshly-restored wallet skip its needed rescan. syncedHere is now stamped only once the wallet's identity is verified (idHash non-empty), so it takes effect at the post-address-refresh index update; 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 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. Completes P1-B. Remaining P1: W3-3 (sweep opid persistence) deferred for careful adversarially-reviewed work — re-tracking a stale opid could hang the migration if the op poller doesn't time out; the existing balance/mined gates already prevent fund loss. See docs/wallet-hardening.md. Build-clean; ctest 1/1. Co-Authored-By: Claude Opus 4.8 --- docs/wallet-hardening.md | 9 +++++++-- src/app.cpp | 22 ++++++++++++++++++++++ src/app_network.cpp | 9 ++++++++- 3 files changed, 37 insertions(+), 3 deletions(-) diff --git a/docs/wallet-hardening.md b/docs/wallet-hardening.md index 9715808..4b71107 100644 --- a/docs/wallet-hardening.md +++ b/docs/wallet-hardening.md @@ -18,8 +18,8 @@ Status legend: ☐ not started · ◐ in progress · ☑ landed & verified |-------|----------|-------|--------| | **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) | ◐ 3/4 | -| **P1-B** | W1-1, W1-2, W1-4 ✓ · W1-3 ☐ | Missing/wrong wallet-file safety | ◐ 3/4 | +| **P1-A** | W3-1, W3-2, W3-4 ✓ · W3-3 ⚑ | Migrate-to-seed correctness (fund-adjacent) | ◐ 3/4 | +| **P1-B** | W1-1, W1-2, W1-3, W1-4 ✓ + startup guard | Missing/wrong wallet-file safety | ☑ | | **P2** | W6-2, W5-1, W5-2, W6-1, W6-3 | Stale state & lite save-failure surfacing | ☐ | | **F** | W7-2, W7-3, W7-4, QoL | Diagnostics foundation + QoL bundle | ☐ | @@ -112,6 +112,11 @@ Land W7-2 first — it unblocks the rest. ## Progress log +- **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)** — ⚑ **deferred for careful, adversarially-reviewed work** (not rushed). `trackOperation` only enqueues the opid for a background poller; a resume that re-tracks a persisted opid is only safe if the poller times out a *stale* opid (daemon restarted → op gone) rather than polling forever — otherwise a resume would hang the migration permanently, worse than today's re-sweep. Verifying that (and the double-sweep interactions) is exactly the "two rounds of adversarial review + a live mainnet run" the migration code mandates. The existing safety gates (adopt requires the legacy balance ~0 AND the sweep tx mined) already prevent fund *loss* on a mid-sweep interruption; W3-3 is a stuck-state robustness improvement, so it can wait for a dedicated pass. - **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". diff --git a/src/app.cpp b/src/app.cpp index 2ce31f1..666fdf0 100644 --- a/src/app.cpp +++ b/src/app.cpp @@ -341,6 +341,28 @@ bool App::init() // Ensure ObsidianDragon config directory and template files exist util::Platform::ensureObsidianDragonSetup(); + // W1-1 (startup): if the recorded active wallet file was moved/deleted between sessions, don't hand a + // missing -wallet= to the daemon — it would auto-create a fresh empty wallet under that name, + // silently "opening" as a zero-balance wallet at launch. Fall back to the always-present default and + // warn. (The default "wallet.dat" is legitimately absent on first run, so it is skipped.) Runs before + // the vault init below so the vault is scoped to the wallet actually opened. + if (settings_) { + const std::string active = settings_->getActiveWalletFile(); + if (!active.empty() && active != "wallet.dat") { + std::error_code walEc; + const std::string walPath = util::Platform::getDragonXDataDir() + "/" + active; + if (!std::filesystem::exists(walPath, walEc)) { + DEBUG_LOGF("[App] active wallet '%s' not found at startup — falling back to wallet.dat\n", + active.c_str()); + settings_->setActiveWalletFile("wallet.dat"); + settings_->save(); + ui::Notifications::instance().warning( + "Your last-used wallet file (" + active + ") was not found — opened the default wallet " + "instead. If you moved it, restore it and switch back from the wallet list.", 20.0f); + } + } + } + // Initialize PIN vault, scoped to the active wallet so one wallet's stored passphrase is never // offered for another (the default wallet keeps the legacy vault.dat). vault_ = std::make_unique(settings_ ? settings_->getActiveWalletFile() : ""); diff --git a/src/app_network.cpp b/src/app_network.cpp index dd89e7a..d8ccfa4 100644 --- a/src/app_network.cpp +++ b/src/app_network.cpp @@ -1096,9 +1096,16 @@ void App::updateWalletIndexForActiveWallet(bool markOpened) if (!ec) e.sizeBytesAtLastOpen = static_cast(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(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(); From 05b00b158ba1dfaffcf33bbcb2068e0baea0e7a0 Mon Sep 17 00:00:00 2001 From: DanS Date: Sun, 2 Aug 2026 15:22:13 -0500 Subject: [PATCH 18/89] fix(wallet): surface silent save failures + stale-state cleanups (W5-1, W5-2, W6-1, W6-3) MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit P2 robustness batch (localized): - W5-1 (Med, lite): persistAfterBroadcast returned false on a persistent post-send/shield save failure, but both callers discarded it and it never logged — completely silent. It now liteLogs the failure (the spent note re-derives on the next sync, so it's a robustness gap, not fund loss). - W5-2 (Med, lite): 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, so it's 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() cleared entries_ then threw on the first non-object array element — discarding EVERY contact. It now guards is_object() + per-entry try/catch, skipping and counting malformed entries. Build-clean; ctest 1/1. Remaining P2: W6-2 (refresh-staleness badge — needs UI, overlaps the diagnostics Foundation bundle). See docs/wallet-hardening.md. Co-Authored-By: Claude Opus 4.8 --- docs/wallet-hardening.md | 8 +++++++- src/data/address_book.cpp | 29 ++++++++++++++++----------- src/data/wallet_state.h | 4 ++++ src/wallet/lite_wallet_controller.cpp | 12 +++++++---- 4 files changed, 36 insertions(+), 17 deletions(-) diff --git a/docs/wallet-hardening.md b/docs/wallet-hardening.md index 4b71107..10f420e 100644 --- a/docs/wallet-hardening.md +++ b/docs/wallet-hardening.md @@ -20,7 +20,7 @@ Status legend: ☐ not started · ◐ in progress · ☑ landed & verified | **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) | ◐ 3/4 | | **P1-B** | W1-1, W1-2, W1-3, W1-4 ✓ + startup guard | Missing/wrong wallet-file safety | ☑ | -| **P2** | W6-2, W5-1, W5-2, W6-1, W6-3 | Stale state & lite save-failure surfacing | ☐ | +| **P2** | W5-1, W5-2, W6-1, W6-3 ✓ · W6-2 ☐ | Stale state & lite save-failure surfacing | ◐ 4/5 | | **F** | W7-2, W7-3, W7-4, QoL | Diagnostics foundation + QoL bundle | ☐ | --- @@ -112,6 +112,12 @@ Land W7-2 first — it unblocks the rest. ## Progress log +- **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. diff --git a/src/data/address_book.cpp b/src/data/address_book.cpp index ef2d2ea..9893406 100644 --- a/src/data/address_book.cpp +++ b/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()); diff --git a/src/data/wallet_state.h b/src/data/wallet_state.h index 1fefe45..6083343 100644 --- a/src/data/wallet_state.h +++ b/src/data/wallet_state.h @@ -335,6 +335,10 @@ 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{}; } // Rebuild combined addresses list from z/t lists diff --git a/src/wallet/lite_wallet_controller.cpp b/src/wallet/lite_wallet_controller.cpp index 960b6c2..6596f4e 100644 --- a/src/wallet/lite_wallet_controller.cpp +++ b/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; } @@ -600,7 +602,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 +634,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); }); From 207f9074db85899d6f3d6741cd48a2b3d923e624 Mon Sep 17 00:00:00 2001 From: DanS Date: Sun, 2 Aug 2026 15:31:23 -0500 Subject: [PATCH 19/89] feat(diagnostics): make the logging + crash infrastructure actually work (W7-2, W7-3, W7-4) MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit The Foundation tier — answers the original "make it easier to diagnose problems" ask. - W7-2 (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(/dragonx-debug.log) on every platform. 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 moved to a separate dragonx-stdout.log so the two writers don't contend on one file. Added testLoggerFileSink (also a deadlock guard — it would hang if the fix regressed). - W7-3: no crash handler existed on Linux/macOS. Added an async-signal-safe sigaction handler (SIGSEGV/ABRT/BUS/FPE/ILL) that writes the signal id + a 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: Logger::init now rotates the log to a single .1 backup past 10 MB, so a long or verbose session can't grow it unbounded. Build-clean; ctest 1/1. Remaining Foundation: the QoL bundle (mostly UI). See docs/wallet-hardening.md. Co-Authored-By: Claude Opus 4.8 --- docs/wallet-hardening.md | 7 +++- src/main.cpp | 85 ++++++++++++++++++++++++++++++++++++++-- src/util/logger.cpp | 26 ++++++++++-- tests/test_phase4.cpp | 29 ++++++++++++++ 4 files changed, 138 insertions(+), 9 deletions(-) diff --git a/docs/wallet-hardening.md b/docs/wallet-hardening.md index 10f420e..8d94fe2 100644 --- a/docs/wallet-hardening.md +++ b/docs/wallet-hardening.md @@ -21,7 +21,7 @@ Status legend: ☐ not started · ◐ in progress · ☑ landed & verified | **P1-A** | W3-1, W3-2, W3-4 ✓ · W3-3 ⚑ | Migrate-to-seed correctness (fund-adjacent) | ◐ 3/4 | | **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 | ◐ 4/5 | -| **F** | W7-2, W7-3, W7-4, QoL | Diagnostics foundation + QoL bundle | ☐ | +| **F** | W7-2, W7-3, W7-4 ✓ · QoL ☐ | Diagnostics foundation + QoL bundle | ◐ infra done | --- @@ -112,6 +112,11 @@ Land W7-2 first — it unblocks the rest. ## Progress log +- **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(/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). diff --git a/src/main.cpp b/src/main.cpp index 68af202..acfe29a 100644 --- a/src/main.cpp +++ b/src/main.cpp @@ -721,6 +721,63 @@ static void handleDisplayScaleChange(SDL_Window* window, float newScale, } } +#if !defined(_WIN32) +#include +#include +#include +#include +#if defined(__has_include) +# if __has_include() +# include +# 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) @@ -738,11 +795,31 @@ int main(int argc, char* argv[]) } } -#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); } diff --git a/src/util/logger.cpp b/src/util/logger.cpp index a912767..ba7b493 100644 --- a/src/util/logger.cpp +++ b/src/util/logger.cpp @@ -5,10 +5,12 @@ #include "logger.h" #include +#include #include #include #include #include +#include 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_; } diff --git a/tests/test_phase4.cpp b/tests/test_phase4.cpp index 1f784a7..2fe7757 100644 --- a/tests/test_phase4.cpp +++ b/tests/test_phase4.cpp @@ -5,6 +5,7 @@ #include "daemon/daemon_controller.h" #include "daemon/embedded_daemon.h" #include "util/connect_stall.h" +#include "util/logger.h" #include "data/transaction_history_cache.h" #include "data/address_book.h" #include "data/wallet_index.h" @@ -2546,6 +2547,33 @@ void testConsoleSecretRedaction() EXPECT_EQ(RedactConsoleCommand("getwalletinfo"), std::string("getwalletinfo")); } +void testLoggerFileSink() +{ + using dragonx::util::Logger; + namespace fsn = std::filesystem; + fsn::path logPath = fsn::temp_directory_path() / "od_logger_test.log"; + std::error_code ec; + fsn::remove(logPath, ec); + fsn::remove(logPath.string() + ".1", ec); + + // W7-2: init() opens the file sink and must NOT deadlock — it writes the banner under the same + // non-recursive lock it holds (this test would hang if that regressed). + Logger& lg = Logger::instance(); + EXPECT_TRUE(lg.init(logPath.string())); + lg.write("hello-w7-2-sink"); + EXPECT_TRUE(fsn::exists(logPath)); + + std::ifstream f(logPath.string()); + std::string all, line; + while (std::getline(f, line)) all += line + "\n"; + f.close(); + EXPECT_TRUE(all.find("hello-w7-2-sink") != std::string::npos); + EXPECT_TRUE(all.find("Logger initialized") != std::string::npos); + + fsn::remove(logPath, ec); + fsn::remove(logPath.string() + ".1", ec); +} + void testConnectHasStalled() { using dragonx::util::connectHasStalled; @@ -6906,6 +6934,7 @@ int main() testIsLocalHost(); testAllowsPlaintextRemote(); testConsoleSecretRedaction(); + testLoggerFileSink(); testDaemonLifecycleExecution(); testDaemonLifecycleAdapters(); testConsoleTextLayout(); From 940dd21464b0bf3a3fa4cad3560cfa699b1869c5 Mon Sep 17 00:00:00 2001 From: DanS Date: Sun, 2 Aug 2026 15:37:52 -0500 Subject: [PATCH 20/89] feat(diagnostics): add "Copy diagnostics" + "Open log folder" actions (Foundation QoL) MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Settings (logging section) gains two support-friendly actions, now that the logging foundation actually produces logs (W7-2): - Open log folder: opens the config dir (Platform::openFolder) so users can 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, and (full- node) daemon status/running/crash-count/lastError, plus 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. See docs/wallet-hardening.md. Co-Authored-By: Claude Opus 4.8 --- docs/wallet-hardening.md | 3 +- src/app.cpp | 57 ++++++++++++++++++++++++++++++++++ src/app.h | 4 +++ src/ui/pages/settings_page.cpp | 15 +++++++++ src/util/i18n.cpp | 5 +++ 5 files changed, 83 insertions(+), 1 deletion(-) diff --git a/docs/wallet-hardening.md b/docs/wallet-hardening.md index 8d94fe2..dceb8d5 100644 --- a/docs/wallet-hardening.md +++ b/docs/wallet-hardening.md @@ -21,7 +21,7 @@ Status legend: ☐ not started · ◐ in progress · ☑ landed & verified | **P1-A** | W3-1, W3-2, W3-4 ✓ · W3-3 ⚑ | Migrate-to-seed correctness (fund-adjacent) | ◐ 3/4 | | **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 | ◐ 4/5 | -| **F** | W7-2, W7-3, W7-4 ✓ · QoL ☐ | Diagnostics foundation + QoL bundle | ◐ infra done | +| **F** | W7-2, W7-3, W7-4 ✓ · QoL: copy-diag + open-log ✓, alert-history/error-banner/staleness ☐ | Diagnostics foundation + QoL bundle | ◐ | --- @@ -112,6 +112,7 @@ Land W7-2 first — it unblocks the rest. ## Progress log +- **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(/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. diff --git a/src/app.cpp b/src/app.cpp index 666fdf0..ad7201d 100644 --- a/src/app.cpp +++ b/src/app.cpp @@ -105,6 +105,7 @@ #include #include #include +#include #include #include #include @@ -5658,6 +5659,62 @@ void App::maybeFinishTransactionSendProgress() if (addresses_dirty_ || network_refresh_.jobInProgress(Job::Addresses)) return; send_progress_active_ = false; } +std::string App::buildDiagnosticsReport() +{ + std::ostringstream os; + os << "=== ObsidianDragon diagnostics ===\n"; + os << "version: " << DRAGONX_VERSION << "\n"; +#if DRAGONX_LITE_BUILD + os << "variant: Lite\n"; +#else + os << "variant: Full-node\n"; +#endif +#if defined(_WIN32) + os << "platform: windows\n"; +#elif defined(__APPLE__) + os << "platform: macos\n"; +#else + os << "platform: linux\n"; +#endif + os << "connected: " << (state_.connected ? "yes" : "no") << "\n"; + os << "status: " << connection_status_ << "\n"; + + const std::string activeWallet = settings_ ? settings_->getActiveWalletFile() : std::string("(none)"); + os << "active wallet: " << activeWallet << "\n"; + { + std::error_code ec; + const std::string wp = util::Platform::getDragonXDataDir() + "/" + activeWallet; + const bool present = std::filesystem::exists(wp, ec); + os << " path: " << wp << (present ? " [present" : " [MISSING"); + if (present) { auto sz = std::filesystem::file_size(wp, ec); if (!ec) os << ", " << sz << " bytes"; } + os << "]\n"; + } + os << "encryption: " + << (state_.encryption_state_known + ? (state_.encrypted ? (state_.locked ? "encrypted, locked" : "encrypted, unlocked") : "unencrypted") + : "unknown") + << "\n"; + os << "sync: block " << state_.sync.blocks << " / " << state_.sync.headers + << (state_.sync.syncing ? " (syncing)" : "") + << (state_.warming_up ? " (warming up)" : "") << "\n"; + +#if !DRAGONX_LITE_BUILD + os << "daemon status: " << daemon_status_ << "\n"; + if (daemon_controller_) { + os << "daemon running: " << (daemon_controller_->isRunning() ? "yes" : "no") + << ", crashes: " << daemon_controller_->crashCount() << "\n"; + const std::string derr = daemon_controller_->lastError(); + if (!derr.empty()) os << "daemon lastError: " << derr << "\n"; + } +#endif + + const std::string cfg = util::Platform::getObsidianDragonDir(); + os << "log folder: " << cfg << "\n"; + os << " " << cfg << "/dragonx-debug.log\n"; + os << " " << cfg << "/dragonx-crash.log\n"; + return os.str(); +} + void App::restartDaemon() { if (!supportsFullNodeLifecycleActions()) { diff --git a/src/app.h b/src/app.h index d0a65a2..98c2c00 100644 --- a/src/app.h +++ b/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()); } diff --git a/src/ui/pages/settings_page.cpp b/src/ui/pages/settings_page.cpp index 7283f24..d4d3dca 100644 --- a/src/ui/pages/settings_page.cpp +++ b/src/ui/pages/settings_page.cpp @@ -1351,6 +1351,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... --- diff --git a/src/util/i18n.cpp b/src/util/i18n.cpp index 52193ee..656aadc 100644 --- a/src/util/i18n.cpp +++ b/src/util/i18n.cpp @@ -1322,6 +1322,11 @@ void I18n::loadBuiltinEnglish() 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"; From e779ded2e88c66a9d312df74f1aa27d5f2871281 Mon Sep 17 00:00:00 2001 From: DanS Date: Sun, 2 Aug 2026 20:21:05 -0500 Subject: [PATCH 21/89] feat(diagnostics): persistent node/RPC error banner at top of content (Foundation QoL) MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit A persistent horizontal strip now appears at the top of the content column whenever the wallet can't reach its node — unlike the transient toasts it stays up for as long as the fault persists, so an offline wallet is never silently mistaken for a working one. The show/severity/action decision is a pure, unit-tested function (ui/node_status_banner.h::evaluateNodeStatusBanner) fed a state snapshot by the new App::renderNodeStatusBanner(). Three cases: - full-node offline -> amber, "Reconnect" (App::tryConnect) - embedded daemon crashed & auto-restart gave up -> red, "Restart node" (App::restartDaemon) - lite wallet open failed -> 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. Banner height lives in res/themes/ui.toml (banners.node-status); colours come from the material semantic palette; the detail text is ellipsis-clipped so it can't push the action button off-screen. Drawn before the content edge-fade vertex capture so it stays fully opaque. New i18n keys (node_banner_*). Build-clean both variants; ctest 1/1 (adds testNodeStatusBanner). Co-Authored-By: Claude Opus 4.8 --- docs/wallet-hardening.md | 3 +- res/themes/ui.toml | 6 ++ src/app.cpp | 141 ++++++++++++++++++++++++++++++++++++ src/app.h | 4 + src/ui/node_status_banner.h | 111 ++++++++++++++++++++++++++++ src/util/i18n.cpp | 6 ++ tests/test_phase4.cpp | 77 ++++++++++++++++++++ 7 files changed, 347 insertions(+), 1 deletion(-) create mode 100644 src/ui/node_status_banner.h diff --git a/docs/wallet-hardening.md b/docs/wallet-hardening.md index dceb8d5..84f5631 100644 --- a/docs/wallet-hardening.md +++ b/docs/wallet-hardening.md @@ -21,7 +21,7 @@ Status legend: ☐ not started · ◐ in progress · ☑ landed & verified | **P1-A** | W3-1, W3-2, W3-4 ✓ · W3-3 ⚑ | Migrate-to-seed correctness (fund-adjacent) | ◐ 3/4 | | **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 | ◐ 4/5 | -| **F** | W7-2, W7-3, W7-4 ✓ · QoL: copy-diag + open-log ✓, alert-history/error-banner/staleness ☐ | Diagnostics foundation + QoL bundle | ◐ | +| **F** | W7-2, W7-3, W7-4 ✓ · QoL: copy-diag + open-log + node-error-banner ✓, alert-history/staleness ☐ | Diagnostics foundation + QoL bundle | ◐ | --- @@ -112,6 +112,7 @@ Land W7-2 first — it unblocks the rest. ## Progress log +- **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(/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). diff --git a/res/themes/ui.toml b/res/themes/ui.toml index 192802a..ef6cbee 100644 --- a/res/themes/ui.toml +++ b/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 diff --git a/src/app.cpp b/src/app.cpp index ad7201d..00e6e95 100644 --- a/src/app.cpp +++ b/src/app.cpp @@ -68,6 +68,7 @@ #include "ui/material/draw_helpers.h" #include "ui/widgets/copy_field.h" #include "ui/notifications.h" +#include "ui/node_status_banner.h" #include "util/i18n.h" #include "util/connect_stall.h" #include "util/platform.h" @@ -1794,6 +1795,11 @@ void App::render() ImGui::BeginChild("##ContentArea", ImVec2(0, contentH), false, contentFlags); + // Persistent node/RPC error banner — drawn first (before the edge-fade vertex capture below, + // so it stays fully opaque) and above every page / overlay in the content column. It renders + // nothing and consumes no space while the node is reachable. + renderNodeStatusBanner(); + // Capture vertex start for edge fade mask ImDrawList* caDL = ImGui::GetWindowDrawList(); int caVtxStart = caDL->VtxBuffer.Size; @@ -2142,6 +2148,141 @@ void App::render() ui::material::LatchBlurOverlayActive(); } +void App::renderNodeStatusBanner() +{ + namespace m = ui::material; + + // Suppress during flows that legitimately have no connection, so the banner never contradicts + // an overlay the app is already showing: the first-run wizard (no daemon started yet), a + // wallet switch, an in-flight daemon restart, the screenshot sweep (forces demo state), and + // shutdown. tryConnect() sets connection_in_progress_ before the first render on normal + // startup, so the ordinary boot path is covered by the evaluator's own in-progress guard. + if (capture_mode_ || isShuttingDown()) return; + if (getWizardPhase() != WizardPhase::None) return; + if (wallet_switch_phase_.load() != 0) return; + if (daemon_restarting_.load()) return; + + ui::NodeBannerInputs in; + in.lite = isLiteBuild(); + in.connected = state_.connected; + in.warming_up = state_.warming_up; + in.daemon_initializing = state_.daemon_initializing; + in.connection_in_progress = connection_in_progress_; + in.using_embedded_daemon = isUsingEmbeddedDaemon(); + in.has_daemon_controller = (daemon_controller_ != nullptr); + in.daemon_running = isEmbeddedDaemonRunning(); + in.daemon_crash_count = daemon_controller_ ? daemon_controller_->crashCount() : 0; + in.connection_status = connection_status_; + in.daemon_last_error = daemon_controller_ ? daemon_controller_->lastError() : std::string(); + in.lite_open_error = lite_open_error_; + + const ui::NodeBannerState banner = ui::evaluateNodeStatusBanner(in); + if (!banner.show) return; + + const auto& S = ui::schema::UI(); + const float minH = S.drawElement("banners.node-status", "min-height").size; + const float baseH = S.drawElement("banners.node-status", "height").size; + const float bannerH = std::max(minH, baseH * ui::Layout::vScale()); + + const bool isError = (banner.severity == ui::NodeBannerSeverity::Error); + const ImU32 sevCol = isError ? m::Error() : m::Warning(); + const ImU32 bgCol = m::WithAlphaF(sevCol, isError ? 0.20f : 0.15f); + + // Translated headline for the reason; `detail` is the live status text (may be empty). + const char* title; + const char* icon; + switch (banner.reason) { + case ui::NodeBannerReason::DaemonCrashed: + title = TR("node_banner_crashed_title"); icon = ICON_MD_ERROR; break; + case ui::NodeBannerReason::LiteOpenFailed: + title = TR("node_banner_lite_open_failed"); icon = ICON_MD_ERROR; break; + case ui::NodeBannerReason::FullNodeOffline: + default: + title = TR("node_banner_offline_title"); icon = ICON_MD_CLOUD_OFF; break; + } + + const char* actionLabel = nullptr; + if (banner.action == ui::NodeBannerAction::Reconnect) actionLabel = TR("node_banner_reconnect"); + else if (banner.action == ui::NodeBannerAction::RestartNode) actionLabel = TR("node_banner_restart"); + + const float padX = ui::Layout::spacingLg(); + + ImGui::PushStyleColor(ImGuiCol_ChildBg, ImGui::ColorConvertU32ToFloat4(bgCol)); + ImGui::BeginChild("##NodeStatusBanner", + ImVec2(ImGui::GetContentRegionAvail().x, bannerH), false, + ImGuiWindowFlags_NoScrollbar | ImGuiWindowFlags_NoScrollWithMouse); + const float winW = ImGui::GetWindowSize().x; + + ImFont* icoFont = m::Type().iconSmall(); + ImFont* txtFont = m::Type().body2(); + + // Icon — centered on its own metrics. + ImGui::SetCursorPos(ImVec2(padX, (bannerH - icoFont->LegacySize) * 0.5f)); + ImGui::PushFont(icoFont); + ImGui::PushStyleColor(ImGuiCol_Text, sevCol); + ImGui::TextUnformatted(icon); + ImGui::PopStyleColor(); + ImGui::PopFont(); + + const float txtCy = (bannerH - txtFont->LegacySize) * 0.5f; + + // Right-aligned action button geometry (measured first so the detail text can be clipped to + // never run underneath it). + float btnW = 0.0f, btnH = 0.0f, actionReserve = 0.0f; + if (actionLabel) { + btnH = std::max(0.0f, bannerH - ui::Layout::spacingSm() * 2.0f); + btnW = ImGui::CalcTextSize(actionLabel).x + ui::Layout::spacingLg() * 1.6f; + actionReserve = btnW + padX + ui::Layout::spacingMd(); + } + + // Title. + ImGui::SameLine(0.0f, ui::Layout::spacingSm()); + ImGui::SetCursorPosY(txtCy); + ImGui::PushFont(txtFont); + ImGui::PushStyleColor(ImGuiCol_Text, sevCol); + ImGui::TextUnformatted(title); + ImGui::PopStyleColor(); + + // Detail (dim) on the same row, clipped with an ellipsis so it can't push the button off-screen. + if (!banner.detail.empty()) { + ImGui::SameLine(0.0f, ui::Layout::spacingSm()); + ImGui::SetCursorPosY(txtCy); + const float budget = winW - ImGui::GetCursorPosX() - actionReserve; + if (budget > ImGui::CalcTextSize("W").x) { + const std::string prefix = "\xC2\xB7 "; // "· " + std::string detail = banner.detail; + std::string shown = prefix + detail; + if (ImGui::CalcTextSize(shown.c_str()).x > budget) { + const std::string ell = "\xE2\x80\xA6"; // "…" + while (!detail.empty() && + ImGui::CalcTextSize((prefix + detail + ell).c_str()).x > budget) { + detail.pop_back(); + while (!detail.empty() && + (static_cast(detail.back()) & 0xC0) == 0x80) + detail.pop_back(); // drop the whole trailing UTF-8 code point + } + shown = prefix + detail + ell; + } + ImGui::PushStyleColor(ImGuiCol_Text, m::OnSurfaceMedium()); + ImGui::TextUnformatted(shown.c_str()); + ImGui::PopStyleColor(); + } + } + ImGui::PopFont(); + + // Action button. + if (actionLabel) { + ImGui::SetCursorPos(ImVec2(winW - btnW - padX, (bannerH - btnH) * 0.5f)); + if (m::TactileButton(actionLabel, ImVec2(btnW, btnH))) { + if (banner.action == ui::NodeBannerAction::RestartNode) restartDaemon(); + else if (banner.action == ui::NodeBannerAction::Reconnect) tryConnect(); + } + } + + ImGui::EndChild(); + ImGui::PopStyleColor(); +} + void App::renderStatusBar() { // Status bar layout from unified UI schema diff --git a/src/app.h b/src/app.h index 98c2c00..f45663e 100644 --- a/src/app.h +++ b/src/app.h @@ -1295,6 +1295,10 @@ 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(); void renderLiteFirstRunPrompt(); // lite-only welcome modal when no wallet exists yet void renderLiteUnlockPrompt(); // lite-only send-time unlock modal void renderImportKeyDialog(); diff --git a/src/ui/node_status_banner.h b/src/ui/node_status_banner.h new file mode 100644 index 0000000..6233e5e --- /dev/null +++ b/src/ui/node_status_banner.h @@ -0,0 +1,111 @@ +#pragma once + +#include + +// 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 diff --git a/src/util/i18n.cpp b/src/util/i18n.cpp index 656aadc..08918da 100644 --- a/src/util/i18n.cpp +++ b/src/util/i18n.cpp @@ -1309,6 +1309,12 @@ 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"; + // 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"; 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 " diff --git a/tests/test_phase4.cpp b/tests/test_phase4.cpp index 2fe7757..dac09ff 100644 --- a/tests/test_phase4.cpp +++ b/tests/test_phase4.cpp @@ -32,6 +32,7 @@ #include "ui/windows/mining_benchmark.h" #include "ui/windows/mining_pool_panel.h" #include "ui/windows/mining_tab_helpers.h" +#include "ui/node_status_banner.h" #include "util/address_validation.h" #include "util/amount_format.h" #include "util/payment_uri.h" @@ -2547,6 +2548,81 @@ void testConsoleSecretRedaction() EXPECT_EQ(RedactConsoleCommand("getwalletinfo"), std::string("getwalletinfo")); } +void testNodeStatusBanner() +{ + using namespace dragonx::ui; + + // Connected full node → no banner. + { + NodeBannerInputs in; in.connected = true; + EXPECT_TRUE(!evaluateNodeStatusBanner(in).show); + } + // Expected startup phases own the screen (loading/warmup overlay) → no banner. + { + NodeBannerInputs in; in.warming_up = true; + EXPECT_TRUE(!evaluateNodeStatusBanner(in).show); + NodeBannerInputs in2; in2.daemon_initializing = true; + EXPECT_TRUE(!evaluateNodeStatusBanner(in2).show); + NodeBannerInputs in3; in3.connection_in_progress = true; + EXPECT_TRUE(!evaluateNodeStatusBanner(in3).show); + } + // Genuinely offline full node → amber, reconnect offered, detail passed through. + { + NodeBannerInputs in; + in.connection_status = "Lost connection to daemon"; + NodeBannerState s = evaluateNodeStatusBanner(in); + EXPECT_TRUE(s.show); + EXPECT_TRUE(s.severity == NodeBannerSeverity::Warning); + EXPECT_TRUE(s.reason == NodeBannerReason::FullNodeOffline); + EXPECT_TRUE(s.action == NodeBannerAction::Reconnect); + EXPECT_EQ(s.detail, std::string("Lost connection to daemon")); + } + // Embedded daemon crashed and auto-restart gave up → red, restart offered, lastError preferred. + { + NodeBannerInputs in; + in.using_embedded_daemon = true; + in.has_daemon_controller = true; + in.daemon_running = false; + in.daemon_crash_count = kNodeBannerCrashGiveUpCount; + in.daemon_last_error = "exit code 134"; + in.connection_status = "Daemon crashed 3 times"; + NodeBannerState s = evaluateNodeStatusBanner(in); + EXPECT_TRUE(s.show); + EXPECT_TRUE(s.severity == NodeBannerSeverity::Error); + EXPECT_TRUE(s.reason == NodeBannerReason::DaemonCrashed); + EXPECT_TRUE(s.action == NodeBannerAction::RestartNode); + EXPECT_EQ(s.detail, std::string("exit code 134")); + } + // Below the give-up threshold it's still just an offline/reconnect banner, not the crash one. + { + NodeBannerInputs in; + in.using_embedded_daemon = true; + in.has_daemon_controller = true; + in.daemon_running = false; + in.daemon_crash_count = kNodeBannerCrashGiveUpCount - 1; + NodeBannerState s = evaluateNodeStatusBanner(in); + EXPECT_TRUE(s.show); + EXPECT_TRUE(s.reason == NodeBannerReason::FullNodeOffline); + EXPECT_TRUE(s.action == NodeBannerAction::Reconnect); + } + // Lite: an open failure shows a red, action-less banner; no failure → nothing. + { + NodeBannerInputs in; in.lite = true; in.connected = false; + in.lite_open_error = "wallet.dat is corrupt"; + NodeBannerState s = evaluateNodeStatusBanner(in); + EXPECT_TRUE(s.show); + EXPECT_TRUE(s.severity == NodeBannerSeverity::Error); + EXPECT_TRUE(s.reason == NodeBannerReason::LiteOpenFailed); + EXPECT_TRUE(s.action == NodeBannerAction::None); + EXPECT_EQ(s.detail, std::string("wallet.dat is corrupt")); + + NodeBannerInputs clean; clean.lite = true; clean.connected = false; // no error yet + EXPECT_TRUE(!evaluateNodeStatusBanner(clean).show); + NodeBannerInputs open; open.lite = true; open.connected = true; + EXPECT_TRUE(!evaluateNodeStatusBanner(open).show); + } +} + void testLoggerFileSink() { using dragonx::util::Logger; @@ -6934,6 +7010,7 @@ int main() testIsLocalHost(); testAllowsPlaintextRemote(); testConsoleSecretRedaction(); + testNodeStatusBanner(); testLoggerFileSink(); testDaemonLifecycleExecution(); testDaemonLifecycleAdapters(); From c7c3440a7bcd1177d8338f9bacf8283a1f5b51d8 Mon Sep 17 00:00:00 2001 From: DanS Date: Sun, 2 Aug 2026 20:48:56 -0500 Subject: [PATCH 22/89] feat(diagnostics): refresh-staleness badge on the Total Balance card (W6-2) MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit When the wallet is connected but the balance has quietly stopped refreshing — a busy daemon can fail z_gettotalbalance without dropping the whole connection (only *both* core RPCs failing 3x triggers a disconnect) — the old number sits on screen while the node-status banner stays hidden. The Total Balance card now shows a small pill on its status line ("Updated 2m ago", amber, escalating to red past 3 min) so the stale value isn't silently trusted; hovering explains it and points at the node connection. No refresh-path changes: WalletState::last_balance_update is already stamped only on a successful fetch (network_refresh_service.cpp), so the badge reads it and computes age against the same std::time clock via util::formatTimeAgoShort. The decision is a pure, unit-tested helper (ui/staleness_badge.h::evaluateStalenessBadge, 45s/180s thresholds) gated on connected so it never contradicts the banner. Closes P2 (5/5). Build-clean; ctest 1/1 (adds testStalenessBadge). Co-Authored-By: Claude Opus 4.8 --- docs/wallet-hardening.md | 5 ++-- src/ui/staleness_badge.h | 48 ++++++++++++++++++++++++++++++++++ src/ui/windows/balance_tab.cpp | 20 ++++++++++++++ src/util/i18n.cpp | 5 ++++ tests/test_phase4.cpp | 33 +++++++++++++++++++++++ 5 files changed, 109 insertions(+), 2 deletions(-) create mode 100644 src/ui/staleness_badge.h diff --git a/docs/wallet-hardening.md b/docs/wallet-hardening.md index 84f5631..790bad1 100644 --- a/docs/wallet-hardening.md +++ b/docs/wallet-hardening.md @@ -20,8 +20,8 @@ Status legend: ☐ not started · ◐ in progress · ☑ landed & verified | **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) | ◐ 3/4 | | **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 | ◐ 4/5 | -| **F** | W7-2, W7-3, W7-4 ✓ · QoL: copy-diag + open-log + node-error-banner ✓, alert-history/staleness ☐ | Diagnostics foundation + QoL bundle | ◐ | +| **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 | ◐ | --- @@ -112,6 +112,7 @@ Land W7-2 first — it unblocks the rest. ## Progress log +- **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): diff --git a/src/ui/staleness_badge.h b/src/ui/staleness_badge.h new file mode 100644 index 0000000..5e01a34 --- /dev/null +++ b/src/ui/staleness_badge.h @@ -0,0 +1,48 @@ +#pragma once + +#include + +// 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 diff --git a/src/ui/windows/balance_tab.cpp b/src/ui/windows/balance_tab.cpp index 46c8aa6..1e07228 100644 --- a/src/ui/windows/balance_tab.cpp +++ b/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 @@ -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 diff --git a/src/util/i18n.cpp b/src/util/i18n.cpp index 08918da..e640503 100644 --- a/src/util/i18n.cpp +++ b/src/util/i18n.cpp @@ -1315,6 +1315,11 @@ void I18n::loadBuiltinEnglish() 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."; 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 " diff --git a/tests/test_phase4.cpp b/tests/test_phase4.cpp index dac09ff..421d818 100644 --- a/tests/test_phase4.cpp +++ b/tests/test_phase4.cpp @@ -33,6 +33,7 @@ #include "ui/windows/mining_pool_panel.h" #include "ui/windows/mining_tab_helpers.h" #include "ui/node_status_banner.h" +#include "ui/staleness_badge.h" #include "util/address_validation.h" #include "util/amount_format.h" #include "util/payment_uri.h" @@ -2623,6 +2624,37 @@ void testNodeStatusBanner() } } +void testStalenessBadge() +{ + using namespace dragonx::ui; + const int64_t now = 1'000'000; + + // Disconnected → banner's job, never a badge. + EXPECT_TRUE(!evaluateStalenessBadge(now - 999, now, /*connected=*/false).show); + // Never updated this session (0 stamp, e.g. fresh start / reset on disconnect) → nothing. + EXPECT_TRUE(!evaluateStalenessBadge(0, now, true).show); + // Fresh (just under the threshold) → no badge. + EXPECT_TRUE(!evaluateStalenessBadge(now - (kStaleAfterSeconds - 1), now, true).show); + // At the threshold → amber badge, age reported. + { + StalenessBadge b = evaluateStalenessBadge(now - kStaleAfterSeconds, now, true); + EXPECT_TRUE(b.show); + EXPECT_TRUE(b.severity == StalenessSeverity::Warning); + EXPECT_EQ(b.seconds_old, (int64_t)kStaleAfterSeconds); + } + // Past the very-stale threshold → red. + { + StalenessBadge b = evaluateStalenessBadge(now - kVeryStaleAfterSeconds, now, true); + EXPECT_TRUE(b.show); + EXPECT_TRUE(b.severity == StalenessSeverity::Error); + } + // Clock skew (future timestamp) is clamped to age 0 → no badge, no negative age. + { + StalenessBadge b = evaluateStalenessBadge(now + 100, now, true); + EXPECT_TRUE(!b.show); + } +} + void testLoggerFileSink() { using dragonx::util::Logger; @@ -7011,6 +7043,7 @@ int main() testAllowsPlaintextRemote(); testConsoleSecretRedaction(); testNodeStatusBanner(); + testStalenessBadge(); testLoggerFileSink(); testDaemonLifecycleExecution(); testDaemonLifecycleAdapters(); From 4b3f0fa92bc1547507b82abdaf108ead2861b573 Mon Sep 17 00:00:00 2001 From: DanS Date: Sun, 2 Aug 2026 20:57:02 -0500 Subject: [PATCH 23/89] feat(diagnostics): persistent alert history with a status-bar bell (Foundation QoL) MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Toasts fade in 1-4s, so anything that scrolled past was gone. 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 opens an upward popup listing recent alerts newest-first: 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 note: every push is on the UI thread (RPC results run as main-thread MainCb callbacks), matching this class's existing lock-free model; documented as a no-raw-worker-thread invariant. New i18n keys (alerts_*). Build-clean; ctest 1/1 (adds testNotificationHistory: retention, order, cap, monotonic counter, clear). Closes the QoL bundle and the Foundation tier. Co-Authored-By: Claude Opus 4.8 --- docs/wallet-hardening.md | 3 +- src/app.cpp | 155 +++++++++++++++++++++++++++++++++++++++ src/app.h | 4 + src/ui/notifications.h | 46 ++++++++++-- src/util/i18n.cpp | 5 ++ tests/test_phase4.cpp | 33 +++++++++ 6 files changed, 239 insertions(+), 7 deletions(-) diff --git a/docs/wallet-hardening.md b/docs/wallet-hardening.md index 790bad1..a63dae3 100644 --- a/docs/wallet-hardening.md +++ b/docs/wallet-hardening.md @@ -21,7 +21,7 @@ Status legend: ☐ not started · ◐ in progress · ☑ landed & verified | **P1-A** | W3-1, W3-2, W3-4 ✓ · W3-3 ⚑ | Migrate-to-seed correctness (fund-adjacent) | ◐ 3/4 | | **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 | ◐ | +| **F** | W7-2, W7-3, W7-4 ✓ · QoL: copy-diag + open-log + node-error-banner + staleness-badge + alert-history ✓ | Diagnostics foundation + QoL bundle | ☑ | --- @@ -112,6 +112,7 @@ Land W7-2 first — it unblocks the rest. ## Progress log +- **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. diff --git a/src/app.cpp b/src/app.cpp index 00e6e95..38adc88 100644 --- a/src/app.cpp +++ b/src/app.cpp @@ -2283,6 +2283,92 @@ void App::renderNodeStatusBanner() ImGui::PopStyleColor(); } +void App::renderAlertHistoryPanel() +{ + namespace m = ui::material; + const float dp = ui::Layout::dpiScale(); + auto& notes = ui::Notifications::instance(); + const auto& hist = notes.history(); + const float innerW = ImGui::GetContentRegionAvail().x; + const float padX = 8.0f * dp; + + ImFont* icoF = m::Type().iconSmall(); + ImFont* txtF = m::Type().caption(); + + // Header: "Recent alerts" on the left, a Clear-all icon button on the right. + ImGui::SetCursorPosX(padX); + ImGui::PushFont(txtF); + ImGui::TextDisabled("%s", TR("alerts_recent")); + ImGui::PopFont(); + if (!hist.empty()) { + const float clrW = icoF->LegacySize + 8.0f * dp; + ImGui::SameLine(); + ImGui::SetCursorPosX(innerW - clrW); + m::IconButtonStyle cst; + cst.color = m::OnSurfaceMedium(); + cst.hoverColor = m::OnSurface(); + cst.hoverBg = m::StateHover(); + cst.bgRounding = 4.0f * dp; + cst.tooltip = TR("alerts_clear"); + if (m::IconButton("##ClearAlerts", ICON_MD_CLEAR_ALL, icoF, + ImVec2(clrW, icoF->LegacySize + 4.0f * dp), cst)) { + notes.clearHistory(); + alerts_seen_total_ = notes.totalPushed(); + } + } + ImGui::Separator(); + + if (hist.empty()) { + ImGui::SetCursorPosX(padX); + ImGui::PushFont(txtF); + ImGui::TextDisabled("%s", TR("alerts_none")); + ImGui::PopFont(); + return; + } + + // Scrollable list, newest first. Height adapts to the entry count but caps so a busy session + // scrolls inside the panel instead of blowing past the popup's max height. + const float perEntry = txtF->LegacySize * 2.0f + 14.0f * dp; // message line + time line + spacing + const float listH = std::min(300.0f * dp, static_cast(hist.size()) * perEntry); + ImGui::BeginChild("##AlertRows", ImVec2(0, listH), false); + int idx = 0; + for (auto it = hist.rbegin(); it != hist.rend(); ++it, ++idx) { + const ui::AlertRecord& a = *it; + ImU32 col; const char* icon; + switch (a.type) { + case ui::NotificationType::Success: col = m::Success(); icon = ICON_MD_CHECK_CIRCLE; break; + case ui::NotificationType::Warning: col = m::Warning(); icon = ICON_MD_WARNING; break; + case ui::NotificationType::Error: col = m::Error(); icon = ICON_MD_ERROR; break; + case ui::NotificationType::Info: + default: col = m::Primary(); icon = ICON_MD_INFO; break; + } + ImGui::PushID(idx); + // Icon + message (message wraps in the remaining width). + ImGui::SetCursorPosX(padX); + ImGui::PushFont(icoF); + ImGui::PushStyleColor(ImGuiCol_Text, col); + ImGui::TextUnformatted(icon); + ImGui::PopStyleColor(); + ImGui::PopFont(); + ImGui::SameLine(0.0f, 6.0f * dp); + ImGui::PushFont(txtF); + ImGui::PushStyleColor(ImGuiCol_Text, m::OnSurface()); + ImGui::PushTextWrapPos(innerW - padX); + ImGui::TextWrapped("%s", a.message.c_str()); + ImGui::PopTextWrapPos(); + ImGui::PopStyleColor(); + // Relative age, dim, indented under the message. + ImGui::SetCursorPosX(padX + icoF->LegacySize + 6.0f * dp); + ImGui::PushStyleColor(ImGuiCol_Text, m::OnSurfaceDisabled()); + ImGui::TextUnformatted(util::formatTimeAgoShort(a.epoch).c_str()); + ImGui::PopStyleColor(); + ImGui::PopFont(); + ImGui::PopID(); + ImGui::Spacing(); + } + ImGui::EndChild(); +} + void App::renderStatusBar() { // Status bar layout from unified UI schema @@ -2559,9 +2645,78 @@ void App::renderStatusBar() float cbX = occupiedX - cbW - gap; ImGui::SameLine(cbX); ImGui::TextUnformatted(cb.c_str()); + occupiedX = cbX; } } + // Alert-history bell — leftmost item of the right cluster. Opens a panel of recent alerts, + // including ones whose toast already faded; an unread dot marks alerts that arrived since + // the panel was last opened. + { + const float dp = ui::Layout::dpiScale(); + auto& notes = ui::Notifications::instance(); + ImFont* bellFont = ui::material::Type().iconSmall(); + const bool anyHist = notes.hasHistory(); + const char* bellGlyph = anyHist ? ICON_MD_NOTIFICATIONS : ICON_MD_NOTIFICATIONS_NONE; + + ImGui::PushFont(bellFont); + const float glyphW = ImGui::CalcTextSize(bellGlyph).x; + ImGui::PopFont(); + const float bellW = glyphW + 10.0f * dp; + const float bellH = bellFont->LegacySize + 4.0f * dp; + const float bellX = occupiedX - bellW - gap; + + ImGui::SameLine(bellX); + ui::material::IconButtonStyle st; + st.color = ui::material::OnSurfaceMedium(); + st.hoverColor = ui::material::OnSurface(); + st.hoverBg = ui::material::StateHover(); + st.bgRounding = 4.0f * dp; + st.tooltip = TR("alerts_history_tooltip"); + const bool clicked = ui::material::IconButton("##AlertBell", bellGlyph, bellFont, + ImVec2(bellW, bellH), st); + const ImVec2 bellMin = ImGui::GetItemRectMin(); + const ImVec2 bellMax = ImGui::GetItemRectMax(); + + // Unread dot: alerts pushed since the panel was last opened, coloured by the most + // severe unseen alert. totalPushed() is monotonic, so this survives capping/clearing. + const std::uint64_t unseen = notes.totalPushed() - alerts_seen_total_; + if (unseen > 0 && anyHist) { + const auto& h = notes.history(); + size_t scan = (unseen < h.size()) ? static_cast(unseen) : h.size(); + bool anyErr = false, anyWarn = false; + for (size_t i = 0; i < scan; ++i) { + auto t = h[h.size() - 1 - i].type; + if (t == ui::NotificationType::Error) { anyErr = true; break; } + if (t == ui::NotificationType::Warning) anyWarn = true; + } + ImU32 dotCol = anyErr ? ui::material::Error() + : anyWarn ? ui::material::Warning() + : ui::material::Primary(); + const float r = 3.0f * dp; + ImGui::GetWindowDrawList()->AddCircleFilled( + ImVec2(bellMax.x - r, bellMin.y + r), r, dotCol); + } + + if (clicked) { + alerts_seen_total_ = notes.totalPushed(); // mark everything currently shown as seen + ImGui::OpenPopup("##AlertHistoryPopup"); + } + + // The status bar sits at the window bottom, so grow the popup UPWARD from the bell + // (pivot bottom-left → the anchor point becomes the popup's bottom-left corner). + ImGui::SetNextWindowPos(ImVec2(bellMin.x, bellMin.y - 4.0f * dp), + ImGuiCond_Always, ImVec2(0.0f, 1.0f)); + const float panelW = 320.0f * dp; + ImGui::SetNextWindowSizeConstraints(ImVec2(panelW, 0), ImVec2(panelW, 360.0f * dp)); + if (ImGui::BeginPopup("##AlertHistoryPopup")) { + renderAlertHistoryPanel(); + ImGui::EndPopup(); + } + + occupiedX = bellX; + } + // Version always at far right ImGui::SameLine(versionX); ImGui::Text("%s", versionBuf); diff --git a/src/app.h b/src/app.h index f45663e..fafbba2 100644 --- a/src/app.h +++ b/src/app.h @@ -1030,6 +1030,7 @@ private: 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; @@ -1299,6 +1300,9 @@ private: // 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(); diff --git a/src/ui/notifications.h b/src/ui/notifications.h index 3b3c77c..fb628f1 100644 --- a/src/ui/notifications.h +++ b/src/ui/notifications.h @@ -9,6 +9,8 @@ #include #include #include +#include +#include #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::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& 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 notifications_; size_t max_notifications_ = 5; std::function console_callback_; + std::deque 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; diff --git a/src/util/i18n.cpp b/src/util/i18n.cpp index e640503..2af105f 100644 --- a/src/util/i18n.cpp +++ b/src/util/i18n.cpp @@ -1320,6 +1320,11 @@ void I18n::loadBuiltinEnglish() 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 " diff --git a/tests/test_phase4.cpp b/tests/test_phase4.cpp index 421d818..17e229b 100644 --- a/tests/test_phase4.cpp +++ b/tests/test_phase4.cpp @@ -34,6 +34,7 @@ #include "ui/windows/mining_tab_helpers.h" #include "ui/node_status_banner.h" #include "ui/staleness_badge.h" +#include "ui/notifications.h" #include "util/address_validation.h" #include "util/amount_format.h" #include "util/payment_uri.h" @@ -2655,6 +2656,37 @@ void testStalenessBadge() } } +void testNotificationHistory() +{ + using dragonx::ui::Notifications; + using dragonx::ui::NotificationType; + auto& n = Notifications::instance(); + n.clearHistory(); + auto base = n.totalPushed(); // monotonic counter is NOT reset by clearHistory() + + n.push("first", NotificationType::Info, 5.0f); + n.push("second", NotificationType::Error, 5.0f); + EXPECT_EQ((int)n.history().size(), 2); + EXPECT_TRUE(n.hasHistory()); + // Oldest first, newest last; type + wall-clock stamp retained. + EXPECT_EQ(n.history().front().message, std::string("first")); + EXPECT_EQ(n.history().back().message, std::string("second")); + EXPECT_TRUE(n.history().back().type == NotificationType::Error); + EXPECT_TRUE(n.history().back().epoch > 0); + EXPECT_EQ((int)(n.totalPushed() - base), 2); + + // Cap at 100: push past it → size caps, oldest entries drop, totalPushed keeps counting. + for (int i = 0; i < 150; ++i) n.push("bulk", NotificationType::Info, 5.0f); + EXPECT_EQ((int)n.history().size(), 100); + EXPECT_EQ((int)(n.totalPushed() - base), 152); + EXPECT_EQ(n.history().front().message, std::string("bulk")); // the two originals fell off + + n.clearHistory(); + EXPECT_TRUE(!n.hasHistory()); + EXPECT_EQ((int)n.history().size(), 0); + EXPECT_EQ((int)(n.totalPushed() - base), 152); // clearing doesn't rewind the counter +} + void testLoggerFileSink() { using dragonx::util::Logger; @@ -7044,6 +7076,7 @@ int main() testConsoleSecretRedaction(); testNodeStatusBanner(); testStalenessBadge(); + testNotificationHistory(); testLoggerFileSink(); testDaemonLifecycleExecution(); testDaemonLifecycleAdapters(); From 8bb3198562e7a268909ddd67ce06429f6a5d65d0 Mon Sep 17 00:00:00 2001 From: DanS Date: Sun, 2 Aug 2026 21:14:38 -0500 Subject: [PATCH 24/89] fix(diagnostics): address adversarial review of the QoL UI (popup, staleness, DPI, i18n) MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Follow-up to the node-banner / staleness-badge / alert-history features — a 5-dimension finder->verify review surfaced 4 real issues (the ImGui-stack-balance finder found none): - 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). Anchor the bottom-RIGHT corner at the bell instead (pivot (1,1) at bellMax.x) so it grows left. - Staleness badge could flash red on reconnect: WalletState::clear() reset everything except the four last_*_update stamps, so the pre-outage timestamp survived and the badge briefly showed "Updated Nm ago" the same frame the node banner cleared. Zero the stamps in clear() (all readers treat 0 as "never"; app_network.cpp:1473 guards != 0). - Banner min-height floor wasn't DPI-scaled: std::max(minH, baseH*vScale()) now uses minH * dpiScale() so both operands are in scaled px. - New i18n keys weren't in res/lang/: back-filled all 16 diagnostics/QoL keys into the 8 language files, additively (128 insertions, 0 deletions). zh/ja/ko reworded around 2 glyphs missing from the CJK subset and hard-asserted tofu-free against the subset font. Build-clean both variants; ctest 1/1. Co-Authored-By: Claude Opus 4.8 --- docs/wallet-hardening.md | 5 +++++ res/lang/de.json | 16 ++++++++++++++++ res/lang/es.json | 16 ++++++++++++++++ res/lang/fr.json | 16 ++++++++++++++++ res/lang/ja.json | 16 ++++++++++++++++ res/lang/ko.json | 16 ++++++++++++++++ res/lang/pt.json | 16 ++++++++++++++++ res/lang/ru.json | 16 ++++++++++++++++ res/lang/zh.json | 16 ++++++++++++++++ src/app.cpp | 14 +++++++++----- src/data/wallet_state.h | 5 +++++ 11 files changed, 147 insertions(+), 5 deletions(-) diff --git a/docs/wallet-hardening.md b/docs/wallet-hardening.md index a63dae3..378e1f5 100644 --- a/docs/wallet-hardening.md +++ b/docs/wallet-hardening.md @@ -112,6 +112,11 @@ Land W7-2 first — it unblocks the rest. ## 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. diff --git a/res/lang/de.json b/res/lang/de.json index 739d7cc..9a9df80 100644 --- a/res/lang/de.json +++ b/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", @@ -956,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...", @@ -1291,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.", @@ -1317,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", @@ -1476,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", @@ -1529,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", diff --git a/res/lang/es.json b/res/lang/es.json index ced7ac5..5535247 100644 --- a/res/lang/es.json +++ b/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", @@ -956,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...", @@ -1291,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.", @@ -1317,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", @@ -1476,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", @@ -1529,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", diff --git a/res/lang/fr.json b/res/lang/fr.json index 19402f6..e3dd5cf 100644 --- a/res/lang/fr.json +++ b/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", @@ -956,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...", @@ -1291,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é.", @@ -1317,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é", @@ -1476,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", @@ -1529,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", diff --git a/res/lang/ja.json b/res/lang/ja.json index 230c66c..7cd4a10 100644 --- a/res/lang/ja.json +++ b/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": "デバッグログ", @@ -956,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": "デーモンに未接続...", @@ -1288,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/アドレスが追加されます。", @@ -1314,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": "プライバシー", @@ -1473,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 をこのウォレットビルドにバンドルされたバージョンで上書きしてから再起動します", @@ -1526,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 を削除しアンロックにパスフレーズを要求", diff --git a/res/lang/ko.json b/res/lang/ko.json index 8b05e1c..7c56e41 100644 --- a/res/lang/ko.json +++ b/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": "디버그 로깅", @@ -955,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": "데몬에 연결되지 않음...", @@ -1290,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/주소가 추가됩니다.", @@ -1316,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": "개인 정보", @@ -1475,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를 이 지갑 빌드에 번들된 버전으로 덮어쓴 다음 재시작합니다", @@ -1528,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을 제거하고 잠금 해제 시 비밀번호 요구", diff --git a/res/lang/pt.json b/res/lang/pt.json index 350f364..a5e0eda 100644 --- a/res/lang/pt.json +++ b/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", @@ -956,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...", @@ -1291,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.", @@ -1317,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", @@ -1476,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", @@ -1529,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", diff --git a/res/lang/ru.json b/res/lang/ru.json index 1ce7f9f..d59c39a 100644 --- a/res/lang/ru.json +++ b/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": "ЖУРНАЛ ОТЛАДКИ", @@ -956,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...", @@ -1291,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/адрес будет добавлен.", @@ -1317,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": "Конфиденциальность", @@ -1476,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 версией, встроенной в эту сборку кошелька, затем перезапустить", @@ -1529,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 и требовать пароль для разблокировки", diff --git a/res/lang/zh.json b/res/lang/zh.json index 9310852..6b0dee2 100644 --- a/res/lang/zh.json +++ b/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": "调试日志", @@ -955,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": "未连接到守护进程...", @@ -1289,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/地址。", @@ -1315,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": "隐私", @@ -1474,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 覆盖已安装的版本，然后重启", @@ -1527,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 并要求密码解锁", diff --git a/src/app.cpp b/src/app.cpp index 38adc88..afeff0c 100644 --- a/src/app.cpp +++ b/src/app.cpp @@ -2182,7 +2182,9 @@ void App::renderNodeStatusBanner() const auto& S = ui::schema::UI(); const float minH = S.drawElement("banners.node-status", "min-height").size; const float baseH = S.drawElement("banners.node-status", "height").size; - const float bannerH = std::max(minH, baseH * ui::Layout::vScale()); + // Both operands must be in scaled px: vScale() already folds in dpiScale(), so the raw min-height + // floor needs the same dpiScale() or it under-clamps the banner at HiDPI. + const float bannerH = std::max(minH * ui::Layout::dpiScale(), baseH * ui::Layout::vScale()); const bool isError = (banner.severity == ui::NodeBannerSeverity::Error); const ImU32 sevCol = isError ? m::Error() : m::Warning(); @@ -2703,10 +2705,12 @@ void App::renderStatusBar() ImGui::OpenPopup("##AlertHistoryPopup"); } - // The status bar sits at the window bottom, so grow the popup UPWARD from the bell - // (pivot bottom-left → the anchor point becomes the popup's bottom-left corner). - ImGui::SetNextWindowPos(ImVec2(bellMin.x, bellMin.y - 4.0f * dp), - ImGuiCond_Always, ImVec2(0.0f, 1.0f)); + // The bell sits near the window's bottom-right, so anchor the popup's bottom-RIGHT + // corner at the bell's right edge (pivot (1,1)) — it then grows LEFT over the canvas and + // UP from the status bar. A left pivot would push a 320px panel off the right edge (and + // an explicit SetNextWindowPos pivot skips ImGui's on-screen clamp, so it would overflow). + ImGui::SetNextWindowPos(ImVec2(bellMax.x, bellMin.y - 4.0f * dp), + ImGuiCond_Always, ImVec2(1.0f, 1.0f)); const float panelW = 320.0f * dp; ImGui::SetNextWindowSizeConstraints(ImVec2(panelW, 0), ImVec2(panelW, 360.0f * dp)); if (ImGui::BeginPopup("##AlertHistoryPopup")) { diff --git a/src/data/wallet_state.h b/src/data/wallet_state.h index 6083343..66a1ba3 100644 --- a/src/data/wallet_state.h +++ b/src/data/wallet_state.h @@ -339,6 +339,11 @@ struct WalletState { // 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 From 32be868dbc1da8f0722fa33981b055123d81aec8 Mon Sep 17 00:00:00 2001 From: DanS Date: Sun, 2 Aug 2026 22:11:37 -0500 Subject: [PATCH 25/89] feat(migrate): persist the sweep opid so a mid-sweep interruption can resume (W3-3) MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Migrate-to-seed submits z_mergetoaddress -> an async opid, then only persists the resolved txid once the op completes. An app-close during Sweeping (opid submitted, txid not yet resolved) dropped the opid and resumed at the re-sweep gate, silently losing the tx. Now the opid is persisted and re-tracked on resume. If the daemon forgot it (restart — its op queue is in-memory only), the existing poller flags it stale and the callback falls back to the dismissable Sweep gate; it can never hang (a thrown RPC aborts the poll, so a stale classification only comes from a *successful* poll that omits the opid). - New seed_migration_sweep_opid setting; adopted atomically with clearing any prior txid in the SAME settings.save(), and only once the submit succeeds — so a failed "Sweep remaining" re-sweep keeps the already-mined first sweep's Confirming context, and txid/opid are never both authoritative (resume checks txid first; torn-write safe). - Resume routing extracted to a pure, unit-tested helper (data/seed_migration_resume.h::decideSeedMigrationResume): txid -> Confirming; opid AND connected -> re-track (Sweeping); else -> the dismissable Sweep gate. The connectivity gate keeps a disconnected resume out of the buttonless Sweeping spinner. - Shared makeSweepCompletionCallback(resumed): success -> Confirming; resumed-stale -> Sweep gate (re-fetch balance + "may have already completed" copy); fresh-fail -> Error. Fund safety unchanged: adopt still gated on legacy balance ~0 AND sweep tx mined; legacy wallet.dat only ever moved to a never-deleted timestamped .bak. Reviewed in two adversarial rounds (design + implementation) per the migration-code mandate; both safety facts (no fund loss, no hang) held, and the resume-UX traps they surfaced are fixed. Build-clean; ctest 1/1 (adds testSeedMigrationResume). See docs/wallet-hardening.md. *** Still requires a live mainnet interrupted-sweep run before release (human gate). *** Co-Authored-By: Claude Opus 4.8 --- docs/wallet-hardening.md | 8 +- src/app.h | 4 + src/app_network.cpp | 142 ++++++++++++++++++++++++------- src/config/settings.cpp | 2 + src/config/settings.h | 6 ++ src/data/seed_migration_resume.h | 37 ++++++++ tests/test_phase4.cpp | 30 +++++++ 7 files changed, 195 insertions(+), 34 deletions(-) create mode 100644 src/data/seed_migration_resume.h diff --git a/docs/wallet-hardening.md b/docs/wallet-hardening.md index 378e1f5..79994ad 100644 --- a/docs/wallet-hardening.md +++ b/docs/wallet-hardening.md @@ -18,7 +18,7 @@ Status legend: ☐ not started · ◐ in progress · ☑ landed & verified |-------|----------|-------|--------| | **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) | ◐ 3/4 | +| **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 | ☑ | @@ -136,7 +136,11 @@ Land W7-2 first — it unblocks the rest. - **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)** — ⚑ **deferred for careful, adversarially-reviewed work** (not rushed). `trackOperation` only enqueues the opid for a background poller; a resume that re-tracks a persisted opid is only safe if the poller times out a *stale* opid (daemon restarted → op gone) rather than polling forever — otherwise a resume would hang the migration permanently, worse than today's re-sweep. Verifying that (and the double-sweep interactions) is exactly the "two rounds of adversarial review + a live mainnet run" the migration code mandates. The existing safety gates (adopt requires the legacy balance ~0 AND the sweep tx mined) already prevent fund *loss* on a mid-sweep interruption; W3-3 is a stuck-state robustness improvement, so it can wait for a dedicated pass. +- **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". diff --git a/src/app.h b/src/app.h index fafbba2..215491d 100644 --- a/src/app.h +++ b/src/app.h @@ -804,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 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 diff --git a/src/app_network.cpp b/src/app_network.cpp index d8ccfa4..d423a8b 100644 --- a/src/app_network.cpp +++ b/src/app_network.cpp @@ -55,6 +55,7 @@ #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/perf_log.h" #include "util/i18n.h" @@ -4177,27 +4178,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; } } @@ -4272,29 +4302,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 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 @@ -4458,6 +4530,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 @@ -4500,6 +4573,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 { diff --git a/src/config/settings.cpp b/src/config/settings.cpp index 612b609..0e95e87 100644 --- a/src/config/settings.cpp +++ b/src/config/settings.cpp @@ -238,6 +238,7 @@ bool Settings::load(const std::string& path) 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_); @@ -505,6 +506,7 @@ bool Settings::save(const std::string& path) 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_; diff --git a/src/config/settings.h b/src/config/settings.h index 072cb7e..bc0f748 100644 --- a/src/config/settings.h +++ b/src/config/settings.h @@ -356,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_; } @@ -587,6 +592,7 @@ private: 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; diff --git a/src/data/seed_migration_resume.h b/src/data/seed_migration_resume.h new file mode 100644 index 0000000..fe138d9 --- /dev/null +++ b/src/data/seed_migration_resume.h @@ -0,0 +1,37 @@ +#pragma once + +#include + +// 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 diff --git a/tests/test_phase4.cpp b/tests/test_phase4.cpp index 17e229b..0b7516d 100644 --- a/tests/test_phase4.cpp +++ b/tests/test_phase4.cpp @@ -35,6 +35,7 @@ #include "ui/node_status_banner.h" #include "ui/staleness_badge.h" #include "ui/notifications.h" +#include "data/seed_migration_resume.h" #include "util/address_validation.h" #include "util/amount_format.h" #include "util/payment_uri.h" @@ -2687,6 +2688,34 @@ void testNotificationHistory() EXPECT_EQ((int)(n.totalPushed() - base), 152); // clearing doesn't rewind the counter } +void testSeedMigrationResume() +{ + using dragonx::decideSeedMigrationResume; + using dragonx::MigrationResume; + + // No pending migration (or missing dest) → start fresh at the intro. + EXPECT_TRUE(decideSeedMigrationResume(false, false, "", "", true) == MigrationResume::Intro); + EXPECT_TRUE(decideSeedMigrationResume(false, true, "tx", "op", true) == MigrationResume::Intro); + EXPECT_TRUE(decideSeedMigrationResume(true, false, "tx", "op", true) == MigrationResume::Intro); + + // A persisted txid outranks everything → resume at the confirm/adopt gate (txid-first invariant). + EXPECT_TRUE(decideSeedMigrationResume(true, true, "tx", "", true) == MigrationResume::Confirming); + EXPECT_TRUE(decideSeedMigrationResume(true, true, "tx", "op", true) == MigrationResume::Confirming); + EXPECT_TRUE(decideSeedMigrationResume(true, true, "tx", "op", false) == MigrationResume::Confirming); + + // Opid but no txid, AND connected → re-track the opid (recover the txid / detect stale). + EXPECT_TRUE(decideSeedMigrationResume(true, true, "", "op", true) == MigrationResume::RetrackOpid); + + // W3-3 connectivity gate: opid but NOT connected → the dismissable Sweep gate, NOT the buttonless + // Sweeping spinner (whose only exit is the opid poller, which needs a connection). This is the + // trap the review caught. + EXPECT_TRUE(decideSeedMigrationResume(true, true, "", "op", false) == MigrationResume::SweepGate); + + // No txid and no opid → the Sweep gate (whether or not connected). + EXPECT_TRUE(decideSeedMigrationResume(true, true, "", "", true) == MigrationResume::SweepGate); + EXPECT_TRUE(decideSeedMigrationResume(true, true, "", "", false) == MigrationResume::SweepGate); +} + void testLoggerFileSink() { using dragonx::util::Logger; @@ -7077,6 +7106,7 @@ int main() testNodeStatusBanner(); testStalenessBadge(); testNotificationHistory(); + testSeedMigrationResume(); testLoggerFileSink(); testDaemonLifecycleExecution(); testDaemonLifecycleAdapters(); From 16244d84a092e4b3d5d0ee502cfdf13c1e4fa723 Mon Sep 17 00:00:00 2001 From: DanS Date: Sun, 2 Aug 2026 22:53:23 -0500 Subject: [PATCH 26/89] chore(release): bump version to 2.0.1 Full-node ObsidianDragon 2.0.0 -> 2.0.1 (single source of truth: the project() VERSION in CMakeLists.txt). Verified the generated header renders "2.0.1 (ObsidianDragon)". The Lite variant is versioned independently (DRAGONX_LITE_VERSION, unchanged at 1.0.0). Co-Authored-By: Claude Opus 4.8 --- CMakeLists.txt | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/CMakeLists.txt b/CMakeLists.txt index d20bafb..c6c2cf6 100644 --- a/CMakeLists.txt +++ b/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" ) From c61c211dfedcbed0852222f8eb8b20a672bb82cc Mon Sep 17 00:00:00 2001 From: DanS Date: Sun, 2 Aug 2026 23:12:20 -0500 Subject: [PATCH 27/89] fix(ui): add vertical padding above and below the recent-alerts popup content The alert-history popup content sat flush against the popup's top and bottom edges. Add a padY spacer above the header and below the content (on both the empty and populated paths). Co-Authored-By: Claude Opus 4.8 --- src/app.cpp | 5 +++++ 1 file changed, 5 insertions(+) diff --git a/src/app.cpp b/src/app.cpp index afeff0c..2ca34eb 100644 --- a/src/app.cpp +++ b/src/app.cpp @@ -2293,10 +2293,13 @@ void App::renderAlertHistoryPanel() const auto& hist = notes.history(); const float innerW = ImGui::GetContentRegionAvail().x; const float padX = 8.0f * dp; + const float padY = 8.0f * dp; ImFont* icoF = m::Type().iconSmall(); ImFont* txtF = m::Type().caption(); + ImGui::Dummy(ImVec2(0.0f, padY)); // breathing room above the content + // Header: "Recent alerts" on the left, a Clear-all icon button on the right. ImGui::SetCursorPosX(padX); ImGui::PushFont(txtF); @@ -2325,6 +2328,7 @@ void App::renderAlertHistoryPanel() ImGui::PushFont(txtF); ImGui::TextDisabled("%s", TR("alerts_none")); ImGui::PopFont(); + ImGui::Dummy(ImVec2(0.0f, padY)); // breathing room below the content return; } @@ -2369,6 +2373,7 @@ void App::renderAlertHistoryPanel() ImGui::Spacing(); } ImGui::EndChild(); + ImGui::Dummy(ImVec2(0.0f, padY)); // breathing room below the content } void App::renderStatusBar() From d603a54618c6f56ee0790a1b3e63da1aab206fc2 Mon Sep 17 00:00:00 2001 From: DanS Date: Sat, 8 Aug 2026 22:22:29 -0500 Subject: [PATCH 28/89] fix(import): recognize real DragonX key formats in the import gate MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit The client-side pre-check rejected legitimate keys before the daemon ever saw them, surfacing "Unrecognized key format" / a cryptic daemon "Invalid" error. Two concrete defects plus the brittle heuristic behind them: - Viewing keys: isViewingKey looked for Zcash's "zxview" extended-FVK prefix, but DragonX's z_exportviewingkey emits a Sapling *incoming* viewing key (HRP "zivks"), which z_importviewingkey is the only form the daemon decodes. Every real DragonX viewing key was refused. (F1) - Uncompressed transparent WIF: the length+first-char heuristic accepted {5,K,L,U} only, but a version-188 uncompressed key starts with '7'. (F2) Replace the heuristic with structural validation using the existing checksum validators (F3): add util::decodeBase58Check (checksum-stripped payload) and util::bech32Hrp (HRP of a valid Bech32 string). Transparent keys are now accepted by decoding Base58Check and checking the payload is a 33/34-byte secret key with a DragonX SECRET_KEY version byte (188 main/ regtest, 128 testnet) — covering compressed and uncompressed, rejecting addresses/typos by real checksum. Viewing keys are matched by the real incoming-VK HRPs (zivks / zivktestsapling / zivkregtestsapling). The Sweep gate and the dialog's live type indicator run off the same predicates, so they are fixed too (F4). Messaging now names the likely cause and appends a wrong-coin/network hint to the daemon's raw "Invalid" error (F5). Adds testPrivateKeyImportRecognition plus decodeBase58Check/bech32Hrp coverage; suite green (1/1). Co-Authored-By: Claude Opus 4.8 (1M context) --- src/app_network.cpp | 12 +++- src/services/wallet_security_controller.cpp | 32 +++++++++-- src/services/wallet_security_controller.h | 2 +- src/util/address_validation.cpp | 25 ++++++++- src/util/address_validation.h | 11 ++++ tests/test_phase4.cpp | 61 +++++++++++++++++++++ 6 files changed, 133 insertions(+), 10 deletions(-) diff --git a/src/app_network.cpp b/src/app_network.cpp index d423a8b..cf84462 100644 --- a/src/app_network.cpp +++ b/src/app_network.cpp @@ -3834,7 +3834,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; } @@ -3874,6 +3876,14 @@ void App::importPrivateKey(const std::string& rawKey, int startHeight, } // 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, ""); diff --git a/src/services/wallet_security_controller.cpp b/src/services/wallet_security_controller.cpp index cf07b1f..29e30ad 100644 --- a/src/services/wallet_security_controller.cpp +++ b/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 +#include #include #include +#include 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 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; } diff --git a/src/services/wallet_security_controller.h b/src/services/wallet_security_controller.h index 239c3ba..da7cf14 100644 --- a/src/services/wallet_security_controller.h +++ b/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); diff --git a/src/util/address_validation.cpp b/src/util/address_validation.cpp index cba64f1..eb87af8 100644 --- a/src/util/address_validation.cpp +++ b/src/util/address_validation.cpp @@ -76,7 +76,7 @@ std::vector bech32HrpExpand(const std::string& hrp) } // namespace -bool isValidBase58Check(const std::string& s) +bool decodeBase58Check(const std::string& s, std::vector& payloadOut) { if (s.size() < 5 || s.size() > 256) return false; std::vector 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 payload; + return decodeBase58Check(s, payload); } bool isValidBech32(const std::string& s) @@ -127,5 +135,18 @@ 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(std::tolower(c)); }); + const std::size_t sep = lower.rfind('1'); + if (sep == std::string::npos) return {}; + return lower.substr(0, sep); +} + } // namespace util } // namespace dragonx diff --git a/src/util/address_validation.h b/src/util/address_validation.h index bc17a33..885f8e1 100644 --- a/src/util/address_validation.h +++ b/src/util/address_validation.h @@ -11,7 +11,9 @@ #pragma once +#include #include +#include namespace dragonx { namespace util { @@ -20,9 +22,18 @@ 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& 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); + } // namespace util } // namespace dragonx diff --git a/tests/test_phase4.cpp b/tests/test_phase4.cpp index 0b7516d..cecc138 100644 --- a/tests/test_phase4.cpp +++ b/tests/test_phase4.cpp @@ -5952,6 +5952,66 @@ void testAddressChecksumValidation() EXPECT_FALSE(isValidBech32("abc1rzg")); // too short / bad checksum EXPECT_FALSE(isValidBech32("Abcdef1qpzry9x8gf2tvdw0s3jn54khce6mua7lmqqqxw")); // mixed case EXPECT_FALSE(isValidBech32("nosalt")); // no separator + + // decodeBase58Check exposes the checksum-stripped payload so callers can inspect version/length. + using dragonx::util::decodeBase58Check; + std::vector payload; + EXPECT_TRUE(decodeBase58Check("1A1zP1eP5QGefi2DMPTfTL5SLmv7DivfNa", payload)); + EXPECT_EQ(payload.size(), (size_t)21); // version(1) + 20-byte hash160, checksum stripped + EXPECT_EQ((int)payload[0], 0); // mainnet P2PKH version byte + EXPECT_FALSE(decodeBase58Check("1A1zP1eP5QGefi2DMPTfTL5SLmv7Divfna", payload)); // bad checksum + + // bech32Hrp returns the (lower-cased) HRP of a valid string, or "" when invalid. + using dragonx::util::bech32Hrp; + EXPECT_EQ(bech32Hrp("abcdef1qpzry9x8gf2tvdw0s3jn54khce6mua7lmqqqxw"), std::string("abcdef")); + EXPECT_EQ(bech32Hrp("A12UEL5L"), std::string("a")); // lower-cased + EXPECT_EQ(bech32Hrp("A12UEL5M"), std::string("")); // invalid → empty +} + +// Import-key recognition: the client gate must accept every real DragonX key form and reject +// non-keys, so it never blocks a valid import with "Unrecognized key format" (audit F1/F2/F3). +void testPrivateKeyImportRecognition() +{ + using dragonx::services::WalletSecurityController; + using KeyKind = WalletSecurityController::KeyKind; + + // --- Transparent WIF (DragonX SECRET_KEY version 188; testnet 128) --- + const std::string wifCompressed = "Up3W7uVYkLxCfH91APxjSpkkGBWJyBrm3tt1bCz64V5fpZK9ef3C"; // v188 compressed 'U' + const std::string wifUncompressed = "7JTPumX2kofLQdHKANy8MMLRkmXCmuJcosiv9f4RFqW9oCJXBHD"; // v188 uncompressed '7' + const std::string wifTestnet = "KwFfpDsaF7yxCELuyrH9gP5XL7TAt5b9HPWC1xCQbmrxvhJgMQHb"; // v128 compressed + + EXPECT_TRUE(WalletSecurityController::isRecognizedPrivateKey(wifCompressed)); + EXPECT_TRUE(WalletSecurityController::isRecognizedPrivateKey(wifUncompressed)); // F2 regression: '7' was rejected + EXPECT_TRUE(WalletSecurityController::isRecognizedPrivateKey(wifTestnet)); + EXPECT_TRUE(WalletSecurityController::isRecognizedImportKey(wifUncompressed)); + EXPECT_EQ(WalletSecurityController::classifyPrivateKey(wifUncompressed), KeyKind::Transparent); + EXPECT_FALSE(WalletSecurityController::isViewingKey(wifCompressed)); + + // A corrupted WIF (flipped last char) fails the checksum → caught locally, not at the daemon. + std::string wifBad = wifCompressed; + wifBad.back() = (wifBad.back() == 'C' ? 'D' : 'C'); + EXPECT_FALSE(WalletSecurityController::isRecognizedPrivateKey(wifBad)); + + // A transparent R-address is Base58Check-valid but NOT a key (21-byte payload, not 33/34). + EXPECT_FALSE(WalletSecurityController::isRecognizedPrivateKey("R9NXAVJezHiBnT3ijTpg3JUZre7PxhJWti")); + + // --- Sapling incoming viewing key (mainnet HRP "zivks") — the F1 regression --- + const std::string ivk = "zivks1qypqxpq9qcrsszg2pvxq6rs0zqg3yyc5z5tpwxqergd3c8g7rusq45amw7"; + EXPECT_TRUE(WalletSecurityController::isViewingKey(ivk)); + EXPECT_TRUE(WalletSecurityController::isRecognizedImportKey(ivk)); + EXPECT_FALSE(WalletSecurityController::isRecognizedPrivateKey(ivk)); // a viewing key can't spend + // The stale Zcash "zxview…" prefix is NOT a DragonX viewing key (and not valid Bech32 here). + EXPECT_FALSE(WalletSecurityController::isViewingKey("zxviews1abcdef")); + + // --- Sapling z spending key (recognized by HRP prefix; daemon vets the long payload) --- + const std::string zspend = "secret-extended-key-main1qxxxxxxxxxxxxxxxxxxxx"; + EXPECT_TRUE(WalletSecurityController::isRecognizedPrivateKey(zspend)); + EXPECT_TRUE(WalletSecurityController::isRecognizedImportKey(zspend)); + EXPECT_EQ(WalletSecurityController::classifyPrivateKey(zspend), KeyKind::Shielded); + + // --- Garbage / empty --- + EXPECT_FALSE(WalletSecurityController::isRecognizedImportKey("")); + EXPECT_FALSE(WalletSecurityController::isRecognizedImportKey("hello world")); } // Live probe of a real lite server (env-gated). Validates CONNECT_ONLY latency + IP capture. @@ -7195,6 +7255,7 @@ int main() testHushChatShuffledReceive(); testWalletFileProbe(); testAddressChecksumValidation(); + testPrivateKeyImportRecognition(); testLiteServerProbeLive(); testXmrigLiveInstall(); testGeneratedResourceBehavior(); From c3e81a5fa65c8e7c449a6ae7e9ce423b36a06c77 Mon Sep 17 00:00:00 2001 From: DanS Date: Sun, 9 Aug 2026 00:12:17 -0500 Subject: [PATCH 29/89] fix(send): accept P2SH/multisig recipients in the send + URI address gates MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Same defect class as the import-key fix: a hardcoded prefix/length pre-filter layered over the checksum validators rejected valid addresses before the daemon saw them. The send-screen recipient gate required a[0]=='R', and the payment-URI parser accepted only 'R'/'t' with rigid length bands — so every valid P2SH / multisig address (DragonX SCRIPT_ADDRESS=85 → 'b…') was silently refused, leaving the Send button disabled with no usable recipient. Centralize recipient recognition in util/address_validation: - isTransparentAddress: Base58Check with a 21-byte version+hash160 payload — covers P2PKH ('R…', v60) AND P2SH ('b…', v85) on every network, rejects WIF keys / typos by real checksum. - isShieldedAddress: Bech32 + a Sapling payment-address HRP (zs / ztestsapling / zregtestsapling), distinguishing a payment address from a viewing key. - isValidRecipientAddress: either of the above. send_tab's two validity helpers (the single choke point for all 5 call sites) and the payment-URI format check now route through these. The URI parser now checksum-validates the recipient (fail-fast on transcription errors) rather than being prefix/length-only. Tests use real checksummed vectors (P2PKH/P2SH/shielded, WIF- and typo-rejection); testPaymentUri updated off its old fake fixed-char addresses. Suite green (1/1). Co-Authored-By: Claude Opus 4.8 (1M context) --- src/ui/windows/send_tab.cpp | 13 ++++++------- src/util/address_validation.cpp | 21 ++++++++++++++++++++ src/util/address_validation.h | 13 +++++++++++++ src/util/payment_uri.cpp | 20 ++++++------------- tests/test_phase4.cpp | 34 +++++++++++++++++++++++++++++++-- 5 files changed, 78 insertions(+), 23 deletions(-) diff --git a/src/ui/windows/send_tab.cpp b/src/ui/windows/send_tab.cpp index 11cc73f..c0cb5ab 100644 --- a/src/ui/windows/send_tab.cpp +++ b/src/ui/windows/send_tab.cpp @@ -148,14 +148,14 @@ static double GetAvailableBalance(App* app) { 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) { @@ -1318,8 +1318,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; diff --git a/src/util/address_validation.cpp b/src/util/address_validation.cpp index eb87af8..6f3d6b6 100644 --- a/src/util/address_validation.cpp +++ b/src/util/address_validation.cpp @@ -148,5 +148,26 @@ std::string bech32Hrp(const std::string& s) return lower.substr(0, sep); } +bool isTransparentAddress(const std::string& s) +{ + std::vector 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 diff --git a/src/util/address_validation.h b/src/util/address_validation.h index 885f8e1..ee3b365 100644 --- a/src/util/address_validation.h +++ b/src/util/address_validation.h @@ -35,5 +35,18 @@ bool isValidBech32(const std::string& s); // `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 diff --git a/src/util/payment_uri.cpp b/src/util/payment_uri.cpp index f7ef8bb..bb835d3 100644 --- a/src/util/payment_uri.cpp +++ b/src/util/payment_uri.cpp @@ -3,6 +3,7 @@ // Released under the GPLv3 #include "payment_uri.h" +#include "address_validation.h" #include #include @@ -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"; diff --git a/tests/test_phase4.cpp b/tests/test_phase4.cpp index cecc138..810398b 100644 --- a/tests/test_phase4.cpp +++ b/tests/test_phase4.cpp @@ -726,7 +726,9 @@ void testConnectionConfig() void testPaymentUri() { - std::string taddr = "R" + std::string(33, 'a'); + // Real checksummed addresses — the parser now checksum-validates the recipient (not a bare + // prefix/length filter), so it accepts P2PKH / P2SH / shielded and rejects transcription errors. + std::string taddr = "R9NXAVJezHiBnT3ijTpg3JUZre7PxhJWti"; // P2PKH (v60) auto parsed = dragonx::util::parsePaymentURI( "drgx:" + taddr + "?amount=1.25000000&label=Main+Wallet&memo=hello%20there&message=thanks"); @@ -737,11 +739,19 @@ void testPaymentUri() EXPECT_EQ(parsed.memo, std::string("hello there")); EXPECT_EQ(parsed.message, std::string("thanks")); - std::string zaddr = "zs" + std::string(76, 'b'); + std::string zaddr = "zs1qqqsyqcyq5rqwzqfpg9scrgwpugpzysnzs23v9ccrydpk8qarc0jqgfzyvjz2f389q5j5ctfvp5"; auto zparsed = dragonx::util::parsePaymentURI("hush://" + zaddr + "?amt=0.5"); EXPECT_TRUE(zparsed.valid); EXPECT_NEAR(zparsed.amount, 0.5, 0.00000001); + // Regression: a P2SH/multisig recipient ("b…", v85) must parse — the old 'R'/'t'-only filter dropped it. + auto p2sh = dragonx::util::parsePaymentURI("drgx:bCpbnCkrjoJ6EHXtLx9eASHEbFYyikt35C?amount=1"); + EXPECT_TRUE(p2sh.valid); + + // A transcription error (flipped checksum char) is now rejected at parse time. + auto typo = dragonx::util::parsePaymentURI("drgx:R9NXAVJezHiBnT3ijTpg3JUZre7PxhJWtX?amount=1"); + EXPECT_FALSE(typo.valid); + auto invalid = dragonx::util::parsePaymentURI("drgx:" + taddr + "?amount=-1"); EXPECT_FALSE(invalid.valid); EXPECT_EQ(invalid.error, std::string("Invalid negative amount")); @@ -5966,6 +5976,26 @@ void testAddressChecksumValidation() EXPECT_EQ(bech32Hrp("abcdef1qpzry9x8gf2tvdw0s3jn54khce6mua7lmqqqxw"), std::string("abcdef")); EXPECT_EQ(bech32Hrp("A12UEL5L"), std::string("a")); // lower-cased EXPECT_EQ(bech32Hrp("A12UEL5M"), std::string("")); // invalid → empty + + // Address type recognizers: accept every real DragonX recipient form, reject non-addresses. + using dragonx::util::isTransparentAddress; + using dragonx::util::isShieldedAddress; + using dragonx::util::isValidRecipientAddress; + const std::string p2pkh = "R9NXAVJezHiBnT3ijTpg3JUZre7PxhJWti"; // v60 + const std::string p2sh = "bCpbnCkrjoJ6EHXtLx9eASHEbFYyikt35C"; // v85 multisig — the regression + const std::string zaddr = "zs1qqqsyqcyq5rqwzqfpg9scrgwpugpzysnzs23v9ccrydpk8qarc0jqgfzyvjz2f389q5j5ctfvp5"; + EXPECT_TRUE(isTransparentAddress(p2pkh)); + EXPECT_TRUE(isTransparentAddress(p2sh)); // was silently dropped by the old 'R'-only filter + EXPECT_FALSE(isShieldedAddress(p2pkh)); + EXPECT_TRUE(isShieldedAddress(zaddr)); + EXPECT_FALSE(isTransparentAddress(zaddr)); + EXPECT_TRUE(isValidRecipientAddress(p2pkh)); + EXPECT_TRUE(isValidRecipientAddress(p2sh)); + EXPECT_TRUE(isValidRecipientAddress(zaddr)); + // A WIF spending key is NOT a recipient (33/34-byte payload, not 21); nor is a typo'd address. + EXPECT_FALSE(isTransparentAddress("Up3W7uVYkLxCfH91APxjSpkkGBWJyBrm3tt1bCz64V5fpZK9ef3C")); + EXPECT_FALSE(isValidRecipientAddress("R9NXAVJezHiBnT3ijTpg3JUZre7PxhJWtX")); // flipped checksum char + EXPECT_FALSE(isValidRecipientAddress("")); } // Import-key recognition: the client gate must accept every real DragonX key form and reject From 5b6ba5094b77d75db4b5777699a1507129d77e0d Mon Sep 17 00:00:00 2001 From: DanS Date: Sun, 9 Aug 2026 00:59:29 -0500 Subject: [PATCH 30/89] docs(lite): clarify SDXL viewing-key HRP differs from the full node MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Audit of the lite import path found no false-rejection defect (no client-side gate; the two-command fallback in importKey makes the U/5/K/L prefix guess non-binding; lite send reuses the now-P2SH-fixed send_tab helpers). But the "zxview" viewing-key comment — which was WRONG in the full node (fixed earlier) — is genuinely CORRECT here: SDXL's import takes an extended full viewing key (zxviews…, hrp_sapling_viewing_key), whereas the full node's z_importviewingkey takes an incoming viewing key (zivks…). The two are not interchangeable. Add a note so nobody "harmonizes" the two gates and reintroduces the full-node bug. Comment-only; no behavior change. Co-Authored-By: Claude Opus 4.8 (1M context) --- src/wallet/lite_wallet_controller.cpp | 5 +++++ 1 file changed, 5 insertions(+) diff --git a/src/wallet/lite_wallet_controller.cpp b/src/wallet/lite_wallet_controller.cpp index 6596f4e..d1bc0e4 100644 --- a/src/wallet/lite_wallet_controller.cpp +++ b/src/wallet/lite_wallet_controller.cpp @@ -887,6 +887,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'); From a1d3964e349c472bc69da6d45cebbe02fefe2d98 Mon Sep 17 00:00:00 2001 From: DanS Date: Sun, 9 Aug 2026 01:32:40 -0500 Subject: [PATCH 31/89] fix(lite): require exactly 24 words on first-run restore (crash on valid seed) MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit The lite first-run restore wizard enabled Restore for {12,15,18,21,24}-word phrases, but the SDXL backend only accepts 24-word / 32-byte-entropy seeds: LightWallet::new does copy_from_slice(&phrase.entropy()) into a [u8;32] (lightwallet.rs:231), which panics on 16/20/24/28-byte entropy. Mnemonic:: from_phrase accepts the shorter valid phrase, and the restore FFI litelib_initialize_new_from_phrase (lib.rs:127) has no catch_unwind (unlike litelib_execute), so the panic unwinds across extern "C" -> process abort (UB on the pinned rustc 1.63). A user restoring a legitimate 12-word seed from another wallet crashed the app. The Settings restore gate was already tightened to == 24 (6ff1fda) but the first-run wizard gate (df14533) was never updated — same restore path, two verdicts, crash only via the more-common first-run path. Add shared util/seed_phrase.{h,cpp} as the single source of truth: - normalizeSeedPhrase: fold NBSP/en/em/ideographic/narrow spaces to ASCII, strip zero-width marks, collapse+trim (word bytes untouched) - seedPhraseWordCount - isCompleteRecoveryPhrase(int) == 24 (the sole SDXL contract) Both restore gates now count via the normalizer and gate via isCompleteRecoveryPhrase, and both submit the normalized phrase. This closes the crash, reconciles the two gates so they can't drift again, and — because tiny-bip39 splits on literal ASCII space with no NFKD — makes an NBSP-pasted 24-word seed (common from PDFs/note apps) restore correctly instead of being undercounted and rejected. Adds testSeedPhraseHelpers. Suite green (1/1). Co-Authored-By: Claude Opus 4.8 (1M context) --- CMakeLists.txt | 2 + src/app.cpp | 27 +++++------- src/ui/pages/settings_page.cpp | 21 +++++----- src/util/seed_phrase.cpp | 77 ++++++++++++++++++++++++++++++++++ src/util/seed_phrase.h | 38 +++++++++++++++++ tests/test_phase4.cpp | 43 +++++++++++++++++++ 6 files changed, 181 insertions(+), 27 deletions(-) create mode 100644 src/util/seed_phrase.cpp create mode 100644 src/util/seed_phrase.h diff --git a/CMakeLists.txt b/CMakeLists.txt index c6c2cf6..31fd4fb 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -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 @@ -1122,6 +1123,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 diff --git a/src/app.cpp b/src/app.cpp index 2ca34eb..47d08a5 100644 --- a/src/app.cpp +++ b/src/app.cpp @@ -74,6 +74,7 @@ #include "util/platform.h" #include "util/text_format.h" #include "util/payment_uri.h" +#include "util/seed_phrase.h" #include "util/texture_loader.h" #include "util/svg_texture.h" #include "ui/material/colors.h" @@ -3074,22 +3075,16 @@ void App::renderLiteFirstRunPrompt() } ImGui::Spacing(); ImGui::Spacing(); - // Trim surrounding whitespace from the entered seed. - std::string seedTrim(restoreSeed); - while (!seedTrim.empty() && std::isspace((unsigned char)seedTrim.front())) seedTrim.erase(seedTrim.begin()); - while (!seedTrim.empty() && std::isspace((unsigned char)seedTrim.back())) seedTrim.pop_back(); + // Normalize the entered seed (trim, fold exotic Unicode whitespace like NBSP to plain + // spaces) so the word count and the phrase we submit agree regardless of paste source. + std::string seedTrim = util::normalizeSeedPhrase(restoreSeed); - // Require a valid BIP39 word count before enabling Restore — otherwise a truncated or - // garbage phrase (previously any non-empty text passed) is submitted and fails opaquely. - int seedWords = 0; - { bool inWord = false; - for (char c : seedTrim) { - bool sp = (c == ' ' || c == '\t' || c == '\n' || c == '\r'); - if (!sp && !inWord) { seedWords++; inWord = true; } - else if (sp) inWord = false; - } } - bool seedLenOk = (seedWords == 12 || seedWords == 15 || seedWords == 18 || - seedWords == 21 || seedWords == 24); + // Require a COMPLETE 24-word phrase before enabling Restore. The SDXL backend only + // accepts 24-word / 32-byte-entropy seeds; a shorter valid-BIP39 phrase (12/15/18/21) + // panics it uncaught across the restore FFI, so it must be refused here (matches the + // Settings restore gate — both go through util::isCompleteRecoveryPhrase). + int seedWords = util::seedPhraseWordCount(seedTrim); + bool seedLenOk = util::isCompleteRecoveryPhrase(seedWords); if (!seedTrim.empty() && !seedLenOk) { ImGui::PushStyleColor(ImGuiCol_Text, ImGui::ColorConvertU32ToFloat4(ui::material::Warning())); ImGui::PushTextWrapPos(ImGui::GetCursorPosX() + 380.0f); @@ -3103,7 +3098,7 @@ void App::renderLiteFirstRunPrompt() ImGui::BeginDisabled(!seedLenOk); if (ui::material::TactileButton(TR("lite_restore_btn"), ImVec2(btnW, 0))) { wallet::LiteWalletRestoreRequest req; - req.seedPhrase = seedTrim; + req.seedPhrase = seedTrim; // normalized: NBSP-glued pastes restore correctly req.birthday = static_cast(std::max(0, restoreBirthday)); req.overwrite = lite_wallet_->walletExists(); // replace any existing wallet file if (lite_wallet_->beginRestoreWalletAsync(std::move(req))) { diff --git a/src/ui/pages/settings_page.cpp b/src/ui/pages/settings_page.cpp index d4d3dca..80bf8e2 100644 --- a/src/ui/pages/settings_page.cpp +++ b/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 #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(*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(std::max(0, s_settingsState.lite_restore_birthday)); input.request.restoreRequest.account = static_cast(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(); diff --git a/src/util/seed_phrase.cpp b/src/util/seed_phrase.cpp new file mode 100644 index 0000000..660ca1e --- /dev/null +++ b/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 + +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(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 diff --git a/src/util/seed_phrase.h b/src/util/seed_phrase.h new file mode 100644 index 0000000..d13ce05 --- /dev/null +++ b/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 + +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 diff --git a/tests/test_phase4.cpp b/tests/test_phase4.cpp index 810398b..7e1f6cb 100644 --- a/tests/test_phase4.cpp +++ b/tests/test_phase4.cpp @@ -37,6 +37,7 @@ #include "ui/notifications.h" #include "data/seed_migration_resume.h" #include "util/address_validation.h" +#include "util/seed_phrase.h" #include "util/amount_format.h" #include "util/payment_uri.h" #include "util/platform.h" @@ -6044,6 +6045,47 @@ void testPrivateKeyImportRecognition() EXPECT_FALSE(WalletSecurityController::isRecognizedImportKey("hello world")); } +// Seed-phrase normalization + word count + the 24-word completeness gate. Guards the lite-restore +// crash fix (only 24-word/32-byte-entropy seeds are safe for the SDXL backend) and the NBSP-paste +// recovery fix. Both restore gates (first-run wizard + Settings) route through these. +void testSeedPhraseHelpers() +{ + using dragonx::util::normalizeSeedPhrase; + using dragonx::util::seedPhraseWordCount; + using dragonx::util::isCompleteRecoveryPhrase; + + // --- completeness gate: 24 words only (12/15/18/21 valid-BIP39 lengths crash the backend) --- + EXPECT_TRUE(isCompleteRecoveryPhrase(24)); + EXPECT_FALSE(isCompleteRecoveryPhrase(12)); + EXPECT_FALSE(isCompleteRecoveryPhrase(15)); + EXPECT_FALSE(isCompleteRecoveryPhrase(21)); + EXPECT_FALSE(isCompleteRecoveryPhrase(23)); + EXPECT_FALSE(isCompleteRecoveryPhrase(25)); + EXPECT_FALSE(isCompleteRecoveryPhrase(0)); + + // --- plain ASCII: trim, collapse runs, count exactly; the common case must be untouched otherwise --- + EXPECT_EQ(normalizeSeedPhrase(" alpha beta\tgamma\ndelta "), std::string("alpha beta gamma delta")); + EXPECT_EQ(seedPhraseWordCount(normalizeSeedPhrase("alpha beta gamma")), 3); + EXPECT_EQ(seedPhraseWordCount(""), 0); + EXPECT_EQ(seedPhraseWordCount(normalizeSeedPhrase(" \t \n ")), 0); // whitespace-only + + // --- NBSP (U+00A0 = 0xC2 0xA0) between words must fold to a real space, not glue the words --- + EXPECT_EQ(normalizeSeedPhrase("alpha\xC2\xA0" "beta"), std::string("alpha beta")); + EXPECT_EQ(seedPhraseWordCount(normalizeSeedPhrase("alpha\xC2\xA0" "beta")), 2); + // Other Unicode spaces: en space U+2002, ideographic U+3000, narrow NBSP U+202F. + EXPECT_EQ(normalizeSeedPhrase("a\xE2\x80\x82" "b\xE3\x80\x80" "c\xE2\x80\xAF" "d"), std::string("a b c d")); + // Zero-width chars (U+200B, U+FEFF BOM) are stripped, not treated as separators. + EXPECT_EQ(normalizeSeedPhrase("\xEF\xBB\xBF" "alpha\xE2\x80\x8B beta"), std::string("alpha beta")); + + // --- a full 24-word phrase pasted with NBSP separators counts as 24 (regression for the fix) --- + std::string words24; + for (int i = 0; i < 24; ++i) { if (i) words24 += "\xC2\xA0"; words24 += "word"; } + EXPECT_EQ(seedPhraseWordCount(normalizeSeedPhrase(words24)), 24); + EXPECT_TRUE(isCompleteRecoveryPhrase(seedPhraseWordCount(normalizeSeedPhrase(words24)))); + // The normalized form is plain single-space separated (what the backend's split(" ") needs). + EXPECT_EQ(normalizeSeedPhrase(words24).find("\xC2\xA0"), std::string::npos); +} + // Live probe of a real lite server (env-gated). Validates CONNECT_ONLY latency + IP capture. void testLiteServerProbeLive() { @@ -7286,6 +7328,7 @@ int main() testWalletFileProbe(); testAddressChecksumValidation(); testPrivateKeyImportRecognition(); + testSeedPhraseHelpers(); testLiteServerProbeLive(); testXmrigLiveInstall(); testGeneratedResourceBehavior(); From 5296dd7ae5d4c27fb37a9a5fbcb699b4b9987e6d Mon Sep 17 00:00:00 2001 From: DanS Date: Sun, 9 Aug 2026 13:38:50 -0500 Subject: [PATCH 32/89] fix(parsers): harden RPC/price/updater parsing against valid-but-unhandled input Audit of the full-node RPC response parsers and updater release-body parsers (find -> adversarially-verify workflow) surfaced three worth fixing; three others guard formats the project doesn't emit and are backstopped by signature verification, so they're documented rather than churned. - Price (Medium): parseCoinGeckoPriceResponse used .value(key, 0.0), which throws type_error on a PRESENT null. CoinGecko emits null for usd_24h_change/ usd_24h_vol on illiquid tokens (DRGX is one) while still returning a valid spot price; the outer catch turned that into no price update at all. Read null-tolerantly so the valid usd/btc survives. - Daemon updater (Medium): parseDaemonChecksums blanked '|'/backtick but not markdown emphasis, so a bolded **archive.zip** checksum row was dropped and a valid, correctly-signed release would be refused. Also blank '*'/'_' (cannot cause a wrong-asset match; the 64-hex + .zip-suffix tests are unchanged). - Opid poll (Low, severe failure mode): parseOperationStatusPoll read id/status via .value() (throws on a present non-string) and the call site parsed OUTSIDE its try/catch, so a throw left opid_poll_in_progress_ stuck true and wedged all z-operation polling for the session. Type-check the reads and parse inside the guard. (dragonxd can't emit non-string id/status; this is defense-in-depth.) Regression tests: CoinGecko null field; opid non-string id/status; **bold** checksum row. Suite green (1/1). Co-Authored-By: Claude Opus 4.8 (1M context) --- src/app.cpp | 5 +++- src/services/network_refresh_service.cpp | 27 ++++++++++++++----- src/util/daemon_updater_core.cpp | 9 ++++--- tests/test_phase4.cpp | 34 ++++++++++++++++++++++++ 4 files changed, 63 insertions(+), 12 deletions(-) diff --git a/src/app.cpp b/src/app.cpp index 47d08a5..6708461 100644 --- a/src/app.cpp +++ b/src/app.cpp @@ -1129,6 +1129,7 @@ void App::update() auto* rpc = (fast_rpc_ && fast_rpc_->isConnected()) ? fast_rpc_.get() : rpc_.get(); if (!rpc) return [this](){ opid_poll_in_progress_ = false; }; json result; + services::NetworkRefreshService::OperationStatusPollResult parsed; try { rpc::RPCClient::TraceScope trace("Send tab / Operation status"); // No per-opid filter: this daemon rejects z_getoperationstatus(["opid"]) with @@ -1136,10 +1137,12 @@ void App::update() // "Waiting for operation". The no-arg form returns ALL operations; // parseOperationStatusPoll() filters down to the opids we're tracking. result = rpc->call("z_getoperationstatus", json::array()); + // Parse INSIDE the guard: a malformed/type-anomalous element must never abort the + // poll and leave opid_poll_in_progress_ stuck true for the whole connected session. + parsed = services::NetworkRefreshService::parseOperationStatusPoll(result, opids); } catch (...) { return [this](){ opid_poll_in_progress_ = false; }; } - auto parsed = services::NetworkRefreshService::parseOperationStatusPoll(result, opids); return [this, parsed = std::move(parsed)]() mutable { opid_poll_in_progress_ = false; diff --git a/src/services/network_refresh_service.cpp b/src/services/network_refresh_service.cpp index fefc08e..03c1887 100644 --- a/src/services/network_refresh_service.cpp +++ b/src/services/network_refresh_service.cpp @@ -426,12 +426,21 @@ std::optional 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() : 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 @@ -1101,12 +1110,16 @@ NetworkRefreshService::OperationStatusPollResult NetworkRefreshService::parseOpe std::set 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(); 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(); if (status == "success") { parsed.doneOpids.push_back(opid); parsed.anySuccess = true; diff --git a/src/util/daemon_updater_core.cpp b/src/util/daemon_updater_core.cpp index 6968804..fb8bae9 100644 --- a/src/util/daemon_updater_core.cpp +++ b/src/util/daemon_updater_core.cpp @@ -140,15 +140,16 @@ std::map 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 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) { diff --git a/tests/test_phase4.cpp b/tests/test_phase4.cpp index 7e1f6cb..9624512 100644 --- a/tests/test_phase4.cpp +++ b/tests/test_phase4.cpp @@ -2032,6 +2032,20 @@ void testNetworkRefreshResultModels() EXPECT_EQ(state.market.price_history.size(), static_cast(1)); } + // Regression: CoinGecko emits JSON null (not an omitted key) for fields it can't compute — + // commonly usd_24h_change on illiquid tokens like DRGX — while still returning a valid spot + // price. The parser must keep the valid usd/btc, not discard the whole update on the null. + auto priceNull = Refresh::parseCoinGeckoPriceResponse( + R"({"dragonx-2":{"usd":0.42,"btc":0.000009,"usd_24h_change":null,"usd_24h_vol":null,"usd_market_cap":50000}})", + 0); + EXPECT_TRUE(priceNull.has_value()); + if (priceNull) { + EXPECT_NEAR(priceNull->market.price_usd, 0.42, 0.00000001); + EXPECT_NEAR(priceNull->market.price_btc, 0.000009, 0.00000001); + EXPECT_NEAR(priceNull->market.change_24h, 0.0, 0.0001); // null -> default, not a throw + EXPECT_NEAR(priceNull->market.market_cap, 50000.0, 0.0001); + } + Refresh::markPriceRefreshStarted(state); Refresh::applyPriceRefreshFailure(state, "timeout"); EXPECT_FALSE(state.market.price_loading); @@ -2213,6 +2227,20 @@ void testOperationStatusPollParsing() EXPECT_FALSE(malformed.anySuccess); EXPECT_TRUE(malformed.doneOpids.empty()); EXPECT_TRUE(malformed.staleOpids.empty()); + + // Regression: a type-anomalous element (non-string "id"/"status") must be skipped, not throw — + // a throw here would escape the parser and permanently wedge opid polling for the session. A + // valid tracked opid alongside the anomaly must still be processed. + auto typeSafe = Refresh::parseOperationStatusPoll(json::array({ + json{{"id", 12345}, {"status", "failed"}}, // non-string id -> skipped, no throw + json{{"id", "op-ok"}, {"status", 7}}, // non-string status -> "" (not done) + json{{"id", "op-good"}, {"status", "success"}, {"result", json{{"txid", "tx-good"}}}} + }), {"op-ok", "op-good", "op-x"}); + EXPECT_TRUE(typeSafe.anySuccess); + EXPECT_EQ(typeSafe.successTxidsByOpid.at("op-good"), std::string("tx-good")); + EXPECT_TRUE(typeSafe.failureMessages.empty()); // the non-string-id "failed" was skipped + EXPECT_EQ(typeSafe.staleOpids.size(), static_cast(1)); // op-x absent; op-ok was seen (not stale) + EXPECT_EQ(typeSafe.staleOpids[0], std::string("op-x")); } void testSecureVaultScope() @@ -6260,6 +6288,12 @@ void testDaemonChecksumParsing() "| DragonX-1.0.2-Win64.ZIP | `dd6a554ac05c834da9910ae796215567e97c426f3aed15b54af1f7b90d48c43a` |"); EXPECT_EQ(mixed.at("dragonx-1.0.2-win64.zip"), std::string("dd6a554ac05c834da9910ae796215567e97c426f3aed15b54af1f7b90d48c43a")); + // Regression: a markdown-bolded filename (**archive.zip**) must still parse — otherwise a valid, + // correctly-signed release whose body bolds the name would fail checksum lookup and be refused. + const auto bold = parseDaemonChecksums( + "| **dragonx-1.0.2-win64.zip** | `dd6a554ac05c834da9910ae796215567e97c426f3aed15b54af1f7b90d48c43a` |"); + EXPECT_EQ(bold.at("dragonx-1.0.2-win64.zip"), + std::string("dd6a554ac05c834da9910ae796215567e97c426f3aed15b54af1f7b90d48c43a")); } void testDaemonBasenamesAndVersionCore() From f88304fed2ef64b60bddae1bc05f8caed385cb75 Mon Sep 17 00:00:00 2001 From: DanS Date: Sun, 9 Aug 2026 15:29:23 -0500 Subject: [PATCH 33/89] fix(wallets): stop a legacy wallet showing as a seed-phrase wallet when linked MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit The wallets list badged the active/linked row from the runtime seed status (activeWalletSeedBadge → wallet_seed_status_, reset only on disconnect) in preference to the offline on-disk probe. Two issues let a genuinely legacy wallet render as "seed phrase": - The offline probe's budget-fallback branch dropped the fMnemonicSeed flag: res.mnemonic was set only in the (parsed && complete) branch. The probe shares a 768 MB budget across all wallet files, so a large wallet (e.g. a 194 MB one) probed after the budget is spent falls into the fallback, loses its seed/legacy classification (mnemonic → 0), and the row defers to the runtime badge. - With mnemonic == 0, the code used the runtime badge, which can still carry a HasMnemonic from a previously-active mnemonic wallet — mislabelling the legacy wallet. Fix: - Carry the definitive positives (fMnemonicSeed/hdSeed/mkey) from a cap-truncated btree walk — a found marker is authoritative even when the scan didn't finish. - Make the on-disk fMnemonicSeed read take precedence: it's the SAME flag the daemon's IsMnemonicSeed()/z_exportmnemonic consult, so a definitive read wins; the runtime badge is used only when the probe genuinely couldn't decide, and never overrides a definitive on-disk classification. Verified the wallet in question is truly legacy (fMnemonicSeed=false on disk, matching the daemon's CHDChain serialization + IsMnemonicSeed). The flag reader (hdChainMnemonicFlag) is already unit-tested; suite green. Co-Authored-By: Claude Opus 4.8 (1M context) --- src/ui/windows/wallets_dialog.h | 34 ++++++++++++++++++++++----------- 1 file changed, 23 insertions(+), 11 deletions(-) diff --git a/src/ui/windows/wallets_dialog.h b/src/ui/windows/wallets_dialog.h index 87e7768..b29daf6 100644 --- a/src/ui/windows/wallets_dialog.h +++ b/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)); } } From d136916e8088ffd7eab753729f52d4672673612a Mon Sep 17 00:00:00 2001 From: DanS Date: Sun, 9 Aug 2026 23:49:46 -0500 Subject: [PATCH 34/89] feat(node): detect an unreadable block DB on startup and offer a one-click reindex MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit When a daemon update changes the block-index on-disk format (or the index is corrupt), dragonxd aborts at startup — "non-canonical optional discriminant" → "Error loading block database. Aborted." — and the wallet silently shows a zero balance. Previously the connect loop just crash-restarted into the same abort up to 3x and then reported a bare "Daemon crashed N times", with no path forward. Now: - daemon/daemon_startup_diagnosis.h: pure blockDbOutputLooksBroken() classifies the crashed node's captured console output (the fatal block-DB markers). - The connect loop detects it on the FIRST abort, STOPS crash-restarting into the same failure (each retry reloads the whole index — wasteful), and offers a fix. - A one-shot -reindex flag (EmbeddedDaemon::setReindexOnNextStart → DaemonController forwarder → args) rebuilds the block index + chainstate from the intact raw blocks; App::reindexBlockDatabase() arms it and un-gates the loop to restart. - An auto-shown dialog (renderBlockDbReindexDialog) + a notification explain the situation ("your coins are safe; the node just can't load the chain") and offer a one-click "Rebuild block database". Full-node only (gated), lite-safe. This is the exact trap behind a real "big wallet shows no funds" report: a post-format-change daemon over pre-change chaindata. Reindex also fixes a plain corrupt index. Adds testBlockDbOutputDiagnosis (the abort sequence + individual markers trip it; normal startup / wallet-corruption / asmap errors do not). Suite green (1/1). Co-Authored-By: Claude Opus 4.8 (1M context) --- src/app.cpp | 52 +++++++++++++++++++++++++++ src/app.h | 7 ++++ src/app_network.cpp | 16 ++++++++- src/daemon/daemon_controller.cpp | 5 +++ src/daemon/daemon_controller.h | 1 + src/daemon/daemon_startup_diagnosis.h | 30 ++++++++++++++++ src/daemon/embedded_daemon.cpp | 8 +++++ src/daemon/embedded_daemon.h | 8 +++++ src/util/i18n.cpp | 9 +++++ tests/test_phase4.cpp | 28 +++++++++++++++ 10 files changed, 163 insertions(+), 1 deletion(-) create mode 100644 src/daemon/daemon_startup_diagnosis.h diff --git a/src/app.cpp b/src/app.cpp index 6708461..95daaf0 100644 --- a/src/app.cpp +++ b/src/app.cpp @@ -2143,6 +2143,7 @@ void App::render() renderDecryptWalletDialog(); renderPinDialogs(); renderSwitchStopDaemonDialog(); + renderBlockDbReindexDialog(); // Render notifications (toast messages) ui::Notifications::instance().render(); @@ -4280,6 +4281,37 @@ void App::renderAntivirusHelpDialog() #endif } +// Auto-shown when the embedded node aborts on an unreadable block database — offers the one-click +// -reindex rebuild instead of leaving the wallet stuck on a silent zero balance. +void App::renderBlockDbReindexDialog() +{ + if (!show_block_db_reindex_confirm_) return; + + ui::material::OverlayDialogSpec ov; + ov.title = TR("block_db_reindex_title"); + ov.p_open = &show_block_db_reindex_confirm_; // X / backdrop dismisses (offer remains; loop stays held) + ov.style = ui::material::OverlayStyle::BlurFloat; + ov.cardWidth = 540.0f; + ov.idSuffix = "blockdbreindex"; + if (!ui::material::BeginOverlayDialog(ov)) return; + const float dp = ui::Layout::dpiScale(); + + ui::material::DialogWarningHeader(TR("block_db_reindex_warn")); + ImGui::Dummy(ImVec2(0, ui::Layout::spacingSm())); + ImGui::TextWrapped("%s", TR("block_db_reindex_body")); + ImGui::Dummy(ImVec2(0, ui::Layout::spacingMd())); + if (ui::material::TactileButton(TR("block_db_reindex_confirm"), ImVec2(260.0f * dp, 0))) { + reindexBlockDatabase(); // clears show_block_db_reindex_confirm_ + block_db_reindex_available_ + } + ImGui::SameLine(); + if (ui::material::TactileButton(TR("cancel"), ImVec2(110.0f * dp, 0))) { + show_block_db_reindex_confirm_ = false; + // Leave block_db_reindex_available_ set: the connect loop keeps HOLDING (no crash-restart storm) + // rather than looping into the same abort; the user can rebuild later from Settings. + } + ui::material::EndOverlayDialog(); +} + void App::renderSwitchStopDaemonDialog() { const bool confirm = show_switch_stop_daemon_confirm_; @@ -6054,4 +6086,24 @@ void App::restartDaemon() }); } +// One-click recovery for an unreadable block database: arm the one-shot -reindex flag, then un-gate the +// connect loop (which detected the abort and stopped restarting). Its next attempt calls +// startEmbeddedDaemon(), which consumes the flag → the node rebuilds its block index + chainstate from +// the raw blocks. The daemon is not running here (it aborted), so no explicit stop/restart is needed. +void App::reindexBlockDatabase() +{ + if (!supportsFullNodeLifecycleActions()) { + ui::Notifications::instance().warning("Full-node lifecycle actions are unavailable in lite build"); + return; + } + if (!daemon_controller_) return; + daemon_controller_->setReindexOnNextStart(true); + daemon_controller_->resetCrashCount(); // the abort no longer counts against the restart budget + show_block_db_reindex_confirm_ = false; + block_db_reindex_available_ = false; // un-gate → the connect loop restarts the node with -reindex + connection_status_ = TR("sb_starting_daemon"); + ui::Notifications::instance().info(TR("block_db_reindex_started"), 12.0f); + DEBUG_LOGF("[App] Block-database reindex requested — restarting node with -reindex\n"); +} + } // namespace dragonx diff --git a/src/app.h b/src/app.h index 215491d..614b8ce 100644 --- a/src/app.h +++ b/src/app.h @@ -895,6 +895,11 @@ 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 // 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. @@ -1324,6 +1329,8 @@ 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 processDeferredEncryption(); // Private methods - connection diff --git a/src/app_network.cpp b/src/app_network.cpp index cf84462..c21a919 100644 --- a/src/app_network.cpp +++ b/src/app_network.cpp @@ -44,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" @@ -501,8 +502,21 @@ void App::tryConnect() VERBOSE_LOGF("[connect #%d] RPC connection failed — no daemon starting, no external detected\n", attempt); if (isUsingEmbeddedDaemon() && !isEmbeddedDaemonRunning()) { + // 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 (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 diff --git a/src/daemon/daemon_controller.cpp b/src/daemon/daemon_controller.cpp index 6f27c48..b357a20 100644 --- a/src/daemon/daemon_controller.cpp +++ b/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(); diff --git a/src/daemon/daemon_controller.h b/src/daemon/daemon_controller.h index 5f2fe25..21dc804 100644 --- a/src/daemon/daemon_controller.h +++ b/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, diff --git a/src/daemon/daemon_startup_diagnosis.h b/src/daemon/daemon_startup_diagnosis.h new file mode 100644 index 0000000..4c17ccb --- /dev/null +++ b/src/daemon/daemon_startup_diagnosis.h @@ -0,0 +1,30 @@ +// 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 + +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" +} + +} // namespace daemon +} // namespace dragonx diff --git a/src/daemon/embedded_daemon.cpp b/src/daemon/embedded_daemon.cpp index 2444a79..ac1b8f3 100644 --- a/src/daemon/embedded_daemon.cpp +++ b/src/daemon/embedded_daemon.cpp @@ -571,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) diff --git a/src/daemon/embedded_daemon.h b/src/daemon/embedded_daemon.h index bce7513..c652843 100644 --- a/src/daemon/embedded_daemon.h +++ b/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 @@ -306,6 +313,7 @@ private: std::atomic rescan_on_next_start_{false}; // -rescan flag for next start std::atomic zap_on_next_start_{false}; // -zapwallettxes=2 flag for next start std::atomic salvage_on_next_start_{false}; // -salvagewallet flag for next start + std::atomic 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 override_extra_args_; // one-shot: extra args for the next start bool skip_port_check_ = false; // isolated instance on a non-default port diff --git a/src/util/i18n.cpp b/src/util/i18n.cpp index 2af105f..62193fe 100644 --- a/src/util/i18n.cpp +++ b/src/util/i18n.cpp @@ -1185,6 +1185,14 @@ 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."; + // Receive Tab strings_["receiving_addresses"] = "Your Receiving Addresses"; strings_["new_z_shielded"] = "New z-Address (Shielded)"; @@ -1309,6 +1317,7 @@ 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"; // 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"; diff --git a/tests/test_phase4.cpp b/tests/test_phase4.cpp index 9624512..be6909e 100644 --- a/tests/test_phase4.cpp +++ b/tests/test_phase4.cpp @@ -38,6 +38,7 @@ #include "data/seed_migration_resume.h" #include "util/address_validation.h" #include "util/seed_phrase.h" +#include "daemon/daemon_startup_diagnosis.h" #include "util/amount_format.h" #include "util/payment_uri.h" #include "util/platform.h" @@ -6114,6 +6115,32 @@ void testSeedPhraseHelpers() EXPECT_EQ(normalizeSeedPhrase(words24).find("\xC2\xA0"), std::string::npos); } +// Block-DB abort detection: classify a crashed daemon's console output so the app can offer a +// one-click reindex instead of silently showing a zero balance (a daemon-vs-chaindata format break). +void testBlockDbOutputDiagnosis() +{ + using dragonx::daemon::blockDbOutputLooksBroken; + + // The exact abort sequence we observed on a format-mismatched datadir. + EXPECT_TRUE(blockDbOutputLooksBroken( + "Opened LevelDB successfully\n" + "GetValue: CDataStream error - non-canonical optional discriminant: iostream error\n" + "ERROR: LoadBlockIndex() : failed to read value\n" + ": Error loading block database.\n" + "Aborted block database rebuild. Exiting.\n")); + // Each individual fatal marker also trips it (partial capture / different phrasing). + EXPECT_TRUE(blockDbOutputLooksBroken("... : Error loading block database.")); + EXPECT_TRUE(blockDbOutputLooksBroken("Aborted block database rebuild. Exiting.")); + EXPECT_TRUE(blockDbOutputLooksBroken("ERROR: LoadBlockIndex() : failed to read value")); + + // Normal startup / other failures must NOT be misread as a block-DB problem (no false reindex offer). + EXPECT_FALSE(blockDbOutputLooksBroken( + "Loading block index...\nVerifying blocks...\nLoading wallet...\nRescanning...\nDone loading\n")); + EXPECT_FALSE(blockDbOutputLooksBroken("Error loading wallet")); // wallet corruption → salvage, not reindex + EXPECT_FALSE(blockDbOutputLooksBroken("Error: Could not find any asmap file!")); + EXPECT_FALSE(blockDbOutputLooksBroken("")); +} + // Live probe of a real lite server (env-gated). Validates CONNECT_ONLY latency + IP capture. void testLiteServerProbeLive() { @@ -7363,6 +7390,7 @@ int main() testAddressChecksumValidation(); testPrivateKeyImportRecognition(); testSeedPhraseHelpers(); + testBlockDbOutputDiagnosis(); testLiteServerProbeLive(); testXmrigLiveInstall(); testGeneratedResourceBehavior(); From 3b7423f3a171bd623808e67595b001174fb9901b Mon Sep 17 00:00:00 2001 From: DanS Date: Mon, 10 Aug 2026 00:30:11 -0500 Subject: [PATCH 35/89] feat(node): warn when the daemon auto-recovers (salvages) wallet.dat MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit dragonxd auto-recovers a wallet.dat that fails BDB verification on startup — no flag needed (CWallet::Verify → CDBEnv::Verify(walletFile, CWalletDB::Recover)): it moves the original to wallet..bak, salvages readable keys into a fresh wallet.dat, and keeps running. The salvage can be incomplete (or the whole thing a FALSE POSITIVE from stale/cross-platform BDB env state — __db.* / the database/ dir carried between machines), so the node silently comes up on a possibly-empty wallet. To the user that reads as fund loss, with no warning. Detect it and warn loudly instead: - daemon/daemon_startup_diagnosis.h: pure walletAutoRecovered() (the salvage / "Original wallet.dat saved as wallet..bak" markers) + newestWalletSalvageBak() (picks the wallet..bak the recovery just made). - onConnected() scans the node's captured output once per session; on a match it shows a warning dialog + notification: the ORIGINAL is safe in wallet..bak, the shown balance may be incomplete, and here are the exact steps to restore it (rename the .bak back + delete the stale database/ + __db.* env). One-click "Open data folder" jumps straight there. Full-node only; lite-safe. Deliberately does NOT auto-swap the wallet files (untested per-platform file manipulation on a real wallet is not worth the risk) — it informs + guides. Adds walletAutoRecovered / newestWalletSalvageBak coverage to testBlockDbOutputDiagnosis. Suite green (1/1). Co-Authored-By: Claude Opus 4.8 (1M context) --- src/app.cpp | 31 ++++++++++++++++++++++++ src/app.h | 7 ++++++ src/app_network.cpp | 14 +++++++++++ src/daemon/daemon_startup_diagnosis.h | 34 +++++++++++++++++++++++++++ src/util/i18n.cpp | 8 +++++++ tests/test_phase4.cpp | 17 ++++++++++++++ 6 files changed, 111 insertions(+) diff --git a/src/app.cpp b/src/app.cpp index 95daaf0..d4cd032 100644 --- a/src/app.cpp +++ b/src/app.cpp @@ -2144,6 +2144,7 @@ void App::render() renderPinDialogs(); renderSwitchStopDaemonDialog(); renderBlockDbReindexDialog(); + renderWalletRecoveredDialog(); // Render notifications (toast messages) ui::Notifications::instance().render(); @@ -4281,6 +4282,36 @@ void App::renderAntivirusHelpDialog() #endif } +// Auto-shown when the node auto-recovered (salvaged) wallet.dat: the real wallet is safe in a +// wallet..bak, but a possibly-incomplete salvaged copy is now loaded — warn loudly and point +// the user at the datadir so they can restore the original instead of mistaking it for fund loss. +void App::renderWalletRecoveredDialog() +{ + if (!show_wallet_recovered_dialog_) return; + + ui::material::OverlayDialogSpec ov; + ov.title = TR("wallet_recovered_title"); + ov.p_open = &show_wallet_recovered_dialog_; + ov.style = ui::material::OverlayStyle::BlurFloat; + ov.cardWidth = 560.0f; + ov.idSuffix = "walletrecovered"; + if (!ui::material::BeginOverlayDialog(ov)) return; + const float dp = ui::Layout::dpiScale(); + + ui::material::DialogWarningHeader(TR("wallet_recovered_warn")); + ImGui::Dummy(ImVec2(0, ui::Layout::spacingSm())); + ImGui::TextWrapped("%s", TR("wallet_recovered_body")); + ImGui::Dummy(ImVec2(0, ui::Layout::spacingMd())); + if (ui::material::TactileButton(TR("wallet_recovered_open_folder"), ImVec2(240.0f * dp, 0))) { + util::Platform::openFolder(util::Platform::getDragonXDataDir()); + } + ImGui::SameLine(); + if (ui::material::TactileButton(TR("wallet_recovered_dismiss"), ImVec2(150.0f * dp, 0))) { + show_wallet_recovered_dialog_ = false; // acknowledged; keeps the salvaged wallet loaded + } + ui::material::EndOverlayDialog(); +} + // Auto-shown when the embedded node aborts on an unreadable block database — offers the one-click // -reindex rebuild instead of leaving the wallet stuck on a silent zero balance. void App::renderBlockDbReindexDialog() diff --git a/src/app.h b/src/app.h index 614b8ce..c8353b9 100644 --- a/src/app.h +++ b/src/app.h @@ -900,6 +900,12 @@ private: // 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..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 // 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. @@ -1331,6 +1337,7 @@ private: 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 processDeferredEncryption(); // Private methods - connection diff --git a/src/app_network.cpp b/src/app_network.cpp index c21a919..f24e766 100644 --- a/src/app_network.cpp +++ b/src/app_network.cpp @@ -572,6 +572,20 @@ void App::onConnected() daemon_last_seen_crashes_ = 0; // (onConnected resets the daemon's crash count too) connection_status_ = TR("connected"); + // Detect a silent wallet AUTO-RECOVERY: dragonxd moves wallet.dat to wallet..bak and loads a + // salvaged copy whenever BDB verify fails (no flag, often a false positive from stale/cross-platform + // env state). The node comes up fine — so we only see it here, on connect — but the loaded wallet can + // be empty/incomplete, which reads as fund loss. Surface it loudly, once per session, so the user can + // restore the untouched original from the .bak. (Full-node only; lite has no embedded dragonxd.) + if (!wallet_auto_recovered_warned_ && isUsingEmbeddedDaemon() && daemon_controller_ && daemon_controller_->daemon() && + daemon::walletAutoRecovered(daemon_controller_->daemon()->getOutput())) { + wallet_auto_recovered_ = true; + wallet_auto_recovered_warned_ = true; + show_wallet_recovered_dialog_ = true; + ui::Notifications::instance().error(TR("wallet_recovered_notify"), 30.0f); + VERBOSE_LOGF("[connect] Daemon auto-recovered wallet.dat (salvage) — warning the user\n"); + } + // 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); diff --git a/src/daemon/daemon_startup_diagnosis.h b/src/daemon/daemon_startup_diagnosis.h index 4c17ccb..38a1883 100644 --- a/src/daemon/daemon_startup_diagnosis.h +++ b/src/daemon/daemon_startup_diagnosis.h @@ -8,6 +8,7 @@ #pragma once #include +#include namespace dragonx { namespace daemon { @@ -26,5 +27,38 @@ inline bool blockDbOutputLooksBroken(const std::string& out) || 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) +{ + return out.find("wallet.dat corrupt, data salvaged") != std::string::npos // RECOVER_OK warning + || out.find("Original wallet.dat saved as wallet.") != std::string::npos // the rename-aside notice + || out.find("wallet.dat corrupt, salvage failed") != std::string::npos; // RECOVER_FAIL +} + +// From a list of datadir filenames, pick the most recent daemon salvage backup — the "wallet..bak" +// the auto-recovery just created (highest timestamp). Returns "" if none present. Pure, so it's testable. +inline std::string newestWalletSalvageBak(const std::vector& filenames) +{ + long long best = -1; + std::string bestName; + for (const auto& f : filenames) { + if (f.rfind("wallet.", 0) != 0) continue; // must start "wallet." + if (f.size() < 12 || f.compare(f.size() - 4, 4, ".bak") != 0) continue; // ...and end ".bak" + const std::string mid = f.substr(7, f.size() - 7 - 4); // digits between the dots + if (mid.empty() || mid.size() > 18) continue; + bool allDigits = true; + for (char c : mid) if (c < '0' || c > '9') { allDigits = false; break; } + if (!allDigits) continue; + long long ts = 0; + for (char c : mid) ts = ts * 10 + (c - '0'); + if (ts > best) { best = ts; bestName = f; } + } + return bestName; +} + } // namespace daemon } // namespace dragonx diff --git a/src/util/i18n.cpp b/src/util/i18n.cpp index 62193fe..9201bb6 100644 --- a/src/util/i18n.cpp +++ b/src/util/i18n.cpp @@ -1193,6 +1193,14 @@ void I18n::loadBuiltinEnglish() 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 was auto-recovered"; + strings_["wallet_recovered_warn"] = "The node moved your wallet aside and loaded a salvaged copy."; + strings_["wallet_recovered_body"] = "On startup the node decided your wallet.dat looked damaged and recovered it automatically. Your ORIGINAL wallet was NOT deleted — it was renamed to \"wallet..bak\" in your data folder, and a salvaged copy is loaded now.\n\nThe salvaged copy may be incomplete, so the balance shown here could be wrong — don't treat it as final.\n\nThis is often a false alarm caused by leftover database files (e.g. after moving the wallet between machines). To restore your original: quit the wallet, then in the data folder rename the current wallet.dat aside, rename \"wallet..bak\" back to \"wallet.dat\", delete the \"database\" folder and any \"__db.*\" files, and reopen."; + strings_["wallet_recovered_open_folder"] = "Open data folder"; + strings_["wallet_recovered_dismiss"] = "Keep salvaged copy"; + strings_["wallet_recovered_notify"] = "The node recovered your wallet and moved the original to a .bak — your shown balance may be incomplete. See the prompt to restore it."; + // Receive Tab strings_["receiving_addresses"] = "Your Receiving Addresses"; strings_["new_z_shielded"] = "New z-Address (Shielded)"; diff --git a/tests/test_phase4.cpp b/tests/test_phase4.cpp index be6909e..b890c01 100644 --- a/tests/test_phase4.cpp +++ b/tests/test_phase4.cpp @@ -6139,6 +6139,23 @@ void testBlockDbOutputDiagnosis() EXPECT_FALSE(blockDbOutputLooksBroken("Error loading wallet")); // wallet corruption → salvage, not reindex EXPECT_FALSE(blockDbOutputLooksBroken("Error: Could not find any asmap file!")); EXPECT_FALSE(blockDbOutputLooksBroken("")); + + // Wallet auto-recovery detection: the node salvaged wallet.dat (moved the original to a .bak). + using dragonx::daemon::walletAutoRecovered; + EXPECT_TRUE(walletAutoRecovered( + "Warning: wallet.dat corrupt, data salvaged! Original wallet.dat saved as wallet.1786300000.bak in ...")); + EXPECT_TRUE(walletAutoRecovered("wallet.dat corrupt, salvage failed")); + EXPECT_FALSE(walletAutoRecovered("Loading wallet...\nWallet completed loading\n")); // normal load + EXPECT_FALSE(walletAutoRecovered(": Error loading block database.")); // block-DB abort != salvage + EXPECT_FALSE(walletAutoRecovered("")); + + // Newest salvage backup picker (the "wallet..bak" the recovery just made). + using dragonx::daemon::newestWalletSalvageBak; + EXPECT_EQ(newestWalletSalvageBak({"wallet.dat", "wallet.1786200000.bak", "wallet.1786300000.bak", "peers.dat"}), + std::string("wallet.1786300000.bak")); // highest timestamp wins + EXPECT_EQ(newestWalletSalvageBak({"wallet.dat", "wallet.dat.encrypted.bak", "notes.txt"}), + std::string("")); // no wallet..bak present + EXPECT_EQ(newestWalletSalvageBak({}), std::string("")); } // Live probe of a real lite server (env-gated). Validates CONNECT_ONLY latency + IP capture. From 384d64ea5d8240ad97f7afffa6770442ce18c6d9 Mon Sep 17 00:00:00 2001 From: DanS Date: Mon, 10 Aug 2026 00:45:47 -0500 Subject: [PATCH 36/89] feat(node): one-click "Restore original wallet" after a daemon auto-recovery MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Adds the restore action to the wallet-auto-recovery warning: undo the daemon's salvage by swapping the untouched original (wallet..bak) back over the salvaged copy and clearing the stale BDB env that triggered the false recovery, then restarting. Modeled on beginAdoptSeedWallet (stop daemon → file ops → restart on a worker; result pumped to the main thread for notifications). Safety (fund-adjacent file ops on a real wallet — copy/rename only, never delete user data): - picks the newest wallet..bak via the pure, unit-tested newestWalletSalvageBak(); aborts if none. - verifies the .bak is a real Berkeley DB (probeWalletFile) before touching anything — won't overwrite a working wallet with a bad backup. - stops the daemon first (stopDaemonForWalletSwitch) so wallet.dat is released. - moves the salvaged copy aside to wallet.dat.salvaged-.dat (kept), COPIES the .bak into place (the .bak stays), moves database/ aside to database.pre-restore-.bak (kept), and drops only the transient __db.* BDB region files. Rolls back the move if the copy fails. - relaunches the node even on failure so it's never left down. The warning dialog now offers Restore original wallet / Open data folder / Keep salvaged copy. Full-node only; lite-safe. Build clean, suite green (1/1). Co-Authored-By: Claude Opus 4.8 (1M context) --- src/app.cpp | 11 +++- src/app.h | 8 +++ src/app_network.cpp | 121 ++++++++++++++++++++++++++++++++++++++++++++ src/util/i18n.cpp | 11 ++++ 4 files changed, 149 insertions(+), 2 deletions(-) diff --git a/src/app.cpp b/src/app.cpp index d4cd032..eed5389 100644 --- a/src/app.cpp +++ b/src/app.cpp @@ -830,6 +830,7 @@ void App::update() // Pick up progress/result from a running seed-wallet migration (create/sweep/adopt). pumpSeedMigration(); + pumpWalletRestore(); // While confirming the sweep, poll the tx confirmations + legacy balance every ~5s. if (show_seed_migration_ && seed_migration_step_ == SeedMigrationStep::Confirming) { seed_migration_poll_timer_ -= ImGui::GetIO().DeltaTime; @@ -4302,8 +4303,14 @@ void App::renderWalletRecoveredDialog() ImGui::Dummy(ImVec2(0, ui::Layout::spacingSm())); ImGui::TextWrapped("%s", TR("wallet_recovered_body")); ImGui::Dummy(ImVec2(0, ui::Layout::spacingMd())); - if (ui::material::TactileButton(TR("wallet_recovered_open_folder"), ImVec2(240.0f * dp, 0))) { - util::Platform::openFolder(util::Platform::getDragonXDataDir()); + // Primary: one-click restore of the untouched original (stops the node, swaps the .bak back over the + // salvaged copy, clears the stale BDB env, restarts). Copy/rename-only — nothing is deleted. + if (ui::material::TactileButton(TR("wallet_recovered_restore"), ImVec2(260.0f * dp, 0))) { + restoreOriginalWallet(); // clears show_wallet_recovered_dialog_ + } + ImGui::SameLine(); + if (ui::material::TactileButton(TR("wallet_recovered_open_folder"), ImVec2(200.0f * dp, 0))) { + util::Platform::openFolder(util::Platform::getDragonXDataDir()); // manual restore instead } ImGui::SameLine(); if (ui::material::TactileButton(TR("wallet_recovered_dismiss"), ImVec2(150.0f * dp, 0))) { diff --git a/src/app.h b/src/app.h index c8353b9..dbb50a5 100644 --- a/src/app.h +++ b/src/app.h @@ -906,6 +906,12 @@ private: 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 + // "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. @@ -1338,6 +1344,8 @@ private: 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 restoreOriginalWallet(); // swap the wallet..bak back over the salvaged copy + restart + void pumpWalletRestore(); // main-thread: surface the restore op's result void processDeferredEncryption(); // Private methods - connection diff --git a/src/app_network.cpp b/src/app_network.cpp index f24e766..2b0e088 100644 --- a/src/app_network.cpp +++ b/src/app_network.cpp @@ -58,6 +58,7 @@ #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 "util/perf_log.h" #include "util/i18n.h" #include "util/secure_vault.h" @@ -4545,6 +4546,126 @@ void App::beginAdoptSeedWallet() }); } +// Undo a daemon wallet auto-recovery: swap the untouched original (wallet..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; + } + show_wallet_recovered_dialog_ = false; + { std::lock_guard 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 newest salvage backup (offline — no daemon needed). + std::vector files; + { + std::error_code lec; + for (const auto& e : fs::directory_iterator(datadir, lec)) + if (!lec) files.push_back(e.path().filename().string()); + } + const std::string bak = daemon::newestWalletSalvageBak(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 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 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; + 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(TR("wallet_restore_ok"), 12.0f); +} + void App::pumpSeedMigration() { if (capture_mode_) return; // no live ops during a UI sweep (steps are set directly) diff --git a/src/util/i18n.cpp b/src/util/i18n.cpp index 9201bb6..2d0e1fe 100644 --- a/src/util/i18n.cpp +++ b/src/util/i18n.cpp @@ -1199,7 +1199,18 @@ void I18n::loadBuiltinEnglish() strings_["wallet_recovered_body"] = "On startup the node decided your wallet.dat looked damaged and recovered it automatically. Your ORIGINAL wallet was NOT deleted — it was renamed to \"wallet..bak\" in your data folder, and a salvaged copy is loaded now.\n\nThe salvaged copy may be incomplete, so the balance shown here could be wrong — don't treat it as final.\n\nThis is often a false alarm caused by leftover database files (e.g. after moving the wallet between machines). To restore your original: quit the wallet, then in the data folder rename the current wallet.dat aside, rename \"wallet..bak\" back to \"wallet.dat\", delete the \"database\" folder and any \"__db.*\" files, and reopen."; strings_["wallet_recovered_open_folder"] = "Open data folder"; strings_["wallet_recovered_dismiss"] = "Keep salvaged copy"; + strings_["wallet_recovered_restore"] = "Restore original wallet"; strings_["wallet_recovered_notify"] = "The node recovered your wallet and moved the original to a .bak — your shown balance may be incomplete. See the prompt to restore it."; + // One-click "Restore original wallet" flow. + strings_["wallet_restore_started"] = "Restoring your original wallet and restarting the node…"; + 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..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."; // Receive Tab strings_["receiving_addresses"] = "Your Receiving Addresses"; From 975650f11b3d872789c4d5853c4af3dbe0412a08 Mon Sep 17 00:00:00 2001 From: DanS Date: Mon, 10 Aug 2026 00:52:41 -0500 Subject: [PATCH 37/89] fix(node): restore the LARGEST salvage backup, not the newest (salvage cascade) MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit The "Restore original wallet" action picked the newest wallet..bak — but the daemon auto-salvages on every failed BDB verify, and each round SHRINKS the wallet (salvage keeps only readable records + drops the dead-page bloat). In a cascade the newest .bak is the most-degraded (seen in the wild as "Salvage found no records") while the original is the oldest and by far the largest. Pick by file SIZE instead: add largestWalletSalvageBak((name,size) pairs) — the largest wallet..bak is the least-salvaged, i.e. the pristine original (an emptied salvage is tiny; a real wallet is large); ties break to the newest ts. Factor the shared parse into parseWalletSalvageBakTs(). restoreOriginalWallet() now gathers file sizes and uses it (still verifies the pick is a valid BDB before swapping). newestWalletSalvageBak kept for reference. Adds a cascade regression test (a 40KB emptied newest .bak must NOT win over the 194MB original). Suite green (1/1). Co-Authored-By: Claude Opus 4.8 (1M context) --- src/app_network.cpp | 17 +++++++--- src/daemon/daemon_startup_diagnosis.h | 46 ++++++++++++++++++++------- tests/test_phase4.cpp | 12 +++++++ 3 files changed, 59 insertions(+), 16 deletions(-) diff --git a/src/app_network.cpp b/src/app_network.cpp index 2b0e088..04007ff 100644 --- a/src/app_network.cpp +++ b/src/app_network.cpp @@ -4575,14 +4575,21 @@ void App::restoreOriginalWallet() std::string err, warn; try { const std::string datadir = util::Platform::getDragonXDataDir(); - // 1. Find the newest salvage backup (offline — no daemon needed). - std::vector files; + // 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> files; { std::error_code lec; - for (const auto& e : fs::directory_iterator(datadir, lec)) - if (!lec) files.push_back(e.path().filename().string()); + 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(sz)); + } } - const std::string bak = daemon::newestWalletSalvageBak(files); + const std::string bak = daemon::largestWalletSalvageBak(files); if (bak.empty()) { err = TR("wallet_restore_no_backup"); } else if (!util::probeWalletFile(datadir + "/" + bak).isBerkeleyDB) { diff --git a/src/daemon/daemon_startup_diagnosis.h b/src/daemon/daemon_startup_diagnosis.h index 38a1883..5307865 100644 --- a/src/daemon/daemon_startup_diagnosis.h +++ b/src/daemon/daemon_startup_diagnosis.h @@ -8,6 +8,7 @@ #pragma once #include +#include #include namespace dragonx { @@ -39,26 +40,49 @@ inline bool walletAutoRecovered(const std::string& out) || out.find("wallet.dat corrupt, salvage failed") != std::string::npos; // RECOVER_FAIL } -// From a list of datadir filenames, pick the most recent daemon salvage backup — the "wallet..bak" -// the auto-recovery just created (highest timestamp). Returns "" if none present. Pure, so it's testable. +// If `name` is a daemon salvage backup "wallet..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& filenames) { long long best = -1; std::string bestName; for (const auto& f : filenames) { - if (f.rfind("wallet.", 0) != 0) continue; // must start "wallet." - if (f.size() < 12 || f.compare(f.size() - 4, 4, ".bak") != 0) continue; // ...and end ".bak" - const std::string mid = f.substr(7, f.size() - 7 - 4); // digits between the dots - if (mid.empty() || mid.size() > 18) continue; - bool allDigits = true; - for (char c : mid) if (c < '0' || c > '9') { allDigits = false; break; } - if (!allDigits) continue; - long long ts = 0; - for (char c : mid) ts = ts * 10 + (c - '0'); + 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>& 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 diff --git a/tests/test_phase4.cpp b/tests/test_phase4.cpp index b890c01..d065651 100644 --- a/tests/test_phase4.cpp +++ b/tests/test_phase4.cpp @@ -6156,6 +6156,18 @@ void testBlockDbOutputDiagnosis() EXPECT_EQ(newestWalletSalvageBak({"wallet.dat", "wallet.dat.encrypted.bak", "notes.txt"}), std::string("")); // no wallet..bak present EXPECT_EQ(newestWalletSalvageBak({}), std::string("")); + + // Restore must pick the LARGEST (least-salvaged) backup, NOT the newest — a salvage cascade shrinks + // the wallet each round, so the newest .bak can be an emptied 40KB copy while the original is huge. + using dragonx::daemon::largestWalletSalvageBak; + EXPECT_EQ(largestWalletSalvageBak({ + {"wallet.dat", 40000ull}, // current (salvaged, tiny) — not a .bak + {"wallet.1786200000.bak", 194174976ull}, // ORIGINAL — oldest ts, biggest + {"wallet.1786340620.bak", 40960ull}, // latest salvage — newest ts, empty + {"peers.dat", 999ull}}), + std::string("wallet.1786200000.bak")); // largest wins over newest + EXPECT_EQ(largestWalletSalvageBak({{"wallet.dat", 100ull}, {"notes.txt", 5ull}}), std::string("")); + EXPECT_EQ(largestWalletSalvageBak({}), std::string("")); } // Live probe of a real lite server (env-gated). Validates CONNECT_ONLY latency + IP capture. From b2e037bb67752556e0d20bf79c9aae9a10af16cc Mon Sep 17 00:00:00 2001 From: DanS Date: Mon, 10 Aug 2026 10:20:32 -0500 Subject: [PATCH 38/89] chore(gitignore): never track wallet.dat (holds private keys) A wallet.dat placed in the repo root for recovery was untracked but NOT ignored, so a stray 'git add .' could commit private keys. *.bak already covered the salvage backups; add wallet.dat / wallet-*.dat / wallet.dat.* explicitly. Co-Authored-By: Claude Opus 4.8 (1M context) --- .gitignore | 4 ++++ 1 file changed, 4 insertions(+) diff --git a/.gitignore b/.gitignore index 134ccab..47b4daa 100644 --- a/.gitignore +++ b/.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 From bc183257b7bc114ebf98ad8ab243d4e3ee1f5162 Mon Sep 17 00:00:00 2001 From: DanS Date: Mon, 10 Aug 2026 11:26:55 -0500 Subject: [PATCH 39/89] feat(node): in-app "Rebuild wallet database" recovery for a BDB-inconsistent wallet MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Automates the manual recovery that fixed a wallet.dat with stale Berkeley DB extent metadata (the "main" subdb metapage records a low last_pgno while its live data spans thousands of pages beyond it). A tolerant page-walk reads every record, but the daemon's BDB verify rejects the file and auto-salvages it — finding nothing and shrinking the wallet to empty on each restart (the salvage cascade that looks like fund loss). Plain "Restore original" can't fix it (hands the same broken file back → re-salvage); a rebuild must produce a fresh, consistent DB. Pieces (Approach A from the design workflow — out-of-process helper keeps AGPL Berkeley DB out of the GPLv3 GUI): - util/wallet_file_probe.h: extractWalletBtreeRecords() — sibling to parseWalletBtree that collects raw (key,value) bytes (same bounds-checked, subdb-aware walk). Records copied verbatim → encrypted key material passes through as opaque ciphertext (no passphrase). Overflow-page values (only large tx history) are skipped + counted; a rescan rebuilds history — funds unaffected. - tools/wallet_rebuild/main.cpp: dragonx-wallet-rebuild CLI — reads via the tolerant reader, writes the records into a fresh BDB "main" btree via libdb (DB_EXCL, never overwrites), prints a JSON summary. New BDB-guarded CMake target. - App::rebuildWalletDatabase(): picks the largest readable wallet/.bak as source, stops the daemon, runs the helper, VERIFIES the output (readable BDB with keys) before swapping, moves the current wallet aside (kept, timestamped), installs the rebuilt one, clears the stale BDB env, sets -rescan, restarts. Copy/rename only — never deletes. Result surfaced via the existing pumpWalletRestore channel. - Wired as the preferred action on the existing wallet-auto-recovery dialog (shown only when the helper is present). Full-node only; lite-safe. Verified end-to-end against the real broken wallet: helper reads 3,808 t-keys + 1 z-key + HD seed and the daemon LOADS the rebuilt output with no salvage. Adds extractWalletBtreeRecords coverage. Build clean, suite green (1/1). Remaining (follow-up): release packaging — build.sh bundling the helper built against the vendored per-platform static libdb (DRAGONX_BDB_ROOT), and a macOS Berkeley DB port (no in-tree artifact). Co-Authored-By: Claude Opus 4.8 (1M context) --- CMakeLists.txt | 20 +++++ src/app.cpp | 13 ++- src/app.h | 4 +- src/app_network.cpp | 156 +++++++++++++++++++++++++++++++++- src/util/i18n.cpp | 8 ++ src/util/wallet_file_probe.h | 150 ++++++++++++++++++++++++++++++++ tests/test_phase4.cpp | 12 +++ tools/wallet_rebuild/main.cpp | 90 ++++++++++++++++++++ 8 files changed, 449 insertions(+), 4 deletions(-) create mode 100644 tools/wallet_rebuild/main.cpp diff --git a/CMakeLists.txt b/CMakeLists.txt index 31fd4fb..6774e0e 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -1075,6 +1075,26 @@ 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}) + 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 # ----------------------------------------------------------------------------- diff --git a/src/app.cpp b/src/app.cpp index eed5389..a504d23 100644 --- a/src/app.cpp +++ b/src/app.cpp @@ -4303,8 +4303,17 @@ void App::renderWalletRecoveredDialog() ImGui::Dummy(ImVec2(0, ui::Layout::spacingSm())); ImGui::TextWrapped("%s", TR("wallet_recovered_body")); ImGui::Dummy(ImVec2(0, ui::Layout::spacingMd())); - // Primary: one-click restore of the untouched original (stops the node, swaps the .bak back over the - // salvaged copy, clears the stale BDB env, restarts). Copy/rename-only — nothing is deleted. + // Preferred fix when available: REBUILD the wallet database. Plain "Restore original" hands the same + // BDB-inconsistent file back and the daemon just re-salvages it (the cascade); the rebuild produces a + // fresh, consistent copy of every key that the daemon loads cleanly. Copy/rename-only — never deletes. + if (walletRebuildAvailable()) { + if (ui::material::TactileButton(TR("wallet_recovered_rebuild"), ImVec2(280.0f * dp, 0))) { + rebuildWalletDatabase(); // clears show_wallet_recovered_dialog_ + } + ImGui::Dummy(ImVec2(0, ui::Layout::spacingSm())); + } + // Restore of the untouched original (stops the node, swaps the .bak back over the salvaged copy, + // clears the stale BDB env, restarts). if (ui::material::TactileButton(TR("wallet_recovered_restore"), ImVec2(260.0f * dp, 0))) { restoreOriginalWallet(); // clears show_wallet_recovered_dialog_ } diff --git a/src/app.h b/src/app.h index dbb50a5..9f66b7b 100644 --- a/src/app.h +++ b/src/app.h @@ -1345,7 +1345,9 @@ private: void reindexBlockDatabase(); // restart the daemon with -reindex to rebuild the block DB void renderWalletRecoveredDialog(); // warn that the node auto-recovered/salvaged wallet.dat void restoreOriginalWallet(); // swap the wallet..bak back over the salvaged copy + restart - void pumpWalletRestore(); // main-thread: surface the restore op's result + 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 diff --git a/src/app_network.cpp b/src/app_network.cpp index 04007ff..e7bd35a 100644 --- a/src/app_network.cpp +++ b/src/app_network.cpp @@ -59,6 +59,8 @@ #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 // popen the rebuild helper #include "util/perf_log.h" #include "util/i18n.h" #include "util/secure_vault.h" @@ -4670,7 +4672,159 @@ void App::pumpWalletRestore() if (!done) return; 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(TR("wallet_restore_ok"), 12.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; + } + return {}; +} + +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; } + + show_wallet_recovered_dialog_ = false; + { std::lock_guard 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(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 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() diff --git a/src/util/i18n.cpp b/src/util/i18n.cpp index 2d0e1fe..87b5de3 100644 --- a/src/util/i18n.cpp +++ b/src/util/i18n.cpp @@ -1211,6 +1211,14 @@ void I18n::loadBuiltinEnglish() 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"] = "Rebuild wallet database (recommended)"; + strings_["wallet_rebuild_started"] = "Rebuilding your wallet database and restarting the node…"; + 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"; diff --git a/src/util/wallet_file_probe.h b/src/util/wallet_file_probe.h index 9f3b100..fa22130 100644 --- a/src/util/wallet_file_probe.h +++ b/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> 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(static_cast(sz), maxBytes); + f.seekg(0, std::ios::beg); + buf.resize(want); + f.read(&buf[0], static_cast(want)); + buf.resize(static_cast(std::max(0, f.gcount()))); + if (buf.size() < 512) return out; + out.bytesRead = buf.size(); + out.complete = (buf.size() == static_cast(sz)); + } + const unsigned char* B = reinterpret_cast(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(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 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 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(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(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 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(pgno) * pagesize + 25]; + if (pt == P_BTREEMETA) { + const uint32_t sr = r32(static_cast(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(kp), kl), + std::string(reinterpret_cast(dp), dl)); + const uint32_t nlen = kp[0]; + if (nlen >= 2 && nlen <= 20 && 1u + nlen <= kl && isKeyType(reinterpret_cast(kp + 1), nlen)) + out.keyRecords++; + }); + if (aborted) return out; + } + out.parsed = true; + return out; +} + } // namespace util } // namespace dragonx diff --git a/tests/test_phase4.cpp b/tests/test_phase4.cpp index d065651..321c783 100644 --- a/tests/test_phase4.cpp +++ b/tests/test_phase4.cpp @@ -845,6 +845,18 @@ void testWalletFileProbe() EXPECT_EQ(s.txCount, 1); EXPECT_EQ(s.transparentKeys, 1); EXPECT_EQ(s.addresses(), 1); EXPECT_EQ(s.createdEpoch, kCreated); EXPECT_FALSE(dragonx::util::parseWalletBtree((dir / "junk.dat").string()).parsed); + + // Byte-collecting reader (the wallet-REBUILD read half): same walk, but collects (key,value) bytes. + auto ex = dragonx::util::extractWalletBtreeRecords((dir / "btree.dat").string()); + EXPECT_TRUE(ex.parsed); + EXPECT_TRUE(ex.records.size() >= static_cast(3)); // tx + key + keymeta captured verbatim + EXPECT_EQ(ex.keyRecords, 1); // the "key" record is fund-critical + bool foundKeyRec = false; // value copied byte-for-byte, name intact + for (const auto& kv : ex.records) + if (kv.first.size() >= 4 && (unsigned char)kv.first[0] == 3 && kv.first.compare(1, 3, "key") == 0 + && !kv.second.empty()) foundKeyRec = true; + EXPECT_TRUE(foundKeyRec); + EXPECT_FALSE(dragonx::util::extractWalletBtreeRecords((dir / "junk.dat").string()).parsed); } // 8) Mnemonic-flag decode (hdChainMnemonicFlag): the fMnemonicSeed byte lives at offset 52 of the diff --git a/tools/wallet_rebuild/main.cpp b/tools/wallet_rebuild/main.cpp new file mode 100644 index 0000000..6586f6b --- /dev/null +++ b/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 +// 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 + +#include +#include +#include + +int main(int argc, char** argv) +{ + if (argc < 3) { + std::fprintf(stderr, "usage: dragonx-wallet-rebuild \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(kv.first.data()); k.size = static_cast(kv.first.size()); + v.data = const_cast(kv.second.data()); v.size = static_cast(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; +} From 8ffcd9cc8c65f6454588be8a909bb66071f4492a Mon Sep 17 00:00:00 2001 From: DanS Date: Mon, 10 Aug 2026 11:38:20 -0500 Subject: [PATCH 40/89] build(node): bundle dragonx-wallet-rebuild in Linux + Windows releases MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Wires the wallet-rebuild recovery helper into the release pipeline so a shipped build actually carries it (the app locates it next to dragonxd). - CMakeLists: link the vendored STATIC Berkeley DB for the helper — add Threads::Threads + dl (Linux) / ws2_32 (Windows) that the static libdb-6.2 needs (the system shared lib pulled those in transitively; the static one doesn't). - build.sh (Linux + Windows): pass BDB_INCLUDE_DIR/BDB_LIBRARY explicitly at configure, pointing at external/dragonx/depends//{include,lib/libdb-6.2.a} — the same libdb the daemon links, so the helper's output is a v6.2 btree the bundled dragonxd reads. Explicit paths bypass find_library (and the mingw toolchain's sysroot-only find restriction). Guarded: no depends → helper simply not built/bundled. Strip + copy the helper next to dragonxd(.exe) in both bundles. Verified: Linux links the vendored libdb-6.2.a statically (no dynamic libdb) and rebuilds the real broken wallet correctly; the helper cross-compiles cleanly with mingw against the vendored Windows libdb-6.2.a to a PE32+ x64 exe. Full app + helper build, suite green (1/1), build.sh syntax OK. Remaining: macOS Berkeley DB (no in-tree depends artifact) + resource-embedding as an alternative to side-by-side bundling. Co-Authored-By: Claude Opus 4.8 (1M context) --- CMakeLists.txt | 6 ++++++ build.sh | 29 +++++++++++++++++++++++++++++ 2 files changed, 35 insertions(+) diff --git a/CMakeLists.txt b/CMakeLists.txt index 6774e0e..90c7188 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -1089,6 +1089,12 @@ 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() diff --git a/build.sh b/build.sh index d8681a4..66d9f3b 100755 --- a/build.sh +++ b/build.sh @@ -286,6 +286,14 @@ bundle_linux_daemon() { # asmap.dat find_asmap && cp "$ASMAP_DAT" "$dest/asmap.dat" && info " Bundled asmap.dat" + # dragonx-wallet-rebuild helper (offline recovery for a BDB-inconsistent wallet.dat) + for p in "$SCRIPT_DIR/build/linux/bin/dragonx-wallet-rebuild" "$SCRIPT_DIR/../dragonx-wallet-rebuild"; do + if [[ -f "$p" ]]; then + cp "$p" "$dest/dragonx-wallet-rebuild"; chmod +x "$dest/dragonx-wallet-rebuild" + info " Bundled dragonx-wallet-rebuild"; break + fi + done + return $found } @@ -336,11 +344,20 @@ 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" ) + 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 ..." @@ -350,6 +367,7 @@ build_release_linux() { 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 @@ -750,11 +768,20 @@ 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" ) + 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[@]}" @@ -779,6 +806,8 @@ 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) + [[ -f "bin/dragonx-wallet-rebuild.exe" ]] && { cp "bin/dragonx-wallet-rebuild.exe" "$dist_dir/"; info " Bundled dragonx-wallet-rebuild.exe"; } # Bundle Sapling params + asmap for the zip distribution # (The single-file exe has these embedded via INCBIN, but the zip From 3216debc7d2094ff441f4049787f6a3d24d65a39 Mon Sep 17 00:00:00 2001 From: DanS Date: Mon, 10 Aug 2026 12:04:07 -0500 Subject: [PATCH 41/89] fix(node): detect a wallet salvage at startup, not only on connect MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Reported: loading a BDB-inconsistent wallet silently renamed it and created a new one — no recovery dialog. Two causes, both fixed: 1) Detection ran only in onConnected(). The salvage happens at STARTUP, and the node may never connect (block-index abort, long sync, crash) — or a long sync trims the salvage line out of the rolling output buffer before connect. Extract detectWalletAutoRecovery() and run it every tryConnect() tick (every ~5s during startup), so the salvage is caught the instant it appears, regardless of whether the node connects. Also hold the crash-restart loop while a salvage is pending, so the wallet can't be re-salvaged/shrunk while the Rebuild/Restore dialog is up. 2) walletAutoRecovered() only matched the SUCCESSFUL-salvage strings. A BDB-inconsistent file makes aggressive salvage FAIL ("found no records"), which prints different lines. Broaden the detector to the signals that fire in every case: "CDBEnv::Salvage", the "Renamed to wallet..bak" rename, and "found no records in wallet" — while still not matching normal startup or a block-DB abort. Adds the exact failed-salvage sequence to the detector test. Build clean, suite green (1/1). Co-Authored-By: Claude Opus 4.8 (1M context) --- src/app.h | 1 + src/app_network.cpp | 40 ++++++++++++++++++--------- src/daemon/daemon_startup_diagnosis.h | 15 ++++++++-- src/util/i18n.cpp | 1 + tests/test_phase4.cpp | 6 ++++ 5 files changed, 47 insertions(+), 16 deletions(-) diff --git a/src/app.h b/src/app.h index 9f66b7b..a9fde2d 100644 --- a/src/app.h +++ b/src/app.h @@ -1344,6 +1344,7 @@ private: 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..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) diff --git a/src/app_network.cpp b/src/app_network.cpp index e7bd35a..f24e1b2 100644 --- a/src/app_network.cpp +++ b/src/app_network.cpp @@ -229,6 +229,24 @@ static constexpr int kDaemonWaitWarnAttempts = 4; // Connection Management // ============================================================================ +// dragonxd moves wallet.dat to wallet..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().error(TR("wallet_recovered_notify"), 30.0f); + 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 @@ -236,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 @@ -519,6 +541,10 @@ void App::tryConnect() // Prevent infinite crash-restart loop 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 @@ -575,19 +601,7 @@ void App::onConnected() daemon_last_seen_crashes_ = 0; // (onConnected resets the daemon's crash count too) connection_status_ = TR("connected"); - // Detect a silent wallet AUTO-RECOVERY: dragonxd moves wallet.dat to wallet..bak and loads a - // salvaged copy whenever BDB verify fails (no flag, often a false positive from stale/cross-platform - // env state). The node comes up fine — so we only see it here, on connect — but the loaded wallet can - // be empty/incomplete, which reads as fund loss. Surface it loudly, once per session, so the user can - // restore the untouched original from the .bak. (Full-node only; lite has no embedded dragonxd.) - if (!wallet_auto_recovered_warned_ && isUsingEmbeddedDaemon() && daemon_controller_ && daemon_controller_->daemon() && - daemon::walletAutoRecovered(daemon_controller_->daemon()->getOutput())) { - wallet_auto_recovered_ = true; - wallet_auto_recovered_warned_ = true; - show_wallet_recovered_dialog_ = true; - ui::Notifications::instance().error(TR("wallet_recovered_notify"), 30.0f); - VERBOSE_LOGF("[connect] Daemon auto-recovered wallet.dat (salvage) — warning the user\n"); - } + 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). diff --git a/src/daemon/daemon_startup_diagnosis.h b/src/daemon/daemon_startup_diagnosis.h index 5307865..72ce57e 100644 --- a/src/daemon/daemon_startup_diagnosis.h +++ b/src/daemon/daemon_startup_diagnosis.h @@ -35,9 +35,18 @@ inline bool blockDbOutputLooksBroken(const std::string& out) // 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) { - return out.find("wallet.dat corrupt, data salvaged") != std::string::npos // RECOVER_OK warning - || out.find("Original wallet.dat saved as wallet.") != std::string::npos // the rename-aside notice - || out.find("wallet.dat corrupt, salvage failed") != std::string::npos; // RECOVER_FAIL + // Cover BOTH salvage outcomes. A successful salvage prints the "data salvaged"/"saved as wallet..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 to wallet..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..bak", return its timestamp; else -1. diff --git a/src/util/i18n.cpp b/src/util/i18n.cpp index 87b5de3..d0fcecd 100644 --- a/src/util/i18n.cpp +++ b/src/util/i18n.cpp @@ -1345,6 +1345,7 @@ void I18n::loadBuiltinEnglish() 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 needs recovery — see the prompt"; // 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"; diff --git a/tests/test_phase4.cpp b/tests/test_phase4.cpp index 321c783..c420a7d 100644 --- a/tests/test_phase4.cpp +++ b/tests/test_phase4.cpp @@ -6157,6 +6157,12 @@ void testBlockDbOutputDiagnosis() EXPECT_TRUE(walletAutoRecovered( "Warning: wallet.dat corrupt, data salvaged! Original wallet.dat saved as wallet.1786300000.bak in ...")); EXPECT_TRUE(walletAutoRecovered("wallet.dat corrupt, salvage failed")); + // The FAILED-salvage sequence a BDB-inconsistent wallet actually produces (must also be detected — + // this is the case that previously slipped through and silently emptied the wallet). + EXPECT_TRUE(walletAutoRecovered( + "Renamed wallet.dat to wallet.1786375505.bak\n" + "CDBEnv::Salvage: Database salvage found errors, all data may not be recoverable.\n" + "Salvage(aggressive) found no records in wallet.1786375505.bak.\n")); EXPECT_FALSE(walletAutoRecovered("Loading wallet...\nWallet completed loading\n")); // normal load EXPECT_FALSE(walletAutoRecovered(": Error loading block database.")); // block-DB abort != salvage EXPECT_FALSE(walletAutoRecovered("")); From ac49f44f84df944207a48477bacd869f0394b3ba Mon Sep 17 00:00:00 2001 From: DanS Date: Mon, 10 Aug 2026 12:28:48 -0500 Subject: [PATCH 42/89] fix(node): show recovery actions in the daemon-error overlay (not a separate dialog) MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Reported with a screenshot: on a salvage-then-abort, the status correctly read "Wallet needs recovery — see the prompt" but no prompt appeared — the separate BeginOverlayDialog is occluded by the full-frame loading/daemon-error overlay that's drawn every frame while the node is down. Render the recovery actions directly IN the daemon-error overlay when a salvage is detected: a concise message + prominent one-click "Rebuild wallet database" / "Restore original" / "Open data folder" buttons (same handlers as the dialog), placed right after the title and skipping the verbose daemon-output dump so they stay on-screen. The verbose diagnostics + crash-count hint still show for non-recovery errors. Build clean, suite green. Co-Authored-By: Claude Opus 4.8 (1M context) --- src/app.cpp | 64 ++++++++++++++++++++++++++++++++++++----------------- 1 file changed, 44 insertions(+), 20 deletions(-) diff --git a/src/app.cpp b/src/app.cpp index a504d23..195ea6c 100644 --- a/src/app.cpp +++ b/src/app.cpp @@ -5679,26 +5679,50 @@ void App::renderLoadingOverlay(float contentH) IM_COL32(255, 90, 90, 255), errTitle); curY += ts.y + gap * 0.5f; - // Error details (wrapped) — show full diagnostic info - const std::string& errDetail = daemon_controller_->lastError(); - if (!errDetail.empty()) { - float wrapW = ws.x * 0.8f; - if (wrapW > 700.0f) wrapW = 700.0f; - ImVec2 es = capFont->CalcTextSizeA(capFont->LegacySize, FLT_MAX, wrapW, errDetail.c_str()); - dl->AddText(capFont, capFont->LegacySize, - ImVec2(wp.x + cx - wrapW * 0.5f, curY), - IM_COL32(255, 180, 180, 220), errDetail.c_str(), nullptr, wrapW); - curY += es.y + gap; - } - - // Crash count hint - if (daemon_controller_->crashCount() >= 3) { - const char* hint = "Use Settings > Restart Daemon to try again"; - ImVec2 hs2 = capFont->CalcTextSizeA(capFont->LegacySize, FLT_MAX, 0.0f, hint); - dl->AddText(capFont, capFont->LegacySize, - ImVec2(wp.x + cx - hs2.x * 0.5f, curY), - IM_COL32(200, 200, 200, 180), hint); - curY += hs2.y + gap; + // Wallet auto-recovery/salvage takes over the error card: a concise message + prominent one-click + // actions, RIGHT HERE in the overlay the user is looking at (the separate dialog can be occluded + // by this full-frame overlay while the node is down). Skip the verbose daemon dump so the buttons + // stay on-screen. Same handlers as the dialog. + if (wallet_auto_recovered_) { + const char* msg = TR("wallet_recovered_warn"); + float wrapW = ws.x * 0.8f; if (wrapW > 640.0f) wrapW = 640.0f; + ImVec2 ms = capFont->CalcTextSizeA(capFont->LegacySize, FLT_MAX, wrapW, msg); + dl->AddText(capFont, capFont->LegacySize, ImVec2(wp.x + cx - wrapW * 0.5f, curY), + IM_COL32(230, 210, 210, 235), msg, nullptr, wrapW); + curY += ms.y + gap; + const float dpi = ui::Layout::dpiScale(); + const float bw = 340.0f * dpi; + auto placeBtn = [&](const char* label) -> bool { + ImGui::SetCursorScreenPos(ImVec2(wp.x + cx - bw * 0.5f, curY)); + const bool clicked = ui::material::TactileButton(label, ImVec2(bw, 0)); + curY = ImGui::GetItemRectMax().y + gap * 0.4f; + return clicked; + }; + if (walletRebuildAvailable() && placeBtn(TR("wallet_recovered_rebuild"))) rebuildWalletDatabase(); + if (placeBtn(TR("wallet_recovered_restore"))) restoreOriginalWallet(); + if (placeBtn(TR("wallet_recovered_open_folder"))) + util::Platform::openFolder(util::Platform::getDragonXDataDir()); + } else { + // Error details (wrapped) — full diagnostic info. + const std::string& errDetail = daemon_controller_->lastError(); + if (!errDetail.empty()) { + float wrapW = ws.x * 0.8f; + if (wrapW > 700.0f) wrapW = 700.0f; + ImVec2 es = capFont->CalcTextSizeA(capFont->LegacySize, FLT_MAX, wrapW, errDetail.c_str()); + dl->AddText(capFont, capFont->LegacySize, + ImVec2(wp.x + cx - wrapW * 0.5f, curY), + IM_COL32(255, 180, 180, 220), errDetail.c_str(), nullptr, wrapW); + curY += es.y + gap; + } + // Crash count hint + if (daemon_controller_->crashCount() >= 3) { + const char* hint = "Use Settings > Restart Daemon to try again"; + ImVec2 hs2 = capFont->CalcTextSizeA(capFont->LegacySize, FLT_MAX, 0.0f, hint); + dl->AddText(capFont, capFont->LegacySize, + ImVec2(wp.x + cx - hs2.x * 0.5f, curY), + IM_COL32(200, 200, 200, 180), hint); + curY += hs2.y + gap; + } } } From 393f3d147e3ec2fe63a6f0f51e15dbab5cba3d6a Mon Sep 17 00:00:00 2001 From: DanS Date: Mon, 10 Aug 2026 22:10:57 -0500 Subject: [PATCH 43/89] feat(recovery): bundle & embed the offline wallet-rebuild helper in every release MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit The dragonx-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 — yet it was silently dropped from every packaged build: - Linux zip/AppImage copied a hand-picked file list that omitted it. - Windows bundled it only behind a soft `[[ -f ]]` guard (silent skip). - macOS never wired Berkeley DB, never built it, never bundled it. build.sh now HARD-REQUIRES the helper for full-node releases (fails the build if the vendored Berkeley DB depends are missing, rather than shipping recovery-less), and ships it in the Linux zip + AppImage, the Windows zip, and the macOS .app. It also compiles the helper standalone for Windows and INCBINs it, and embedded_resources gains ensureWalletRebuildHelperExtracted() to extract it on demand — so a self-contained ObsidianDragon.exe carries recovery exactly like the embedded daemon, even on a machine where first-run param extraction already ran. Co-Authored-By: Claude Opus 4.8 (1M context) --- build.sh | 82 +++++++++++++++++++++++++--- src/resources/embedded_resources.cpp | 47 ++++++++++++++++ src/resources/embedded_resources.h | 7 +++ 3 files changed, 127 insertions(+), 9 deletions(-) diff --git a/build.sh b/build.sh index 66d9f3b..e54ff98 100755 --- a/build.sh +++ b/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,13 +304,8 @@ bundle_linux_daemon() { # asmap.dat find_asmap && cp "$ASMAP_DAT" "$dest/asmap.dat" && info " Bundled asmap.dat" - # dragonx-wallet-rebuild helper (offline recovery for a BDB-inconsistent wallet.dat) - for p in "$SCRIPT_DIR/build/linux/bin/dragonx-wallet-rebuild" "$SCRIPT_DIR/../dragonx-wallet-rebuild"; do - if [[ -f "$p" ]]; then - cp "$p" "$dest/dragonx-wallet-rebuild"; chmod +x "$dest/dragonx-wallet-rebuild" - info " Bundled dragonx-wallet-rebuild"; break - fi - done + # (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 } @@ -351,6 +364,10 @@ build_release_linux() { 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" \ @@ -365,6 +382,9 @@ 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" @@ -402,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" @@ -435,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" @@ -656,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 @@ -775,6 +824,10 @@ HDR 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" \ @@ -791,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" @@ -806,8 +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) - [[ -f "bin/dragonx-wallet-rebuild.exe" ]] && { cp "bin/dragonx-wallet-rebuild.exe" "$dist_dir/"; info " Bundled dragonx-wallet-rebuild.exe"; } + # 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 @@ -1063,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/) — 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" @@ -1135,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 diff --git a/src/resources/embedded_resources.cpp b/src/resources/embedded_resources.cpp index f1f2c92..e144eb9 100644 --- a/src/resources/embedded_resources.cpp +++ b/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 diff --git a/src/resources/embedded_resources.h b/src/resources/embedded_resources.h index a45b13d..ae8f0a7 100644 --- a/src/resources/embedded_resources.h +++ b/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"; From 001e85ac1a1e27ac0fe6ac2a3b6ce8e9890e7524 Mon Sep 17 00:00:00 2001 From: DanS Date: Mon, 10 Aug 2026 22:11:07 -0500 Subject: [PATCH 44/89] fix(ui): prevent text/button cutoff and scale hand-drawn geometry at HiDPI MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Findings from a UI-cutoff audit — each is a spot where an in-tree helper (truncateMiddle / TruncateToWidth / measured button width / the *dpiScale/*hs factors) was bypassed: - notifications: the toast-pill height/padding/icon-gap were raw logical px while the icon/text drawn inside are DPI-baked, so they clipped the pill at HiDPI. Scale the geometry by dpiScale (not the already-scaled glyph metrics). - settings: in the two-column NODE & SECURITY layout the data-directory path could overrun into the Daemon-binary column (shared draw list, no clip rect between them). Middle-ellipsize it to the column width; the full path stays in the tooltip + click-to-open + copy. - send: the "Confirm & Send" button width came straight from the schema and was never measured against the label, clipping the Russian translation on the pre-broadcast dialog. Size to max(schema width, measured label + padding). - balance: the recent-tx address-column offset missed the `* hs` DPI factor its sibling (amount-right-margin) uses, overlapping the type label at HiDPI. Co-Authored-By: Claude Opus 4.8 (1M context) --- src/ui/notifications.cpp | 19 +++++++++++-------- src/ui/pages/settings_page.cpp | 14 ++++++++++++-- src/ui/windows/balance_components.cpp | 2 +- src/ui/windows/send_tab.cpp | 12 +++++++++++- 4 files changed, 35 insertions(+), 12 deletions(-) diff --git a/src/ui/notifications.cpp b/src/ui/notifications.cpp index 7f0b012..7d6d1d5 100644 --- a/src/ui/notifications.cpp +++ b/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); diff --git a/src/ui/pages/settings_page.cpp b/src/ui/pages/settings_page.cpp index 80bf8e2..0b0c227 100644 --- a/src/ui/pages/settings_page.cpp +++ b/src/ui/pages/settings_page.cpp @@ -2081,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()); diff --git a/src/ui/windows/balance_components.cpp b/src/ui/windows/balance_components.cpp index dd97827..8ee7d78 100644 --- a/src/ui/windows/balance_components.cpp +++ b/src/ui/windows/balance_components.cpp @@ -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()); diff --git a/src/ui/windows/send_tab.cpp b/src/ui/windows/send_tab.cpp index c0cb5ab..1bee4fd 100644 --- a/src/ui/windows/send_tab.cpp +++ b/src/ui/windows/send_tab.cpp @@ -822,7 +822,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. From 5edbe8a276d9f5ef38df74783a098773aa79c172 Mon Sep 17 00:00:00 2001 From: DanS Date: Mon, 10 Aug 2026 22:11:26 -0500 Subject: [PATCH 45/89] feat(recovery): redesign the wallet auto-recovery flow MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Turns the "Daemon Error + raw log dump" moment into one calm, honest recovery dialog plus a recovery-aware rescan screen. Presentation + orchestration only — the file-safety logic in rebuildWalletDatabase()/restoreOriginalWallet() (source selection, verify-before-swap, copy/rename-never-delete, .bak) is unchanged. - One authoritative dialog with a phase machine Offer -> Working -> Done/Failed. The duplicate in-overlay recovery card, the untranslated red "Daemon Error" heading, and the raw daemon-log dump are gone for the recovery case (they stay for genuine, unrelated crashes). - Offer is a choice-cards layout: "Repair automatically" (recommended, accent- tinted) vs "Restore original", side by side; the rare actions ("Show me the files", "Decide later") and a plain-language "What happens to my files?" sit in a quiet footer. When the rebuild helper is missing, it collapses to a single Restore card — never a dead end. - Post-repair rescan shows a calm "Finishing your wallet repair" screen with elapsed time + the growing wallet size, instead of "RPC timeout / taking longer than expected / restart daemon"; the daemon-crash toast is suppressed and the detection toast is downgraded from red to info. - Fixes a confirmed dead-end: if a repair succeeds but the restarted daemon then crashes for a *different* reason (block index, disk, OOM), the recovery flags now clear (in tryConnect + onConnected) so it surfaces as a normal daemon failure instead of freezing forever on a reassuring "don't restart" screen. - Clickable "Wallet repair available" status-bar chip for re-entry. The same app.cpp changes HiDPI-harden the surfaces the recovery flow lives on: the status-bar and loading-overlay hand-drawn geometry are multiplied by dpiScale (they rendered native-size and clipped at HiDPI / font_scale>1), the loading- overlay status text wraps instead of running off both edges, and the node-status banner floors its height to its DPI-baked font so the title can't clip off the top. Co-Authored-By: Claude Opus 4.8 (1M context) --- src/app.cpp | 608 ++++++++++++++++++++++++++++++++++++-------- src/app.h | 14 + src/app_network.cpp | 54 +++- src/util/i18n.cpp | 58 ++++- 4 files changed, 604 insertions(+), 130 deletions(-) diff --git a/src/app.cpp b/src/app.cpp index 195ea6c..05cc0f7 100644 --- a/src/app.cpp +++ b/src/app.cpp @@ -1644,8 +1644,10 @@ void App::render() float v = ui::schema::UI().drawElement("components.sidebar", key).size; return (v >= 0 ? v : fb) * dp; }; - float statusBarH = ui::schema::UI().window("components.status-bar").height; - if (statusBarH <= 0.0f) statusBarH = 24.0f; // safety fallback + // Scale by dp to match the rendered status-bar child height (renderStatusBar), so the reserved + // content strip stays in step with the bar at HiDPI instead of under-reserving. + float statusBarH = ui::schema::UI().window("components.status-bar").height * dp; + if (statusBarH <= 0.0f) statusBarH = 24.0f * dp; // safety fallback // Content area padding from ui.toml schema const auto& caWin = ui::schema::UI().window("components.content-area"); const float caMarginTop = ui::schema::UI().drawElement("components.content-area", "margin-top").size; @@ -2189,9 +2191,18 @@ void App::renderNodeStatusBanner() const auto& S = ui::schema::UI(); const float minH = S.drawElement("banners.node-status", "min-height").size; const float baseH = S.drawElement("banners.node-status", "height").size; + + // Fonts up-front so the banner height can never be shorter than the glyph row it vertically + // centers — otherwise the title/icon draw above the child's top clip rect and slice off (seen at + // HiDPI / large font scale, where the DPI-baked glyphs outgrow the schema height). Metrics scaled. + ImFont* icoFont = m::Type().iconSmall(); + ImFont* txtFont = m::Type().body2(); + const float glyphH = std::max(icoFont ? icoFont->LegacySize : 0.0f, + txtFont ? txtFont->LegacySize : 0.0f); // Both operands must be in scaled px: vScale() already folds in dpiScale(), so the raw min-height // floor needs the same dpiScale() or it under-clamps the banner at HiDPI. - const float bannerH = std::max(minH * ui::Layout::dpiScale(), baseH * ui::Layout::vScale()); + float bannerH = std::max(minH * ui::Layout::dpiScale(), baseH * ui::Layout::vScale()); + bannerH = std::max(bannerH, glyphH + ui::Layout::spacingSm() * 2.0f); // never shorter than text const bool isError = (banner.severity == ui::NodeBannerSeverity::Error); const ImU32 sevCol = isError ? m::Error() : m::Warning(); @@ -2222,18 +2233,15 @@ void App::renderNodeStatusBanner() ImGuiWindowFlags_NoScrollbar | ImGuiWindowFlags_NoScrollWithMouse); const float winW = ImGui::GetWindowSize().x; - ImFont* icoFont = m::Type().iconSmall(); - ImFont* txtFont = m::Type().body2(); - - // Icon — centered on its own metrics. - ImGui::SetCursorPos(ImVec2(padX, (bannerH - icoFont->LegacySize) * 0.5f)); + // Icon — centered on its own metrics (clamped so it never draws above the child's top). + ImGui::SetCursorPos(ImVec2(padX, std::max(0.0f, (bannerH - icoFont->LegacySize) * 0.5f))); ImGui::PushFont(icoFont); ImGui::PushStyleColor(ImGuiCol_Text, sevCol); ImGui::TextUnformatted(icon); ImGui::PopStyleColor(); ImGui::PopFont(); - const float txtCy = (bannerH - txtFont->LegacySize) * 0.5f; + const float txtCy = std::max(0.0f, (bannerH - txtFont->LegacySize) * 0.5f); // Right-aligned action button geometry (measured first so the detail text can be clipped to // never run underneath it). @@ -2281,7 +2289,7 @@ void App::renderNodeStatusBanner() // Action button. if (actionLabel) { - ImGui::SetCursorPos(ImVec2(winW - btnW - padX, (bannerH - btnH) * 0.5f)); + ImGui::SetCursorPos(ImVec2(winW - btnW - padX, std::max(0.0f, (bannerH - btnH) * 0.5f))); if (m::TactileButton(actionLabel, ImVec2(btnW, btnH))) { if (banner.action == ui::NodeBannerAction::RestartNode) restartDaemon(); else if (banner.action == ui::NodeBannerAction::Reconnect) tryConnect(); @@ -2388,12 +2396,15 @@ void App::renderStatusBar() // Status bar layout from unified UI schema const auto& S = ui::schema::UI(); const auto& sbWin = S.window("components.status-bar"); - const float sbHeight = sbWin.height; - const float sbPadX = sbWin.padding[0]; - const float sbPadY = sbWin.padding[1]; - const float sbIconTextGap = S.drawElement("components.status-bar", "icon-text-gap").size; - const float sbSectionGap = S.drawElement("components.status-bar", "section-gap").size; - const float sbSeparatorGap = S.drawElement("components.status-bar", "separator-gap").size; + // Schema values are logical px; the fonts/icons drawn inside are DPI-baked, so the box and its + // gaps must be scaled by the same factor or they clip the text at HiDPI / font_scale > 1. + const float dp = ui::Layout::dpiScale(); + const float sbHeight = sbWin.height * dp; + const float sbPadX = sbWin.padding[0] * dp; + const float sbPadY = sbWin.padding[1] * dp; + const float sbIconTextGap = S.drawElement("components.status-bar", "icon-text-gap").size * dp; + const float sbSectionGap = S.drawElement("components.status-bar", "section-gap").size * dp; + const float sbSeparatorGap = S.drawElement("components.status-bar", "separator-gap").size * dp; ImGuiWindowFlags childFlags = ImGuiWindowFlags_NoScrollbar | ImGuiWindowFlags_NoScrollWithMouse; @@ -2625,6 +2636,8 @@ void App::renderStatusBar() // Compute positions dynamically from actual text widths so they // never overlap and always stay within the window at any font scale. { + // Where the left-side chain ended, so the right cluster never SameLine()s backward onto it. + const float leftEndX = ImGui::GetCursorPosX(); char versionBuf[32]; snprintf(versionBuf, sizeof(versionBuf), "v%s", DRAGONX_VERSION); float versionW = ImGui::CalcTextSize(versionBuf).x; @@ -2636,10 +2649,36 @@ void App::renderStatusBar() float gap = sbSectionGap; float occupiedX = versionX; // leftmost X used by the version + connection status so far if (!connection_status_.empty() && connection_status_ != "Connected") { - float statusW = ImGui::CalcTextSize(connection_status_.c_str()).x; + // During a post-repair rescan the raw status is a scary "RPC request failed: Timeout" — show a + // calm line instead (the rescan legitimately can't answer RPC yet). + const std::string statusBase = post_recovery_rescan_ ? std::string(TR("sb_finishing_repair")) + : connection_status_; + // Middle-ellipsize to the space between the left chain and the version so a long status + // (e.g. "Wallet needs recovery — see the prompt") can't push off-screen or overprint the + // left chain; then clamp its start so it never crosses left of where the chain ended. + float availW = versionX - leftEndX - gap * 2.0f; + if (availW < 24.0f * dp) availW = 24.0f * dp; + ImFont* stFont = ImGui::GetFont(); + std::string statusShown = ui::material::TruncateToWidth( + statusBase, stFont, stFont->LegacySize, availW); + float statusW = ImGui::CalcTextSize(statusShown.c_str()).x; float statusX = versionX - statusW - gap; + if (statusX < leftEndX + gap) statusX = leftEndX + gap; ImGui::SameLine(statusX); - ImGui::TextDisabled("%s", connection_status_.c_str()); + if (wallet_auto_recovered_ && !post_recovery_rescan_) { + // Actionable re-entry: a full-opacity accent chip that reopens the recovery dialog. + // Dismiss is non-destructive, so this is the guaranteed way back to the prompt. + ImGui::PushStyleColor(ImGuiCol_Text, ui::material::Warning()); + ImGui::TextUnformatted(statusShown.c_str()); + ImGui::PopStyleColor(); + if (ImGui::IsItemHovered()) ImGui::SetMouseCursor(ImGuiMouseCursor_Hand); + if (ImGui::IsItemClicked() && recovery_phase_ != RecoveryPhase::Working) { + show_wallet_recovered_dialog_ = true; // reopen the (non-destructively dismissed) prompt + recovery_phase_ = RecoveryPhase::Offer; + } + } else { + ImGui::TextDisabled("%s", statusShown.c_str()); + } occupiedX = statusX; } else if (!daemon_status_.empty() && daemon_status_.find("Error") != std::string::npos) { const char* errText = TR("sb_daemon_not_found"); @@ -2667,7 +2706,6 @@ void App::renderStatusBar() // including ones whose toast already faded; an unread dot marks alerts that arrived since // the panel was last opened. { - const float dp = ui::Layout::dpiScale(); auto& notes = ui::Notifications::instance(); ImFont* bellFont = ui::material::Type().iconSmall(); const bool anyHist = notes.hasHistory(); @@ -3994,9 +4032,16 @@ void App::renderSeedMigrationDialog() ImGui::TextWrapped("%s", TR("mig_already_mnemonic")); ImGui::PopStyleColor(); ImGui::Spacing(); - if (ui::material::TactileButton(TR("mig_backup_instead"), ImVec2(200 * dp, 0))) { - close(); - showSeedBackupDialog(); + { + // Size to the label — the fixed 200px clipped the FR/PT/ES/DE/RU translations. + ImFont* bkFont = ui::material::Type().button(); + const float bkW = std::max(200.0f * dp, + bkFont->CalcTextSizeA(bkFont->LegacySize, FLT_MAX, 0, TR("mig_backup_instead")).x + + ImGui::GetStyle().FramePadding.x * 2.0f + 24.0f * dp); + if (ui::material::TactileButton(TR("mig_backup_instead"), ImVec2(bkW, 0))) { + close(); + showSeedBackupDialog(); + } } ImGui::SameLine(); if (ui::material::TactileButton(TR("close"), ImVec2(120 * dp, 0))) close(); @@ -4167,8 +4212,12 @@ void App::renderSeedMigrationDialog() ImGui::Spacing(); char cbuf[64]; snprintf(cbuf, sizeof(cbuf), TR("mig_confs"), seed_migration_sweep_confs_); ImGui::TextColored(kMedium, "%s", cbuf); - if (!seed_migration_sweep_txid_.empty()) - ImGui::TextColored(kMedium, "%s%s", TR("mig_txid"), seed_migration_sweep_txid_.c_str()); + if (!seed_migration_sweep_txid_.empty()) { + // A 64-hex txid overflows the fixed 580px card; render it in a wrapping, copyable field + // (same widget the import-key sweep result uses) instead of a raw one-line label. + ImGui::TextColored(kMedium, "%s", TR("mig_txid")); + ui::widgets::AddressCopyField("##migtxid", seed_migration_sweep_txid_); + } if (seed_migration_legacy_remaining_ >= 0.0) { char rbuf[96]; snprintf(rbuf, sizeof(rbuf), TR("mig_remaining"), seed_migration_legacy_remaining_); ImGui::TextColored(kMedium, "%s", rbuf); @@ -4292,39 +4341,319 @@ void App::renderWalletRecoveredDialog() ui::material::OverlayDialogSpec ov; ov.title = TR("wallet_recovered_title"); - ov.p_open = &show_wallet_recovered_dialog_; + // Dismiss (backdrop / [X]) is disabled during Working — files are mid-swap. A null p_open is safe: + // BeginOverlayDialog guards both the close button and backdrop-close on it. + ov.p_open = (recovery_phase_ == RecoveryPhase::Working) ? nullptr : &show_wallet_recovered_dialog_; ov.style = ui::material::OverlayStyle::BlurFloat; - ov.cardWidth = 560.0f; + ov.cardWidth = 620.0f; // wide enough for the two side-by-side choice cards ov.idSuffix = "walletrecovered"; if (!ui::material::BeginOverlayDialog(ov)) return; const float dp = ui::Layout::dpiScale(); + // Size each button to its label (with a modest floor) instead of a magic fixed width, so + // translations of these keys — added additively to res/lang later — can't silently clip. + ImFont* rbf = ui::material::Type().button(); + auto fitBtnW = [&](const char* label) { + return std::max(96.0f * dp, + rbf->CalcTextSizeA(rbf->LegacySize, FLT_MAX, 0, label).x + + ImGui::GetStyle().FramePadding.x * 2.0f + 28.0f * dp); + }; + // A full-width action row: the button, then a dim wrapped one-line explanation of what it does. + auto actionRow = [&](const char* label, const char* sub) -> bool { + const bool clicked = ui::material::TactileButton(label, ImVec2(fitBtnW(label), 0)); + if (sub && sub[0]) { + ImGui::PushFont(ui::material::Type().caption()); + ImGui::PushTextWrapPos(0.0f); + ImGui::TextDisabled("%s", sub); + ImGui::PopTextWrapPos(); + ImGui::PopFont(); + } + return clicked; + }; + // A disclosure that recedes: no filled bar, dim label — so the primary action stays dominant. + auto quietHeader = [&](const char* label) -> bool { + ImGui::PushStyleColor(ImGuiCol_Header, ImVec4(0, 0, 0, 0)); + ImGui::PushStyleColor(ImGuiCol_HeaderHovered, ui::material::WithAlpha(ui::material::OnSurface(), 20)); + ImGui::PushStyleColor(ImGuiCol_HeaderActive, ui::material::WithAlpha(ui::material::OnSurface(), 32)); + ImGui::PushStyleColor(ImGuiCol_Text, ui::material::OnSurfaceMedium()); + const bool open = ImGui::CollapsingHeader(label); + ImGui::PopStyleColor(4); + return open; + }; + // Opt-in daemon log — the same lines that used to be dumped on screen, now behind a quiet disclosure. + auto techDetails = [&]() { + if (!daemon_controller_) return; + ImGui::Dummy(ImVec2(0, ui::Layout::spacingSm())); + if (quietHeader(TR("wallet_recovery_details_label"))) { + ImGui::PushFont(ui::material::Type().caption()); + ImGui::PushTextWrapPos(0.0f); + for (const auto& ln : daemon_controller_->recentLines(8)) + ImGui::TextDisabled("%s", ln.c_str()); + ImGui::PopTextWrapPos(); + ImGui::PopFont(); + } + }; + // Funds-safety hero: a shield icon + the reassurance, made the visual focal point of the screen. + auto safetyHero = [&]() { + ImFont* icoF = ui::material::Type().iconLarge(); + ImFont* txtF = ui::material::Type().subtitle1(); + const float rowTop = ImGui::GetCursorPosY(); + ImGui::PushFont(icoF); + ImGui::TextColored(ui::material::SuccessVec4(), ICON_MD_HEALTH_AND_SAFETY); + ImGui::PopFont(); + ImGui::SameLine(); + const float iconH = icoF->LegacySize; + const float textH = txtF ? txtF->LegacySize : ImGui::GetFontSize(); + if (iconH > textH) ImGui::SetCursorPosY(rowTop + (iconH - textH) * 0.5f); + ImGui::PushFont(txtF); + ImGui::TextColored(ui::material::SuccessVec4(), "%s", TR("wallet_recovered_safety")); + ImGui::PopFont(); + }; + // Accent-tinted primary action so the recommended button clearly dominates the quiet disclosures + // (a translucent Primary tint over the glass button — keeps the label readable on any theme). + auto primaryAction = [&](const char* label, const char* sub) -> bool { + ImGui::PushStyleColor(ImGuiCol_Button, ui::material::WithAlpha(ui::material::Primary(), 60)); + ImGui::PushStyleColor(ImGuiCol_ButtonHovered, ui::material::WithAlpha(ui::material::Primary(), 90)); + ImGui::PushStyleColor(ImGuiCol_ButtonActive, ui::material::WithAlpha(ui::material::Primary(), 115)); + const bool clicked = actionRow(label, sub); + ImGui::PopStyleColor(3); + return clicked; + }; + // A choice card: icon + title (+ optional "recommended" chip) + wrapped blurb + a full-width button + // pinned to the card bottom. The recommended card gets a gold-tinted fill + border so the choice + // reads at a glance. cardH is precomputed by the caller so side-by-side cards stay equal height. + auto renderCard = [&](const char* id, const char* glyph, const char* title, const char* desc, + const char* btn, bool recommended, float cardW, float cardH) -> bool { + const float pad = ui::Layout::spacingMd(); + ImGui::PushStyleColor(ImGuiCol_ChildBg, + recommended ? ui::material::WithAlpha(ui::material::Primary(), 22) + : ui::material::WithAlpha(ui::material::OnSurface(), 8)); + ImGui::PushStyleColor(ImGuiCol_Border, + recommended ? ui::material::WithAlpha(ui::material::Primary(), 140) + : ui::material::WithAlpha(ui::material::OnSurface(), 28)); + ImGui::PushStyleVar(ImGuiStyleVar_ChildRounding, 6.0f * dp); + ImGui::PushStyleVar(ImGuiStyleVar_ChildBorderSize, 1.0f); + ImGui::PushStyleVar(ImGuiStyleVar_WindowPadding, ImVec2(pad, pad)); + ImGui::BeginChild(id, ImVec2(cardW, cardH), true, + ImGuiWindowFlags_NoScrollbar | ImGuiWindowFlags_NoScrollWithMouse); + // Zero implicit item spacing so the only vertical gaps are the explicit Dummy()s below — that + // keeps the caller's measured cardH exact, so the bottom-pinned button never clips. + ImGui::PushStyleVar(ImGuiStyleVar_ItemSpacing, ImVec2(0.0f, 0.0f)); - ui::material::DialogWarningHeader(TR("wallet_recovered_warn")); - ImGui::Dummy(ImVec2(0, ui::Layout::spacingSm())); - ImGui::TextWrapped("%s", TR("wallet_recovered_body")); - ImGui::Dummy(ImVec2(0, ui::Layout::spacingMd())); - // Preferred fix when available: REBUILD the wallet database. Plain "Restore original" hands the same - // BDB-inconsistent file back and the daemon just re-salvages it (the cascade); the rebuild produces a - // fresh, consistent copy of every key that the daemon loads cleanly. Copy/rename-only — never deletes. - if (walletRebuildAvailable()) { - if (ui::material::TactileButton(TR("wallet_recovered_rebuild"), ImVec2(280.0f * dp, 0))) { - rebuildWalletDatabase(); // clears show_wallet_recovered_dialog_ + ImGui::PushFont(ui::material::Type().iconMed()); + ImGui::TextColored(recommended ? ui::material::PrimaryVec4() + : ImGui::ColorConvertU32ToFloat4(ui::material::OnSurfaceMedium()), + "%s", glyph); + ImGui::PopFont(); + ImGui::Dummy(ImVec2(0, ui::Layout::spacingXs())); + + ImGui::PushFont(ui::material::Type().subtitle2()); + ImGui::TextUnformatted(title); + ImGui::PopFont(); + if (recommended) { + ImGui::PushFont(ui::material::Type().caption()); + ImGui::TextColored(ui::material::PrimaryVec4(), "%s", TR("wallet_recovery_recommended")); + ImGui::PopFont(); + } + ImGui::Dummy(ImVec2(0, ui::Layout::spacingXs())); + + ImGui::PushFont(ui::material::Type().caption()); + ImGui::PushStyleColor(ImGuiCol_Text, ui::material::OnSurfaceMedium()); + ImGui::PushTextWrapPos(0.0f); + ImGui::TextWrapped("%s", desc); + ImGui::PopTextWrapPos(); + ImGui::PopStyleColor(); + ImGui::PopFont(); + + // Pin the button to the card bottom so both cards' buttons line up. + const float btnH = ImGui::GetFrameHeight() + 6.0f * dp; + const float remaining = ImGui::GetContentRegionAvail().y - btnH; + if (remaining > 0.0f) ImGui::Dummy(ImVec2(0, remaining)); + bool clicked; + if (recommended) { + ImGui::PushStyleColor(ImGuiCol_Button, ui::material::WithAlpha(ui::material::Primary(), 65)); + ImGui::PushStyleColor(ImGuiCol_ButtonHovered, ui::material::WithAlpha(ui::material::Primary(), 100)); + ImGui::PushStyleColor(ImGuiCol_ButtonActive, ui::material::WithAlpha(ui::material::Primary(), 125)); + clicked = ui::material::TactileButton(btn, ImVec2(-FLT_MIN, btnH)); + ImGui::PopStyleColor(3); + } else { + clicked = ui::material::TactileButton(btn, ImVec2(-FLT_MIN, btnH)); + } + ImGui::PopStyleVar(); // ItemSpacing + ImGui::EndChild(); + ImGui::PopStyleVar(3); + ImGui::PopStyleColor(2); + return clicked; + }; + // A quiet clickable text link for the footer (Show me the files / Not now). + auto linkText = [&](const char* label) -> bool { + ImGui::PushStyleColor(ImGuiCol_Text, ui::material::OnSurfaceMedium()); + ImGui::TextUnformatted(label); + ImGui::PopStyleColor(); + const bool clicked = ImGui::IsItemClicked(); + if (ImGui::IsItemHovered()) { + ImGui::SetMouseCursor(ImGuiMouseCursor_Hand); + const ImVec2 mn = ImGui::GetItemRectMin(), mx = ImGui::GetItemRectMax(); + ImGui::GetWindowDrawList()->AddLine(ImVec2(mn.x, mx.y), ImVec2(mx.x, mx.y), + ui::material::OnSurface()); + } + return clicked; + }; + + switch (recovery_phase_) { + case RecoveryPhase::Offer: { + safetyHero(); + ImGui::Dummy(ImVec2(0, ui::Layout::spacingSm())); + ImGui::TextWrapped("%s", TR("wallet_recovered_warn")); + ImGui::Dummy(ImVec2(0, ui::Layout::spacingMd())); + + // The two real actions as side-by-side CHOICE CARDS — the recommended one gold-tinted, so the + // decision reads at a glance instead of hiding in a menu. Rebuild is the more complete fix; when + // its helper is missing, Restore becomes the single recommended card (never a dead end). + const bool canRebuild = walletRebuildAvailable(); + const float cardGap = ui::Layout::spacingMd(); + const float pad = cardGap; + const float contentW = ImGui::GetContentRegionAvail().x; + const float cardW = canRebuild ? (contentW - cardGap) * 0.5f + : std::min(contentW, 320.0f * dp); + // Fix a shared card height off the taller card body so the two cards line up. Measure title AND + // desc wraps (titles/descs can be multi-line, esp. after translation), with a little width slack. + ImFont* descF = ui::material::Type().caption(); + ImFont* titleF = ui::material::Type().subtitle2(); + const float innerW = std::max(1.0f, cardW - 2.0f * pad - 6.0f * dp); + auto measureH = [&](ImFont* f, const char* s) { + return f->CalcTextSizeA(f->LegacySize, FLT_MAX, innerW, s).y; + }; + const float titleH = std::max(measureH(titleF, TR("wallet_recovery_rebuild_card")), + measureH(titleF, TR("wallet_recovery_restore_card"))); + const float descH = std::max(measureH(descF, TR("wallet_recovery_rebuild_card_desc")), + measureH(descF, TR("wallet_recovery_restore_card_desc"))); + const float cardH = 2.0f * pad + + ui::material::Type().iconMed()->LegacySize + ui::Layout::spacingXs() // icon + gap + + titleH + descF->LegacySize // title + RECOMMENDED chip + + ui::Layout::spacingXs() // gap before desc + + descH + ui::Layout::spacingSm() // desc + gap before button + + ImGui::GetFrameHeight() + 6.0f * dp // button + + ui::Layout::spacingXs(); // small buffer + + if (canRebuild) { + const bool r = renderCard("##rcRepair", ICON_MD_AUTO_FIX_HIGH, TR("wallet_recovery_rebuild_card"), + TR("wallet_recovery_rebuild_card_desc"), TR("wallet_recovery_repair_go"), + true, cardW, cardH); + ImGui::SameLine(0, cardGap); + const bool s = renderCard("##rcRestore", ICON_MD_SETTINGS_BACKUP_RESTORE, TR("wallet_recovery_restore_card"), + TR("wallet_recovery_restore_card_desc"), TR("wallet_recovery_restore_go"), + false, cardW, cardH); + if (r) rebuildWalletDatabase(); + if (s) restoreOriginalWallet(); + } else { + const float indent = (contentW - cardW) * 0.5f; + if (indent > 0.0f) ImGui::Indent(indent); + const bool s = renderCard("##rcRestoreOnly", ICON_MD_SETTINGS_BACKUP_RESTORE, TR("wallet_recovery_restore_card"), + TR("wallet_recovery_restore_card_desc"), TR("wallet_recovery_restore_go"), + true, cardW, cardH); + if (indent > 0.0f) ImGui::Unindent(indent); + if (s) restoreOriginalWallet(); + } + + // Quiet footer: inspect-files link + a clearly-labelled, reversible dismiss (with a tooltip that + // spells out the consequence — plain "Not now" was ambiguous). + ImGui::Dummy(ImVec2(0, ui::Layout::spacingMd())); + if (linkText(TR("wallet_recovered_open_folder"))) + util::Platform::openFolder(util::Platform::getDragonXDataDir()); + ImGui::SameLine(0, ui::Layout::spacingSm()); + ImGui::TextDisabled("\xC2\xB7"); // middle dot separator + ImGui::SameLine(0, ui::Layout::spacingSm()); + if (linkText(TR("wallet_recovery_decide_later"))) { + show_wallet_recovered_dialog_ = false; // non-destructive; reopen from the status bar + recovery_phase_ = RecoveryPhase::Offer; + } + if (ImGui::IsItemHovered()) { + ImGui::BeginTooltip(); + ImGui::PushTextWrapPos(ImGui::GetFontSize() * 22.0f); + ImGui::TextUnformatted(TR("wallet_recovery_decide_later_tip")); + ImGui::PopTextWrapPos(); + ImGui::EndTooltip(); + } + // Plain-language "what happens to my files" — replaces the unhelpful raw daemon log on this screen + // (the log is still available in the Console tab for troubleshooting). + ImGui::Dummy(ImVec2(0, ui::Layout::spacingSm())); + if (quietHeader(TR("wallet_recovery_files_label"))) { + ImGui::PushFont(ui::material::Type().caption()); + ImGui::PushStyleColor(ImGuiCol_Text, ui::material::OnSurfaceMedium()); + ImGui::PushTextWrapPos(0.0f); + ImGui::TextWrapped("%s", TR("wallet_recovery_files_detail")); + ImGui::PopTextWrapPos(); + ImGui::PopStyleColor(); + ImGui::PopFont(); + } + break; + } + case RecoveryPhase::Working: { + ImGui::TextWrapped("%s", recovery_last_action_rebuild_ ? TR("wallet_rebuild_started") + : TR("wallet_restore_started")); + ImGui::Dummy(ImVec2(0, ui::Layout::spacingMd())); + ImGui::Text("%s%s", TR("wallet_recovery_working_label"), ui::material::LoadingDots()); + break; + } + case RecoveryPhase::Done: { + safetyHero(); + ImGui::Dummy(ImVec2(0, ui::Layout::spacingSm())); + ImGui::TextWrapped("%s", recovery_last_action_rebuild_ ? TR("wallet_recovery_success_body") + : TR("wallet_recovery_success_restore")); + // A sev-1 warning (e.g. restored but the node didn't relaunch) carries a specific message. + if (recovery_outcome_sev_ == 1 && !recovery_outcome_msg_.empty()) { + ImGui::Dummy(ImVec2(0, ui::Layout::spacingXs())); + ImGui::PushStyleColor(ImGuiCol_Text, ui::material::Warning()); + ImGui::TextWrapped("%s", recovery_outcome_msg_.c_str()); + ImGui::PopStyleColor(); + } + ImGui::Dummy(ImVec2(0, ui::Layout::spacingMd())); + if (ui::material::TactileButton(TR("wallet_recovery_done"), ImVec2(fitBtnW(TR("wallet_recovery_done")), 0))) { + show_wallet_recovered_dialog_ = false; + recovery_phase_ = RecoveryPhase::Offer; + // Clean success — clear the session flag so a later unrelated disconnect doesn't re-raise the + // "repair available" chip/dialog for a wallet that's already fixed. (Warnings keep it set.) + if (recovery_outcome_sev_ == 0) wallet_auto_recovered_ = false; + } + techDetails(); + break; + } + case RecoveryPhase::Failed: { + ImGui::PushFont(ui::material::Type().subtitle1()); + ImGui::PushStyleColor(ImGuiCol_Text, ui::material::ReadableError()); + ImGui::TextWrapped("%s", TR("wallet_recovery_failure_title")); + ImGui::PopStyleColor(); + ImGui::PopFont(); + ImGui::Dummy(ImVec2(0, ui::Layout::spacingSm())); + ImGui::TextWrapped("%s", TR("wallet_recovery_failure_body")); + if (!recovery_outcome_msg_.empty()) { + ImGui::Dummy(ImVec2(0, ui::Layout::spacingXs())); + ImGui::PushStyleColor(ImGuiCol_Text, ui::material::ReadableError()); + ImGui::TextWrapped("%s", recovery_outcome_msg_.c_str()); + ImGui::PopStyleColor(); + } + ImGui::Dummy(ImVec2(0, ui::Layout::spacingMd())); + // Offer the UNtried option (Restore needs no helper; Rebuild only if its helper exists). + if (recovery_last_action_rebuild_) { + if (actionRow(TR("wallet_recovery_try_other"), TR("wallet_recovered_restore_sub"))) + restoreOriginalWallet(); + } else if (walletRebuildAvailable()) { + if (actionRow(TR("wallet_recovery_try_other"), TR("wallet_recovered_rebuild_sub"))) + rebuildWalletDatabase(); } ImGui::Dummy(ImVec2(0, ui::Layout::spacingSm())); + if (actionRow(TR("wallet_recovered_open_folder"), TR("wallet_recovered_open_folder_sub"))) + util::Platform::openFolder(util::Platform::getDragonXDataDir()); + ImGui::Dummy(ImVec2(0, ui::Layout::spacingSm())); + if (ui::material::TactileButton(TR("close"), ImVec2(fitBtnW(TR("close")), 0))) { + show_wallet_recovered_dialog_ = false; + recovery_phase_ = RecoveryPhase::Offer; + } + techDetails(); + break; } - // Restore of the untouched original (stops the node, swaps the .bak back over the salvaged copy, - // clears the stale BDB env, restarts). - if (ui::material::TactileButton(TR("wallet_recovered_restore"), ImVec2(260.0f * dp, 0))) { - restoreOriginalWallet(); // clears show_wallet_recovered_dialog_ - } - ImGui::SameLine(); - if (ui::material::TactileButton(TR("wallet_recovered_open_folder"), ImVec2(200.0f * dp, 0))) { - util::Platform::openFolder(util::Platform::getDragonXDataDir()); // manual restore instead - } - ImGui::SameLine(); - if (ui::material::TactileButton(TR("wallet_recovered_dismiss"), ImVec2(150.0f * dp, 0))) { - show_wallet_recovered_dialog_ = false; // acknowledged; keeps the salvaged wallet loaded } + ui::material::EndOverlayDialog(); } @@ -5462,6 +5791,10 @@ void App::renderLoadingOverlay(float contentH) using namespace ui::material; constexpr float kPi = 3.14159265f; + // The wallet-recovery dialog owns the screen while a salvage is pending — suppress the loading + // spinner underneath it so "still loading" and "make a decision" are never the same screen. + if (show_wallet_recovered_dialog_) return; + auto loadElem = [](const char* key, float fb) { float v = ui::schema::UI().drawElement("screens.loading", key).size; return v >= 0 ? v : fb; @@ -5473,12 +5806,17 @@ void App::renderLoadingOverlay(float contentH) ImVec2 wp = ImGui::GetWindowPos(); ImVec2 ws = ImGui::GetWindowSize(); + // Hand-drawn geometry here is in logical px; the fonts drawn between the elements are DPI-baked, + // so every spinner/bar/gap constant must be multiplied by dpiScale or it renders native-tiny and + // the spacing/centering drifts at HiDPI / font_scale > 1. (Font metrics are already scaled.) + const float dpi = ui::Layout::dpiScale(); + // Layout constants float lineH = ImGui::GetTextLineHeightWithSpacing(); - float spinnerR = loadElem("spinner-radius", 18.0f); - float gap = loadElem("vertical-gap", 8.0f); - float barH = loadElem("progress-bar", 6.0f); - float barW = loadElem("progress-width", 260.0f); + float spinnerR = loadElem("spinner-radius", 18.0f) * dpi; + float gap = loadElem("vertical-gap", 8.0f) * dpi; + float barH = loadElem("progress-bar", 6.0f) * dpi; + float barW = loadElem("progress-width", 260.0f) * dpi; float cx = ws.x * 0.5f; // centre X (local coords) // Estimate total block height for vertical centering @@ -5494,8 +5832,8 @@ void App::renderLoadingOverlay(float contentH) // ------------------------------------------------------------------- { float r = spinnerR; - float thick = loadElem("spinner-thickness", 2.5f); - ImVec2 sc(wp.x + cx, curY + r + 2.0f); + float thick = loadElem("spinner-thickness", 2.5f) * dpi; + ImVec2 sc(wp.x + cx, curY + r + 2.0f * dpi); // Background ring (dim) dl->PathArcTo(sc, r, 0.0f, kPi * 2.0f, 48); @@ -5508,7 +5846,63 @@ void App::renderLoadingOverlay(float contentH) dl->PathStroke(ui::schema::UI().resolveColor("var(--spinner-active)", IM_COL32(255, 218, 0, 200)), 0, thick); - curY += r * 2.0f + gap + 4.0f; + curY += r * 2.0f + gap + 4.0f * dpi; + } + + // ------------------------------------------------------------------- + // Post-repair rescan — a calm, recovery-aware screen (not the generic "daemon stuck / RPC timeout / + // restart daemon" text). The daemon was intentionally restarted with a full rescan, which + // legitimately takes minutes and won't answer RPC yet; reassure + show elapsed and the growing size. + // ------------------------------------------------------------------- + // Only while the daemon is actually alive-and-rescanning. If it EXITED (crashed for a reason distinct + // from the wallet file), fall through to the normal error/stall UI — tryConnect() clears the flag, but + // gate here too so a lingering frame never shows "everything's fine" over a dead daemon. + if (post_recovery_rescan_ && + !(daemon_controller_ && daemon_controller_->state() == daemon::EmbeddedDaemon::State::Error)) { + if (post_recovery_rescan_since_ <= 0.0) post_recovery_rescan_since_ = ImGui::GetTime(); + ImFont* titleF = Type().subtitle1(); if (!titleF) titleF = ImGui::GetFont(); + ImFont* capF = Type().caption(); if (!capF) capF = ImGui::GetFont(); + + auto centeredLine = [&](ImFont* f, ImU32 col, const char* s, float wrapW) { + ImVec2 ts = f->CalcTextSizeA(f->LegacySize, FLT_MAX, wrapW, s); + float x = (wrapW > 0.0f) ? (wp.x + cx - wrapW * 0.5f) : (wp.x + cx - ts.x * 0.5f); + dl->AddText(f, f->LegacySize, ImVec2(x, curY), col, s, nullptr, wrapW); + curY += ts.y + gap; + }; + + centeredLine(titleF, IM_COL32(230, 210, 90, 235), TR("wallet_recovery_rescan_title"), 0.0f); + float wrapW = ws.x * 0.8f; if (wrapW > 620.0f * dpi) wrapW = 620.0f * dpi; + centeredLine(capF, IM_COL32(200, 200, 200, 220), TR("wallet_recovery_rescan_body"), wrapW); + + // Elapsed + the growing wallet size — concrete "it's working" feedback while RPC is silent. Recompute + // at most once a second (the display granularity) to avoid a stat()+format on every frame. + int secs = (int)(ImGui::GetTime() - post_recovery_rescan_since_); if (secs < 0) secs = 0; + static int s_lastSec = -1; + static std::string s_elapsed, s_size; + if (secs != s_lastSec) { + s_lastSec = secs; + char clock[16]; snprintf(clock, sizeof(clock), "%d:%02d", secs / 60, secs % 60); + char ebuf[96]; snprintf(ebuf, sizeof(ebuf), TR("wallet_recovery_rescan_elapsed"), clock); + s_elapsed = ebuf; + const std::string walletPath = util::Platform::getDragonXDataDir() + "/" + + ((settings_ && !settings_->getActiveWalletFile().empty()) + ? settings_->getActiveWalletFile() : std::string("wallet.dat")); + uint64_t wsz = util::Platform::getFileSize(walletPath); + if (wsz > 0) { char sbuf[96]; snprintf(sbuf, sizeof(sbuf), TR("wallet_recovery_rescan_size"), + util::Platform::formatFileSize(wsz).c_str()); s_size = sbuf; } + else s_size.clear(); + } + curY += gap * 0.5f; + centeredLine(capF, IM_COL32(150, 150, 150, 220), s_elapsed.c_str(), 0.0f); + if (!s_size.empty()) centeredLine(capF, IM_COL32(130, 130, 130, 210), s_size.c_str(), 0.0f); + + // Backstop for a genuinely slow (but still running) rescan: after several minutes add a gentle + // "it's safe to leave running / watch the Console" line — never the scary "restart the node". + if (secs > 600) { + curY += gap * 0.5f; + centeredLine(capF, IM_COL32(150, 150, 150, 200), TR("wallet_recovery_rescan_slow"), wrapW); + } + return; // skip the generic status / stall / error / daemon-log sections } // ------------------------------------------------------------------- @@ -5518,11 +5912,23 @@ void App::renderLoadingOverlay(float contentH) const char* statusText = connection_status_.c_str(); ImFont* font = Type().subtitle1(); if (!font) font = ImGui::GetFont(); - ImVec2 ts = font->CalcTextSizeA(font->LegacySize, FLT_MAX, 0.0f, statusText); - dl->AddText(font, font->LegacySize, - ImVec2(wp.x + cx - ts.x * 0.5f, curY), - IM_COL32(220, 220, 220, 255), statusText); - curY += ts.y + gap; + // Short statuses (the common case: "Connected", "Starting daemon") stay centered; long ones + // (a full dir_error path, a libcurl connect error) wrap to a clamped box instead of running + // off both edges of the overlay — the same clamp the daemon-error blocks below use. + float wrapW = ws.x * 0.8f; if (wrapW > 640.0f * dpi) wrapW = 640.0f * dpi; + ImVec2 full = font->CalcTextSizeA(font->LegacySize, FLT_MAX, 0.0f, statusText); + if (full.x <= wrapW) { + dl->AddText(font, font->LegacySize, + ImVec2(wp.x + cx - full.x * 0.5f, curY), + IM_COL32(220, 220, 220, 255), statusText); + curY += full.y + gap; + } else { + ImVec2 ts = font->CalcTextSizeA(font->LegacySize, FLT_MAX, wrapW, statusText); + dl->AddText(font, font->LegacySize, + ImVec2(wp.x + cx - wrapW * 0.5f, curY), + IM_COL32(220, 220, 220, 255), statusText, nullptr, wrapW); + curY += ts.y + gap; + } } // ------------------------------------------------------------------- @@ -5546,7 +5952,7 @@ void App::renderLoadingOverlay(float contentH) float progress = state_.sync.witness_progress; if (progress < 0.0f) progress = 0.0f; if (progress > 1.0f) progress = 1.0f; - float barRadius = loadElem("progress-bar", 3.0f); + float barRadius = loadElem("progress-bar", 3.0f) * dpi; float barX = wp.x + cx - barW * 0.5f; ImVec2 barMin(barX, curY); ImVec2 barMax(barX + barW, curY + barH); @@ -5583,7 +5989,7 @@ void App::renderLoadingOverlay(float contentH) // ------------------------------------------------------------------- if (state_.connected && state_.sync.syncing) { float progress = static_cast(state_.sync.verification_progress); - float barRadius = loadElem("progress-bar", 3.0f); + float barRadius = loadElem("progress-bar", 3.0f) * dpi; float barX = wp.x + cx - barW * 0.5f; ImVec2 barMin(barX, curY); @@ -5647,7 +6053,7 @@ void App::renderLoadingOverlay(float contentH) // Indeterminate progress bar float encBarW = barW * 0.6f; - float encBarH = 4.0f; + float encBarH = 4.0f * dpi; float encBarX = wp.x + cx - encBarW * 0.5f; dl->AddRectFilled(ImVec2(encBarX, curY), ImVec2(encBarX + encBarW, curY + encBarH), IM_COL32(255, 255, 255, 20), 2.0f); @@ -5664,7 +6070,8 @@ void App::renderLoadingOverlay(float contentH) // 3c. Daemon crash error message // ------------------------------------------------------------------- if (daemon_controller_ && - daemon_controller_->state() == daemon::EmbeddedDaemon::State::Error) { + daemon_controller_->state() == daemon::EmbeddedDaemon::State::Error && + !wallet_auto_recovered_) { // a salvage is NOT a crash — it has its own recovery dialog curY += gap; ImFont* capFont = Type().caption(); if (!capFont) capFont = ImGui::GetFont(); @@ -5679,50 +6086,25 @@ void App::renderLoadingOverlay(float contentH) IM_COL32(255, 90, 90, 255), errTitle); curY += ts.y + gap * 0.5f; - // Wallet auto-recovery/salvage takes over the error card: a concise message + prominent one-click - // actions, RIGHT HERE in the overlay the user is looking at (the separate dialog can be occluded - // by this full-frame overlay while the node is down). Skip the verbose daemon dump so the buttons - // stay on-screen. Same handlers as the dialog. - if (wallet_auto_recovered_) { - const char* msg = TR("wallet_recovered_warn"); - float wrapW = ws.x * 0.8f; if (wrapW > 640.0f) wrapW = 640.0f; - ImVec2 ms = capFont->CalcTextSizeA(capFont->LegacySize, FLT_MAX, wrapW, msg); - dl->AddText(capFont, capFont->LegacySize, ImVec2(wp.x + cx - wrapW * 0.5f, curY), - IM_COL32(230, 210, 210, 235), msg, nullptr, wrapW); - curY += ms.y + gap; - const float dpi = ui::Layout::dpiScale(); - const float bw = 340.0f * dpi; - auto placeBtn = [&](const char* label) -> bool { - ImGui::SetCursorScreenPos(ImVec2(wp.x + cx - bw * 0.5f, curY)); - const bool clicked = ui::material::TactileButton(label, ImVec2(bw, 0)); - curY = ImGui::GetItemRectMax().y + gap * 0.4f; - return clicked; - }; - if (walletRebuildAvailable() && placeBtn(TR("wallet_recovered_rebuild"))) rebuildWalletDatabase(); - if (placeBtn(TR("wallet_recovered_restore"))) restoreOriginalWallet(); - if (placeBtn(TR("wallet_recovered_open_folder"))) - util::Platform::openFolder(util::Platform::getDragonXDataDir()); - } else { - // Error details (wrapped) — full diagnostic info. - const std::string& errDetail = daemon_controller_->lastError(); - if (!errDetail.empty()) { - float wrapW = ws.x * 0.8f; - if (wrapW > 700.0f) wrapW = 700.0f; - ImVec2 es = capFont->CalcTextSizeA(capFont->LegacySize, FLT_MAX, wrapW, errDetail.c_str()); - dl->AddText(capFont, capFont->LegacySize, - ImVec2(wp.x + cx - wrapW * 0.5f, curY), - IM_COL32(255, 180, 180, 220), errDetail.c_str(), nullptr, wrapW); - curY += es.y + gap; - } - // Crash count hint - if (daemon_controller_->crashCount() >= 3) { - const char* hint = "Use Settings > Restart Daemon to try again"; - ImVec2 hs2 = capFont->CalcTextSizeA(capFont->LegacySize, FLT_MAX, 0.0f, hint); - dl->AddText(capFont, capFont->LegacySize, - ImVec2(wp.x + cx - hs2.x * 0.5f, curY), - IM_COL32(200, 200, 200, 180), hint); - curY += hs2.y + gap; - } + // Error details (wrapped) — full diagnostic info for a genuine (non-recovery) crash. + const std::string& errDetail = daemon_controller_->lastError(); + if (!errDetail.empty()) { + float wrapW = ws.x * 0.8f; + if (wrapW > 700.0f * dpi) wrapW = 700.0f * dpi; + ImVec2 es = capFont->CalcTextSizeA(capFont->LegacySize, FLT_MAX, wrapW, errDetail.c_str()); + dl->AddText(capFont, capFont->LegacySize, + ImVec2(wp.x + cx - wrapW * 0.5f, curY), + IM_COL32(255, 180, 180, 220), errDetail.c_str(), nullptr, wrapW); + curY += es.y + gap; + } + // Crash count hint + if (daemon_controller_->crashCount() >= 3) { + const char* hint = "Use Settings > Restart Daemon to try again"; + ImVec2 hs2 = capFont->CalcTextSizeA(capFont->LegacySize, FLT_MAX, 0.0f, hint); + dl->AddText(capFont, capFont->LegacySize, + ImVec2(wp.x + cx - hs2.x * 0.5f, curY), + IM_COL32(200, 200, 200, 180), hint); + curY += hs2.y + gap; } } @@ -5757,7 +6139,7 @@ void App::renderLoadingOverlay(float contentH) snprintf(stallBody, sizeof(stallBody), TR("loading_stall_body"), (float)(ImGui::GetTime() - connect_stall_since_)); float wrapW = ws.x * 0.8f; - if (wrapW > 640.0f) wrapW = 640.0f; + if (wrapW > 640.0f * dpi) wrapW = 640.0f * dpi; ImVec2 bs = capFont->CalcTextSizeA(capFont->LegacySize, FLT_MAX, wrapW, stallBody); dl->AddText(capFont, capFont->LegacySize, ImVec2(wp.x + cx - wrapW * 0.5f, curY), @@ -5778,19 +6160,19 @@ void App::renderLoadingOverlay(float contentH) // ------------------------------------------------------------------- // 4. Daemon output snippet (last few lines, if embedded) // ------------------------------------------------------------------- - if (daemon_controller_) { + if (daemon_controller_ && !wallet_auto_recovered_) { // recovery moves the log behind the dialog's disclosure auto lines = daemon_controller_->recentLines(8); if (!lines.empty()) { curY += gap; float panelW = ws.x * 0.85f; - if (panelW > 900.0f) panelW = 900.0f; + if (panelW > 900.0f * dpi) panelW = 900.0f * dpi; float panelX = wp.x + cx - panelW * 0.5f; - float panelPad = 8.0f; + float panelPad = 8.0f * dpi; ImFont* capFont = Type().caption(); if (!capFont) capFont = ImGui::GetFont(); - float panelLineH = capFont->LegacySize + 4.0f; + float panelLineH = capFont->LegacySize + 4.0f * dpi; float panelContentH = panelPad * 2.0f + panelLineH * (float)lines.size(); ImVec2 panelMin(panelX, curY); diff --git a/src/app.h b/src/app.h index a9fde2d..dbba9a3 100644 --- a/src/app.h +++ b/src/app.h @@ -906,6 +906,20 @@ private: 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_; diff --git a/src/app_network.cpp b/src/app_network.cpp index f24e1b2..1f8ed88 100644 --- a/src/app_network.cpp +++ b/src/app_network.cpp @@ -243,7 +243,7 @@ void App::detectWalletAutoRecovery() wallet_auto_recovered_ = true; wallet_auto_recovered_warned_ = true; show_wallet_recovered_dialog_ = true; - ui::Notifications::instance().error(TR("wallet_recovered_notify"), 30.0f); + 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"); } @@ -408,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); } @@ -527,6 +530,15 @@ 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 @@ -597,6 +609,11 @@ 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"); @@ -4575,7 +4592,12 @@ void App::restoreOriginalWallet() ui::Notifications::instance().warning(TR("wallet_restore_busy")); return; } - show_wallet_recovered_dialog_ = false; + // 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 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"); @@ -4684,6 +4706,19 @@ void App::pumpWalletRestore() 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); @@ -4705,7 +4740,10 @@ static std::string findWalletRebuildHelper() const std::string p = d + "/" + exe; if (fs::exists(p, ec)) return p; } - return {}; + // 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(); } @@ -4724,7 +4762,11 @@ void App::rebuildWalletDatabase() const std::string helper = findWalletRebuildHelper(); if (helper.empty()) { ui::Notifications::instance().error(TR("wallet_rebuild_no_helper"), 15.0f); return; } - show_wallet_recovered_dialog_ = false; + // 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 lk(wallet_restore_mutex_); wallet_restore_done_ = false; } daemon_restarting_ = true; connection_status_ = TR("sb_restarting_daemon"); diff --git a/src/util/i18n.cpp b/src/util/i18n.cpp index d0fcecd..c90f996 100644 --- a/src/util/i18n.cpp +++ b/src/util/i18n.cpp @@ -1194,15 +1194,50 @@ void I18n::loadBuiltinEnglish() 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 was auto-recovered"; - strings_["wallet_recovered_warn"] = "The node moved your wallet aside and loaded a salvaged copy."; - strings_["wallet_recovered_body"] = "On startup the node decided your wallet.dat looked damaged and recovered it automatically. Your ORIGINAL wallet was NOT deleted — it was renamed to \"wallet..bak\" in your data folder, and a salvaged copy is loaded now.\n\nThe salvaged copy may be incomplete, so the balance shown here could be wrong — don't treat it as final.\n\nThis is often a false alarm caused by leftover database files (e.g. after moving the wallet between machines). To restore your original: quit the wallet, then in the data folder rename the current wallet.dat aside, rename \"wallet..bak\" back to \"wallet.dat\", delete the \"database\" folder and any \"__db.*\" files, and reopen."; - strings_["wallet_recovered_open_folder"] = "Open data folder"; - strings_["wallet_recovered_dismiss"] = "Keep salvaged copy"; - strings_["wallet_recovered_restore"] = "Restore original wallet"; - strings_["wallet_recovered_notify"] = "The node recovered your wallet and moved the original to a .bak — your shown balance may be incomplete. See the prompt to restore it."; + 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..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 wallet and restarting the node…"; + 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..bak to restore. Nothing was changed."; @@ -1212,8 +1247,9 @@ void I18n::loadBuiltinEnglish() 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"] = "Rebuild wallet database (recommended)"; - strings_["wallet_rebuild_started"] = "Rebuilding your wallet database and restarting the node…"; + 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."; @@ -1345,7 +1381,7 @@ void I18n::loadBuiltinEnglish() 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 needs recovery — see the prompt"; + 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"; From 08aed34bbe7181eaacfe82875ebf50a9e7d435b2 Mon Sep 17 00:00:00 2001 From: DanS Date: Wed, 12 Aug 2026 00:08:08 -0500 Subject: [PATCH 46/89] fix(daemon): actually stop an external daemon on quit when the setting is on MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit "Stop external daemon" silently left an external dragonxd running. beginShutdown() calls rpc_->requestAbort() (a sticky abort flag, cleared only by connect()) to unblock in-flight requests; the shutdown thread's stopEmbeddedDaemon() then sent the graceful "stop" over that same connection, so curl self-aborted it (CURLE_ABORTED_BY_CALLBACK). doRPC swallowed the error but stop_sent was set true anyway, skipping the temp-connection fallback that would have worked — so the daemon never received "stop" and only died via the 20s by-name force-kill (which collides with the 8s "Force Quit / may corrupt chain data" prompt, so it read as "doesn't work"). Clear the abort before the shutdown stop and send it synchronously via sendStopCommandSafely so real delivery success is surfaced (and the fallback can still run on failure). The graceful stop now reaches the daemon, it exits in a second or two, and the 20s stall / Force-Quit prompt no longer appears. Co-Authored-By: Claude Opus 4.8 (1M context) --- src/app.cpp | 16 ++++++++-------- 1 file changed, 8 insertions(+), 8 deletions(-) diff --git a/src/app.cpp b/src/app.cpp index 05cc0f7..85607e5 100644 --- a/src/app.cpp +++ b/src/app.cpp @@ -5047,17 +5047,17 @@ void App::stopEmbeddedDaemon() // daemon flush state, save block indexes, close sockets, etc. bool stop_sent = false; - // Try the existing RPC connection first + // Try the existing RPC connection first. beginShutdown() called rpc_->requestAbort() to unblock any + // in-flight request — but that sticky abort (cleared only by connect()) would make THIS "stop" self- + // abort mid-flight (CURLE_ABORTED_BY_CALLBACK). The old async rpc_->stop() swallowed that error yet + // set stop_sent=true, so the daemon never heard "stop" and the working temp-connection fallback was + // skipped — which is why "Stop external daemon" left an external dragonxd running (it only died via + // the 20s force-kill). Clear the abort and send SYNCHRONOUSLY so real success is surfaced. if (rpc_ && rpc_->isConnected()) { DEBUG_LOGF("Sending stop command via existing RPC connection...\n"); - try { - rpc_->stop([](const json&) { - DEBUG_LOGF("Stop command acknowledged by daemon\n"); - }); + rpc_->clearAbort(); + if (sendStopCommandSafely(*rpc_, "existing connection stop")) stop_sent = true; - } catch (...) { - DEBUG_LOGF("Failed to send stop via existing connection\n"); - } } // If the main connection wasn't established (e.g. daemon was still From 13b225d8f5a2bda6a61112f5426c2e20fc732d1c Mon Sep 17 00:00:00 2001 From: DanS Date: Thu, 13 Aug 2026 15:49:09 -0500 Subject: [PATCH 47/89] fix(send): prefix shielded-send memos with "utf8:" so the daemon accepts them MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit A shielded send with a memo failed: "Invalid parameter, expected memo data in hexadecimal format or to use 'utf8:' prefix." The Send-tab path (and its fee-gap retry) put the user's plain-text memo straight into the z_sendmany recipient, which the daemon now rejects — it wants the memo hex-encoded or with a "utf8:" prefix. The chat path already prefixes with "utf8:"; do the same for user memos. Only the RPC recipient["memo"] is prefixed; the raw memo is still what's stored for the transaction-history display, and the daemon returns the decoded memoStr to receivers, so it round-trips as plain text. Co-Authored-By: Claude Opus 4.8 (1M context) --- src/app_network.cpp | 7 +++++-- 1 file changed, 5 insertions(+), 2 deletions(-) diff --git a/src/app_network.cpp b/src/app_network.cpp index 1f8ed88..91f3083 100644 --- a/src/app_network.cpp +++ b/src/app_network.cpp @@ -5062,7 +5062,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); @@ -5206,7 +5209,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; From ea26c0cbbb2fbd70518012e9ae2bee08d6e3b1d0 Mon Sep 17 00:00:00 2001 From: DanS Date: Thu, 13 Aug 2026 16:40:14 -0500 Subject: [PATCH 48/89] fix(balance): stop the displayed balance cratering during a pending shielded send MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit 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) --- src/app_network.cpp | 22 +++++---- src/app_sweep.cpp | 4 +- src/data/wallet_state.cpp | 9 ++-- src/data/wallet_state.h | 23 +++++++--- src/services/network_refresh_service.cpp | 58 ++++++++++++++++++------ src/services/network_refresh_service.h | 6 ++- src/ui/windows/balance_components.cpp | 6 +-- src/ui/windows/send_tab.cpp | 12 +++-- src/wallet/lite_wallet_controller.cpp | 7 +++ tests/test_phase4.cpp | 18 +++++--- 10 files changed, 115 insertions(+), 50 deletions(-) diff --git a/src/app_network.cpp b/src/app_network.cpp index 91f3083..e85d17b 100644 --- a/src/app_network.cpp +++ b/src/app_network.cpp @@ -1012,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& 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; } } @@ -1024,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); } } @@ -1685,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) { @@ -1696,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 = @@ -3046,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 } diff --git a/src/app_sweep.cpp b/src/app_sweep.cpp index cb6407a..000865e 100644 --- a/src/app_sweep.cpp +++ b/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"), diff --git a/src/data/wallet_state.cpp b/src/data/wallet_state.cpp index 880ec6b..2767c01 100644 --- a/src/data/wallet_state.cpp +++ b/src/data/wallet_state.cpp @@ -19,12 +19,13 @@ std::vector sortedSpendableAddressIndices(const std::vector 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& 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(i); } } diff --git a/src/data/wallet_state.h b/src/data/wallet_state.h index 66a1ba3..988110d 100644 --- a/src/data/wallet_state.h +++ b/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; diff --git a/src/services/network_refresh_service.cpp b/src/services/network_refresh_service.cpp index 03c1887..2abcd31 100644 --- a/src/services/network_refresh_service.cpp +++ b/src/services/network_refresh_service.cpp @@ -37,16 +37,27 @@ void applyBalancesFromUnspent(std::vector& addresses, const json& u { if (!unspent.is_array()) return; - std::map 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 total; + std::map spendable; for (const auto& output : unspent) { auto address = readOptional(output, "address"); - auto amount = readOptional(output, "amount"); - if (address && amount) balances[*address] += *amount; + auto amount = readOptional(output, "amount"); + if (!address || !amount) continue; + total[*address] += *amount; + auto conf = readOptional(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( @@ -611,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(); + 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(); } 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() : info.balance; + } catch (...) { info.spendableBalance = info.balance; } } } @@ -631,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()); @@ -1197,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; } diff --git a/src/services/network_refresh_service.h b/src/services/network_refresh_service.h index efdf024..7fd1b88 100644 --- a/src/services/network_refresh_service.h +++ b/src/services/network_refresh_service.h @@ -98,9 +98,12 @@ public: struct CoreRefreshResult { bool balanceOk = false; - std::optional shieldedBalance; + std::optional shieldedBalance; // display (minconf=0, incl. pending change) std::optional transparentBalance; std::optional totalBalance; + std::optional spendableShieldedBalance; // confirmed (minconf=1) + std::optional spendableTransparentBalance; + std::optional spendableTotalBalance; bool blockchainOk = false; std::optional blocks; std::optional headers; @@ -227,6 +230,7 @@ public: RefreshRpcGateway& rpc, const std::optional& prefetchedInfo = std::nullopt); static CoreRefreshResult parseCoreRefreshResult(const nlohmann::json& totalBalance, + const nlohmann::json& spendableBalance, bool balanceOk, const nlohmann::json& blockInfo, bool blockOk); diff --git a/src/ui/windows/balance_components.cpp b/src/ui/windows/balance_components.cpp index 8ee7d78..2a836bf 100644 --- a/src/ui/windows/balance_components.cpp +++ b/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); diff --git a/src/ui/windows/send_tab.cpp b/src/ui/windows/send_tab.cpp index 1bee4fd..0b3c0f5 100644 --- a/src/ui/windows/send_tab.cpp +++ b/src/ui/windows/send_tab.cpp @@ -137,13 +137,15 @@ 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(state.addresses.size())) { - return state.addresses[s_selected_from_idx].balance; + return state.addresses[s_selected_from_idx].spendableBalance; } return 0.0; } @@ -252,7 +254,7 @@ static void RenderSourceDropdown(App* app, float width) { std::string trunc = util::truncateMiddle(addr.address, static_cast(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(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(); } diff --git a/src/wallet/lite_wallet_controller.cpp b/src/wallet/lite_wallet_controller.cpp index d1bc0e4..1b0d891 100644 --- a/src/wallet/lite_wallet_controller.cpp +++ b/src/wallet/lite_wallet_controller.cpp @@ -139,6 +139,12 @@ void applyLiteRefreshModelToWalletState(const LiteWalletAppRefreshModel& model, state.transparentBalance = static_cast(model.balance.transparentZatoshis) / kZatoshisPerCoin; state.totalBalance = static_cast(model.balance.totalZatoshis) / kZatoshisPerCoin; state.unconfirmedBalance = static_cast(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) { @@ -178,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) { diff --git a/tests/test_phase4.cpp b/tests/test_phase4.cpp index c420a7d..1d33034 100644 --- a/tests/test_phase4.cpp +++ b/tests/test_phase4.cpp @@ -934,6 +934,7 @@ void testSpendableFiltering() addresses.push_back({"zs-low", 2.0, "shielded", true}); addresses.push_back({"R-zero", 0.0, "transparent", true}); addresses.push_back({"R-high", 5.0, "transparent", true}); + for (auto& a : addresses) a.spendableBalance = a.balance; // selection now ranks by CONFIRMED balance EXPECT_EQ(dragonx::bestSpendableAddressIndex(addresses), 3); @@ -1424,10 +1425,10 @@ void testNetworkRefreshRpcCollectors() }); auto core = Refresh::collectCoreRefreshResult(coreRpc); EXPECT_TRUE(coreRpc.methodNames() == std::vector({ - "z_gettotalbalance", "getblockchaininfo" + "z_gettotalbalance", "z_gettotalbalance", "getblockchaininfo" // display (minconf=0) + spendable (minconf=1) })); - EXPECT_EQ(coreRpc.calls[0].params, json::array()); - EXPECT_EQ(coreRpc.calls[1].params, json::array()); + EXPECT_EQ(coreRpc.calls[0].params, json::array({0})); + EXPECT_EQ(coreRpc.calls[1].params, json::array({1})); EXPECT_TRUE(core.balanceOk); EXPECT_TRUE(core.blockchainOk); EXPECT_NEAR(*core.totalBalance, 4.25, 0.00000001); @@ -1440,7 +1441,7 @@ void testNetworkRefreshRpcCollectors() coreFallbackRpc.addResponse("getblockchaininfo", json{{"blocks", 8}, {"headers", 9}}); auto partialCore = Refresh::collectCoreRefreshResult(coreFallbackRpc); EXPECT_TRUE(coreFallbackRpc.methodNames() == std::vector({ - "z_gettotalbalance", "getblockchaininfo" + "z_gettotalbalance", "z_gettotalbalance", "getblockchaininfo" })); EXPECT_FALSE(partialCore.balanceOk); EXPECT_TRUE(partialCore.blockchainOk); @@ -1566,7 +1567,7 @@ void testNetworkRefreshRpcCollectors() auto fallbackAddresses = Refresh::collectAddressRefreshResult(fallbackRpc); EXPECT_TRUE(fallbackRpc.methodNames() == std::vector({ "z_listaddresses", "z_validateaddress", "z_listunspent", - "z_getbalance", "getaddressesbyaccount", "listunspent" + "z_getbalance", "z_getbalance", "getaddressesbyaccount", "listunspent" // display (minconf=0) + spendable (minconf=1) })); EXPECT_TRUE(fallbackAddresses.shieldedAddresses[0].has_spending_key); EXPECT_NEAR(fallbackAddresses.shieldedAddresses[0].balance, 4.75, 0.00000001); @@ -1963,7 +1964,8 @@ void testNetworkRefreshResultModels() dragonx::WalletState state; auto core = Refresh::parseCoreRefreshResult( - json{{"private", "1.25000000"}, {"transparent", "0.50000000"}, {"total", "1.75000000"}}, + json{{"private", "1.25000000"}, {"transparent", "0.50000000"}, {"total", "1.75000000"}}, // display (minconf=0) + json{{"private", "1.00000000"}, {"transparent", "0.50000000"}, {"total", "1.50000000"}}, // spendable (minconf=1) true, json{{"blocks", 100}, {"headers", 105}, {"bestblockhash", "apply-best-100"}, {"verificationprogress", 0.75}, {"longestchain", 110}, {"notarized", 90}}, @@ -1972,6 +1974,10 @@ void testNetworkRefreshResultModels() EXPECT_NEAR(state.shielded_balance, 1.25, 0.00000001); EXPECT_NEAR(state.transparent_balance, 0.5, 0.00000001); EXPECT_NEAR(state.total_balance, 1.75, 0.00000001); + // Confirmed/spendable stays at minconf=1; unconfirmed = display total - spendable total (the pending change). + EXPECT_NEAR(state.spendablePrivateBalance, 1.0, 0.00000001); + EXPECT_NEAR(state.spendableTotalBalance, 1.5, 0.00000001); + EXPECT_NEAR(state.unconfirmedBalance, 0.25, 0.00000001); EXPECT_EQ(state.sync.blocks, 100); EXPECT_EQ(state.sync.headers, 105); EXPECT_EQ(state.sync.best_blockhash, std::string("apply-best-100")); From 6ee81a5abeb1f88b0aa0f446677bfb3b890cec46 Mon Sep 17 00:00:00 2001 From: DanS Date: Tue, 18 Aug 2026 13:18:49 -0500 Subject: [PATCH 49/89] fix: security-audit remediation (15 findings), empty-wallet warning, and send/chat/console/shutdown UX Security audit remediation (15 confirmed findings from the codebase audit): - H-02: scrub+delete the decrypt-flow plaintext key export on ALL exit paths (RAII guard) and purge stale obsidiandecryptexport* files at startup. - M-01/L-03/L-04/L-05/L-07: sodium_memzero the Set-PIN and encrypt-PIN worker passphrase/PIN copies, the RPC Basic-auth string (auth_), the exported/imported key buffers (App::wipeSecrets, called from ~App and before main's _Exit), and the first-run wizard "Skip" buffers. - M-03/M-04/M-05/L-06: return locked COPIES from XmrigManager/EmbeddedDaemon getters (dedicated error_mutex_; DaemonController::lastError now by value), route xmrig last_error_ writes through a locked setter, and wrap shutdown_status_/wizard_stop_status_ in a locking GuardedStatus (wizard_stopping_external_ -> std::atomic). - M-02: persist after a console send/shield/import in the lite backend. - L-01: require the confirm click for z_shieldcoinbase/z_mergetoaddress. - L-02: quote/escape each Windows daemon argv per the MSDN CommandLineToArgvW rules. - L-08: pin json/tomlplusplus/libwebp FetchContent to immutable commit SHAs. - I-01: extract updater archives from the already-verified in-memory buffer (no disk re-read TOCTOU). Feature: warn once (full-node) when the active wallet loads empty while a sibling wallet file in the datadir holds keys. A funded salvage wallet..bak routes to the recovery/Restore flow; a funded sibling .dat routes to the wallet manager. Per-wallet-file dismissal; gated on synced + address-list-loaded to avoid false positives on warm reconnect / spent-down wallets. UX fixes: - send: show the TOTAL balance (with a spendable "available" note) in the source dropdown and keep pending-change addresses visible. - chat: insert emoji at the cursor position; restrict new-chat recipients to shielded (z) addresses. - console: optional auto-focus of the command input on tab open (off by default). - shutdown: when "stop external daemon" is on, keep the shutdown screen up until the external node actually exits, showing live status. Adversarially reviewed; verified across full-node, lite, and Windows builds; tests pass. Co-Authored-By: Claude Opus 4.8 (1M context) --- CMakeLists.txt | 6 +- res/fonts/NotoSansCJK-Subset.ttf | Bin 667124 -> 669212 bytes res/lang/de.json | 11 ++ res/lang/es.json | 11 ++ res/lang/fr.json | 11 ++ res/lang/ja.json | 11 ++ res/lang/ko.json | 11 ++ res/lang/pt.json | 11 ++ res/lang/ru.json | 11 ++ res/lang/zh.json | 11 ++ src/app.cpp | 188 ++++++++++++++++++- src/app.h | 37 +++- src/app_network.cpp | 117 ++++++++++++ src/app_security.cpp | 74 +++++--- src/app_wizard.cpp | 10 +- src/config/settings.cpp | 10 + src/config/settings.h | 13 ++ src/daemon/daemon_controller.cpp | 6 +- src/daemon/daemon_controller.h | 2 +- src/daemon/embedded_daemon.cpp | 29 ++- src/daemon/embedded_daemon.h | 5 +- src/daemon/xmrig_manager.cpp | 27 +-- src/daemon/xmrig_manager.h | 9 +- src/data/wallet_state.h | 3 +- src/main.cpp | 1 + src/rpc/rpc_client.cpp | 9 +- src/services/network_refresh_service.cpp | 2 + src/services/network_refresh_service.h | 4 + src/ui/pages/settings_page.cpp | 8 + src/ui/windows/chat_tab.cpp | 43 ++++- src/ui/windows/console_command_reference.cpp | 4 +- src/ui/windows/console_tab.cpp | 7 +- src/ui/windows/console_tab.h | 5 + src/ui/windows/send_tab.cpp | 42 ++++- src/ui/windows/wallets_dialog.h | 5 +- src/util/daemon_updater.cpp | 7 +- src/util/i18n.cpp | 17 ++ src/util/wallet_file_probe.h | 43 +++++ src/util/xmrig_updater.cpp | 7 +- src/wallet/lite_wallet_controller.cpp | 7 + 40 files changed, 745 insertions(+), 90 deletions(-) diff --git a/CMakeLists.txt b/CMakeLists.txt index 90c7188..ba26f5d 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -213,7 +213,7 @@ include(FetchContent) FetchContent_Declare( json GIT_REPOSITORY https://github.com/nlohmann/json.git - GIT_TAG v3.11.3 + GIT_TAG 9cca280a4d0ccf0c08f47a99aa71d1b0e52f8d03 # v3.11.3 — pinned to immutable commit (L-08); tags are mutable GIT_SHALLOW TRUE ) FetchContent_MakeAvailable(json) @@ -222,7 +222,7 @@ FetchContent_MakeAvailable(json) FetchContent_Declare( tomlplusplus GIT_REPOSITORY https://github.com/marzer/tomlplusplus.git - GIT_TAG v3.4.0 + GIT_TAG 30172438cee64926dc41fdd9c11fb3ba5b2ba9de # v3.4.0 — pinned to immutable commit (L-08); tags are mutable GIT_SHALLOW TRUE ) FetchContent_MakeAvailable(tomlplusplus) @@ -289,7 +289,7 @@ message(STATUS "Fetching libwebp (decode-only, static)...") FetchContent_Declare( libwebp GIT_REPOSITORY https://github.com/webmproject/libwebp.git - GIT_TAG v1.4.0 + GIT_TAG 845d5476a866141ba35ac133f856fa62f0b7445f # v1.4.0 — pinned to immutable commit (L-08); tags are mutable GIT_SHALLOW TRUE # libwebp's cpu.cmake applies -mno-sse2/-mno-sse4.1 to its scalar reference DSP # files when it can't probe SSE support. Under a macOS universal build diff --git a/res/fonts/NotoSansCJK-Subset.ttf b/res/fonts/NotoSansCJK-Subset.ttf index 6f3f92d43a17c05406c9e5516a1d042d3b612ba0..9d09bd06c7205c6e54a3061cbf2b36dda2b41f21 100644 GIT binary patch delta 20807 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 diff --git a/res/lang/de.json b/res/lang/de.json index 9a9df80..dee943f 100644 --- a/res/lang/de.json +++ b/res/lang/de.json @@ -485,6 +485,17 @@ "download_bootstrap": "Bootstrap herunterladen", "dragonx_green": "DragonX (Grün)", "edit": "Bearbeiten", + "empty_wallet_keys_suffix": "Schlüssel", + "empty_wallet_open_manager": "Wallet-Verwaltung öffnen", + "empty_wallet_restore": "Mein Wallet wiederherstellen", + "empty_wallet_salvage_body": "Dieses Wallet ist leer, weil eine frühere automatische Reparatur Ihr ursprüngliches Wallet als Sicherung beiseitegelegt hat. Ihre Coins befinden sich fast sicher in dieser Sicherung und sind nicht verloren. Stellen Sie sie wieder her, um Ihr Guthaben erneut zu laden — nichts wird gelöscht; die aktuelle Datei wird zuerst beiseitegelegt.", + "empty_wallet_salvage_headline": "Ihre Coins sind sicher in einer Sicherungsdatei.", + "empty_wallet_salvage_title": "Ihr Wallet wurde möglicherweise repariert", + "empty_wallet_warning_body": "Dieses Wallet hat keine Adressen und kein Guthaben, aber eine andere Wallet-Datei in Ihrem DragonX-Ordner enthält Schlüssel. Ihre Coins befinden sich höchstwahrscheinlich dort und sind nicht verloren. Öffnen Sie die Wallet-Verwaltung, um zu dem Wallet mit Ihrem Guthaben zu wechseln.", + "empty_wallet_warning_dismiss": "Für dieses Wallet nicht mehr warnen", + "empty_wallet_warning_dismiss_tip": "Beendet diese Warnung nur für die aktuelle Wallet-Datei. Wenn Sie später zu einem anderen leeren Wallet wechseln, kann die Warnung erneut erscheinen.", + "empty_wallet_warning_headline": "Möglicherweise haben Sie das falsche Wallet geöffnet.", + "empty_wallet_warning_title": "Dieses Wallet ist leer", "enc_confirm": "Bestätigen:", "enc_desc": "Die Verschlüsselung Ihrer Wallet schützt Ihre privaten Schlüssel mit einer Passphrase. Nach der Verschlüsselung wird der Daemon neu gestartet.", "enc_encrypting": "Wallet wird verschlüsselt...", diff --git a/res/lang/es.json b/res/lang/es.json index 5535247..78009cd 100644 --- a/res/lang/es.json +++ b/res/lang/es.json @@ -485,6 +485,17 @@ "download_bootstrap": "Descargar Bootstrap", "dragonx_green": "DragonX (Verde)", "edit": "Editar", + "empty_wallet_keys_suffix": "claves", + "empty_wallet_open_manager": "Abrir administrador de carteras", + "empty_wallet_restore": "Restaurar mi cartera", + "empty_wallet_salvage_body": "Esta cartera está vacía porque una reparación automática anterior apartó tu cartera original como copia de seguridad. Tus monedas casi con certeza están en esa copia, no perdidas. Restáurala para volver a cargar tus fondos: no se elimina nada; primero se aparta el archivo actual.", + "empty_wallet_salvage_headline": "Tus monedas están a salvo en un archivo de copia de seguridad.", + "empty_wallet_salvage_title": "Es posible que tu cartera haya sido reparada", + "empty_wallet_warning_body": "Esta cartera no tiene direcciones ni fondos, pero otro archivo de cartera en tu carpeta de DragonX contiene claves. Lo más probable es que tus monedas estén ahí, no perdidas. Abre el administrador de carteras para cambiar a la cartera que tiene tus fondos.", + "empty_wallet_warning_dismiss": "No volver a avisar para esta cartera", + "empty_wallet_warning_dismiss_tip": "Detiene este aviso solo para el archivo de cartera actual. Si más tarde cambias a otra cartera vacía, podría avisarte de nuevo.", + "empty_wallet_warning_headline": "Es posible que haya abierto la cartera equivocada.", + "empty_wallet_warning_title": "Esta cartera está vacía", "enc_confirm": "Confirmar:", "enc_desc": "Cifrar tu monedero protege tus claves privadas con una frase de contraseña. Tras el cifrado, el daemon se reiniciará.", "enc_encrypting": "Cifrando el monedero...", diff --git a/res/lang/fr.json b/res/lang/fr.json index e3dd5cf..b5ae70a 100644 --- a/res/lang/fr.json +++ b/res/lang/fr.json @@ -485,6 +485,17 @@ "download_bootstrap": "Télécharger Bootstrap", "dragonx_green": "DragonX (Vert)", "edit": "Modifier", + "empty_wallet_keys_suffix": "clés", + "empty_wallet_open_manager": "Ouvrir le gestionnaire de portefeuilles", + "empty_wallet_restore": "Restaurer mon portefeuille", + "empty_wallet_salvage_body": "Ce portefeuille est vide car une réparation automatique antérieure a mis votre portefeuille d'origine de côté comme sauvegarde. Vos pièces se trouvent presque certainement dans cette sauvegarde, elles ne sont pas perdues. Restaurez-la pour recharger vos fonds — rien n'est supprimé ; le fichier actuel est d'abord mis de côté.", + "empty_wallet_salvage_headline": "Vos pièces sont en sécurité dans un fichier de sauvegarde.", + "empty_wallet_salvage_title": "Votre portefeuille a peut-être été réparé", + "empty_wallet_warning_body": "Ce portefeuille n'a aucune adresse ni fonds, mais un autre fichier de portefeuille dans votre dossier DragonX contient des clés. Vos pièces s'y trouvent très probablement, elles ne sont pas perdues. Ouvrez le gestionnaire de portefeuilles pour passer au portefeuille qui contient vos fonds.", + "empty_wallet_warning_dismiss": "Ne plus avertir pour ce portefeuille", + "empty_wallet_warning_dismiss_tip": "Arrête cet avertissement uniquement pour le fichier de portefeuille actuel. Si vous passez plus tard à un autre portefeuille vide, il pourra avertir à nouveau.", + "empty_wallet_warning_headline": "Vous avez peut-être ouvert le mauvais portefeuille.", + "empty_wallet_warning_title": "Ce portefeuille est vide", "enc_confirm": "Confirmer :", "enc_desc": "Chiffrer votre portefeuille protège vos clés privées avec une phrase secrète. Après le chiffrement, le daemon redémarrera.", "enc_encrypting": "Chiffrement du portefeuille...", diff --git a/res/lang/ja.json b/res/lang/ja.json index 7cd4a10..931fb5d 100644 --- a/res/lang/ja.json +++ b/res/lang/ja.json @@ -485,6 +485,17 @@ "download_bootstrap": "ブートストラップをダウンロード", "dragonx_green": "DragonX（グリーン）", "edit": "編集", + "empty_wallet_keys_suffix": "個の鍵", + "empty_wallet_open_manager": "ウォレットマネージャーを開く", + "empty_wallet_restore": "ウォレットを復元", + "empty_wallet_salvage_body": "このウォレットが空なのは、以前の自動修復によって元のウォレットがバックアップとして脇に保存されたためです。コインはほぼ確実にそのバックアップの中にあり、失われていません。復元すれば資金を再び読み込めます。何も削除されません。現在のファイルは先に脇へ保存されます。", + "empty_wallet_salvage_headline": "コインはバックアップファイルに安全に保管されています。", + "empty_wallet_salvage_title": "ウォレットが修復された可能性があります", + "empty_wallet_warning_body": "このウォレットにはアドレスも資金もありませんが、DragonX フォルダー内の別のウォレットファイルに鍵が含まれています。コインはおそらくそちらにあり、失われていません。ウォレットマネージャーを開いて、資金のあるウォレットに切り替えてください。", + "empty_wallet_warning_dismiss": "このウォレットでは今後警告しない", + "empty_wallet_warning_dismiss_tip": "現在のウォレットファイルに対してのみこの警告を停止します。後で別の空のウォレットに切り替えると、再び警告される場合があります。", + "empty_wallet_warning_headline": "間違ったウォレットを開いた可能性があります。", + "empty_wallet_warning_title": "このウォレットは空です", "enc_confirm": "確認:", "enc_desc": "ウォレットを暗号化すると、パスフレーズで秘密鍵が保護されます。暗号化後、デーモンが再起動します。", "enc_encrypting": "ウォレットを暗号化しています...", diff --git a/res/lang/ko.json b/res/lang/ko.json index 7c56e41..0a3d210 100644 --- a/res/lang/ko.json +++ b/res/lang/ko.json @@ -485,6 +485,17 @@ "download_bootstrap": "부트스트랩 다운로드", "dragonx_green": "DragonX(그린)", "edit": "편집", + "empty_wallet_keys_suffix": "개 키", + "empty_wallet_open_manager": "지갑 관리자 열기", + "empty_wallet_restore": "내 지갑 복원", + "empty_wallet_salvage_body": "이 지갑이 비어 있는 것은 이전의 자동 복구가 원본 지갑을 백업으로 따로 보관했기 때문입니다. 코인은 거의 확실히 그 백업에 있으며 사라지지 않았습니다. 복원하면 자금을 다시 불러올 수 있습니다. 아무것도 삭제되지 않으며, 현재 파일은 먼저 따로 보관됩니다.", + "empty_wallet_salvage_headline": "코인은 백업 파일에 안전하게 보관되어 있습니다.", + "empty_wallet_salvage_title": "지갑이 복구되었을 수 있습니다", + "empty_wallet_warning_body": "이 지갑에는 주소도 자금도 없지만, DragonX 폴더의 다른 지갑 파일에 키가 들어 있습니다. 코인은 대부분 그 안에 있으며 사라진 것이 아닙니다. 지갑 관리자를 열어 자금이 있는 지갑으로 전환하세요.", + "empty_wallet_warning_dismiss": "이 지갑에 대해 다시 경고하지 않기", + "empty_wallet_warning_dismiss_tip": "현재 지갑 파일에 대해서만 이 경고를 중지합니다. 나중에 다른 빈 지갑으로 전환하면 다시 경고할 수 있습니다.", + "empty_wallet_warning_headline": "잘못된 지갑을 열었을 수 있습니다.", + "empty_wallet_warning_title": "이 지갑은 비어 있습니다", "enc_confirm": "확인:", "enc_desc": "지갑을 암호화하면 암호로 개인 키를 보호합니다. 암호화 후 데몬이 다시 시작됩니다.", "enc_encrypting": "지갑을 암호화하는 중...", diff --git a/res/lang/pt.json b/res/lang/pt.json index a5e0eda..6d0c0bf 100644 --- a/res/lang/pt.json +++ b/res/lang/pt.json @@ -485,6 +485,17 @@ "download_bootstrap": "Baixar Bootstrap", "dragonx_green": "DragonX (Verde)", "edit": "Editar", + "empty_wallet_keys_suffix": "chaves", + "empty_wallet_open_manager": "Abrir gerenciador de carteiras", + "empty_wallet_restore": "Restaurar minha carteira", + "empty_wallet_salvage_body": "Esta carteira está vazia porque um reparo automático anterior colocou sua carteira original de lado como backup. Suas moedas quase certamente estão nesse backup, não perdidas. Restaure-o para carregar seus fundos novamente — nada é excluído; o arquivo atual é guardado primeiro.", + "empty_wallet_salvage_headline": "Suas moedas estão seguras em um arquivo de backup.", + "empty_wallet_salvage_title": "Sua carteira pode ter sido reparada", + "empty_wallet_warning_body": "Esta carteira não tem endereços nem fundos, mas outro arquivo de carteira na sua pasta do DragonX contém chaves. Suas moedas provavelmente estão nele, não perdidas. Abra o gerenciador de carteiras para mudar para a carteira que contém seus fundos.", + "empty_wallet_warning_dismiss": "Não avisar novamente para esta carteira", + "empty_wallet_warning_dismiss_tip": "Interrompe este aviso apenas para o arquivo de carteira atual. Se você mudar para outra carteira vazia mais tarde, poderá avisar novamente.", + "empty_wallet_warning_headline": "Você pode ter aberto a carteira errada.", + "empty_wallet_warning_title": "Esta carteira está vazia", "enc_confirm": "Confirmar:", "enc_desc": "Criptografar sua carteira protege suas chaves privadas com uma senha. Após a criptografia, o daemon será reiniciado.", "enc_encrypting": "Criptografando a carteira...", diff --git a/res/lang/ru.json b/res/lang/ru.json index d59c39a..e476059 100644 --- a/res/lang/ru.json +++ b/res/lang/ru.json @@ -485,6 +485,17 @@ "download_bootstrap": "Скачать бутстрап", "dragonx_green": "DragonX (Зелёная)", "edit": "Редактировать", + "empty_wallet_keys_suffix": "ключей", + "empty_wallet_open_manager": "Открыть менеджер кошельков", + "empty_wallet_restore": "Восстановить мой кошелёк", + "empty_wallet_salvage_body": "Этот кошелёк пуст, потому что предыдущее автоматическое восстановление отложило ваш исходный кошелёк в качестве резервной копии. Ваши монеты почти наверняка находятся в этой копии и не потеряны. Восстановите её, чтобы снова загрузить средства — ничего не удаляется; текущий файл сначала откладывается в сторону.", + "empty_wallet_salvage_headline": "Ваши монеты в безопасности в файле резервной копии.", + "empty_wallet_salvage_title": "Возможно, ваш кошелёк был восстановлен", + "empty_wallet_warning_body": "В этом кошельке нет адресов и средств, но другой файл кошелька в вашей папке DragonX содержит ключи. Ваши монеты, скорее всего, находятся в нём и не потеряны. Откройте менеджер кошельков, чтобы переключиться на кошелёк с вашими средствами.", + "empty_wallet_warning_dismiss": "Больше не предупреждать для этого кошелька", + "empty_wallet_warning_dismiss_tip": "Останавливает это предупреждение только для текущего файла кошелька. Если позже вы переключитесь на другой пустой кошелёк, предупреждение может появиться снова.", + "empty_wallet_warning_headline": "Возможно, вы открыли не тот кошелёк.", + "empty_wallet_warning_title": "Этот кошелёк пуст", "enc_confirm": "Подтвердите:", "enc_desc": "Шифрование кошелька защищает ваши приватные ключи паролем. После шифрования демон перезапустится.", "enc_encrypting": "Шифрование кошелька...", diff --git a/res/lang/zh.json b/res/lang/zh.json index 6b0dee2..fa7c265 100644 --- a/res/lang/zh.json +++ b/res/lang/zh.json @@ -485,6 +485,17 @@ "download_bootstrap": "下载引导程序", "dragonx_green": "DragonX（绿色）", "edit": "编辑", + "empty_wallet_keys_suffix": "个密钥", + "empty_wallet_open_manager": "打开钱包管理器", + "empty_wallet_restore": "恢复我的钱包", + "empty_wallet_salvage_body": "此钱包为空，因为先前的一次自动修复已将您的原始钱包作为备份保存到一旁。您的币几乎肯定在该备份中，并未丢失。恢复它即可重新加载您的资金——不会删除任何内容；当前文件会先被保存到一旁。", + "empty_wallet_salvage_headline": "您的币安全地存放在备份文件中。", + "empty_wallet_salvage_title": "您的钱包可能已被修复", + "empty_wallet_warning_body": "此钱包没有地址也没有资金，但您的 DragonX 文件夹中的另一个钱包文件包含密钥。您的币很可能在其中，并未丢失。打开钱包管理器以切换到持有您资金的钱包。", + "empty_wallet_warning_dismiss": "不再为此钱包提示", + "empty_wallet_warning_dismiss_tip": "仅对当前钱包文件停止此提示。如果您以后切换到另一个空钱包，可能会再次提示。", + "empty_wallet_warning_headline": "您可能打开了错误的钱包。", + "empty_wallet_warning_title": "此钱包为空", "enc_confirm": "确认：", "enc_desc": "加密钱包会用密码短语保护您的私钥。加密后，守护进程将重新启动。", "enc_encrypting": "正在加密钱包...", diff --git a/src/app.cpp b/src/app.cpp index 85607e5..2991453 100644 --- a/src/app.cpp +++ b/src/app.cpp @@ -127,14 +127,24 @@ App::App() // Seed the auto-balance RNG once per run so weighted-random pool selection isn't // deterministic across launches. balance_rng_.seed(std::random_device{}()); + // Purge any plaintext key export left behind by a crashed/interrupted decrypt flow. (H-02) + sweepStaleDecryptExports(); } App::~App() { - // Scrub any seed/phrase secret still resident (e.g. app quit with a backup/migration modal open). + wipeSecrets(); +} + +// Scrub every resident secret buffer. Idempotent + safe to call from the forced-exit path (main.cpp +// _Exit bypasses destructors), so key/seed material isn't left in freed heap on the real quit path. (L-05) +void App::wipeSecrets() +{ if (!seed_migration_seed_.empty()) sodium_memzero(&seed_migration_seed_[0], seed_migration_seed_.size()); if (!seed_backup_phrase_.empty()) sodium_memzero(&seed_backup_phrase_[0], seed_backup_phrase_.size()); + sodium_memzero(export_result_, sizeof(export_result_)); // exported WIF/z-key (SECRET) + sodium_memzero(import_key_input_, sizeof(import_key_input_)); // pasted private key (SECRET) } namespace { @@ -824,6 +834,10 @@ void App::update() // One-time reminder to back up the wallet's seed phrase (mnemonic wallets only). maybeRemindSeedBackup(); + // One-time warning if the active wallet loaded empty while a sibling wallet file holds funds + // (a prior/unwitnessed salvage likely moved the coins into a wallet..bak). + maybeWarnEmptyWalletWithFundedSiblings(); + // Classify the wallet's mnemonic status (once per connect) so the Migrate-to-seed button can // glow for a legacy, pre-seed-phrase wallet. probeWalletSeedStatus(); @@ -957,7 +971,7 @@ void App::update() if (xmrig_poll_tick && xmrig_manager_ && xmrig_manager_->isRunning()) { xmrig_manager_->pollStats(); auto& ps = state_.pool_mining; - auto& xs = xmrig_manager_->getStats(); + const auto xs = xmrig_manager_->getStats(); // getStats() now returns a locked copy (M-03) ps.xmrig_running = true; ps.hashrate_10s = xs.hashrate_10s; ps.hashrate_60s = xs.hashrate_60s; @@ -1777,6 +1791,12 @@ void App::render() // Page transition: detect change, ramp alpha if (current_page_ != prev_page_) { page_alpha_ = (ui::effects::isLowSpecMode() || (settings_ && settings_->getReduceMotion())) ? 1.0f : 0.0f; + // Switching INTO the console → put the cursor in the command box (toggleable). Done here at the + // transition (not in the console render) because prev_page_ is updated below; the console renders + // later this same frame and consumes the one-shot request. + if ((current_page_ == ui::NavPage::Console || current_page_ == ui::NavPage::LiteConsole) + && settings_ && settings_->getConsoleAutoFocus()) + console_tab_.requestInputFocus(); prev_page_ = current_page_; } if (page_alpha_ < 1.0f) { @@ -2148,6 +2168,7 @@ void App::render() renderSwitchStopDaemonDialog(); renderBlockDbReindexDialog(); renderWalletRecoveredDialog(); + renderEmptyWalletWarningDialog(); // Render notifications (toast messages) ui::Notifications::instance().render(); @@ -4657,6 +4678,129 @@ void App::renderWalletRecoveredDialog() ui::material::EndOverlayDialog(); } +// Auto-shown when the active wallet loaded EMPTY but a sibling wallet file in the datadir still holds keys +// (see maybeWarnEmptyWalletWithFundedSiblings). Funds are not lost — they're in another file, most likely a +// wallet..bak left by an earlier BDB salvage. This routes the user to the wallet manager to switch, and +// remembers a per-file dismissal so it never nags again for this wallet. +void App::renderEmptyWalletWarningDialog() +{ + if (!show_empty_wallet_warning_) return; + + const bool salvage = empty_wallet_has_salvage_bak_; // salvage .bak → offer Restore; else → switch wallet + + ui::material::OverlayDialogSpec ov; + ov.title = TR(salvage ? "empty_wallet_salvage_title" : "empty_wallet_warning_title"); + ov.p_open = &show_empty_wallet_warning_; + ov.style = ui::material::OverlayStyle::BlurFloat; + ov.cardWidth = 560.0f; + ov.idSuffix = "emptywalletwarn"; + if (!ui::material::BeginOverlayDialog(ov)) return; + const float dp = ui::Layout::dpiScale(); + + // Header: wallet icon in a warning tint + a calm "your coins are likely in another file" framing. + { + ImFont* icoF = ui::material::Type().iconLarge(); + const float rowTop = ImGui::GetCursorPosY(); + ImGui::PushFont(icoF); + ImGui::PushStyleColor(ImGuiCol_Text, ui::material::Warning()); + ImGui::TextUnformatted(ICON_MD_ACCOUNT_BALANCE_WALLET); + ImGui::PopStyleColor(); + ImGui::PopFont(); + ImGui::SameLine(); + ImFont* txtF = ui::material::Type().subtitle1(); + const float iconH = icoF->LegacySize; + const float textH = txtF ? txtF->LegacySize : ImGui::GetFontSize(); + if (iconH > textH) ImGui::SetCursorPosY(rowTop + (iconH - textH) * 0.5f); + ImGui::PushFont(txtF); + ImGui::TextWrapped("%s", TR(salvage ? "empty_wallet_salvage_headline" : "empty_wallet_warning_headline")); + ImGui::PopFont(); + } + ImGui::Dummy(ImVec2(0, ui::Layout::spacingSm())); + + ImGui::PushTextWrapPos(0.0f); + ImGui::TextWrapped("%s", TR(salvage ? "empty_wallet_salvage_body" : "empty_wallet_warning_body")); + ImGui::PopTextWrapPos(); + + // For the "wrong wallet" case, name the other wallet file(s) that hold keys, with a compact key count — + // concrete evidence the coins are recoverable from them. The count is built with std::to_string so no + // printf format lives in a translatable string (translations are additive and could otherwise drop a %d). + // (The salvage case has no sibling list — restoreOriginalWallet() finds the backup itself.) + if (!empty_wallet_funded_siblings_.empty()) { + ImGui::Dummy(ImVec2(0, ui::Layout::spacingSm())); + for (const auto& s : empty_wallet_funded_siblings_) { + ImGui::Bullet(); + ImGui::SameLine(); + ImGui::TextUnformatted(s.fileName.c_str()); + ImGui::PushFont(ui::material::Type().caption()); + ImGui::PushStyleColor(ImGuiCol_Text, ui::material::OnSurfaceMedium()); + const std::string keys = " " + std::to_string(s.transparentKeys + s.shieldedKeys) + + " " + TR("empty_wallet_keys_suffix"); + ImGui::SameLine(); + ImGui::TextUnformatted(keys.c_str()); + ImGui::PopStyleColor(); + ImGui::PopFont(); + } + } + + // Primary action: route the user to the wallet manager to switch files (accent-tinted so it dominates). + ImGui::Dummy(ImVec2(0, ui::Layout::spacingMd())); + ImFont* rbf = ui::material::Type().button(); + auto fitBtnW = [&](const char* label) { + return std::max(120.0f * dp, + rbf->CalcTextSizeA(rbf->LegacySize, FLT_MAX, 0, label).x + + ImGui::GetStyle().FramePadding.x * 2.0f + 28.0f * dp); + }; + const char* primaryLabel = salvage ? TR("empty_wallet_restore") : TR("empty_wallet_open_manager"); + ImGui::PushStyleColor(ImGuiCol_Button, ui::material::WithAlpha(ui::material::Primary(), 65)); + ImGui::PushStyleColor(ImGuiCol_ButtonHovered, ui::material::WithAlpha(ui::material::Primary(), 100)); + ImGui::PushStyleColor(ImGuiCol_ButtonActive, ui::material::WithAlpha(ui::material::Primary(), 125)); + if (ui::material::TactileButton(primaryLabel, ImVec2(fitBtnW(primaryLabel), 0))) { + show_empty_wallet_warning_ = false; + if (salvage) + restoreOriginalWallet(); // self-contained: swaps the .bak back + drives the recovery dialog's progress + else + ui::WalletsDialog::show(this); + } + ImGui::PopStyleColor(3); + + // Quiet footer: open the data folder, or dismiss permanently for THIS wallet file. + auto linkText = [&](const char* label) -> bool { + ImGui::PushStyleColor(ImGuiCol_Text, ui::material::OnSurfaceMedium()); + ImGui::TextUnformatted(label); + ImGui::PopStyleColor(); + const bool clicked = ImGui::IsItemClicked(); + if (ImGui::IsItemHovered()) { + ImGui::SetMouseCursor(ImGuiMouseCursor_Hand); + const ImVec2 mn = ImGui::GetItemRectMin(), mx = ImGui::GetItemRectMax(); + ImGui::GetWindowDrawList()->AddLine(ImVec2(mn.x, mx.y), ImVec2(mx.x, mx.y), + ui::material::OnSurface()); + } + return clicked; + }; + ImGui::Dummy(ImVec2(0, ui::Layout::spacingMd())); + if (linkText(TR("wallet_recovered_open_folder"))) + util::Platform::openFolder(util::Platform::getDragonXDataDir()); + ImGui::SameLine(0, ui::Layout::spacingSm()); + ImGui::TextDisabled("\xC2\xB7"); // middle dot separator + ImGui::SameLine(0, ui::Layout::spacingSm()); + if (linkText(TR("empty_wallet_warning_dismiss"))) { + if (settings_) { + settings_->ackEmptyWalletWarn(settings_->getActiveWalletFile()); + settings_->save(); + } + show_empty_wallet_warning_ = false; + } + if (ImGui::IsItemHovered()) { + ImGui::BeginTooltip(); + ImGui::PushTextWrapPos(ImGui::GetFontSize() * 22.0f); + ImGui::TextUnformatted(TR("empty_wallet_warning_dismiss_tip")); + ImGui::PopTextWrapPos(); + ImGui::EndTooltip(); + } + + ui::material::EndOverlayDialog(); +} + // Auto-shown when the embedded node aborts on an unreadable block database — offers the one-click // -reindex rebuild instead of leaving the wallet stuck on a silent zero balance. void App::renderBlockDbReindexDialog() @@ -5043,6 +5187,12 @@ void App::stopEmbeddedDaemon() return; } + // Do we hold a live process handle for this node? Capture it BEFORE stop() reaps the pid. If owned, + // daemon_controller_->stop() below BLOCKS until the process actually exits. If NOT owned (external / + // adopted / direct-connected), stop() returns at once — we can only ask it over RPC and then watch + // for it to disappear (handled after the stop() call). + const bool owned = daemon_controller_->isRunning(); + // Send RPC "stop" command — this is the graceful path that lets the // daemon flush state, save block indexes, close sockets, etc. bool stop_sent = false; @@ -5099,6 +5249,27 @@ void App::stopEmbeddedDaemon() // 20s grace period for the RPC "stop" to complete (LevelDB flush). // Only after that does stop() escalate to SIGTERM, then SIGKILL. daemon_controller_->stop(20000); + + // EXTERNAL / adopted node during app shutdown: we hold no process handle, so the stop() above returned + // immediately (it can only wait on a node WE spawned). But the user turned on "Stop external daemon", + // so keep the window on the shutdown screen and poll until the node is actually gone — surfacing a live + // status so they can SEE it stop — rather than closing while it's still flushing. Bounded ~120s (a + // graceful full-node shutdown can flush LevelDB for 60-90s). Scoped to real shutdown; the shutdown + // screen's Force Quit stays available and flips shutdown_complete_, which breaks us out at once. + if (stop_sent && !owned && shutting_down_) { + auto stillUp = []() { + return daemon::EmbeddedDaemon::isRpcPortInUse() || daemon::EmbeddedDaemon::isDaemonProcessRunning(); + }; + // Set the phase text ONCE, then just poll — the shutdown screen already renders a live "N seconds" + // elapsed counter on the UI thread, so the user still sees time passing. (shutdown_status_ is now a + // GuardedStatus, so per-iteration writes would be race-safe; the single write is just a UX choice.) + shutdown_status_ = "Waiting for the external node to stop..."; + for (int i = 0; i < 1200 && stillUp() && !shutdown_complete_; ++i) + std::this_thread::sleep_for(std::chrono::milliseconds(100)); + shutdown_status_ = stillUp() ? "External node still stopping — closing anyway..." + : "External node stopped"; + DEBUG_LOGF("stopEmbeddedDaemon: external node %s\n", stillUp() ? "still up (timed out)" : "confirmed stopped"); + } } bool App::isEmbeddedDaemonRunning() const @@ -5497,7 +5668,8 @@ void App::renderShutdownScreen() // it's never impossible to escape. static std::string s_lastShutStatus; static float s_shutStallTimer = 0.0f; - if (shutdown_status_ != s_lastShutStatus) { s_lastShutStatus = shutdown_status_; s_shutStallTimer = 0.0f; } + const std::string curShut = shutdown_status_.get(); // one consistent snapshot per frame (M-05) + if (curShut != s_lastShutStatus) { s_lastShutStatus = curShut; s_shutStallTimer = 0.0f; } else s_shutStallTimer += ImGui::GetIO().DeltaTime; const bool shutdownStalled = s_shutStallTimer >= 8.0f; const bool allowForceQuit = shutdownStalled || shutdown_timer_ >= 20.0f; @@ -5593,11 +5765,11 @@ void App::renderShutdownScreen() // ------------------------------------------------------------------- // 3. Phase status (what the shutdown thread is doing) // ------------------------------------------------------------------- - if (!shutdown_status_.empty()) { - ImVec2 ts = ImGui::CalcTextSize(shutdown_status_.c_str()); + if (!curShut.empty()) { + ImVec2 ts = ImGui::CalcTextSize(curShut.c_str()); ImGui::SetCursorPosX(cx - ts.x * 0.5f); ImGui::PushStyleColor(ImGuiCol_Text, ImVec4(0.75f, 0.75f, 0.75f, 1.0f)); - ImGui::TextUnformatted(shutdown_status_.c_str()); + ImGui::TextUnformatted(curShut.c_str()); ImGui::PopStyleColor(); } @@ -5631,8 +5803,8 @@ void App::renderShutdownScreen() ImGui::Spacing(); // State-aware caution: while the status is a daemon flush/exit step, force-quitting risks the // chainstate; say so instead of a bare button. - if (shutdownStalled && !shutdown_status_.empty()) { - std::string stalledMsg = "Still \"" + shutdown_status_ + "\" — force quitting now may corrupt chain data."; + if (shutdownStalled && !curShut.empty()) { + std::string stalledMsg = "Still \"" + curShut + "\" — force quitting now may corrupt chain data."; ImVec2 ms = ImGui::CalcTextSize(stalledMsg.c_str()); ImGui::SetCursorPosX(cx - ms.x * 0.5f); ImGui::PushStyleColor(ImGuiCol_Text, ImGui::ColorConvertU32ToFloat4(Warning())); diff --git a/src/app.h b/src/app.h index dbba9a3..48c9cac 100644 --- a/src/app.h +++ b/src/app.h @@ -71,14 +71,28 @@ enum class EncryptDialogPhase { Done // Finished — close dialog }; +// A status string written by a background/worker thread and read every frame by the UI thread. Its +// operator= locks, so all the plain `x = "..."` assignment sites stay unchanged; readers call get() +// for a consistent per-frame snapshot instead of racing a non-atomic std::string. (M-05, L-06) +class GuardedStatus { +public: + GuardedStatus() = default; + GuardedStatus& operator=(std::string v) { std::lock_guard lk(m_); v_ = std::move(v); return *this; } + std::string get() const { std::lock_guard lk(m_); return v_; } +private: + mutable std::mutex m_; + std::string v_; +}; + /** * @brief Main application class - * + * * Manages application state, RPC connection, and coordinates UI rendering. */ class App { public: App(); + void wipeSecrets(); // scrub all resident secret buffers; called from ~App() AND the forced-exit path (L-05) ~App(); // Non-copyable @@ -798,6 +812,10 @@ private: // One-time nudge: on a full-node wallet that has a mnemonic, remind the user (once per // install) to back up their seed phrase. Cheap early-outs keep it idle until it can act. void maybeRemindSeedBackup(); + void maybeWarnEmptyWalletWithFundedSiblings(); // full-node: empty active wallet + a funded sibling → warn once + void scanFundedSiblingsAsync(); // off-UI-thread probe of sibling wallet files + static void scrubAndRemoveExport(const std::string& path); // zero + delete a plaintext key export (H-02) + void sweepStaleDecryptExports(); // startup net: purge stale obsidiandecryptexport* files (H-02) // Seed-wallet migration (Phase 1: create a new mnemonic wallet in isolation, no funds moved). void beginCreateSeedWallet(); // starts the isolated create on a background thread @@ -869,7 +887,7 @@ private: std::atomic shutting_down_{false}; std::atomic shutdown_complete_{false}; bool address_list_dirty_ = false; // P8: dedup rebuildAddressList - std::string shutdown_status_; + GuardedStatus shutdown_status_; // thread-safe: written by the shutdown thread, read by the UI (M-05) std::thread shutdown_thread_; float shutdown_timer_ = 0.0f; bool force_quit_confirm_ = false; @@ -906,6 +924,16 @@ private: 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 + // Complementary on-disk safety net for a salvage we DIDN'T witness this launch (happened on a prior + // run, or under an external daemon whose startup output we never captured): if the active wallet loads + // empty while a sibling wallet file in the datadir still holds keys, warn once so the user's funds + // (likely in a wallet..bak) aren't mistaken for loss. See maybeWarnEmptyWalletWithFundedSiblings(). + struct FundedSibling { std::string fileName; int transparentKeys = 0; int shieldedKeys = 0; }; + bool show_empty_wallet_warning_ = false; // auto-shown warning modal + bool empty_wallet_warn_checked_ = false; // evaluated this wallet-open already (reset in onConnected) + bool empty_wallet_scan_in_flight_ = false; // a sibling scan is running (main-thread only) + bool empty_wallet_has_salvage_bak_ = false; // modal variant: a funded salvage .bak → offer Restore + std::vector empty_wallet_funded_siblings_; // scan result (main-thread only) // 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. @@ -1264,8 +1292,8 @@ private: services::WalletSecurityWorkflow wallet_security_workflow_; // Wizard: stopping an external daemon before bootstrap - bool wizard_stopping_external_ = false; - std::string wizard_stop_status_; + std::atomic wizard_stopping_external_{false}; // written by the stop worker, read by the UI (L-06) + GuardedStatus wizard_stop_status_; // thread-safe: written by the stop worker, read by the UI (L-06) // PIN vault std::unique_ptr vault_; @@ -1358,6 +1386,7 @@ private: 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 renderEmptyWalletWarningDialog();// warn that the active wallet is empty while a sibling holds funds void detectWalletAutoRecovery(); // scan daemon output for a salvage; fire the warning once/session void restoreOriginalWallet(); // swap the wallet..bak back over the salvaged copy + restart void pumpWalletRestore(); // main-thread: surface the restore/rebuild op's result diff --git a/src/app_network.cpp b/src/app_network.cpp index e85d17b..e586e9e 100644 --- a/src/app_network.cpp +++ b/src/app_network.cpp @@ -620,6 +620,13 @@ void App::onConnected() detectWalletAutoRecovery(); // also runs every tryConnect tick — catches a salvage even if we never connect + // Re-arm the empty-wallet-with-funded-sibling check for this (possibly switched) wallet: re-evaluate the + // on-disk state once it finishes loading + syncing. Deliberately DON'T touch empty_wallet_scan_in_flight_ + // here — a scan from a prior connect self-clears it when it posts back, and resetting it while that scan + // is still running would let the next submit() block the UI thread on join() (async_tasks_ is only ever + // cancelled at shutdown, so the flag can't wedge during normal runtime). + empty_wallet_warn_checked_ = false; + // 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); @@ -1761,7 +1768,12 @@ void App::refreshAddressData() auto result = NetworkRefreshService::collectAddressRefreshResult(refreshRpc, addressSnapshot); return [this, previousAddressCount, previousWalletIdentity, result = std::move(result)]() mutable { + const bool addrListOk = result.addressListOk; // capture before the move NetworkRefreshService::applyAddressRefreshResult(state_, std::move(result)); + // Mark the address list as loaded ONLY if enumeration actually succeeded — a swallowed + // z_listaddresses/getaddressesbyaccount failure returns a falsely-short list, and stamping it + // would let the empty-wallet warning trust a spurious 0 count (see maybeWarnEmptyWallet…). + if (addrListOk) state_.last_address_update = std::time(nullptr); applyPendingSendBalanceDeltas(false); address_validation_cache_dirty_ = false; address_list_dirty_ = true; @@ -4190,6 +4202,111 @@ void App::maybeRemindSeedBackup() }); } +// Complementary on-disk safety net (full-node) for a wallet salvage we did NOT witness this launch — it +// happened on a prior run, or under an external daemon whose startup output we never captured, so +// detectWalletAutoRecovery() never fired. If the active wallet loads EMPTY while a sibling wallet file in +// the datadir still holds keys, warn once: the user's funds were likely moved into a wallet..bak by a +// prior BDB salvage and are not lost, just in another file. Fires at most once per wallet-open and once per +// unacknowledged wallet filename; the probe runs off the UI thread (scanFundedSiblingsAsync). +void App::maybeWarnEmptyWalletWithFundedSiblings() +{ + if (capture_mode_) return; // no live ops during a UI sweep + if (lite_wallet_ || !supportsFullNodeLifecycleActions()) return; // full-node only (lite = single-file dir) + if (!settings_) return; + if (empty_wallet_warn_checked_ || empty_wallet_scan_in_flight_) return; // at most once per wallet-open + if (show_empty_wallet_warning_) return; // already surfaced + // The console-driven recovery flow owns the salvage-this-launch case — don't double-warn. + if (wallet_auto_recovered_ || show_wallet_recovered_dialog_) return; + // Only meaningful once the wallet is truly loaded AND fully synced: a mid-sync wallet reads empty. + if (!state_.connected || !state_.encryption_state_known) return; + if (state_.warming_up || state_.daemon_initializing || !state_.sync.isSynced()) return; + // Wait for the first Core refresh to land. The ConnectionInit prefetch sets sync.blocks but NOT headers, + // so isSynced() (blocks >= headers-2) is spuriously true in the window before the Core refresh — during + // which balance/addresses also read 0. last_balance_update flips non-zero only when the Core refresh + // applies (network_refresh_service.cpp), by which point balance & headers are real. + if (state_.last_balance_update == 0) return; + // And wait for the ADDRESS list to have loaded at least once — otherwise getAddressCount()==0 is + // ambiguous ("no keys" vs "not fetched yet"), which would false-fire on a spent-down wallet (0 balance + // but has addresses) whose address refresh lands a beat after the balance refresh. + if (state_.last_address_update == 0) return; + // "Empty" = no addresses and no funds. A salvage-created fresh wallet has no keys; a legitimately + // spent-down wallet keeps its addresses, so requiring zero addresses avoids nagging the latter. + if (state_.getAddressCount() != 0) return; + if (state_.totalBalance > 0.0 || state_.spendableTotalBalance > 0.0) return; + if (settings_->isEmptyWalletWarnAcked(settings_->getActiveWalletFile())) return; // dismissed for this file + + empty_wallet_warn_checked_ = true; // evaluate the on-disk state once for this wallet-open + scanFundedSiblingsAsync(); +} + +// Off-UI-thread: enumerate the datadir's OTHER wallet files (incl. salvage wallet..bak backups) and +// offline-probe each for key material. Read-only; never opens a file in the daemon. The probe reads up to a +// bounded prefix per file, so it runs on its own task thread (not the RPC worker) and the result is +// marshaled back to the main thread before touching any UI state. Routing, applied on the main thread: +// • a funded salvage .bak exists → the coins were moved aside by an unwitnessed salvage; hand off to the +// existing recovery dialog, whose Restore action swaps the .bak back (the correct, tested fix). +// • otherwise a funded sibling .dat exists → the user simply opened the wrong (empty) wallet; show the +// lightweight warning modal that routes to the wallet manager to switch. +void App::scanFundedSiblingsAsync() +{ + if (empty_wallet_scan_in_flight_) return; + empty_wallet_scan_in_flight_ = true; + const std::string datadir = util::Platform::getDragonXDataDir(); + const std::string activeFile = settings_ ? settings_->getActiveWalletFile() : std::string("wallet.dat"); + async_tasks_.submit("Empty-wallet sibling scan", + [this, datadir, activeFile](const util::AsyncTaskManager::Token& tok) { + std::vector funded; // funded plain-.dat wallets → the "switch wallet" modal + bool hasSalvageBak = false; // a funded wallet..bak → route to the recovery/restore dialog + for (const auto& path : util::enumerateDatadirWalletFiles(datadir, activeFile, /*includeSalvageBaks=*/true)) { + if (tok.cancelled()) return; + const auto bt = util::parseWalletBtree(path); + if (!(bt.parsed && bt.addresses() > 0)) continue; // ignore junk / empty siblings + const std::string name = std::filesystem::path(path).filename().string(); + const bool isBak = name.size() > 4 && name.compare(name.size() - 4, 4, ".bak") == 0; + if (isBak) { + // Only a salvage-pattern wallet..bak has a defined restore path; other .bak files are + // ignored (the wallet manager lists only .dat, so routing them there would be a dead end). + if (daemon::parseWalletSalvageBakTs(name) >= 0) hasSalvageBak = true; + continue; + } + FundedSibling s; + s.fileName = name; + s.transparentKeys = bt.transparentKeys; + s.shieldedKeys = bt.shieldedKeys; + funded.push_back(std::move(s)); + } + // On teardown/cancel, skip posting (shutdown only; the in-flight flag is irrelevant then). + if (tok.cancelled() || !worker_) return; + // Apply UI state on the main thread only (the render loop reads these members). + worker_->post([this, funded, hasSalvageBak]() -> rpc::RPCWorker::MainCb { + return [this, funded, hasSalvageBak]() { + empty_wallet_scan_in_flight_ = false; + if (wallet_auto_recovered_ || show_wallet_recovered_dialog_) return; // recovery already owns it + // Re-validate emptiness on the main thread: balance/address refreshes may have landed while + // the scan ran (it takes long enough to read+parse sibling files), so a warm-reconnect or a + // spent-down wallet that momentarily read empty is now correctly excluded. + if (!state_.connected || state_.getAddressCount() != 0 || + state_.totalBalance > 0.0 || state_.spendableTotalBalance > 0.0) return; + // Both cases surface OUR modal (renderEmptyWalletWarningDialog), keyed by has_salvage_bak. + // We deliberately DON'T set the wallet_auto_recovered_ latch or auto-open the recovery dialog: + // the daemon is healthy, and that latch gates the crash-restart loop (app_network.cpp:556) + + // crash-toast suppression, so it would wedge the wallet offline on any later unrelated crash. + // For the salvage case the modal's "Restore" button calls restoreOriginalWallet() directly + // (self-contained: it drives the recovery dialog into its Working phase itself). + if (hasSalvageBak) { + empty_wallet_has_salvage_bak_ = true; + empty_wallet_funded_siblings_.clear(); + show_empty_wallet_warning_ = true; + } else if (!funded.empty()) { + empty_wallet_has_salvage_bak_ = false; + empty_wallet_funded_siblings_ = funded; + show_empty_wallet_warning_ = true; + } + }; + }); + }); +} + // One-shot (per connect) probe of the current wallet's mnemonic status, so the Settings // Migrate-to-seed button can glow for a legacy wallet without opening the migration dialog. Same // classification as the migration Intro pre-flight, but proactive and cached. Reads no secret past diff --git a/src/app_security.cpp b/src/app_security.cpp index 15c8217..192f986 100644 --- a/src/app_security.cpp +++ b/src/app_security.cpp @@ -238,6 +238,41 @@ private: // daemon off the main thread (to avoid stalling the UI), or ask the user to // restart an external daemon. Shared by encryptWalletWithPassphrase() and // processDeferredEncryption(); must be called on the main thread. +// Zero (overwrite) then delete a plaintext key export so a full cleartext dump of every private key is +// never left readable on disk. Idempotent + error-tolerant (safe on a missing/locked file). (H-02) +void App::scrubAndRemoveExport(const std::string& path) +{ + if (path.empty()) return; + std::error_code ec; + const auto sz = std::filesystem::file_size(path, ec); + if (!ec && sz > 0) { + std::fstream scrub(path, std::ios::binary | std::ios::in | std::ios::out); + if (scrub) { + const std::vector zeros(static_cast(sz), 0); + scrub.write(zeros.data(), static_cast(sz)); + scrub.flush(); + } + } + std::filesystem::remove(path, ec); +} + +// Startup net for H-02: a crash/kill/early-return between exporting the cleartext keys and scrubbing them +// could leave an obsidiandecryptexport* file behind. Purge any found in the data dir on launch. +void App::sweepStaleDecryptExports() +{ + std::error_code ec; + const std::string dir = util::Platform::getDragonXDataDir(); + std::filesystem::directory_iterator it(dir, ec), end; + for (; it != end; it.increment(ec)) { + if (ec) break; + const std::string name = it->path().filename().string(); + if (name.rfind("obsidiandecryptexport", 0) == 0) { + scrubAndRemoveExport(it->path().string()); + DEBUG_LOGF("[decrypt] swept stale plaintext key export: %s\n", name.c_str()); + } + } +} + void App::restartDaemonAfterEncryption(const char* taskName, bool announceRestartStatus) { if (isUsingEmbeddedDaemon()) { if (announceRestartStatus) { @@ -1344,9 +1379,13 @@ void App::renderEncryptWalletDialog() { enc_dlg_pin_status_.clear(); std::string savedPass = enc_dlg_saved_passphrase_; if (worker_ && vault_) { - worker_->post([this, pinStr, savedPass]() -> rpc::RPCWorker::MainCb { + worker_->post([this, pinStr, savedPass]() mutable -> rpc::RPCWorker::MainCb { // Argon2id runs here (worker thread) bool ok = vault_->store(pinStr, savedPass); + // Scrub the captured PIN + passphrase copies (they live in the worker's task + // queue until this runs); the source member is scrubbed in the MainCb. (L-03) + if (!savedPass.empty()) util::SecureVault::secureZero(&savedPass[0], savedPass.size()); + if (!pinStr.empty()) util::SecureVault::secureZero(&pinStr[0], pinStr.size()); return [this, ok]() { if (ok) { settings_->setPinEnabled(true); @@ -1588,6 +1627,11 @@ void App::renderDecryptWalletDialog() { std::chrono::steady_clock::now()); auto restartAndImport = [this, exportPath](const util::AsyncTaskManager::Token& token) { + // Scrub + delete the plaintext key export (obsidiandecryptexport…) on EVERY exit path — + // success, a restart-failure early return, or an exception. A full cleartext dump of all + // private keys must never outlive this step. The startup sweep is a further net for a + // crash/kill mid-flight. (H-02) + struct ExportScrub { std::string p; ~ExportScrub() { App::scrubAndRemoveExport(p); } } exportScrub{exportPath}; WalletSecurityDaemonAdapter daemonAdapter(*this, token); WalletSecurityDecryptRpcAdapter decryptRpc(rpc_.get(), [this](rpc::RPCClient& client, const char* context) { @@ -1641,26 +1685,7 @@ 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 zeros(static_cast(sz), 0); - scrub.write(zeros.data(), static_cast(sz)); - scrub.flush(); - } - } - std::filesystem::remove(exportPath, delEc); - DEBUG_LOGF("[decrypt] removed plaintext key export after import\n"); - } + // (exportScrub scrubs + deletes the plaintext key export on scope exit — H-02) if (!importResult.ok) { std::string err = importResult.error; @@ -1930,12 +1955,14 @@ void App::renderPinDialogs() { memset(pin_confirm_buf_, 0, sizeof(pin_confirm_buf_)); if (rpc_ && rpc_->isConnected() && worker_) { - worker_->post([this, passphrase, pin]() -> rpc::RPCWorker::MainCb { + worker_->post([this, passphrase, pin]() mutable -> rpc::RPCWorker::MainCb { // Verify passphrase via RPC (worker thread) try { rpc::RPCClient::TraceScope trace("Security / PIN setup"); rpc_->call("walletpassphrase", {passphrase, 5}); } catch (const std::exception& e) { + if (!passphrase.empty()) util::SecureVault::secureZero(&passphrase[0], passphrase.size()); + if (!pin.empty()) util::SecureVault::secureZero(&pin[0], pin.size()); return [this]() { pin_status_ = "Incorrect passphrase"; pin_in_progress_ = false; @@ -1944,6 +1971,9 @@ void App::renderPinDialogs() { // Passphrase correct — store in vault (Argon2id, worker thread) bool storeOk = vault_ && vault_->store(pin, passphrase); + // Captured passphrase + PIN are no longer needed — scrub the worker-queue copies. (M-01) + if (!passphrase.empty()) util::SecureVault::secureZero(&passphrase[0], passphrase.size()); + if (!pin.empty()) util::SecureVault::secureZero(&pin[0], pin.size()); // Lock wallet back try { diff --git a/src/app_wizard.cpp b/src/app_wizard.cpp index 84f8be1..a878c4f 100644 --- a/src/app_wizard.cpp +++ b/src/app_wizard.cpp @@ -889,8 +889,9 @@ void App::renderFirstRunWizard() { } if (wizard_stopping_external_) { + const std::string ws = wizard_stop_status_.get(); dl->AddText(captionFont, captionFont->LegacySize, ImVec2(cx, cy), dimCol, - wizard_stop_status_.c_str()); + ws.c_str()); cy += captionFont->LegacySize + 8.0f * dp; } else { float stopW = 150.0f * dp; @@ -1376,6 +1377,13 @@ void App::renderFirstRunWizard() { encrypt_status_ = TR("wiz_skip_confirm"); } else { s_skipEncConfirm = false; + // Skipping leaves the wallet UNENCRYPTED — wipe the passphrase/PIN the user may have + // typed so it doesn't linger in these process-lifetime buffers (only the Encrypt + // path cleared them before). (L-07) + memset(encrypt_pass_buf_, 0, sizeof(encrypt_pass_buf_)); + memset(encrypt_confirm_buf_, 0, sizeof(encrypt_confirm_buf_)); + memset(wizard_pin_buf_, 0, sizeof(wizard_pin_buf_)); + memset(wizard_pin_confirm_buf_, 0, sizeof(wizard_pin_confirm_buf_)); wizard_phase_ = WizardPhase::Done; settings_->setWizardCompleted(true); settings_->save(); diff --git a/src/config/settings.cpp b/src/config/settings.cpp index 0e95e87..7374515 100644 --- a/src/config/settings.cpp +++ b/src/config/settings.cpp @@ -204,6 +204,7 @@ bool Settings::load(const std::string& path) loadScalar(j, "console_text_color", console_text_color_); loadScalar(j, "console_zoom", console_zoom_); if (!(console_zoom_ >= 0.25f && console_zoom_ <= 4.0f)) console_zoom_ = 1.0f; // guard bad/NaN + loadScalar(j, "console_auto_focus", console_auto_focus_); if (j.contains("hidden_addresses") && j["hidden_addresses"].is_array()) { hidden_addresses_.clear(); for (const auto& a : j["hidden_addresses"]) @@ -231,6 +232,11 @@ bool Settings::load(const std::string& path) } loadScalar(j, "wizard_completed", wizard_completed_); loadScalar(j, "seed_backup_reminded", seed_backup_reminded_); + if (j.contains("empty_wallet_warning_acked") && j["empty_wallet_warning_acked"].is_array()) { + empty_wallet_warning_acked_.clear(); + for (const auto& w : j["empty_wallet_warning_acked"]) + if (w.is_string()) empty_wallet_warning_acked_.insert(w.get()); + } loadScalar(j, "encryption_pending", encryption_pending_); loadScalar(j, "daemon_update_prompted_size", daemon_update_prompted_size_); loadScalar(j, "active_wallet_file", active_wallet_file_); @@ -478,6 +484,7 @@ bool Settings::save(const std::string& path) j["console_line_accents"] = console_line_accents_; j["console_text_color"] = console_text_color_; j["console_zoom"] = console_zoom_; + j["console_auto_focus"] = console_auto_focus_; j["hidden_addresses"] = json::array(); for (const auto& addr : hidden_addresses_) j["hidden_addresses"].push_back(addr); @@ -499,6 +506,9 @@ bool Settings::save(const std::string& path) } j["wizard_completed"] = wizard_completed_; j["seed_backup_reminded"] = seed_backup_reminded_; + j["empty_wallet_warning_acked"] = json::array(); + for (const auto& w : empty_wallet_warning_acked_) + j["empty_wallet_warning_acked"].push_back(w); j["encryption_pending"] = encryption_pending_; j["daemon_update_prompted_size"] = daemon_update_prompted_size_; j["active_wallet_file"] = active_wallet_file_; diff --git a/src/config/settings.h b/src/config/settings.h index bc0f748..2fb7129 100644 --- a/src/config/settings.h +++ b/src/config/settings.h @@ -256,6 +256,9 @@ public: void setConsoleTextColor(bool v) { console_text_color_ = v; } float getConsoleZoom() const { return console_zoom_; } void setConsoleZoom(float v) { console_zoom_ = v; } + // Auto-place the text cursor in the command box when the Console tab is opened. + bool getConsoleAutoFocus() const { return console_auto_focus_; } + void setConsoleAutoFocus(bool v) { console_auto_focus_ = v; } // Hidden addresses (addresses hidden from the UI by the user) const std::set& getHiddenAddresses() const { return hidden_addresses_; } @@ -327,6 +330,14 @@ public: bool getSeedBackupReminded() const { return seed_backup_reminded_; } void setSeedBackupReminded(bool v) { seed_backup_reminded_ = v; } + // Wallet filenames for which the one-time "this wallet is empty but a sibling holds funds" + // warning has been dismissed. Keyed per active wallet file so switching to a different empty + // wallet can warn again (see App::maybeWarnEmptyWalletWithFundedSiblings). + bool isEmptyWalletWarnAcked(const std::string& walletFile) const { + return empty_wallet_warning_acked_.count(walletFile) > 0; + } + void ackEmptyWalletWarn(const std::string& walletFile) { empty_wallet_warning_acked_.insert(walletFile); } + // 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. @@ -580,11 +591,13 @@ private: bool console_line_accents_ = true; // left color accent bars in console output bool console_text_color_ = true; // per-channel text coloring in console output float console_zoom_ = 1.0f; // console output font zoom factor + bool console_auto_focus_ = false; // focus the command input when the Console tab is opened (opt-in) std::set hidden_addresses_; std::set favorite_addresses_; std::map address_meta_; bool wizard_completed_ = false; bool seed_backup_reminded_ = false; + std::set empty_wallet_warning_acked_; // wallet files whose empty-wallet warning was dismissed 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= the daemon loads (multi-wallet) diff --git a/src/daemon/daemon_controller.cpp b/src/daemon/daemon_controller.cpp index b357a20..d960975 100644 --- a/src/daemon/daemon_controller.cpp +++ b/src/daemon/daemon_controller.cpp @@ -71,9 +71,11 @@ DaemonController::State DaemonController::state() const return daemon_->getState(); } -const std::string& DaemonController::lastError() const +std::string DaemonController::lastError() const { - return daemon_->getLastError(); + // By value — getLastError() now returns a mutex-locked COPY, so forwarding it by reference would + // dangle (bind a reference to that temporary). (M-04 follow-through) + return daemon_ ? daemon_->getLastError() : std::string(); } int DaemonController::crashCount() const diff --git a/src/daemon/daemon_controller.h b/src/daemon/daemon_controller.h index 21dc804..d55ebfd 100644 --- a/src/daemon/daemon_controller.h +++ b/src/daemon/daemon_controller.h @@ -95,7 +95,7 @@ public: bool externalDaemonDetected() const; void clearExternalDaemonDetected(); State state() const; - const std::string& lastError() const; + std::string lastError() const; // by value: EmbeddedDaemon::getLastError() returns a locked copy (M-04) int crashCount() const; int lastBlockHeight() const; double memoryUsageMB() const; diff --git a/src/daemon/embedded_daemon.cpp b/src/daemon/embedded_daemon.cpp index ac1b8f3..e4487eb 100644 --- a/src/daemon/embedded_daemon.cpp +++ b/src/daemon/embedded_daemon.cpp @@ -224,12 +224,11 @@ std::vector EmbeddedDaemon::getChainParams() void EmbeddedDaemon::setState(State s, const std::string& message) { state_ = s; - if (!message.empty()) { - if (s == State::Error) { - last_error_ = message; - } + if (!message.empty() && s == State::Error) { + std::lock_guard lk(error_mutex_); // dedicated mutex — never taken with output_mutex_ held + last_error_ = message; } - + if (state_callback_) { state_callback_(s, message); } @@ -621,12 +620,28 @@ bool EmbeddedDaemon::start(const std::string& binary_path) // Forward declaration — defined after startProcess static DWORD findProcessByName(const char* name); +// Quote a single argument per the CommandLineToArgvW rules (MSDN) so a value containing a space or a +// quote is delivered as ONE argv token to the daemon instead of splitting/corrupting argv (L-02). +static std::string quoteWinArg(const std::string& arg) { + if (!arg.empty() && arg.find_first_of(" \t\n\v\"") == std::string::npos) return arg; + std::string out = "\""; + for (size_t i = 0; ; ++i) { + size_t nbs = 0; + while (i < arg.size() && arg[i] == '\\') { ++nbs; ++i; } + if (i == arg.size()) { out.append(nbs * 2, '\\'); break; } + if (arg[i] == '"') { out.append(nbs * 2 + 1, '\\'); out.push_back('"'); } + else { out.append(nbs, '\\'); out.push_back(arg[i]); } + } + out.push_back('"'); + return out; +} + bool EmbeddedDaemon::startProcess(const std::string& binary_path, const std::vector& args) { - // Build command line + // Build command line (binary path always quoted; each arg quoted/escaped per Windows rules — L-02) std::string cmd = "\"" + binary_path + "\""; for (const auto& arg : args) { - cmd += " " + arg; + cmd += " " + quoteWinArg(arg); } DEBUG_LOGF("[INFO] Starting daemon: %s\n", cmd.c_str()); diff --git a/src/daemon/embedded_daemon.h b/src/daemon/embedded_daemon.h index c652843..86d9abc 100644 --- a/src/daemon/embedded_daemon.h +++ b/src/daemon/embedded_daemon.h @@ -79,7 +79,9 @@ public: /** * @brief Get last error message */ - const std::string& getLastError() const { return last_error_; } + // Copy under lock: last_error_ is written from the monitor thread (setState on an unexpected exit) + // while the UI thread reads it — a reference would be a torn-read / use-after-free race (M-04). + std::string getLastError() const { std::lock_guard lk(error_mutex_); return last_error_; } /** * @brief Get dragonxd process output (thread-safe copy) @@ -286,6 +288,7 @@ private: std::atomic state_{State::Stopped}; std::atomic external_daemon_detected_{false}; std::string last_error_; + mutable std::mutex error_mutex_; // protects last_error_ (written by main + monitor threads) mutable std::mutex output_mutex_; // protects process_output_ std::string process_output_; StateCallback state_callback_; diff --git a/src/daemon/xmrig_manager.cpp b/src/daemon/xmrig_manager.cpp index 696b6d3..9ca5a76 100644 --- a/src/daemon/xmrig_manager.cpp +++ b/src/daemon/xmrig_manager.cpp @@ -210,7 +210,7 @@ bool XmrigManager::generateConfig(const Config& cfg, const std::string& outPath) fs::create_directories(fs::path(outPath).parent_path()); std::ofstream ofs(outPath, std::ios::trunc); if (!ofs.is_open()) { - last_error_ = "Cannot write xmrig config: " + outPath; + setLastError("Cannot write xmrig config: " + outPath); DEBUG_LOGF("[ERROR] XmrigManager: %s\n", last_error_.c_str()); return false; } @@ -224,7 +224,7 @@ bool XmrigManager::generateConfig(const Config& cfg, const std::string& outPath) ofs.close(); return true; } catch (const std::exception& e) { - last_error_ = std::string("Config write error: ") + e.what(); + setLastError(std::string("Config write error: ") + e.what()); DEBUG_LOGF("[ERROR] XmrigManager: %s\n", last_error_.c_str()); return false; } @@ -236,19 +236,22 @@ bool XmrigManager::generateConfig(const Config& cfg, const std::string& outPath) bool XmrigManager::start(const Config& cfg) { if (state_ == State::Running || state_ == State::Starting) { - last_error_ = "Already running"; + setLastError("Already running"); DEBUG_LOGF("[WARN] XmrigManager: %s\n", last_error_.c_str()); return false; } state_ = State::Starting; should_stop_ = false; - last_error_.clear(); + setLastError(std::string()); { std::lock_guard lk(output_mutex_); process_output_.clear(); } - stats_ = PoolStats{}; + { + std::lock_guard lk(stats_mutex_); + stats_ = PoolStats{}; + } // Extract pool hostname for stats API queries { @@ -265,7 +268,7 @@ bool XmrigManager::start(const Config& cfg) { // Find binary std::string binary = findXmrigBinary(); if (binary.empty()) { - last_error_ = "xmrig binary not found"; + setLastError("xmrig binary not found"); state_ = State::Error; DEBUG_LOGF("[ERROR] XmrigManager: xmrig binary not found\n"); return false; @@ -368,7 +371,7 @@ bool XmrigManager::startProcess(const std::string& xmrigPath, const std::string& HANDLE hRead = nullptr, hWrite = nullptr; if (!CreatePipe(&hRead, &hWrite, &sa, 0)) { - last_error_ = "CreatePipe failed"; + setLastError("CreatePipe failed"); DEBUG_LOGF("[ERROR] XmrigManager: %s\n", last_error_.c_str()); return false; } @@ -400,7 +403,7 @@ bool XmrigManager::startProcess(const std::string& xmrigPath, const std::string& char errBuf[256]; FormatMessageA(FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_IGNORE_INSERTS, NULL, err, 0, errBuf, sizeof(errBuf), NULL); - last_error_ = "CreateProcess failed for xmrig (error " + std::to_string(err) + "): " + errBuf; + setLastError("CreateProcess failed for xmrig (error " + std::to_string(err) + "): " + errBuf); DEBUG_LOGF("[ERROR] XmrigManager: %s\nCommand: %s\n", last_error_.c_str(), cmdLine.c_str()); return false; } @@ -451,14 +454,14 @@ void XmrigManager::drainOutput() { bool XmrigManager::startProcess(const std::string& xmrigPath, const std::string& cfgPath, int threads) { int pipefd[2]; if (pipe(pipefd) != 0) { - last_error_ = "pipe() failed"; + setLastError("pipe() failed"); DEBUG_LOGF("[ERROR] XmrigManager: %s\n", last_error_.c_str()); return false; } pid_t pid = fork(); if (pid < 0) { - last_error_ = "fork() failed"; + setLastError("fork() failed"); DEBUG_LOGF("[ERROR] XmrigManager: %s\n", last_error_.c_str()); close(pipefd[0]); close(pipefd[1]); @@ -629,7 +632,7 @@ void XmrigManager::monitorProcess() { if (GetExitCodeProcess(process_handle_, &exitCode) && exitCode != STILL_ACTIVE) { DEBUG_LOGF("[ERROR] XmrigManager: process exited (code %lu)\n", exitCode); state_ = State::Error; - last_error_ = "xmrig process exited unexpectedly"; + setLastError("xmrig process exited unexpectedly"); break; } } @@ -640,7 +643,7 @@ void XmrigManager::monitorProcess() { if (ret == process_pid_ || ret < 0) { DEBUG_LOGF("[ERROR] XmrigManager: process exited (waitpid=%d)\n", ret); state_ = State::Error; - last_error_ = "xmrig process exited unexpectedly"; + setLastError("xmrig process exited unexpectedly"); break; } } diff --git a/src/daemon/xmrig_manager.h b/src/daemon/xmrig_manager.h index 3935daf..54d1834 100644 --- a/src/daemon/xmrig_manager.h +++ b/src/daemon/xmrig_manager.h @@ -86,8 +86,10 @@ public: bool isRunning() const; State getState() const { return state_.load(std::memory_order_relaxed); } - const PoolStats& getStats() const { return stats_; } - const std::string& getLastError() const { return last_error_; } + // Return COPIES under lock: stats_ and last_error_ are mutated by the monitor thread while the UI + // thread reads them, so handing out a reference is a torn-read / use-after-free race (M-03, M-04). + PoolStats getStats() const { std::lock_guard lk(stats_mutex_); return stats_; } + std::string getLastError() const { std::lock_guard lk(error_mutex_); return last_error_; } /// Thread count requested at start() — available immediately, unlike /// PoolStats::threads_active which requires an API response. @@ -156,11 +158,14 @@ private: void monitorProcess(); void drainOutput(); void appendOutput(const char* data, size_t len); + // Set last_error_ under error_mutex_ (writers run on both the main thread and the monitor thread). + void setLastError(std::string e) { std::lock_guard lk(error_mutex_); last_error_ = std::move(e); } void fetchStatsHttp(); // Blocking HTTP call — runs on monitor thread only void fetchPoolApiStats(); // Fetch pool-side stats (hashrate) from pool HTTP API std::atomic state_{State::Stopped}; std::string last_error_; + mutable std::mutex error_mutex_; // guards last_error_ (written by main + monitor threads) mutable std::mutex output_mutex_; std::string process_output_; diff --git a/src/data/wallet_state.h b/src/data/wallet_state.h index 988110d..dc0a00f 100644 --- a/src/data/wallet_state.h +++ b/src/data/wallet_state.h @@ -312,6 +312,7 @@ struct WalletState { // Timestamps for refresh logic int64_t last_balance_update = 0; + int64_t last_address_update = 0; // set when an address-list refresh applies; 0 = never loaded yet int64_t last_tx_update = 0; int64_t last_peer_update = 0; int64_t last_mining_update = 0; @@ -354,7 +355,7 @@ struct WalletState { // 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; + last_balance_update = last_address_update = last_tx_update = last_peer_update = last_mining_update = 0; } // Rebuild combined addresses list from z/t lists diff --git a/src/main.cpp b/src/main.cpp index acfe29a..4e1dbd7 100644 --- a/src/main.cpp +++ b/src/main.cpp @@ -2127,6 +2127,7 @@ int main(int argc, char* argv[]) // deadlocks waiting for detached pthreads. On Linux, static // destructors and atexit handlers can also block. _Exit() bypasses // all of that. + app.wipeSecrets(); // _Exit() below bypasses ~App(), so scrub secret buffers here (L-05) fflush(stdout); fflush(stderr); _Exit(0); diff --git a/src/rpc/rpc_client.cpp b/src/rpc/rpc_client.cpp index a1e8c04..72be115 100644 --- a/src/rpc/rpc_client.cpp +++ b/src/rpc/rpc_client.cpp @@ -146,7 +146,11 @@ RPCClient::RPCClient() : impl_(std::make_unique()) { } -RPCClient::~RPCClient() = default; +RPCClient::~RPCClient() { + // Scrub the persistent Basic-auth secret on destruction (disconnect() may not have run). impl_ is + // still destroyed normally afterward (curl cleanup unchanged). (L-04) + if (!auth_.empty()) sodium_memzero(auth_.data(), auth_.size()); +} bool RPCClient::connect(const std::string& host, const std::string& port, const std::string& user, const std::string& password) @@ -166,6 +170,7 @@ bool RPCClient::connect(const std::string& host, const std::string& port, // Create Basic auth header with proper base64 encoding, then wipe the plaintext // "user:password" temporary (std::string does not zero its buffer on destruction). std::string credentials = user + ":" + password; + if (!auth_.empty()) sodium_memzero(auth_.data(), auth_.size()); // wipe any prior secret before overwrite (L-04) auth_ = util::base64_encode(credentials); if (!credentials.empty()) sodium_memzero(credentials.data(), credentials.size()); @@ -193,6 +198,7 @@ bool RPCClient::connect(const std::string& host, const std::string& port, impl_->headers = curl_slist_append(nullptr, "Content-Type: text/plain"); std::string auth_header = "Authorization: Basic " + auth_; impl_->headers = curl_slist_append(impl_->headers, auth_header.c_str()); + if (!auth_header.empty()) sodium_memzero(auth_header.data(), auth_header.size()); // curl copied it (L-04) // Configure curl curl_easy_setopt(impl_->curl, CURLOPT_URL, impl_->url.c_str()); @@ -299,6 +305,7 @@ void RPCClient::disconnect() curl_slist_free_all(impl_->headers); impl_->headers = nullptr; } + if (!auth_.empty()) { sodium_memzero(auth_.data(), auth_.size()); auth_.clear(); } // scrub Basic-auth secret (L-04) } json RPCClient::makePayload(const std::string& method, const json& params) diff --git a/src/services/network_refresh_service.cpp b/src/services/network_refresh_service.cpp index 2abcd31..39755e5 100644 --- a/src/services/network_refresh_service.cpp +++ b/src/services/network_refresh_service.cpp @@ -628,6 +628,7 @@ NetworkRefreshService::AddressRefreshResult NetworkRefreshService::collectAddres } } catch (const std::exception& e) { DEBUG_LOGF("z_listaddresses error: %s\n", e.what()); + result.addressListOk = false; // enumeration failed → the shielded list may be falsely short } try { @@ -652,6 +653,7 @@ NetworkRefreshService::AddressRefreshResult NetworkRefreshService::collectAddres result.transparentAddresses = parseTransparentAddressList(tList); } catch (const std::exception& e) { DEBUG_LOGF("getaddressesbyaccount error: %s\n", e.what()); + result.addressListOk = false; // enumeration failed → the transparent list may be falsely short } try { diff --git a/src/services/network_refresh_service.h b/src/services/network_refresh_service.h index 7fd1b88..26f2215 100644 --- a/src/services/network_refresh_service.h +++ b/src/services/network_refresh_service.h @@ -149,6 +149,10 @@ public: struct AddressRefreshResult { std::vector shieldedAddresses; std::vector transparentAddresses; + // False if either address-enumeration RPC (z_listaddresses / getaddressesbyaccount) threw, so the + // lists may be falsely short. Consumers that treat an empty list as authoritative (e.g. the + // empty-wallet warning) must not trust a 0 count unless this is true. + bool addressListOk = true; }; struct AddressRefreshSnapshot { diff --git a/src/ui/pages/settings_page.cpp b/src/ui/pages/settings_page.cpp index 0b0c227..237c89d 100644 --- a/src/ui/pages/settings_page.cpp +++ b/src/ui/pages/settings_page.cpp @@ -515,6 +515,14 @@ static void renderConsoleColorToggles(App* app) { app->settings()->save(); } if (ImGui::IsItemHovered()) material::Tooltip("%s", TR("console_toggle_text_color")); + // Console behavior (not a GPU effect): focus the command input when the tab opens. Bound straight to + // settings — the App reads it at the page transition; no ConsoleTab static needed. + bool autoFocus = app->settings()->getConsoleAutoFocus(); + if (ImGui::Checkbox(TrId("console_auto_focus", "con_autofocus").c_str(), &autoFocus)) { + app->settings()->setConsoleAutoFocus(autoFocus); + app->settings()->save(); + } + if (ImGui::IsItemHovered()) material::Tooltip("%s", TR("console_toggle_auto_focus")); ImGui::BeginDisabled(s_settingsState.low_spec_mode); } diff --git a/src/ui/windows/chat_tab.cpp b/src/ui/windows/chat_tab.cpp index 3539252..d17e3d9 100644 --- a/src/ui/windows/chat_tab.cpp +++ b/src/ui/windows/chat_tab.cpp @@ -10,6 +10,7 @@ #include "../../data/address_book.h" #include "../../chat/chat_service.h" #include "../../util/i18n.h" +#include "../../util/address_validation.h" // isShieldedAddress — chat requires a z-address recipient #include "../../util/platform.h" // getConfigDir + writeFileAtomically — conversation export (Q11) #include "../../config/settings.h" // per-conversation mute (Q10) #include "../material/colors.h" @@ -59,6 +60,10 @@ bool s_msgsel_dragging = false; // Composer + new-conversation UI state. char s_compose[512] = ""; std::string s_compose_cid; // the conversation s_compose is a draft for; draft is wiped when it changes +// Live byte offset of the composer's text caret, kept in sync by composeInputCallback while the composer +// is active (the callback only fires then). The emoji picker uses it to splice a glyph at the cursor +// instead of always appending. -1 = unknown/never-focused => append at the end. +int s_composeCursor = -1; // On-chain chat body cap in bytes = (512 − len("utf8:"))/2 − secretstream ABYTES (see chat_outgoing.cpp). // The composer hard-caps input to this; the emoji picker respects it too. constexpr int kChatBodyMaxBytes = (512 - 5) / 2 - 17; // = 236 @@ -70,11 +75,16 @@ float s_composerTargetH = 0.0f; // target height measured in the composer block // neither the plain-Enter (submit) nor the Ctrl+Enter shortcut — ImGui does nothing with it. We insert the // newline ourselves here (running under CallbackAlways), respecting the on-chain byte cap. int composeInputCallback(ImGuiInputTextCallbackData* data) { + // Track the live caret so the emoji picker can insert at the cursor. This callback runs under + // CallbackAlways, which ImGui only invokes while the field is active — so when the composer loses + // focus (e.g. to the emoji picker) s_composeCursor keeps the last edit position. + s_composeCursor = data->CursorPos; ImGuiIO& io = ImGui::GetIO(); if (io.KeyShift && (ImGui::IsKeyPressed(ImGuiKey_Enter) || ImGui::IsKeyPressed(ImGuiKey_KeypadEnter)) && data->BufTextLen < kChatBodyMaxBytes) { data->InsertChars(data->CursorPos, "\n"); + s_composeCursor = data->CursorPos; // InsertChars advanced the caret past the newline } return 0; } @@ -625,16 +635,22 @@ static const EmojiEntry kEmoji[] = { // Emoji picker overlay: fills the conversation-list pane (cancel + keyword search at the top, then a // grid). Clicking an emoji appends its UTF-8 bytes to `buf` (the composer), respecting the buffer. void renderEmojiPickerOverlay(char* buf, std::size_t bufSize, ImTextureID drgxTex) { - // Insert a token (emoji glyph or the ":drgx:" shortcode) at the end of the draft, prepending a space - // when the draft isn't empty and doesn't already end in whitespace. Respects the on-chain byte cap. + // Insert a token (emoji glyph or the ":drgx:" shortcode) at the composer's caret (s_composeCursor, + // kept live by composeInputCallback; -1 => end of draft), prepending a space when the char before the + // caret is a non-space word char so the emoji doesn't fuse onto it. Respects the on-chain byte cap. + // The composer is inactive whenever the picker is open, so it renders straight from buf — splicing + // here shows immediately. auto insertToken = [&](const char* tok) { const std::size_t cur = std::strlen(buf), add = std::strlen(tok); - const bool needsSpace = cur > 0 && static_cast(buf[cur - 1]) > ' '; + const std::size_t pos = (s_composeCursor < 0) + ? cur : std::min(static_cast(s_composeCursor), cur); + const bool needsSpace = pos > 0 && static_cast(buf[pos - 1]) > ' '; const std::size_t pad = needsSpace ? 1 : 0; if (cur + pad + add <= static_cast(kChatBodyMaxBytes) && cur + pad + add < bufSize) { - if (needsSpace) buf[cur] = ' '; - std::memcpy(buf + cur + pad, tok, add); - buf[cur + pad + add] = '\0'; + std::memmove(buf + pos + pad + add, buf + pos, (cur - pos) + 1); // shift tail right (incl NUL) + if (needsSpace) buf[pos] = ' '; + std::memcpy(buf + pos + pad, tok, add); + s_composeCursor = static_cast(pos + pad + add); // keep the caret after the inserted token } }; if (ImGui::SmallButton(TR("chat_cancel"))) { s_show_emoji_picker = false; s_emoji_search[0] = '\0'; return; } @@ -747,6 +763,7 @@ void RenderChatTab(App* app) // for one contact can't be sent to another (B5). if (s_selected_cid != s_compose_cid) { sodium_memzero(s_compose, sizeof(s_compose)); + s_composeCursor = -1; // fresh draft — next emoji appends until the caret is known again s_compose_cid = s_selected_cid; s_composerAnimH = 0.0f; // re-arm the first-frame snap so the box doesn't animate-collapse on switch } @@ -1705,6 +1722,7 @@ void RenderChatTab(App* app) if (submit && s_compose[0] != '\0' && !overCap) { app->sendChatMessage(sel->cid, s_compose); sodium_memzero(s_compose, sizeof(s_compose)); + s_composeCursor = -1; s_scroll_to_cid = sel->cid; s_composerAnimH = 0.0f; // snap back to collapsed instead of animating while unfocused // Sending closes the emoji picker (it takes over the conversation-list pane) so the list @@ -1726,6 +1744,17 @@ void RenderChatTab(App* app) if (material::BeginOverlayDialog(ov)) { const float fieldW = ImGui::GetContentRegionAvail().x; material::LabeledInput(TR("chat_new_zaddr"), "##newz", s_new_zaddr, sizeof(s_new_zaddr), fieldW); + // Chat rides on encrypted memos, which only shielded (z) addresses carry — a transparent (t) + // address can't receive one. Contacts can hold t-addresses, so guard the manual field too: + // warn when the entry isn't a valid z-address and keep Send disabled below. + const bool newAddrIsZ = dragonx::util::isShieldedAddress(s_new_zaddr); + if (s_new_zaddr[0] != '\0' && !newAddrIsZ) { + ImGui::PushStyleColor(ImGuiCol_Text, material::Warning()); + ImGui::PushTextWrapPos(0.0f); + ImGui::TextUnformatted(TR("chat_new_needs_zaddr")); + ImGui::PopTextWrapPos(); + ImGui::PopStyleColor(); + } // Or pick from contacts — chat needs a shielded z-address, so only z-addr contacts are listed. // Selecting one fills the field above (manual paste still works). ImGui::SetNextItemWidth(fieldW); @@ -1757,7 +1786,7 @@ void RenderChatTab(App* app) material::LabeledInput(TR("chat_new_message"), "##newm", s_new_msg, sizeof(s_new_msg), fieldW); ImGui::Dummy(ImVec2(0, Layout::spacingMd())); - const bool canSend = s_new_zaddr[0] != '\0' && s_new_msg[0] != '\0'; + const bool canSend = newAddrIsZ && s_new_msg[0] != '\0'; const float actionW = std::max(130.0f * dp, ImGui::CalcTextSize(TR("chat_new_send")).x + ImGui::GetStyle().FramePadding.x * 2.0f + 24.0f * dp); const float actionGap = Layout::spacingSm(); diff --git a/src/ui/windows/console_command_reference.cpp b/src/ui/windows/console_command_reference.cpp index 9ec3ded..575f666 100644 --- a/src/ui/windows/console_command_reference.cpp +++ b/src/ui/windows/console_command_reference.cpp @@ -160,10 +160,10 @@ const ConsoleCommandEntry kWalletCommands[] = { "z_sendmany \"RfromAddr\" [{\"address\":\"zs1toAddr\",\"amount\":1.0}]", "send pay private shielded transfer money", true}, {"z_shieldcoinbase", "Shield transparent coinbase funds to a z-address", "\"fromaddress\" \"tozaddress\" [fee] [limit]", "Moves newly mined (coinbase) transparent funds into a private shielded z-address, since mined rewards must be shielded before they can be spent normally. Runs in the background and returns an operation id.", - "z_shieldcoinbase \"RyourMiningAddr\" \"zs1yourShieldedAddr\"", "shield mining rewards coinbase private hide mined funds move to shielded"}, + "z_shieldcoinbase \"RyourMiningAddr\" \"zs1yourShieldedAddr\"", "shield mining rewards coinbase private hide mined funds move to shielded", true}, {"z_mergetoaddress", "Merge multiple UTXOs/notes to one address", "[\"fromaddress\",...] \"toaddress\" [fee] [limit]", "Combines many small balances (from transparent and/or shielded addresses) into a single destination address in one transaction, to consolidate funds. Runs in the background and returns an operation id.", - "z_mergetoaddress [\"RyourAddr\",\"zs1yourShieldedAddr\"] \"zs1destShieldedAddr\"", "merge combine consolidate funds sweep small balances into one address"}, + "z_mergetoaddress [\"RyourAddr\",\"zs1yourShieldedAddr\"] \"zs1destShieldedAddr\"", "merge combine consolidate funds sweep small balances into one address", true}, {"listtransactions", "List recent wallet transactions", "[\"account\"] [count] [from]", "Your most recent wallet transactions, newest first \xE2\x80\x94 amounts, addresses and confirmations.", "listtransactions", "transactions history recent payments received sent"}, diff --git a/src/ui/windows/console_tab.cpp b/src/ui/windows/console_tab.cpp index d893de7..c57e04f 100644 --- a/src/ui/windows/console_tab.cpp +++ b/src/ui/windows/console_tab.cpp @@ -1406,10 +1406,13 @@ void ConsoleTab::renderInput(ConsoleCommandExecutor& exec) ImGui::PopItemWidth(); ImGui::PopFont(); - // Auto-focus on input - if (reclaim_focus) { + // Auto-focus on input — after submitting a command (reclaim), or once when the Console tab is opened + // (focus_input_pending_, set by requestInputFocus() and gated on the console_auto_focus setting). + // Skip while a command is running: SetKeyboardFocusHere can't focus the disabled field anyway. + if ((reclaim_focus || focus_input_pending_) && !busy) { ImGui::SetKeyboardFocusHere(-1); } + focus_input_pending_ = false; } bool ConsoleTab::submitConsoleCommand(ConsoleCommandExecutor& exec, const std::string& cmd) diff --git a/src/ui/windows/console_tab.h b/src/ui/windows/console_tab.h index b3ba243..13a64d2 100644 --- a/src/ui/windows/console_tab.h +++ b/src/ui/windows/console_tab.h @@ -65,6 +65,10 @@ public: */ void clear(); + // Ask the console to place the keyboard focus in the command input on the next render (consumed once). + // Called when the user switches to the Console tab, gated by the console_auto_focus setting. + void requestInputFocus() { focus_input_pending_ = true; } + // Scanline effect toggle (set from settings) static bool s_scanline_enabled; @@ -156,6 +160,7 @@ private: int history_index_ = -1; char input_buffer_[4096] = {0}; bool stop_confirm_pending_ = false; // 'stop' typed once, awaiting a confirming second 'stop' + bool focus_input_pending_ = false; // one-shot: focus the command input next render (tab-open auto-focus) // (log-ingestion cursors + result queue moved to the ConsoleCommandExecutor) // Auto-scroll state machine (pin-to-bottom, wheel-up cooldown, new-line backlog count). diff --git a/src/ui/windows/send_tab.cpp b/src/ui/windows/send_tab.cpp index 0b3c0f5..f71a515 100644 --- a/src/ui/windows/send_tab.cpp +++ b/src/ui/windows/send_tab.cpp @@ -160,6 +160,20 @@ static bool IsValidTransparentAddr(const char* a) { return a && dragonx::util::isTransparentAddress(a); } +// Source-address balance caption for the "sending from" dropdown: the TOTAL balance is the headline (so +// it matches the Overview figure and a source whose change is still confirming never looks like it lost +// funds), with the confirmed-spendable amount shown as a smaller "(N available)" note ONLY when a pending +// send/receive makes it differ. The Max button + validation still cap spends at the spendable amount. +static std::string FormatSourceBalance(double total, double spendable) { + char b[128]; + if (total - spendable > 1e-9) + snprintf(b, sizeof(b), "%.8f %s (%.8f %s)", total, DRAGONX_TICKER, + spendable, TR("send_available_note")); + else + snprintf(b, sizeof(b), "%.8f %s", total, DRAGONX_TICKER); + return b; +} + static std::string timeAgo(int64_t timestamp) { return dragonx::util::formatTimeAgoShort(timestamp); } @@ -253,8 +267,9 @@ static void RenderSourceDropdown(App* app, float width) { const char* tag = isZ ? "[Z]" : "[T]"; std::string trunc = util::truncateMiddle(addr.address, static_cast(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.spendableBalance, DRAGONX_TICKER); + snprintf(buf, sizeof(buf), "%s %s — %s", + tag, trunc.c_str(), + FormatSourceBalance(addr.balance, addr.spendableBalance).c_str()); s_source_preview = buf; } else { s_source_preview = TR("send_select_source"); @@ -267,8 +282,17 @@ static void RenderSourceDropdown(App* app, float width) { if (!app->isConnected() || state.addresses.empty()) { ImGui::TextDisabled("%s", TR("no_addresses_available")); } else { - // Sort by balance descending, only show spendable addresses with balance - std::vector sortedIdx = sortedSpendableAddressIndices(state.addresses); + // List every address that HOLDS a balance (confirmed or still-confirming), sorted by total + // descending — so a source whose change is pending stays visible with its real total instead + // of vanishing. The spend gates (Max / validation) below still cap at the spendable amount. + std::vector sortedIdx; + sortedIdx.reserve(state.addresses.size()); + for (size_t i = 0; i < state.addresses.size(); ++i) + if (state.addresses[i].isSpendable() && state.addresses[i].balance > 0.0) + sortedIdx.push_back(i); + std::sort(sortedIdx.begin(), sortedIdx.end(), [&](size_t a, size_t b) { + return state.addresses[a].balance > state.addresses[b].balance; + }); if (sortedIdx.empty()) { ImGui::TextDisabled("%s", TR("send_no_balance")); @@ -283,8 +307,9 @@ static void RenderSourceDropdown(App* app, float width) { const char* tag = isZ ? "[Z]" : "[T]"; std::string trunc = util::truncateMiddle(addr.address, (int)addrTruncLen); - snprintf(buf, sizeof(buf), "%s %s — %.8f %s", - tag, trunc.c_str(), addr.spendableBalance, DRAGONX_TICKER); + snprintf(buf, sizeof(buf), "%s %s — %s", + tag, trunc.c_str(), + FormatSourceBalance(addr.balance, addr.spendableBalance).c_str()); ImGui::PushID(static_cast(i)); if (ImGui::Selectable(buf, isCurrent)) { @@ -293,8 +318,9 @@ static void RenderSourceDropdown(App* app, float width) { addr.address.c_str()); } if (ImGui::IsItemHovered()) { - material::Tooltip("%s\nBalance: %.8f %s", - addr.address.c_str(), addr.spendableBalance, DRAGONX_TICKER); + material::Tooltip("%s\n%s", + addr.address.c_str(), + FormatSourceBalance(addr.balance, addr.spendableBalance).c_str()); } ImGui::PopID(); } diff --git a/src/ui/windows/wallets_dialog.h b/src/ui/windows/wallets_dialog.h index b29daf6..66494b8 100644 --- a/src/ui/windows/wallets_dialog.h +++ b/src/ui/windows/wallets_dialog.h @@ -594,8 +594,9 @@ private: // Each external wallet gets its own STABLE link name derived from its path — so switching between two // of them is a real -wallet= switch (not a no-op on one shared name), and the wallet // index tracks each separately (correct per-wallet rescan + cached data). Hidden from the list. - static constexpr const char* kLinkPrefix = "wallet-ip-"; - static bool isLinkName(const std::string& n) { return n.rfind(kLinkPrefix, 0) == 0; } + // Single source of truth lives in util/wallet_file_probe.h (shared with the offline enumeration helper). + static constexpr const char* kLinkPrefix = util::kInPlaceLinkPrefix; + static bool isLinkName(const std::string& n) { return util::isInPlaceLinkName(n); } // Stable per-target bare link name, e.g. "wallet-ip-1a2b3c4d.dat" (FNV-1a of the absolute path — a // deterministic, cross-platform, cross-run hash, unlike std::hash). Feed it a canonicalOf() path so the diff --git a/src/util/daemon_updater.cpp b/src/util/daemon_updater.cpp index c8a9cc8..d818c55 100644 --- a/src/util/daemon_updater.cpp +++ b/src/util/daemon_updater.cpp @@ -277,6 +277,7 @@ void DaemonUpdater::installResolved(const std::string& targetDir, const DaemonRe // checksum and (b) verify a detached ed25519 signature over the archive bytes against the // pinned key, so a checksum rewritten in a tampered release body is not sufficient to install. setProgress(State::Verifying, "Verifying download…"); + std::string bytes; // kept in scope through extraction so we extract the VERIFIED buffer (I-01) { std::ifstream f(zipPath, std::ios::binary); if (!f) { @@ -284,7 +285,7 @@ void DaemonUpdater::installResolved(const std::string& targetDir, const DaemonRe setProgress(State::Failed, "Could not read the downloaded archive."); return; } - const std::string bytes((std::istreambuf_iterator(f)), std::istreambuf_iterator()); + bytes.assign(std::istreambuf_iterator(f), std::istreambuf_iterator()); if (f.bad()) { fs::remove(zipPath, ec); setProgress(State::Failed, "Could not read the downloaded archive."); @@ -342,7 +343,9 @@ void DaemonUpdater::installResolved(const std::string& targetDir, const DaemonRe const std::string daemonName = wanted.front(); // "dragonxd" / "dragonxd.exe" mz_zip_archive zip{}; - if (!mz_zip_reader_init_file(&zip, zipPath.c_str(), 0)) { + // Extract from the ALREADY-VERIFIED in-memory buffer, not by reopening zipPath — otherwise a fast + // local attacker could swap the file on disk between the hash/signature check and extraction. (I-01) + if (!mz_zip_reader_init_mem(&zip, bytes.data(), bytes.size(), 0)) { fs::remove(zipPath, ec); setProgress(State::Failed, "Could not open the downloaded archive."); return; diff --git a/src/util/i18n.cpp b/src/util/i18n.cpp index c90f996..f5ab0ca 100644 --- a/src/util/i18n.cpp +++ b/src/util/i18n.cpp @@ -223,6 +223,7 @@ void I18n::loadBuiltinEnglish() strings_["chat_send"] = "Send"; strings_["chat_new_title"] = "New chat"; strings_["chat_new_zaddr"] = "Recipient z-address"; + strings_["chat_new_needs_zaddr"] = "Chat needs a shielded (z) address — transparent (t) addresses can't receive encrypted messages."; strings_["chat_new_message"] = "Message"; strings_["chat_new_send"] = "Send request"; strings_["chat_cancel"] = "Cancel"; @@ -1194,6 +1195,19 @@ void I18n::loadBuiltinEnglish() 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). + // Empty-active-wallet-with-funded-sibling warning (App::renderEmptyWalletWarningDialog). + strings_["empty_wallet_warning_title"] = "This wallet is empty"; + strings_["empty_wallet_warning_headline"] = "You may have opened the wrong wallet."; + strings_["empty_wallet_warning_body"] = "This wallet has no addresses and no funds, but another wallet file in your DragonX folder holds keys. Your coins are most likely in it, not lost. Open the wallet manager to switch to the wallet that holds your funds."; + strings_["empty_wallet_keys_suffix"] = "keys"; + strings_["empty_wallet_open_manager"] = "Open wallet manager"; + strings_["empty_wallet_warning_dismiss"] = "Don't warn again for this wallet"; + strings_["empty_wallet_warning_dismiss_tip"] = "Stops this warning for the current wallet file only. If you switch to a different empty wallet later, it can warn again."; + // Salvage-backup variant of the same modal (a funded wallet..bak from an earlier auto-repair). + strings_["empty_wallet_salvage_title"] = "Your wallet may have been repaired"; + strings_["empty_wallet_salvage_headline"] = "Your coins are safe in a backup file."; + strings_["empty_wallet_salvage_body"] = "This wallet is empty because an earlier automatic repair set your original wallet aside as a backup. Your coins are almost certainly in that backup, not lost. Restore it to load your funds again — nothing is deleted; the current file is kept aside first."; + strings_["empty_wallet_restore"] = "Restore my wallet"; 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."; @@ -1616,6 +1630,8 @@ void I18n::loadBuiltinEnglish() strings_["console_zoom_out"] = "Zoom out"; strings_["console_toggle_accents"] = "Toggle line color accents"; strings_["console_toggle_text_color"] = "Toggle line text colors"; + strings_["console_auto_focus"] = "Focus input on open"; + strings_["console_toggle_auto_focus"] = "Place the cursor in the command box when you open the Console tab"; strings_["console_accents"] = "Color accents"; strings_["console_text_colors"] = "Text colors"; strings_["console_cat_control"] = "Control"; @@ -2123,6 +2139,7 @@ void I18n::loadBuiltinEnglish() strings_["send_recipient"] = "RECIPIENT"; strings_["send_select_source"] = "Select a source address..."; strings_["send_sending_from"] = "SENDING FROM"; + strings_["send_available_note"] = "available"; strings_["send_submitting"] = "Submitting transaction..."; strings_["send_switch_to_receive"] = "Switch to Receive to get your address and start receiving funds."; strings_["send_tooltip_enter_amount"] = "Enter an amount to send"; diff --git a/src/util/wallet_file_probe.h b/src/util/wallet_file_probe.h index fa22130..b9c5266 100644 --- a/src/util/wallet_file_probe.h +++ b/src/util/wallet_file_probe.h @@ -18,14 +18,57 @@ #include #include #include +#include #include #include +#include #include #include namespace dragonx { namespace util { +// A reserved bare-filename PREFIX for the datadir "in-place link" wallets: an out-of-datadir wallet the +// user opens gets a stable symlink/hardlink under this name in the datadir so the daemon can load it by +// bare -wallet=. These are plumbing, not standalone wallet files, so wallet enumeration hides them. +// Single source of truth shared with the wallets UI (ui/windows/wallets_dialog.h). +constexpr const char* kInPlaceLinkPrefix = "wallet-ip-"; +inline bool isInPlaceLinkName(const std::string& name) { return name.rfind(kInPlaceLinkPrefix, 0) == 0; } + +// Enumerate the standalone wallet-bearing files in a DragonX datadir (TOP-LEVEL only): bare "wallet*.dat" +// files, excluding in-place links and (optionally) one active filename. The "wallet" prefix already excludes +// node artifacts (peers.dat / blk*.dat / asmap.dat / …). With includeSalvageBaks, also returns "wallet*.bak" +// files — the daemon's salvage backups (wallet..bak) that hold the pre-salvage keys. Returns full paths. +// Exception-safe (error_code iteration); never descends into subdirectories. This is the lightweight +// datadir-only counterpart to the wallets dialog's richer scan (which also walks user-added external folders +// and de-dups by canonical path); the default (.dat only, no baks) matches that dialog's semantics. +inline std::vector enumerateDatadirWalletFiles(const std::string& datadir, + const std::string& excludeActiveName = "", + bool includeSalvageBaks = false) { + namespace fs = std::filesystem; + std::vector out; + std::error_code ec; + fs::directory_iterator it(datadir, ec), end; + if (ec) return out; + for (; it != end; it.increment(ec)) { + if (ec) break; + const fs::path p = it->path(); + const std::string name = p.filename().string(); + if (name.size() <= 4) continue; + const std::string ext = name.substr(name.size() - 4); + const bool isDat = (ext == ".dat"); + const bool isBak = includeSalvageBaks && (ext == ".bak"); + if (!isDat && !isBak) continue; // *.dat (+ *.bak) only + if (name.rfind("wallet", 0) != 0) continue; // wallet-prefixed only + if (isInPlaceLinkName(name)) continue; // hide in-place links + if (!excludeActiveName.empty() && name == excludeActiveName) continue; // skip the active wallet + std::error_code fec; + if (!fs::is_regular_file(p, fec)) continue; + out.push_back(p.string()); + } + return out; +} + struct WalletFileProbe { bool isBerkeleyDB = false; ///< file has a valid BDB btree metapage magic (looks like a real wallet.dat) bool encrypted = false; ///< has an "mkey" master-key record → passphrase-encrypted diff --git a/src/util/xmrig_updater.cpp b/src/util/xmrig_updater.cpp index 25e8343..026a115 100644 --- a/src/util/xmrig_updater.cpp +++ b/src/util/xmrig_updater.cpp @@ -265,6 +265,7 @@ void XmrigUpdater::installResolved(const std::string& targetDir, const XmrigRele // the archive bytes against that key, so a checksum rewritten in a tampered release body is // not sufficient to install. setProgress(State::Verifying, "Verifying download…"); + std::string bytes; // kept in scope through extraction so we extract the VERIFIED buffer (I-01) { std::ifstream f(zipPath, std::ios::binary); if (!f) { @@ -272,7 +273,7 @@ void XmrigUpdater::installResolved(const std::string& targetDir, const XmrigRele setProgress(State::Failed, "Could not read the downloaded archive."); return; } - const std::string bytes((std::istreambuf_iterator(f)), std::istreambuf_iterator()); + bytes.assign(std::istreambuf_iterator(f), std::istreambuf_iterator()); if (f.bad()) { fs::remove(zipPath, ec); setProgress(State::Failed, "Could not read the downloaded archive."); @@ -333,7 +334,9 @@ void XmrigUpdater::installResolved(const std::string& targetDir, const XmrigRele const std::string minerName = wanted.front(); // "xmrig" / "xmrig.exe" mz_zip_archive zip{}; - if (!mz_zip_reader_init_file(&zip, zipPath.c_str(), 0)) { + // Extract from the ALREADY-VERIFIED in-memory buffer, not by reopening zipPath — otherwise a fast + // local attacker could swap the file on disk between the hash/signature check and extraction. (I-01) + if (!mz_zip_reader_init_mem(&zip, bytes.data(), bytes.size(), 0)) { fs::remove(zipPath, ec); setProgress(State::Failed, "Could not open the downloaded archive."); return; diff --git a/src/wallet/lite_wallet_controller.cpp b/src/wallet/lite_wallet_controller.cpp index 1b0d891..f5971e0 100644 --- a/src/wallet/lite_wallet_controller.cpp +++ b/src/wallet/lite_wallet_controller.cpp @@ -856,6 +856,13 @@ bool LiteWalletController::runConsoleCommand(std::string commandLine) r.ok = call.ok; r.response = call.ok ? call.value : (call.error.empty() ? "command failed" : call.error); + // send/shield/import mutate wallet state and the backend does NOT auto-save (same reason + // doSend/doShield call persistAfterBroadcast). Persist so a console-driven tx survives a + // restart instead of only being re-derived on the next full sync. (M-02) + if (call.ok && (command == "send" || command == "shield" || + command == "import" || command == "timport")) { + persistAfterBroadcast(*bridge); + } } else { r.response = "lite backend unavailable"; } From 06afbee4f891b547d40e6f10b0b7a4a0db2f0e96 Mon Sep 17 00:00:00 2001 From: DanS Date: Tue, 18 Aug 2026 14:53:46 -0500 Subject: [PATCH 50/89] =?UTF-8?q?fix(mining):=20remediate=20mining-tab=20a?= =?UTF-8?q?udit=20(22=20findings)=20=E2=80=94=20crash-safety,=20async=20co?= =?UTF-8?q?ntrol,=20validation,=20math?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Fixes all 22 confirmed findings from the mining-tab audit (10 Medium, 12 Low; 0 Critical/High), adversarially reviewed (6 follow-ups found + fixed, incl. the review-caught idle-auto-start bypass and a wrong benchmark-restore condition). Crash-safety & lifecycle: - M-04: join a stale/finished monitor thread in XmrigManager::start() and ~XmrigManager so an xmrig crash-then-restart (or quit) no longer std::terminate()s the wallet. - L-03/L-10: surface an unexpected miner exit once and clear the stale running flag. UI never blocks (M-03/L-06/L-08/L-09/L-13): pool start/stop now run on a dedicated serialized FIFO mining-control thread (joined before teardown), so the ~13 call sites don't block the render thread on stop()'s SIGTERM->SIGKILL->join; the spawn result marshals back to the UI. Miner-process / pool trust boundary: - M-01: validate the payout address (util::isValidRecipientAddress) at EVERY start path — the UI gate AND App::startPoolMining() (idle auto-start / thread scaling) — so a stale/wrong-chain address can't silently lose rewards. - M-09: SSRF guard skips the background pool-stats GET for loopback/private/link-local/single-label hosts. - M-02/L-02: cap the pool-stats + xmrig-API HTTP response bodies. - L-01: write the xmrig config 0600 at creation (POSIX open with mode) — no world/group-readable window. - M-10: reject shell-metacharacter binary paths before the version popen (excluding '()' so Program Files (x86) still works). Solo mining: M-06/M-08 clamp thread count to [1, cores] at the setgenerate/xmrig boundary; M-07 notify + don't lie on stop failure. Correctness: L-05 block-time constant 75->150s (chainparams); M-05 discloses pool-mode "Est. Daily" as a rough solo-equivalent; L-04/L-11/L-12 benchmark lifecycle (cancel on nav-away / mode-switch with restore, skip rebalance mid-benchmark); L-07 honor cancel mid-extract in both the xmrig and daemon updaters. Two new i18n keys back-filled across all 8 languages; CJK subset font rebuilt for the new glyphs. Verified across full-node, lite, and Windows builds; tests pass. Co-Authored-By: Claude Opus 4.8 (1M context) --- res/fonts/NotoSansCJK-Subset.ttf | Bin 669212 -> 670108 bytes res/lang/de.json | 2 + res/lang/es.json | 2 + res/lang/fr.json | 2 + res/lang/ja.json | 2 + res/lang/ko.json | 2 + res/lang/pt.json | 2 + res/lang/ru.json | 2 + res/lang/zh.json | 2 + src/app.cpp | 66 +++++++++++++++++++ src/app.h | 11 ++++ src/app_network.cpp | 90 +++++++++++++++++--------- src/app_security.cpp | 4 ++ src/daemon/xmrig_manager.cpp | 87 +++++++++++++++++++++---- src/ui/windows/mining_controls.cpp | 7 +- src/ui/windows/mining_earnings.cpp | 10 ++- src/ui/windows/mining_mode_toggle.cpp | 5 ++ src/ui/windows/mining_tab.cpp | 13 ++++ src/ui/windows/mining_tab.h | 7 ++ src/ui/windows/mining_tab_helpers.cpp | 2 +- src/util/daemon_updater.cpp | 1 + src/util/i18n.cpp | 2 + src/util/pool_stats_service.cpp | 10 ++- src/util/xmrig_updater.cpp | 1 + 24 files changed, 285 insertions(+), 47 deletions(-) diff --git a/res/fonts/NotoSansCJK-Subset.ttf b/res/fonts/NotoSansCJK-Subset.ttf index 9d09bd06c7205c6e54a3061cbf2b36dda2b41f21..5d58ab03d7cd0603adec2441a3b2912a41fc222c 100644 GIT binary patch delta 17171 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 G^Zx;0xQV3z diff --git a/res/lang/de.json b/res/lang/de.json index dee943f..450dbc1 100644 --- a/res/lang/de.json +++ b/res/lang/de.json @@ -886,6 +886,7 @@ "mining_difficulty_copied": "Schwierigkeit kopiert", "mining_est_block": "Gesch. Block", "mining_est_daily": "Gesch. täglich", + "mining_est_daily_pool_sub": "grobe Solo-Äquivalenz, vor Pool-Gebühr", "mining_filter_all": "Alle", "mining_filter_tip_all": "Alle Einnahmen anzeigen", "mining_filter_tip_pool": "Nur Pool-Einnahmen anzeigen", @@ -914,6 +915,7 @@ "mining_open_in_explorer": "Im Explorer öffnen", "mining_payout_address": "Auszahlungsadresse", "mining_payout_foreign": "⚠ Diese Auszahlungsadresse befindet sich nicht in Ihrer aktuellen Wallet — geschürfte Belohnungen würden an eine andere Wallet gehen. Aktualisieren Sie sie, wenn Sie die Wallet gewechselt haben.", + "mining_payout_invalid": "Keine gültige DragonX-Adresse — vor dem Start korrigieren, sonst gehen die Mining-Belohnungen verloren.", "mining_payout_tooltip": "Adresse für Mining-Belohnungen", "mining_pool": "Pool", "mining_pool_fee": "Gebühr", diff --git a/res/lang/es.json b/res/lang/es.json index 78009cd..4bf7d17 100644 --- a/res/lang/es.json +++ b/res/lang/es.json @@ -886,6 +886,7 @@ "mining_difficulty_copied": "Dificultad copiada", "mining_est_block": "Bloque Est.", "mining_est_daily": "Diario Est.", + "mining_est_daily_pool_sub": "equivalente solo aproximado, antes de la comisión del pool", "mining_filter_all": "Todos", "mining_filter_tip_all": "Mostrar todas las ganancias", "mining_filter_tip_pool": "Mostrar solo ganancias del pool", @@ -914,6 +915,7 @@ "mining_open_in_explorer": "Abrir en explorador", "mining_payout_address": "Dirección de Pago", "mining_payout_foreign": "⚠ Esta dirección de pago no está en tu cartera actual — las recompensas minadas irían a otra cartera. Actualízala si cambiaste de cartera.", + "mining_payout_invalid": "No es una dirección DragonX válida — corrígela antes de empezar, o se pierden las recompensas de minería.", "mining_payout_tooltip": "Dirección para recibir recompensas de minería", "mining_pool": "Pool", "mining_pool_fee": "Comisión", diff --git a/res/lang/fr.json b/res/lang/fr.json index b5ae70a..2030811 100644 --- a/res/lang/fr.json +++ b/res/lang/fr.json @@ -886,6 +886,7 @@ "mining_difficulty_copied": "Difficulté copiée", "mining_est_block": "Bloc est.", "mining_est_daily": "Est. quotidien", + "mining_est_daily_pool_sub": "équivalent solo approximatif, avant les frais du pool", "mining_filter_all": "Tout", "mining_filter_tip_all": "Afficher tous les gains", "mining_filter_tip_pool": "Afficher uniquement les gains du pool", @@ -914,6 +915,7 @@ "mining_open_in_explorer": "Ouvrir dans l'explorateur", "mining_payout_address": "Adresse de paiement", "mining_payout_foreign": "⚠ Cette adresse de paiement ne fait pas partie de votre portefeuille actuel — les récompenses minées iraient vers un autre portefeuille. Mettez-la à jour si vous avez changé de portefeuille.", + "mining_payout_invalid": "Adresse DragonX invalide — corrigez-la avant de démarrer, sinon les récompenses de minage sont perdues.", "mining_payout_tooltip": "Adresse pour recevoir les récompenses de minage", "mining_pool": "Pool", "mining_pool_fee": "Frais", diff --git a/res/lang/ja.json b/res/lang/ja.json index 931fb5d..72e5117 100644 --- a/res/lang/ja.json +++ b/res/lang/ja.json @@ -886,6 +886,7 @@ "mining_difficulty_copied": "難易度をコピーしました", "mining_est_block": "予測ブロック", "mining_est_daily": "予測日収", + "mining_est_daily_pool_sub": "おおよそのソロ換算（プール手数料前）", "mining_filter_all": "すべて", "mining_filter_tip_all": "すべての収益を表示", "mining_filter_tip_pool": "プール収益のみ表示", @@ -914,6 +915,7 @@ "mining_open_in_explorer": "エクスプローラーで開く", "mining_payout_address": "支払いアドレス", "mining_payout_foreign": "⚠ この支払いアドレスは現在のウォレットに含まれていません — マイニング報酬が別のウォレットに送られます。ウォレットを切り替えた場合は更新してください。", + "mining_payout_invalid": "有効な DragonX アドレスではありません — 開始前に修正してください。さもないとマイニング報酬が失われます。", "mining_payout_tooltip": "マイニング報酬の受取アドレス", "mining_pool": "プール", "mining_pool_fee": "手数料", diff --git a/res/lang/ko.json b/res/lang/ko.json index 0a3d210..05aa546 100644 --- a/res/lang/ko.json +++ b/res/lang/ko.json @@ -885,6 +885,7 @@ "mining_difficulty_copied": "난이도가 복사되었습니다", "mining_est_block": "예상 블록", "mining_est_daily": "예상 일일 수익", + "mining_est_daily_pool_sub": "대략적인 솔로 환산, 풀 수수료 전", "mining_filter_all": "전체", "mining_filter_tip_all": "모든 수익 표시", "mining_filter_tip_pool": "풀 수익만 표시", @@ -913,6 +914,7 @@ "mining_open_in_explorer": "탐색기에서 열기", "mining_payout_address": "지급 주소", "mining_payout_foreign": "⚠ 이 지급 주소는 현재 지갑에 없습니다 — 채굴한 보상이 다른 지갑으로 전송됩니다. 지갑을 전환했다면 주소를 업데이트하세요.", + "mining_payout_invalid": "유효한 DragonX 주소가 아닙니다 — 시작하기 전에 수정하세요. 그렇지 않으면 채굴 보상이 사라집니다.", "mining_payout_tooltip": "채굴 보상 수신 주소", "mining_pool": "풀", "mining_pool_fee": "수수료", diff --git a/res/lang/pt.json b/res/lang/pt.json index 6d0c0bf..07bceae 100644 --- a/res/lang/pt.json +++ b/res/lang/pt.json @@ -886,6 +886,7 @@ "mining_difficulty_copied": "Dificuldade copiada", "mining_est_block": "Bloco Est.", "mining_est_daily": "Est. Diário", + "mining_est_daily_pool_sub": "equivalente solo aproximado, antes da taxa do pool", "mining_filter_all": "Todos", "mining_filter_tip_all": "Mostrar todos os ganhos", "mining_filter_tip_pool": "Mostrar apenas ganhos do pool", @@ -914,6 +915,7 @@ "mining_open_in_explorer": "Abrir no explorador", "mining_payout_address": "Endereço de Pagamento", "mining_payout_foreign": "⚠ Este endereço de pagamento não está na sua carteira atual — as recompensas mineradas iriam para uma carteira diferente. Atualize-o se você trocou de carteira.", + "mining_payout_invalid": "Endereço DragonX inválido — corrija antes de iniciar, ou as recompensas de mineração serão perdidas.", "mining_payout_tooltip": "Endereço para receber recompensas de mineração", "mining_pool": "Pool", "mining_pool_fee": "Taxa", diff --git a/res/lang/ru.json b/res/lang/ru.json index e476059..b6842d2 100644 --- a/res/lang/ru.json +++ b/res/lang/ru.json @@ -886,6 +886,7 @@ "mining_difficulty_copied": "Сложность скопирована", "mining_est_block": "Расч. блок", "mining_est_daily": "Расч. за день", + "mining_est_daily_pool_sub": "примерный соло-эквивалент, до комиссии пула", "mining_filter_all": "Все", "mining_filter_tip_all": "Показать все доходы", "mining_filter_tip_pool": "Показать только доходы пула", @@ -914,6 +915,7 @@ "mining_open_in_explorer": "Открыть в обозревателе", "mining_payout_address": "Адрес выплат", "mining_payout_foreign": "⚠ Этот адрес выплат отсутствует в вашем текущем кошельке — намайненные вознаграждения будут отправлены в другой кошелёк. Обновите его, если вы сменили кошелёк.", + "mining_payout_invalid": "Недействительный адрес DragonX — исправьте перед запуском, иначе награды за майнинг будут потеряны.", "mining_payout_tooltip": "Адрес для получения вознаграждений за майнинг", "mining_pool": "Пул", "mining_pool_fee": "Комиссия", diff --git a/res/lang/zh.json b/res/lang/zh.json index fa7c265..7c51509 100644 --- a/res/lang/zh.json +++ b/res/lang/zh.json @@ -885,6 +885,7 @@ "mining_difficulty_copied": "难度已复制", "mining_est_block": "预计区块", "mining_est_daily": "预计日收益", + "mining_est_daily_pool_sub": "粗略的单人挖矿等值，扣除矿池费用前", "mining_filter_all": "全部", "mining_filter_tip_all": "显示所有收益", "mining_filter_tip_pool": "仅显示矿池收益", @@ -913,6 +914,7 @@ "mining_open_in_explorer": "在浏览器中打开", "mining_payout_address": "支付地址", "mining_payout_foreign": "⚠ 此支付地址不在您当前的钱包中——挖矿奖励将进入另一个钱包。如果您切换过钱包，请更新它。", + "mining_payout_invalid": "不是有效的 DragonX 地址——启动前请更正，否则挖矿奖励将丢失。", "mining_payout_tooltip": "接收挖矿奖励的地址", "mining_pool": "矿池", "mining_pool_fee": "费用", diff --git a/src/app.cpp b/src/app.cpp index 2991453..7a94b2a 100644 --- a/src/app.cpp +++ b/src/app.cpp @@ -147,6 +147,45 @@ void App::wipeSecrets() sodium_memzero(import_key_input_, sizeof(import_key_input_)); // pasted private key (SECRET) } +// Enqueue a blocking xmrig start/stop op onto the dedicated serialized control thread so the render thread +// never blocks on stop()'s SIGTERM->SIGKILL->join, while start/stop still execute in FIFO order. (M-03/…) +void App::postMiningControl(std::function job) +{ + { + std::lock_guard lk(mining_ctl_mutex_); + if (mining_ctl_stop_) return; // shutting down — don't enqueue new mining ops + if (!mining_ctl_thread_.joinable()) { + mining_ctl_thread_ = std::thread([this]() { + for (;;) { + std::function j; + { + std::unique_lock lk(mining_ctl_mutex_); + mining_ctl_cv_.wait(lk, [this]{ return mining_ctl_stop_ || !mining_ctl_queue_.empty(); }); + if (mining_ctl_stop_) return; // abandon any pending jobs on shutdown + j = std::move(mining_ctl_queue_.front()); + mining_ctl_queue_.pop_front(); + } + j(); + } + }); + } + mining_ctl_queue_.push_back(std::move(job)); + } + mining_ctl_cv_.notify_one(); +} + +// Signal the mining-control thread to stop and join it. Called at shutdown BEFORE xmrig_manager_ is stopped +// or destroyed, so no control job runs concurrently with teardown. Idempotent. +void App::stopMiningControlThread() +{ + { + std::lock_guard lk(mining_ctl_mutex_); + mining_ctl_stop_ = true; + } + mining_ctl_cv_.notify_all(); + if (mining_ctl_thread_.joinable()) mining_ctl_thread_.join(); +} + namespace { // How often auto-balance re-evaluates the pool while active. Long, because switching // restarts the miner (drops in-flight shares + reconnect); the incumbent stickiness @@ -166,6 +205,7 @@ void App::updatePoolAutoBalance() if (!supportsPoolMining()) return; // pool mining is available in both builds (solo is full-node only) if (settings_->getPoolSelectMode() != config::Settings::PoolSelectMode::AutoBalance) return; if (!settings_->getPoolMode()) return; // only while POOL mode is selected + if (ui::IsMiningBenchmarkActive()) return; // don't auto-switch pools mid-benchmark — it restarts xmrig at the wrong thread count (L-12) const long long now = steadyNowMs(); const bool intervalDue = (last_balance_eval_ms_ == 0) || @@ -965,6 +1005,20 @@ void App::update() } } + // Surface an unexpected miner exit (crash / OOM-kill / external SIGKILL) once, and clear the stale + // running flag so the UI and auto-balance don't keep believing it's still hashing. (L-03, L-10) + if (xmrig_manager_ && state_.pool_mining.xmrig_running + && xmrig_manager_->getState() == daemon::XmrigManager::State::Error) { + state_.pool_mining.xmrig_running = false; + state_.pool_mining.hashrate_10s = 0.0; + state_.pool_mining.hashrate_60s = 0.0; + state_.pool_mining.hashrate_15m = 0.0; + pool_starting_.store(false, std::memory_order_relaxed); + const std::string err = xmrig_manager_->getLastError(); + ui::Notifications::instance().error(err.empty() ? "Miner stopped unexpectedly." + : ("Miner stopped: " + err)); + } + // Poll xmrig stats every ~2 seconds (use a simple toggle) static bool xmrig_poll_tick = false; xmrig_poll_tick = !xmrig_poll_tick; @@ -1797,6 +1851,10 @@ void App::render() if ((current_page_ == ui::NavPage::Console || current_page_ == ui::NavPage::LiteConsole) && settings_ && settings_->getConsoleAutoFocus()) console_tab_.requestInputFocus(); + // Leaving the Mining tab → cancel a running thread benchmark so the miner isn't abandoned at a + // benchmark step. (L-04) + if (prev_page_ == ui::NavPage::Mining && current_page_ != ui::NavPage::Mining) + ui::CancelMiningBenchmark(this); prev_page_ = current_page_; } if (page_alpha_ < 1.0f) { @@ -5595,6 +5653,10 @@ void App::beginShutdown() fast_worker_->requestStop(); } + // Drain + join the mining-control thread FIRST so no async start/stop job runs while we tear the miner + // down here (avoids two threads driving xmrig_manager_ during shutdown). (M-03 cluster) + stopMiningControlThread(); + // Stop xmrig pool miner before stopping the daemon if (xmrig_manager_ && xmrig_manager_->isRunning()) { shutdown_status_ = "Stopping pool miner..."; @@ -6380,6 +6442,10 @@ void App::renderLoadingOverlay(float contentH) void App::shutdown() { + // Ensure the mining-control thread is stopped + joined (idempotent; beginShutdown already did it on the + // normal quit path, but shutdown() can also run without it). Must precede xmrig_manager_ teardown. + stopMiningControlThread(); + // Wipe any copied secret from the OS clipboard before we exit — the 45s auto-clear timer // never fires if the user quits sooner, which would otherwise leave a key/seed resident. // (ImGui context is still alive here; App::shutdown() runs before ImGui::DestroyContext().) diff --git a/src/app.h b/src/app.h index 48c9cac..323f1d1 100644 --- a/src/app.h +++ b/src/app.h @@ -14,6 +14,7 @@ #include #include #include +#include #include #include "data/transaction_history_cache.h" #include "data/address_book.h" @@ -855,6 +856,16 @@ private: bool lite_startup_lock_checked_ = false; std::unique_ptr daemon_controller_; std::unique_ptr xmrig_manager_; + // Serialized async mining-control queue: xmrig start/stop (SIGTERM->SIGKILL->join, up to ~3s) run on + // this dedicated FIFO thread instead of the render thread, so the UI never blocks and stop/start + // ordering is preserved across the ~13 call sites. (M-03/L-06/L-08/L-09/L-13) + std::thread mining_ctl_thread_; + std::mutex mining_ctl_mutex_; + std::condition_variable mining_ctl_cv_; + std::deque> mining_ctl_queue_; + bool mining_ctl_stop_ = false; + void postMiningControl(std::function job); // enqueue a blocking xmrig op onto the FIFO thread + void stopMiningControlThread(); // signal + join the control thread (shutdown) // Auto-balance runtime state (pool mining, full-node only). The service fetches // pool hashrates off-thread; the RNG drives the weighted-random pick. util::PoolStatsService pool_stats_service_; diff --git a/src/app_network.cpp b/src/app_network.cpp index e586e9e..64b0eca 100644 --- a/src/app_network.cpp +++ b/src/app_network.cpp @@ -63,6 +63,7 @@ #include // popen the rebuild helper #include "util/perf_log.h" #include "util/i18n.h" +#include "util/address_validation.h" // isValidRecipientAddress — payout validation at every start path (M-01) #include "util/secure_vault.h" #include @@ -2338,6 +2339,10 @@ void App::startMining(int threads) return; } if (!state_.connected || !rpc_ || !worker_) return; + // Clamp the requested thread count to [1, logical cores] before setgenerate — an unclamped value + // (from a settings field or idle-scaling) would ask the daemon to spawn arbitrarily many threads. (M-08) + const int maxThreads = std::max(1, (int)std::thread::hardware_concurrency()); + threads = std::clamp(threads, 1, maxThreads); if (mining_toggle_in_progress_.exchange(true)) return; // already in progress worker_->post([this, threads]() -> rpc::RPCWorker::MainCb { @@ -2372,19 +2377,25 @@ void App::stopMining() worker_->post([this]() -> rpc::RPCWorker::MainCb { bool ok = false; + std::string errMsg; try { rpc::RPCClient::TraceScope trace("Mining tab / Stop mining"); rpc_->call("setgenerate", {false, 0}); ok = true; } catch (const std::exception& e) { - DEBUG_LOGF("Failed to stop mining: %s\n", e.what()); + errMsg = e.what(); + DEBUG_LOGF("Failed to stop mining: %s\n", errMsg.c_str()); } - return [this, ok]() { + return [this, ok, errMsg]() { mining_toggle_in_progress_.store(false); if (ok) { state_.mining.generate = false; state_.mining.localHashrate = 0.0; DEBUG_LOGF("Mining stopped\n"); + } else { + // Don't silently leave generate=true as if it worked: tell the user and let the next + // getmininginfo refresh reconcile the true daemon state. (M-07) + ui::Notifications::instance().error("Failed to stop mining: " + errMsg); } }; }); @@ -2397,21 +2408,28 @@ void App::startPoolMining(int threads) ui::Notifications::instance().warning("Pool mining is unavailable in this build"); return; } + // Clamp to [1, logical cores] before the count reaches xmrig (M-06/M-08 pool path). + threads = std::clamp(threads, 1, std::max(1, (int)std::thread::hardware_concurrency())); if (!xmrig_manager_) xmrig_manager_ = std::make_unique(); - // If already running, stop first (e.g. thread count change) - if (xmrig_manager_->isRunning()) { - xmrig_manager_->stop(); - } - - // Stop solo mining first if active + // Stop solo mining first if active (async via the RPC worker). if (state_.mining.generate) stopMining(); + // (the "stop the already-running miner first" step is done inside the control job below, in FIFO order) daemon::XmrigManager::Config cfg; cfg.pool_url = settings_->getPoolUrl(); cfg.worker_name = settings_->getPoolWorker(); + // Validate the payout address at EVERY start entry point (manual Start button, idle auto-start, thread + // scaling) — not just the UI gate — since a stale/hand-edited/wrong-chain address here silently loses + // mining rewards. (M-01) worker_name IS the pool login the rewards are credited to (see below). + if (!cfg.worker_name.empty() && cfg.worker_name != "x" && + !util::isValidRecipientAddress(cfg.worker_name)) { + ui::Notifications::instance().error( + "Pool payout address is not a valid DragonX address — mining not started."); + return; + } // The algo follows the pool: official pools use their own algo (pool.dragonx.cc // needs rx/dragonx, pool.dragonx.is rx/hush); custom hosts keep the setting. cfg.algo = util::resolvePoolAlgo(cfg.pool_url, settings_->getPoolAlgo()); @@ -2443,34 +2461,46 @@ void App::startPoolMining(int threads) return; } - if (!xmrig_manager_->start(cfg)) { - std::string err = xmrig_manager_->getLastError(); - DEBUG_LOGF("[ERROR] Pool mining: %s\n", err.c_str()); - - // Check for Windows Defender blocking (error 225 = ERROR_VIRUS_INFECTED) - if (err.find("error 225") != std::string::npos || - err.find("virus") != std::string::npos) { - ui::Notifications::instance().error( - "Windows Defender blocked xmrig. Add exclusion for %APPDATA%\\ObsidianDragon"); + // Run the blocking stop(if running)+start on the serialized mining-control thread so the render thread + // never blocks on stop()'s SIGTERM->SIGKILL->join; marshal the spawn result back to the UI. (M-03/L-06/ + // L-08/L-09/L-13). cfg was fully built above on this (main) thread. + daemon::XmrigManager::Config cfgCopy = cfg; + postMiningControl([this, cfgCopy]() { + if (xmrig_manager_->isRunning()) xmrig_manager_->stop(3000); + const bool ok = xmrig_manager_->start(cfgCopy); + const std::string err = ok ? std::string() : xmrig_manager_->getLastError(); + if (!worker_) return; + worker_->post([this, ok, err]() -> rpc::RPCWorker::MainCb { + return [this, ok, err]() { + if (ok) { + // Miner spawned — it still needs a few seconds to connect to the pool and start hashing. + pool_starting_.store(true, std::memory_order_relaxed); + ui::Notifications::instance().info("Starting pool miner — connecting to the pool…"); + } else { + DEBUG_LOGF("[ERROR] Pool mining: %s\n", err.c_str()); + // Windows Defender blocking (error 225 = ERROR_VIRUS_INFECTED) + if (err.find("error 225") != std::string::npos || err.find("virus") != std::string::npos) { + ui::Notifications::instance().error( + "Windows Defender blocked xmrig. Add exclusion for %APPDATA%\\ObsidianDragon"); #ifdef _WIN32 - // Offer to open Windows Security settings - pending_antivirus_dialog_ = true; + pending_antivirus_dialog_ = true; #endif - } else { - ui::Notifications::instance().error("Failed to start pool miner: " + err); - } - } else { - // Miner spawned — it still needs a few seconds to connect to the pool and start hashing. - pool_starting_.store(true, std::memory_order_relaxed); - ui::Notifications::instance().info("Starting pool miner — connecting to the pool…"); - } + } else { + ui::Notifications::instance().error("Failed to start pool miner: " + err); + } + } + }; + }); + }); } void App::stopPoolMining() { - if (xmrig_manager_ && xmrig_manager_->isRunning()) { - xmrig_manager_->stop(3000); - } + if (!xmrig_manager_) return; + // Off the render thread — stop()'s SIGTERM->SIGKILL->join can block up to ~3s. (M-03/L-06/L-08/L-09) + postMiningControl([this]() { + if (xmrig_manager_->isRunning()) xmrig_manager_->stop(3000); + }); } // ============================================================================ diff --git a/src/app_security.cpp b/src/app_security.cpp index 192f986..845894b 100644 --- a/src/app_security.cpp +++ b/src/app_security.cpp @@ -759,6 +759,10 @@ void App::checkIdleMining() { // Resolve auto values: active defaults to half, idle defaults to all if (activeThreads <= 0) activeThreads = std::max(1, maxThreads / 2); if (idleThreads <= 0) idleThreads = maxThreads; + // Clamp to [1, logical cores] before these reach setgenerate / startPoolMining — a settings field + // could otherwise carry an arbitrary count straight past every bound. (M-06) + activeThreads = std::clamp(activeThreads, 1, maxThreads); + idleThreads = std::clamp(idleThreads, 1, maxThreads); if (systemIdle) { // System is idle — scale up to idle thread count diff --git a/src/daemon/xmrig_manager.cpp b/src/daemon/xmrig_manager.cpp index 9ca5a76..4d76c21 100644 --- a/src/daemon/xmrig_manager.cpp +++ b/src/daemon/xmrig_manager.cpp @@ -89,8 +89,32 @@ static std::string getConfigDir() { // libcurl write callback static size_t curlWriteCb(void* ptr, size_t sz, size_t n, void* userdata) { auto* s = static_cast(userdata); - s->append(static_cast(ptr), sz * n); - return sz * n; + const size_t add = sz * n; + // Stats JSON (local xmrig HTTP API + pool API) is tiny; refuse an unbounded body from a hostile or + // MITM'd endpoint so it can't grow this string until OOM. Returning < add aborts the transfer. (L-02) + constexpr size_t kMaxStatsBytes = 1u << 20; // 1 MiB + if (s->size() + add > kMaxStatsBytes) return 0; + s->append(static_cast(ptr), add); + return add; +} + +// True if `host` (already stripped of scheme+port) is a loopback/private/link-local/single-label target +// that a public mining pool would never be — used to refuse a background stats GET to it (M-09). +static bool hostLooksInternal(const std::string& host) { + if (host.empty() || host == "localhost") return true; + if (host.rfind("127.", 0) == 0 || host.rfind("10.", 0) == 0 || + host.rfind("192.168.", 0) == 0 || host.rfind("169.254.", 0) == 0) return true; + if (host.rfind("172.", 0) == 0) { // 172.16.0.0 - 172.31.255.255 + const int second = std::atoi(host.c_str() + 4); + if (second >= 16 && second <= 31) return true; + } + if (host.find(':') != std::string::npos) { // IPv6 literal: loopback / ULA / link-local + if (host == "::1" || host.rfind("fc", 0) == 0 || host.rfind("fd", 0) == 0 || + host.rfind("fe80", 0) == 0) return true; + } + if (host.size() >= 6 && host.compare(host.size() - 6, 6, ".local") == 0) return true; + if (host.find('.') == std::string::npos) return true; // bare single-label name = LAN/hosts, not a pool + return false; } // ============================================================================ @@ -100,9 +124,14 @@ static size_t curlWriteCb(void* ptr, size_t sz, size_t n, void* userdata) { XmrigManager::XmrigManager() = default; XmrigManager::~XmrigManager() { + should_stop_ = true; if (isRunning()) { stop(3000); } + // Join a monitor thread left joinable by an unexpected xmrig exit (State::Error, so isRunning() is + // false and stop() above was skipped) — std::thread's destructor would otherwise std::terminate(). (M-04) + if (monitor_thread_.joinable()) + monitor_thread_.join(); } // ============================================================================ @@ -208,21 +237,41 @@ bool XmrigManager::generateConfig(const Config& cfg, const std::string& outPath) try { fs::create_directories(fs::path(outPath).parent_path()); + const std::string dumped = j.dump(4); +#ifndef _WIN32 + // Create the config 0600 AT CREATION (open with mode) so the API token + wallet address are never + // in a world/group-readable file — even for a local attacker who opened it in the old + // create-then-chmod window and held the fd open across the chmod. (L-01) + int fd = ::open(outPath.c_str(), O_WRONLY | O_CREAT | O_TRUNC, 0600); + if (fd < 0) { + setLastError("Cannot write xmrig config: " + outPath); + DEBUG_LOGF("[ERROR] XmrigManager: %s\n", last_error_.c_str()); + return false; + } + size_t off = 0; + bool wrote = true; + while (off < dumped.size()) { + ssize_t nw = ::write(fd, dumped.data() + off, dumped.size() - off); + if (nw <= 0) { wrote = false; break; } + off += static_cast(nw); + } + ::close(fd); + if (!wrote) { + setLastError("Cannot write xmrig config: " + outPath); + return false; + } + return true; +#else std::ofstream ofs(outPath, std::ios::trunc); if (!ofs.is_open()) { setLastError("Cannot write xmrig config: " + outPath); DEBUG_LOGF("[ERROR] XmrigManager: %s\n", last_error_.c_str()); return false; } -#ifndef _WIN32 - // Restrict to owner (0600) BEFORE writing any secret material (API token, wallet - // address, worker name). The file is still empty here, so the config is never - // world-readable — closing the window between creation and the previous post-write chmod. - chmod(outPath.c_str(), 0600); -#endif - ofs << j.dump(4); + ofs << dumped; ofs.close(); return true; +#endif } catch (const std::exception& e) { setLastError(std::string("Config write error: ") + e.what()); DEBUG_LOGF("[ERROR] XmrigManager: %s\n", last_error_.c_str()); @@ -296,7 +345,11 @@ bool XmrigManager::start(const Config& cfg) { return false; } - // Start monitor thread + // Join a prior monitor thread before move-assigning: if xmrig exited unexpectedly, monitorProcess set + // State::Error and returned, leaving monitor_thread_ joinable — move-assigning over a joinable + // std::thread calls std::terminate() and aborts the whole wallet. (M-04) + if (monitor_thread_.joinable()) + monitor_thread_.join(); monitor_thread_ = std::thread(&XmrigManager::monitorProcess, this); state_ = State::Running; DEBUG_LOGF("[INFO] XmrigManager: started\n"); @@ -783,6 +836,11 @@ void XmrigManager::fetchPoolApiStats() { // own API shape (pool.dragonx.is = custom /api/stats; pool.dragonx.cc = Miningcore // /api/pools); unknown/custom hosts fall back to the .is convention. const util::KnownPool* known = util::findKnownPoolByUrl(pool_host_); + // SSRF guard: for an UNKNOWN (user-typed) pool host, don't let the wallet issue a background GET to a + // loopback/private/link-local/single-label target — those aren't public mining pools, and a + // paste-a-pool-config lure could otherwise point us at an internal host. Known pools use their trusted + // registry statsUrl and are exempt. (M-09) + if (!known && hostLooksInternal(pool_host_)) return; const std::string url = known ? known->statsUrl : ("https://" + pool_host_ + "/api/stats"); @@ -861,7 +919,14 @@ void XmrigManager::startVersionDetection() std::thread([]() { const std::string bin = findXmrigBinary(); std::string ver; - if (!bin.empty()) { + // Don't hand a path containing shell/cmd metacharacters to popen()'s shell — bin is normally an + // app-controlled path, but this closes command injection if it ever isn't. (M-10) + // Reject only chars that stay shell-special INSIDE the double-quotes we wrap bin in ("\"" + bin + "\"") + // on cmd.exe or /bin/sh. Parens are inert when quoted, so they're excluded — otherwise common Windows + // paths like "C:\Program Files (x86)\..." would be rejected and version detection would silently fail. (M-10) + const bool binShellSafe = + !bin.empty() && bin.find_first_of("\"'`$;&|<>^%\n\r") == std::string::npos; + if (binShellSafe) { const std::string cmd = "\"" + bin + "\" --version 2>&1"; #ifdef _WIN32 FILE* fp = _popen(cmd.c_str(), "r"); diff --git a/src/ui/windows/mining_controls.cpp b/src/ui/windows/mining_controls.cpp index 133db30..8e25f47 100644 --- a/src/ui/windows/mining_controls.cpp +++ b/src/ui/windows/mining_controls.cpp @@ -12,6 +12,7 @@ #include "../../config/settings.h" #include "../../util/i18n.h" #include "../../util/platform.h" +#include "../../util/address_validation.h" // isValidRecipientAddress — payout validation (M-01) #include "../schema/ui_schema.h" #include "../material/type.h" #include "../material/draw_helpers.h" @@ -685,8 +686,12 @@ void RenderMiningControls(App* app, const WalletState& state, const MiningInfo& bool poolStillRunning = !s_pool_mode && state.pool_mining.xmrig_running; // Can't start pool mining without a payout address (blank for a new wallet with no z-address); // only blocks starting — stopping a running miner stays enabled. + // Block start when the payout address is empty OR not a valid DragonX address — mining to a + // malformed / wrong-chain address silently loses the rewards. (M-01) + const std::string poolPayoutStr(s_pool_worker); bool poolNeedsPayout = s_pool_mode && !state.pool_mining.xmrig_running && - std::string(s_pool_worker).empty(); + (poolPayoutStr.empty() || + (poolPayoutStr != "x" && !util::isValidRecipientAddress(poolPayoutStr))); bool disabled = s_pool_mode ? (isToggling || poolBlockedBySolo || poolNeedsPayout) : (poolStillRunning ? false : (!app->isConnected() || isToggling || isSyncing)); diff --git a/src/ui/windows/mining_earnings.cpp b/src/ui/windows/mining_earnings.cpp index 8c10471..2bccb17 100644 --- a/src/ui/windows/mining_earnings.cpp +++ b/src/ui/windows/mining_earnings.cpp @@ -104,7 +104,10 @@ void RenderMiningEarnings(App* app, const WalletState& state, const MiningInfo& } } - // Use pool hashrate for EST. DAILY when in pool mode + // Est. Daily = expected reward for YOUR own hashrate share of the network. In pool mode this uses + // your local miner rate (pool_mining.hashrate_10s), NOT the pool's aggregate rate: pool payouts are + // share-proportional, so your expected daily is the same solo-equivalent value (a rough estimate, + // before the pool fee). Using the pool's total rate here would show the POOL's earnings, not yours. (M-05) double estHashrate = s_pool_mode ? state.pool_mining.hashrate_10s : mining.localHashrate; double est_hours_2 = EstimateHoursToBlock(estHashrate, mining.networkHashrate, mining.difficulty); double estDailyBlocks = (est_hours_2 > 0) ? (24.0 / est_hours_2) : 0.0; @@ -218,12 +221,15 @@ void RenderMiningEarnings(App* app, const WalletState& state, const MiningInfo& snprintf(estVal, sizeof(estVal), "~%.4f", estDaily); else snprintf(estVal, sizeof(estVal), "N/A"); + // Disclose in pool mode that Est. Daily is a rough solo-equivalent (before the pool fee), so the + // number isn't silently mismatched to its plain "Est. Daily" label. (M-05) + const char* estSub = (s_pool_mode && estActive) ? TR("mining_est_daily_pool_sub") : nullptr; EarningsEntry entries[] = { { TR("mining_today"), todayVal, todaySub, greenCol2 }, { TR("mining_yesterday"), yesterdayVal, yesterdaySub, OnSurface() }, { TR("mining_all_time"), allVal, allSub, OnSurface() }, - { TR("mining_est_daily"), estVal, nullptr, estActive ? greenCol2 : OnSurfaceDisabled() }, + { TR("mining_est_daily"), estVal, estSub, estActive ? greenCol2 : OnSurfaceDisabled() }, }; for (int ei = 0; ei < numCols; ei++) { diff --git a/src/ui/windows/mining_mode_toggle.cpp b/src/ui/windows/mining_mode_toggle.cpp index 862fd36..65f7e2c 100644 --- a/src/ui/windows/mining_mode_toggle.cpp +++ b/src/ui/windows/mining_mode_toggle.cpp @@ -4,6 +4,7 @@ #include "mining_mode_toggle.h" #include "mining_tab_helpers.h" +#include "mining_tab.h" // CancelMiningBenchmark (L-11) #include "mining_pool_panel.h" #include "../../app.h" @@ -16,6 +17,7 @@ #include "../material/type.h" #include "../material/draw_helpers.h" #include "../material/colors.h" +#include "../../util/address_validation.h" // isValidRecipientAddress — payout validation (M-01) #include "../layout.h" #include "../notifications.h" #include "../../embedded/IconsMaterialDesign.h" @@ -101,6 +103,7 @@ void RenderMiningModeToggle(App* app, const WalletState& state, const MiningInfo s_pool_mode = false; app->settings()->setPoolMode(false); app->settings()->save(); + CancelMiningBenchmark(app); // don't leave a pool benchmark running after switching to solo (L-11) app->stopPoolMining(); } if (soloHov) ImGui::SetMouseCursor(ImGuiMouseCursor_Hand); @@ -382,6 +385,8 @@ void RenderMiningModeToggle(App* app, const WalletState& state, const MiningInfo std::string currentWorkerStr(s_pool_worker); if (currentWorkerStr.empty()) { material::Tooltip("%s", TR("mining_generate_z_address_hint")); + } else if (currentWorkerStr != "x" && !util::isValidRecipientAddress(currentWorkerStr)) { + material::Tooltip("%s", TR("mining_payout_invalid")); // block start below too (M-01) } else { material::Tooltip("%s", TR("mining_payout_tooltip")); } diff --git a/src/ui/windows/mining_tab.cpp b/src/ui/windows/mining_tab.cpp index 49b8774..3749c87 100644 --- a/src/ui/windows/mining_tab.cpp +++ b/src/ui/windows/mining_tab.cpp @@ -55,6 +55,19 @@ bool IsMiningBenchmarkActive() { return s_benchmark.active(); } +void CancelMiningBenchmark(App* app) { + if (!s_benchmark.active()) return; + const int restoreThreads = s_benchmark.prev_threads; + s_benchmark.reset(); + // Restore the miner to its pre-benchmark thread count. A benchmark runs in pool mode, so restore + // regardless of the instantaneous running state — the sweep may be mid inter-candidate stop, where an + // isPoolMinerRunning() check would be transiently false and silently drop the restart. (L-04, L-11) + if (app && restoreThreads > 0) { + app->stopPoolMining(); + app->startPoolMining(restoreThreads); + } +} + // Miner-update version check (one shot per session): fetches the latest DRG-XMRig release tag in // the background so the "Update" button can show it. Network call to the project Gitea, started // the first time the pool section is shown. diff --git a/src/ui/windows/mining_tab.h b/src/ui/windows/mining_tab.h index 2f55762..0515925 100644 --- a/src/ui/windows/mining_tab.h +++ b/src/ui/windows/mining_tab.h @@ -21,5 +21,12 @@ void RenderMiningTab(App* app); */ bool IsMiningBenchmarkActive(); +/** + * @brief Cancel a running thread benchmark and restore the miner to its pre-benchmark thread count. + * Safe to call when no benchmark is active (no-op). Used when leaving the Mining tab or switching to + * solo mode so the miner isn't left stuck at a benchmark step. (L-04, L-11) + */ +void CancelMiningBenchmark(App* app); + } // namespace ui } // namespace dragonx diff --git a/src/ui/windows/mining_tab_helpers.cpp b/src/ui/windows/mining_tab_helpers.cpp index d1d8d7b..801e1b7 100644 --- a/src/ui/windows/mining_tab_helpers.cpp +++ b/src/ui/windows/mining_tab_helpers.cpp @@ -60,7 +60,7 @@ double EstimateHoursToBlock(double localHashrate, double networkHashrate, double { (void)difficulty; if (localHashrate <= 0.0 || networkHashrate <= 0.0) return 0.0; - double blocksPerHour = 3600.0 / 75.0; + double blocksPerHour = 3600.0 / 150.0; // DragonX mainnet target spacing is 150s (chainparams) (L-05) double share = localHashrate / networkHashrate; if (share <= 0.0) return 0.0; return 1.0 / (blocksPerHour * share); diff --git a/src/util/daemon_updater.cpp b/src/util/daemon_updater.cpp index d818c55..4dd905e 100644 --- a/src/util/daemon_updater.cpp +++ b/src/util/daemon_updater.cpp @@ -354,6 +354,7 @@ void DaemonUpdater::installResolved(const std::string& targetDir, const DaemonRe bool failed = false; const int numFiles = static_cast(mz_zip_reader_get_num_files(&zip)); for (int i = 0; i < numFiles && !failed; ++i) { + if (cancel_requested_) { failed = true; break; } // honor cancel mid-extraction so the join returns promptly (L-07) mz_zip_archive_file_stat st; if (!mz_zip_reader_file_stat(&zip, i, &st)) continue; if (mz_zip_reader_is_file_a_directory(&zip, i)) continue; diff --git a/src/util/i18n.cpp b/src/util/i18n.cpp index f5ab0ca..d591196 100644 --- a/src/util/i18n.cpp +++ b/src/util/i18n.cpp @@ -1880,6 +1880,8 @@ void I18n::loadBuiltinEnglish() strings_["mining_open_in_explorer"] = "Open in explorer"; strings_["mining_payout_address"] = "Payout Address"; strings_["mining_payout_tooltip"] = "Address to receive mining rewards"; + strings_["mining_payout_invalid"] = "Not a valid DragonX address — fix it before starting, or mining rewards are lost."; + strings_["mining_est_daily_pool_sub"] = "rough solo-equivalent, before pool fee"; strings_["mining_generate_z_address_hint"] = "Generate a Z address in the Receive tab to use as your payout address"; strings_["mining_pool"] = "Pool"; strings_["mining_payout_foreign"] = "⚠ This payout address isn't in your current wallet — mined rewards would go to a different wallet. Update it if you switched wallets."; diff --git a/src/util/pool_stats_service.cpp b/src/util/pool_stats_service.cpp index 7bc479d..0be6a34 100644 --- a/src/util/pool_stats_service.cpp +++ b/src/util/pool_stats_service.cpp @@ -13,8 +13,14 @@ namespace { size_t writeStringCb(void* contents, size_t size, size_t nmemb, void* userp) { - static_cast(userp)->append(static_cast(contents), size * nmemb); - return size * nmemb; + auto* s = static_cast(userp); + const size_t add = size * nmemb; + // Pool stats JSON is tiny; refuse an unbounded body from a hostile/MITM'd endpoint (returning < add + // aborts the transfer) so it can't grow this string until OOM. (M-02) + constexpr size_t kMaxPoolStatsBytes = 1u << 20; // 1 MiB + if (s->size() + add > kMaxPoolStatsBytes) return 0; + s->append(static_cast(contents), add); + return add; } // Returning non-zero asks libcurl to abort the transfer — used so shutdown doesn't diff --git a/src/util/xmrig_updater.cpp b/src/util/xmrig_updater.cpp index 026a115..67453a6 100644 --- a/src/util/xmrig_updater.cpp +++ b/src/util/xmrig_updater.cpp @@ -345,6 +345,7 @@ void XmrigUpdater::installResolved(const std::string& targetDir, const XmrigRele bool failed = false; const int numFiles = static_cast(mz_zip_reader_get_num_files(&zip)); for (int i = 0; i < numFiles && !failed; ++i) { + if (cancel_requested_) { failed = true; break; } // honor cancel mid-extraction so the dialog's join returns promptly (L-07) mz_zip_archive_file_stat st; if (!mz_zip_reader_file_stat(&zip, i, &st)) continue; if (mz_zip_reader_is_file_a_directory(&zip, i)) continue; From 0de44569b77c7ed71feb333995862af0e65d24ef Mon Sep 17 00:00:00 2001 From: DanS Date: Tue, 18 Aug 2026 15:39:43 -0500 Subject: [PATCH 51/89] feat(mining): thread-count stepper, adaptive tiles, dropdown click-through fix, xmrig version state MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Mining-tab UI improvements: - Thread selector: a centered [-] N [+] stepper (top-aligned in the header) to pick an exact thread count — number centered, -/+ step by one (clamped to [1, cores]), still typeable (commits on Enter so it doesn't restart the miner mid-typing). - Thread tiles now render at an adaptive step (1/2/4/8 by core count) plus 1 and the max, so a high-core CPU (e.g. a 192-thread EPYC) shows ~25 tiles instead of one-per-thread and no longer overflows the card. Unchanged for <=24-core machines. - Fix: clicking the X (or a row) in an open saved-pools / payout-address dropdown no longer bleeds through to the thread tiles / Mine button — the custom drawlist hit-tests now gate on IsPopupOpen(AnyPopup). - xmrig update button: shows "xmrig releases" when installed >= latest (numeric version compare), else "Update "; the "Current: " text and the button are subtle green when up to date and subtle orange when an update is available (neutral when either version is unknown). New i18n keys back-filled across all 8 languages; CJK subset font rebuilt for the new glyphs. Verified across full-node, lite, and Windows builds; the stepper layout confirmed via the UI sweep. Co-Authored-By: Claude Opus 4.8 (1M context) --- res/fonts/NotoSansCJK-Subset.ttf | Bin 670108 -> 671092 bytes res/lang/de.json | 4 + res/lang/es.json | 4 + res/lang/fr.json | 4 + res/lang/ja.json | 4 + res/lang/ko.json | 4 + res/lang/pt.json | 4 + res/lang/ru.json | 4 + res/lang/zh.json | 4 + src/ui/windows/mining_controls.cpp | 144 ++++++++++++++++++++++++++--- src/util/i18n.cpp | 4 + 11 files changed, 165 insertions(+), 15 deletions(-) diff --git a/res/fonts/NotoSansCJK-Subset.ttf b/res/fonts/NotoSansCJK-Subset.ttf index 5d58ab03d7cd0603adec2441a3b2912a41fc222c..955157817d2cad9dfb6c0a8c38449b4cf8afbd6d 100644 GIT binary patch delta 16020 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 delta 15410 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 ZSh=Pk{{TDElkxxn diff --git a/res/lang/de.json b/res/lang/de.json index 450dbc1..e799578 100644 --- a/res/lang/de.json +++ b/res/lang/de.json @@ -949,6 +949,9 @@ "mining_syncing_tooltip": "Blockchain synchronisiert...", "mining_tag": " · Mining", "mining_threads": "Mining-Threads", + "mining_threads_input_tooltip": "Genaue Thread-Anzahl eingeben (Enter zum Übernehmen)", + "mining_threads_minus_tooltip": "Weniger Threads", + "mining_threads_plus_tooltip": "Mehr Threads", "mining_to_save": "zum Speichern", "mining_today": "Heute", "mining_uptime": "Laufzeit", @@ -1785,6 +1788,7 @@ "xmrig_loading_releases": "Releases werden geladen…", "xmrig_none": "keiner", "xmrig_reinstall": "Neu installieren", + "xmrig_releases": "xmrig-Releases", "xmrig_stop_mining_first": "Stoppen Sie das Mining, bevor Sie den Miner aktualisieren.", "xmrig_unavailable_body": "Für diese Plattform ist kein Miner-Build verfügbar.", "xmrig_unavailable_title": "Miner-Updates nicht verfügbar", diff --git a/res/lang/es.json b/res/lang/es.json index 4bf7d17..0b912d7 100644 --- a/res/lang/es.json +++ b/res/lang/es.json @@ -949,6 +949,9 @@ "mining_syncing_tooltip": "El blockchain está sincronizando...", "mining_tag": " · Minería", "mining_threads": "Hilos de Minería", + "mining_threads_input_tooltip": "Escribe un número exacto de hilos (pulsa Enter para aplicar)", + "mining_threads_minus_tooltip": "Menos hilos", + "mining_threads_plus_tooltip": "Más hilos", "mining_to_save": "para guardar", "mining_today": "Hoy", "mining_uptime": "Tiempo activo", @@ -1785,6 +1788,7 @@ "xmrig_loading_releases": "Cargando versiones…", "xmrig_none": "ninguno", "xmrig_reinstall": "Reinstalar", + "xmrig_releases": "versiones de xmrig", "xmrig_stop_mining_first": "Detén la minería antes de actualizar el minero.", "xmrig_unavailable_body": "No hay ninguna versión del minero disponible para esta plataforma.", "xmrig_unavailable_title": "Actualizaciones del minero no disponibles", diff --git a/res/lang/fr.json b/res/lang/fr.json index 2030811..f28389b 100644 --- a/res/lang/fr.json +++ b/res/lang/fr.json @@ -949,6 +949,9 @@ "mining_syncing_tooltip": "La blockchain se synchronise...", "mining_tag": " · Minage", "mining_threads": "Threads de minage", + "mining_threads_input_tooltip": "Saisissez un nombre exact de threads (Entrée pour appliquer)", + "mining_threads_minus_tooltip": "Moins de threads", + "mining_threads_plus_tooltip": "Plus de threads", "mining_to_save": "pour enregistrer", "mining_today": "Aujourd'hui", "mining_uptime": "Temps de fonctionnement", @@ -1785,6 +1788,7 @@ "xmrig_loading_releases": "Chargement des versions…", "xmrig_none": "aucun", "xmrig_reinstall": "Réinstaller", + "xmrig_releases": "versions de xmrig", "xmrig_stop_mining_first": "Arrêtez le minage avant de mettre à jour le mineur.", "xmrig_unavailable_body": "Aucune version du mineur n'est disponible pour cette plateforme.", "xmrig_unavailable_title": "Mises à jour du mineur indisponibles", diff --git a/res/lang/ja.json b/res/lang/ja.json index 72e5117..c02d619 100644 --- a/res/lang/ja.json +++ b/res/lang/ja.json @@ -949,6 +949,9 @@ "mining_syncing_tooltip": "ブロックチェーン同期中...", "mining_tag": " · マイニング", "mining_threads": "マイニングスレッド", + "mining_threads_input_tooltip": "正確なスレッド数を入力（Enter で適用）", + "mining_threads_minus_tooltip": "スレッドを減らす", + "mining_threads_plus_tooltip": "スレッドを増やす", "mining_to_save": "保存する", "mining_today": "今日", "mining_uptime": "稼働時間", @@ -1782,6 +1785,7 @@ "xmrig_loading_releases": "リリースを読み込み中…", "xmrig_none": "なし", "xmrig_reinstall": "再インストール", + "xmrig_releases": "xmrig リリース", "xmrig_stop_mining_first": "マイナーを更新する前にマイニングを停止してください。", "xmrig_unavailable_body": "このプラットフォーム向けのマイナービルドは利用できません。", "xmrig_unavailable_title": "マイナーの更新は利用できません", diff --git a/res/lang/ko.json b/res/lang/ko.json index 05aa546..3970d60 100644 --- a/res/lang/ko.json +++ b/res/lang/ko.json @@ -948,6 +948,9 @@ "mining_syncing_tooltip": "블록체인 동기화 중...", "mining_tag": " · 채굴", "mining_threads": "채굴 스레드", + "mining_threads_input_tooltip": "정확한 스레드 수 입력 (Enter로 적용)", + "mining_threads_minus_tooltip": "스레드 줄이기", + "mining_threads_plus_tooltip": "스레드 늘리기", "mining_to_save": "저장하려면", "mining_today": "오늘", "mining_uptime": "가동 시간", @@ -1784,6 +1787,7 @@ "xmrig_loading_releases": "릴리스를 불러오는 중…", "xmrig_none": "없음", "xmrig_reinstall": "재설치", + "xmrig_releases": "xmrig 릴리스", "xmrig_stop_mining_first": "채굴기를 업데이트하기 전에 채굴을 중지하세요.", "xmrig_unavailable_body": "이 플랫폼에서 사용 가능한 채굴기 빌드가 없습니다.", "xmrig_unavailable_title": "채굴기 업데이트를 사용할 수 없습니다", diff --git a/res/lang/pt.json b/res/lang/pt.json index 07bceae..1df6a8a 100644 --- a/res/lang/pt.json +++ b/res/lang/pt.json @@ -949,6 +949,9 @@ "mining_syncing_tooltip": "Blockchain está sincronizando...", "mining_tag": " · Mineração", "mining_threads": "Threads de Mineração", + "mining_threads_input_tooltip": "Digite um número exato de threads (Enter para aplicar)", + "mining_threads_minus_tooltip": "Menos threads", + "mining_threads_plus_tooltip": "Mais threads", "mining_to_save": "para salvar", "mining_today": "Hoje", "mining_uptime": "Tempo Ativo", @@ -1785,6 +1788,7 @@ "xmrig_loading_releases": "Carregando versões…", "xmrig_none": "nenhum", "xmrig_reinstall": "Reinstalar", + "xmrig_releases": "versões do xmrig", "xmrig_stop_mining_first": "Pare a mineração antes de atualizar o minerador.", "xmrig_unavailable_body": "Nenhuma versão do minerador está disponível para esta plataforma.", "xmrig_unavailable_title": "Atualizações do minerador indisponíveis", diff --git a/res/lang/ru.json b/res/lang/ru.json index b6842d2..195bd2d 100644 --- a/res/lang/ru.json +++ b/res/lang/ru.json @@ -949,6 +949,9 @@ "mining_syncing_tooltip": "Блокчейн синхронизируется...", "mining_tag": " · Майнинг", "mining_threads": "Потоки майнинга", + "mining_threads_input_tooltip": "Введите точное число потоков (Enter для применения)", + "mining_threads_minus_tooltip": "Меньше потоков", + "mining_threads_plus_tooltip": "Больше потоков", "mining_to_save": "для сохранения", "mining_today": "Сегодня", "mining_uptime": "Время работы", @@ -1785,6 +1788,7 @@ "xmrig_loading_releases": "Загрузка релизов…", "xmrig_none": "нет", "xmrig_reinstall": "Переустановить", + "xmrig_releases": "релизы xmrig", "xmrig_stop_mining_first": "Остановите майнинг перед обновлением майнера.", "xmrig_unavailable_body": "Для этой платформы нет доступной сборки майнера.", "xmrig_unavailable_title": "Обновления майнера недоступны", diff --git a/res/lang/zh.json b/res/lang/zh.json index 7c51509..21c4629 100644 --- a/res/lang/zh.json +++ b/res/lang/zh.json @@ -948,6 +948,9 @@ "mining_syncing_tooltip": "区块链同步中...", "mining_tag": " · 挖矿", "mining_threads": "挖矿线程", + "mining_threads_input_tooltip": "输入精确的线程数（按 Enter 应用）", + "mining_threads_minus_tooltip": "减少线程", + "mining_threads_plus_tooltip": "增加线程", "mining_to_save": "保存", "mining_today": "今天", "mining_uptime": "运行时间", @@ -1783,6 +1786,7 @@ "xmrig_loading_releases": "正在加载发行版…", "xmrig_none": "无", "xmrig_reinstall": "重新安装", + "xmrig_releases": "xmrig 版本", "xmrig_stop_mining_first": "更新矿工程序前请先停止挖矿。", "xmrig_unavailable_body": "此平台没有可用的矿工构建版本。", "xmrig_unavailable_title": "矿工更新不可用", diff --git a/src/ui/windows/mining_controls.cpp b/src/ui/windows/mining_controls.cpp index 8e25f47..a06aeeb 100644 --- a/src/ui/windows/mining_controls.cpp +++ b/src/ui/windows/mining_controls.cpp @@ -28,6 +28,7 @@ #include #include #include +#include // std::atoi (xmrig version compare) namespace dragonx { namespace ui { @@ -56,6 +57,25 @@ void RenderMiningControls(App* app, const WalletState& state, const MiningInfo& float miningBtnGap = gap; float miningBtnMaxW = availWidth * schema::UI().drawElement("tabs.mining", "btn-max-width-ratio").size; + // Thread-count tiles at an adaptive step (multiples of 1/2/4/8, chosen by core count) plus 1 and the + // max, so the tile row stays bounded (~<=24 tiles) instead of one tile per thread — a 192-thread + // EPYC would otherwise overflow the card. Exact in-between counts are settable via the input box. + int tileStep = 1; + if (max_threads > 96) tileStep = 8; + else if (max_threads > 48) tileStep = 4; + else if (max_threads > 24) tileStep = 2; + std::vector threadOptions; + threadOptions.push_back(1); + for (int v = tileStep; v < max_threads; v += tileStep) + if (v > 1) threadOptions.push_back(v); + if (max_threads > 1 && threadOptions.back() != max_threads) threadOptions.push_back(max_threads); + const int nOpts = (int)threadOptions.size(); + + // Custom drawlist hit-tests (the thread tiles + the Mine button) bypass ImGui's popup input capture, + // so a click on an open dropdown (saved pools / payout addresses) would ALSO fire them. Gate on this + // so clicking the dropdown's X (or a row) doesn't bleed through to the tiles/Mine button. + const bool anyPopupOpen = ImGui::IsPopupOpen("", ImGuiPopupFlags_AnyPopupId | ImGuiPopupFlags_AnyPopupLevel); + // --- Compute thread grid layout based on controls card width --- // Estimate controlsW first to compute cols correctly // The Mine button is square (= card height, which scales with DPI), so the width we @@ -65,8 +85,8 @@ void RenderMiningControls(App* app, const WalletState& state, const MiningInfo& float innerW = estControlsW - pad * 2; float cellSz = std::clamp(schema::UI().drawElement("tabs.mining", "cell-size").size * vs, schema::UI().drawElement("tabs.mining", "cell-min-size").size, schema::UI().drawElement("tabs.mining", "cell-max-size").sizeOr(42.0f)); float cellGap = std::max(schema::UI().drawElement("tabs.mining", "cell-gap-min").size, cellSz * schema::UI().drawElement("tabs.mining", "cell-gap-ratio").size); - int cols = std::max(1, std::min(max_threads, (int)(innerW / (cellSz + cellGap)))); - int rows = (max_threads + cols - 1) / cols; + int cols = std::max(1, std::min(nOpts, (int)(innerW / (cellSz + cellGap)))); + int rows = (nOpts + cols - 1) / cols; float gridW = cols * cellSz + (cols - 1) * cellGap; float gridH = rows * cellSz + (rows - 1) * cellGap; @@ -116,6 +136,67 @@ void RenderMiningControls(App* app, const WalletState& state, const MiningInfo& OnSurfaceDisabled(), buf); } + // Centered, top-aligned thread-count stepper: [-] centered editable number [+]. Lets a + // high-core CPU pick an EXACT count that isn't one of the tiles. The input commits on Enter + // (not per keystroke) so it doesn't restart the miner while the user is still typing. + { + auto applyThreads = [&](int tc) { + tc = std::clamp(tc, 1, max_threads); + if (tc == s_selected_threads) return; + s_selected_threads = tc; + app->settings()->setPoolThreads(tc); + app->settings()->save(); + if (mining.generate) app->startMining(tc); + if (s_pool_mode && state.pool_mining.xmrig_running) { + app->stopPoolMining(); + app->startPoolMining(tc); + } + }; + ImFont* stepFont = Type().iconSmall(); + const float fieldH = capFont->LegacySize + 6.0f * dp; + const float sideW = fieldH; // square -/+ buttons + const float fieldW = 46.0f * dp; + const float g = 2.0f * dp; + const float totalW = sideW + g + fieldW + g + sideW; + float sx = cardMin.x + (controlsW - totalW) * 0.5f; + const float sy = curY; + ImVec2 savedCur = ImGui::GetCursorScreenPos(); + + material::IconButtonStyle sideStyle; + sideStyle.color = OnSurfaceMedium(); + sideStyle.hoverBg = StateHover(); + + // "-" button + sideStyle.tooltip = TR("mining_threads_minus_tooltip"); + ImGui::SetCursorScreenPos(ImVec2(sx, sy)); + if (material::IconButton("##ThreadMinus", ICON_MD_REMOVE, stepFont, ImVec2(sideW, fieldH), sideStyle)) + applyThreads(s_selected_threads - 1); + sx += sideW + g; + + // Centered editable number: symmetric FramePadding pushes the digits to the field centre. + char tb[8]; snprintf(tb, sizeof(tb), "%d", s_selected_threads); + float basePad = ImGui::GetStyle().FramePadding.x; + float txtW = ImGui::CalcTextSize(tb).x; + float centerPad = std::max(basePad, (fieldW - txtW) * 0.5f); + ImGui::PushStyleVar(ImGuiStyleVar_FramePadding, ImVec2(centerPad, ImGui::GetStyle().FramePadding.y)); + ImGui::SetCursorScreenPos(ImVec2(sx, sy)); + ImGui::SetNextItemWidth(fieldW); + int tc = s_selected_threads; + if (ImGui::InputInt("##ThreadCountInput", &tc, 0, 0, ImGuiInputTextFlags_EnterReturnsTrue)) + applyThreads(tc); + if (ImGui::IsItemHovered()) material::Tooltip("%s", TR("mining_threads_input_tooltip")); + ImGui::PopStyleVar(); + sx += fieldW + g; + + // "+" button + sideStyle.tooltip = TR("mining_threads_plus_tooltip"); + ImGui::SetCursorScreenPos(ImVec2(sx, sy)); + if (material::IconButton("##ThreadPlus", ICON_MD_ADD, stepFont, ImVec2(sideW, fieldH), sideStyle)) + applyThreads(s_selected_threads + 1); + + ImGui::SetCursorScreenPos(savedCur); + } + // Idle mining toggle (top-right corner of card) float idleRightEdge = cardMax.x - pad; { @@ -475,8 +556,39 @@ void RenderMiningControls(App* app, const WalletState& state, const MiningInfo& std::string curVer = s_live_miner_ver; if (curVer.empty()) curVer = app->poolMiningInstalledVersion(); if (curVer.empty()) curVer = app->settings()->getXmrigVersion(); + // Version state: subtle GREEN + "xmrig releases" when up to date, subtle ORANGE + + // "Update " when an update is available, neutral when either version is unknown. + auto verNum = [](std::string s) -> std::vector { + if (!s.empty() && (s[0] == 'v' || s[0] == 'V')) s.erase(0, 1); + s = s.substr(0, s.find('-')); // drop any -build suffix + std::vector v; size_t p = 0; + while (p <= s.size()) { + size_t q = s.find('.', p); + v.push_back(std::atoi(s.substr(p, q == std::string::npos ? std::string::npos : q - p).c_str())); + if (q == std::string::npos) break; + p = q + 1; + } + return v; + }; + const bool verKnown = !curVer.empty() && !s_xmrig_latest_tag.empty(); + bool upToDate = false; + if (verKnown) { + auto a = verNum(curVer), b = verNum(s_xmrig_latest_tag); + int cmp = 0; + for (size_t i = 0; i < std::max(a.size(), b.size()) && cmp == 0; ++i) { + int x = i < a.size() ? a[i] : 0, y = i < b.size() ? b[i] : 0; + if (x != y) cmp = x < y ? -1 : 1; + } + upToDate = (cmp >= 0); // installed >= latest + } + const bool outdated = verKnown && !upToDate; + const ImU32 subtleGreen = IM_COL32(120, 190, 130, 255); + const ImU32 subtleOrange = IM_COL32(214, 158, 74, 255); + char xbtn[64]; - if (!s_xmrig_latest_tag.empty()) + if (upToDate) + snprintf(xbtn, sizeof(xbtn), "%s", TR("xmrig_releases")); + else if (!s_xmrig_latest_tag.empty()) snprintf(xbtn, sizeof(xbtn), "%s %s", TR("xmrig_update_short"), s_xmrig_latest_tag.c_str()); else snprintf(xbtn, sizeof(xbtn), "%s", TR("xmrig_update_button")); @@ -499,7 +611,9 @@ void RenderMiningControls(App* app, const WalletState& state, const MiningInfo& xpill, xbtnH * 0.3f); dl->AddText(capFont, capFont->LegacySize, ImVec2(xbtnX + xpadX, xbtnY + (xbtnH - xlblSz.y) * 0.5f), - minerBusy ? OnSurfaceDisabled() : OnSurfaceMedium(), xbtn); + minerBusy ? OnSurfaceDisabled() + : (upToDate ? subtleGreen : outdated ? subtleOrange : OnSurfaceMedium()), + xbtn); if (xhov) { ImGui::SetMouseCursor(ImGuiMouseCursor_Hand); material::Tooltip("%s", minerBusy ? TR("xmrig_stop_mining_first") @@ -515,7 +629,7 @@ void RenderMiningControls(App* app, const WalletState& state, const MiningInfo& float xcurX = xbtnX - 6.0f * dp - xcurSz.x; dl->AddText(capFont, capFont->LegacySize, ImVec2(xcurX, curY + (headerH - xcurSz.y) * 0.5f), - OnSurfaceDisabled(), xcur); + upToDate ? subtleGreen : outdated ? subtleOrange : OnSurfaceDisabled(), xcur); idleRightEdge = xcurX - 8.0f * dp; } @@ -548,14 +662,14 @@ void RenderMiningControls(App* app, const WalletState& state, const MiningInfo& // Track which thread the mouse is currently over (-1 = none) int hovered_thread = -1; - // First pass: hit-test all cells to find hovered thread - for (int i = 0; i < max_threads; i++) { + // First pass: hit-test all cells to find the hovered thread-count option (its value, not index) + for (int i = 0; i < nOpts; i++) { int row = i / cols; int col = i % cols; float cx = gridX + col * (cellSz + cellGap); float cy = gridY + row * (cellSz + cellGap); if (material::IsRectHovered(ImVec2(cx, cy), ImVec2(cx + cellSz, cy + cellSz))) { - hovered_thread = i + 1; + hovered_thread = threadOptions[i]; break; } } @@ -566,8 +680,8 @@ void RenderMiningControls(App* app, const WalletState& state, const MiningInfo& if (hovered_thread > 0 && !benchActive) ImGui::SetMouseCursor(ImGuiMouseCursor_Hand); - // Drag-to-select logic (disabled during benchmark) - if (!benchActive && ImGui::IsMouseClicked(0) && hovered_thread > 0) { + // Drag-to-select logic (disabled during benchmark; ignored while a dropdown popup is open) + if (!benchActive && !anyPopupOpen && ImGui::IsMouseClicked(0) && hovered_thread > 0) { // Begin drag s_drag_active = true; s_drag_anchor_thread = hovered_thread; @@ -587,8 +701,8 @@ void RenderMiningControls(App* app, const WalletState& state, const MiningInfo& } } - // Render cells - for (int i = 0; i < max_threads; i++) { + // Render cells (one per discrete thread-count option) + for (int i = 0; i < nOpts; i++) { int row = i / cols; int col = i % cols; float cx = gridX + col * (cellSz + cellGap); @@ -596,8 +710,8 @@ void RenderMiningControls(App* app, const WalletState& state, const MiningInfo& ImVec2 cMin(cx, cy); ImVec2 cMax(cx + cellSz, cy + cellSz); - int threadNum = i + 1; - bool active = threadNum <= s_selected_threads; + int threadNum = threadOptions[i]; + bool active = threadNum <= s_selected_threads; // fill-up-to-selected heat metaphor bool hovered = (threadNum == hovered_thread); // Determine visual state @@ -674,7 +788,7 @@ void RenderMiningControls(App* app, const WalletState& state, const MiningInfo& ImVec2 bMin(btnX, btnY); ImVec2 bMax(btnX + miningBtnSz, btnY + cardH); - bool btnHovered = material::IsRectHovered(bMin, bMax); + bool btnHovered = !anyPopupOpen && material::IsRectHovered(bMin, bMax); // don't bleed through an open dropdown bool btnClicked = btnHovered && ImGui::IsMouseClicked(0); bool isSyncing = state.sync.syncing; bool poolBlockedBySolo = s_pool_mode && mining.generate && !state.pool_mining.xmrig_running; diff --git a/src/util/i18n.cpp b/src/util/i18n.cpp index d591196..9a126f4 100644 --- a/src/util/i18n.cpp +++ b/src/util/i18n.cpp @@ -1296,6 +1296,9 @@ void I18n::loadBuiltinEnglish() strings_["start_mining"] = "Start Mining"; strings_["stop_mining"] = "Stop Mining"; strings_["mining_threads"] = "Mining Threads"; + strings_["mining_threads_input_tooltip"] = "Type an exact thread count (press Enter to apply)"; + strings_["mining_threads_minus_tooltip"] = "Fewer threads"; + strings_["mining_threads_plus_tooltip"] = "More threads"; strings_["mining_statistics"] = "Mining Statistics"; strings_["local_hashrate"] = "Local Hashrate"; strings_["network_hashrate"] = "Network Hashrate"; @@ -1933,6 +1936,7 @@ void I18n::loadBuiltinEnglish() // --- Miner (xmrig) updater --- strings_["xmrig_update_button"] = "Update miner…"; strings_["xmrig_update_short"] = "Update"; + strings_["xmrig_releases"] = "xmrig releases"; strings_["xmrig_current"] = "Current:"; strings_["xmrig_none"] = "none"; strings_["xmrig_update_title"] = "Update Miner"; From e24ca015d15d794d7cf917e3f91e0d39ab7d2c4d Mon Sep 17 00:00:00 2001 From: DanS Date: Tue, 18 Aug 2026 17:54:15 -0500 Subject: [PATCH 52/89] =?UTF-8?q?feat(ui):=20implement=20UI/UX=20audit=20?= =?UTF-8?q?=E2=80=94=20i18n,=20HiDPI,=20theme,=20destructive-action=20&=20?= =?UTF-8?q?overflow=20fixes?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Implements all 26 confirmed UI/UX audit findings plus the 4 dashboard/timeline tile labels. Verified across full-node + Lite + Windows builds (ctest green) and an adversarial diff review (one market-tab delete regression caught + fixed). i18n coverage: - Balance hero/quick-actions/toasts + dashboard & timeline tiles (Total Balance, Shielded, Transparent, Quick Send, Quick Receive, Click to open, Market) - Send: Review Send / Cancel / Paste / view-only tooltip / memo byte counter - Settings: Lite lifecycle errors, plaintext-RPC security warning, 8 toasts - Mining pool-payout tooltip - Resolve daemon_update_title double-assignment collision (new daemon_update_prompt_title) - 23 new keys translated into all 8 locales; CJK subset font rebuilt HiDPI: DPI-scale the Send amount bar, mining thread-tile clamp bounds, receive loading skeleton, and sidebar notification-badge insets. Light theme: theme-aware material::SurfaceOverlay() for balance bar tracks and row-hover highlights; contacts active-pill foreground uses OnPrimary(). Destructive actions: arm/confirm for portfolio-group delete, saved pool/worker remove, and avatar-image delete. Interaction/overflow: route balance star/eye buttons and the console fold-toggle through popup-safe guards; clip peer addr/subver; truncate the balance custom label; measure Settings tool-button widths; mining stepper disabled-state feedback; +/- stepper buttons restyled to match the thread tiles. Co-Authored-By: Claude Opus 4.8 (1M context) --- res/fonts/NotoSansCJK-Subset.ttf | Bin 671092 -> 671376 bytes res/lang/de.json | 24 ++++++ res/lang/es.json | 24 ++++++ res/lang/fr.json | 24 ++++++ res/lang/ja.json | 24 ++++++ res/lang/ko.json | 24 ++++++ res/lang/pt.json | 24 ++++++ res/lang/ru.json | 24 ++++++ res/lang/zh.json | 24 ++++++ src/app.cpp | 2 +- src/ui/material/colors.h | 20 +++++ src/ui/pages/settings_page.cpp | 55 +++++++++---- src/ui/sidebar.h | 6 +- src/ui/windows/balance_components.cpp | 30 ++++++-- src/ui/windows/balance_tab.cpp | 106 ++++++++++++++++++-------- src/ui/windows/console_tab.cpp | 3 + src/ui/windows/contacts_tab.cpp | 24 ++++-- src/ui/windows/market_tab.cpp | 31 +++++++- src/ui/windows/mining_controls.cpp | 56 +++++++++----- src/ui/windows/mining_mode_toggle.cpp | 96 +++++++++++++++-------- src/ui/windows/peers_tab.cpp | 63 +++++++++++---- src/ui/windows/receive_tab.cpp | 20 +++-- src/ui/windows/send_tab.cpp | 18 +++-- src/util/i18n.cpp | 25 +++++- 24 files changed, 599 insertions(+), 148 deletions(-) diff --git a/res/fonts/NotoSansCJK-Subset.ttf b/res/fonts/NotoSansCJK-Subset.ttf index 955157817d2cad9dfb6c0a8c38449b4cf8afbd6d..2bb3213d7758faa87984afefe439eeadac89efdc 100644 GIT binary patch delta 12360 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 delta 12268 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 IM_COL32_R_SHIFT) & 0xFF) / 255.0f; + float g = ((bg >> IM_COL32_G_SHIFT) & 0xFF) / 255.0f; + float b = ((bg >> IM_COL32_B_SHIFT) & 0xFF) / 255.0f; + bool light = (0.299f * r + 0.587f * g + 0.114f * b) > 0.5f; + return light ? IM_COL32(0, 0, 0, alpha) : IM_COL32(255, 255, 255, alpha); +} + /** * @brief Get color with applied state overlay * diff --git a/src/ui/pages/settings_page.cpp b/src/ui/pages/settings_page.cpp index 237c89d..21b65c8 100644 --- a/src/ui/pages/settings_page.cpp +++ b/src/ui/pages/settings_page.cpp @@ -309,7 +309,7 @@ static void evaluateLiteLifecycleRequestFromPageState(App* app) { std::string trimmedPath(s_settingsState.lite_wallet_path); const auto first = trimmedPath.find_first_not_of(" \t\r\n"); if (first == std::string::npos) { - s_settingsState.lite_lifecycle_status = "Enter a wallet path"; + s_settingsState.lite_lifecycle_status = TR("lite_enter_wallet_path"); s_settingsState.lite_lifecycle_summary.clear(); return; } @@ -320,8 +320,9 @@ static void evaluateLiteLifecycleRequestFromPageState(App* app) { if (input.request.operation == wallet::LiteWalletLifecycleOperation::RestoreFromSeed) { const int words = liteSeedWordCount(s_settingsState.lite_restore_seed); if (!dragonx::util::isCompleteRecoveryPhrase(words)) { - s_settingsState.lite_lifecycle_status = - "Enter all 24 seed words to restore (got " + std::to_string(words) + ")"; + char seedBuf[128]; + snprintf(seedBuf, sizeof(seedBuf), TR("lite_enter_all_seed_words"), words); + s_settingsState.lite_lifecycle_status = seedBuf; s_settingsState.lite_lifecycle_summary.clear(); return; } @@ -353,7 +354,7 @@ static void evaluateLiteLifecycleRequestFromPageState(App* app) { // Rejected before any thread launched (wallet already open, an attempt in flight, or no // usable server). The controller's status carries the reason. s_settingsState.lite_lifecycle_status = lite->status().message.empty() - ? "Could not start the operation" + ? TR("lite_could_not_start") : lite->status().message; Notifications::instance().warning(s_settingsState.lite_lifecycle_status); } @@ -364,7 +365,7 @@ static void evaluateLiteLifecycleRequestFromPageState(App* app) { // failed to load / rollout-disabled). The live path above returns when a backend is // present, so reaching here means there is nothing to run. s_settingsState.lite_lifecycle_summary.clear(); - s_settingsState.lite_lifecycle_status = "Lite wallet backend unavailable"; + s_settingsState.lite_lifecycle_status = TR("lite_backend_unavailable"); Notifications::instance().warning(s_settingsState.lite_lifecycle_status); } @@ -819,7 +820,7 @@ void RenderSettingsPage(App* app) { ImGui::SameLine(0, Layout::spacingSm()); if (TactileButton(TR("refresh"), ImVec2(refreshBtnW, 0), S.resolveFont("button"))) { schema::SkinManager::instance().refresh(); - Notifications::instance().info("Theme list refreshed"); + Notifications::instance().info(TR("settings_theme_refreshed")); } if (ImGui::IsItemHovered()) { material::Tooltip(TR("tt_scan_themes"), @@ -1064,7 +1065,7 @@ void RenderSettingsPage(App* app) { ImGui::SameLine(); if (TactileButton(TR("refresh"), ImVec2(refreshBtnW, 0), S.resolveFont("button"))) { schema::SkinManager::instance().refresh(); - Notifications::instance().info("Theme list refreshed"); + Notifications::instance().info(TR("settings_theme_refreshed")); } if (ImGui::IsItemHovered()) { material::Tooltip(TR("tt_scan_themes"), @@ -1386,6 +1387,30 @@ void RenderSettingsPage(App* app) { float bw = (contentW - btnSpacing * (btnsPerRow - 1)) / btnsPerRow; float minBtnW = S.drawElement("components.settings-page", "wallet-btn-min-width").sizeOr(100.0f); bw = std::max(minBtnW, bw); + // Grow the column so the longest translated label (e.g. German) isn't clipped inside + // ImGui::Button. Measure every label with the actual button font (LegacySize is already + // DPI-scaled — don't scale it again) and add the button's own FramePadding on both sides; + // if that exceeds bw, drop to fewer columns rather than overflow the card width. + { + ImFont* toolsFont = S.resolveFont("button"); + if (!toolsFont) toolsFont = Type().button(); + const char* toolLabels[] = { + TR("settings_address_book"), TR("settings_validate_address"), + TR("settings_request_payment"), TR("settings_shield_mining"), + TR("settings_merge_to_address"), TR("settings_clear_ztx"), + }; + float widestLabel = 0.0f; + for (const char* lbl : toolLabels) + widestLabel = std::max(widestLabel, + toolsFont->CalcTextSizeA(toolsFont->LegacySize, FLT_MAX, 0, lbl).x); + const float needW = widestLabel + ImGui::GetStyle().FramePadding.x * 2.0f + + 8.0f * Layout::dpiScale(); + // Shed columns until the widest label fits (or we're down to a single column). + while (btnsPerRow > 1 && + ((contentW - btnSpacing * (btnsPerRow - 1)) / btnsPerRow) < needW) + --btnsPerRow; + bw = std::max({minBtnW, (contentW - btnSpacing * (btnsPerRow - 1)) / btnsPerRow, needW}); + } if (TactileButton(TR("settings_address_book"), ImVec2(bw, 0), S.resolveFont("button"))) app->setCurrentPage(ui::NavPage::Contacts); // now a top-level tab @@ -2225,7 +2250,7 @@ void RenderSettingsPage(App* app) { if (s_settingsState.rpc_plaintext_remote) { ImGui::PushStyleColor(ImGuiCol_Text, ImGui::ColorConvertU32ToFloat4(Warning())); ImGui::PushTextWrapPos(sectionOrigin.x + contentW); - ImGui::TextWrapped("Remote RPC is using plaintext HTTP. Add rpctls=1 to DRAGONX.conf if your daemon supports TLS."); + ImGui::TextWrapped("%s", TR("rpc_plaintext_remote_warning")); ImGui::PopTextWrapPos(); ImGui::PopStyleColor(); } @@ -2367,14 +2392,14 @@ void RenderSettingsPage(App* app) { try { rpc::RPCClient::TraceScope trace("Settings / Test connection"); rpc->call("getinfo"); - return []() { Notifications::instance().success("RPC connection OK"); }; + return []() { Notifications::instance().success(TR("settings_rpc_ok")); }; } catch (const std::exception& e) { std::string err = e.what(); - return [err]() { Notifications::instance().error("RPC error: " + err); }; + return [err]() { Notifications::instance().error(std::string(TR("settings_rpc_error_prefix")) + err); }; } }); } else { - Notifications::instance().warning("Not connected to daemon"); + Notifications::instance().warning(TR("settings_not_connected")); } } if (ImGui::IsItemHovered(ImGuiHoveredFlags_AllowWhenDisabled)) material::Tooltip("%s", TR("tt_test_conn")); @@ -2587,14 +2612,14 @@ void RenderSettingsPage(App* app) { if (aboutGrid) ImGui::Dummy(ImVec2(0, Layout::spacingXs())); else ImGui::SameLine(0, Layout::spacingMd()); if (TactileButton(TrId("save_settings", "about_save").c_str(), ImVec2(aboutBtnW, 0), S.resolveFont("button"))) { saveSettingsPageState(app->settings()); - Notifications::instance().success("Settings saved"); + Notifications::instance().success(TR("settings_saved")); } if (ImGui::IsItemHovered()) material::Tooltip("%s", TR("tt_save_settings")); ImGui::SameLine(0, Layout::spacingMd()); if (TactileButton(TrId("reset_to_defaults", "about_reset").c_str(), ImVec2(aboutBtnW, 0), S.resolveFont("button"))) { if (app->settings()) { loadSettingsPageState(app->settings()); - Notifications::instance().info("Settings reloaded from disk"); + Notifications::instance().info(TR("settings_reloaded")); } } if (ImGui::IsItemHovered()) material::Tooltip("%s", TR("tt_reset_settings")); @@ -2913,9 +2938,9 @@ void RenderSettingsPage(App* app) { if (doConfirm) { std::string ztx_file = util::Platform::getDragonXDataDir() + "ztx_history.json"; if (util::Platform::deleteFile(ztx_file)) { - Notifications::instance().success("Z-transaction history cleared"); + Notifications::instance().success(TR("settings_ztx_cleared")); } else { - Notifications::instance().info("No history file found"); + Notifications::instance().info(TR("settings_ztx_not_found")); } s_settingsState.confirm_clear_ztx = false; } diff --git a/src/ui/sidebar.h b/src/ui/sidebar.h index 14a56d4..e07ada9 100644 --- a/src/ui/sidebar.h +++ b/src/ui/sidebar.h @@ -722,8 +722,10 @@ inline bool RenderSidebar(NavPage& current, float sidebarWidth, float contentHei if (badgeCount > 0 || dotOnly) { float badgeR = dotOnly ? badgeRadiusDot : badgeRadiusNumber; - float bx = indMax.x - badgeR - 6.0f; - float by = indMin.y + badgeR + 5.0f; + float badgeInsetX = sde("badge-inset-x", 6.0f); + float badgeInsetY = sde("badge-inset-y", 5.0f); + float bx = indMax.x - badgeR - badgeInsetX; + float by = indMin.y + badgeR + badgeInsetY; dl->AddCircleFilled(ImVec2(bx, by), badgeR, badgeCol); if (!dotOnly && showLabels) { char buf[16]; diff --git a/src/ui/windows/balance_components.cpp b/src/ui/windows/balance_components.cpp index 2a836bf..4ef26d8 100644 --- a/src/ui/windows/balance_components.cpp +++ b/src/ui/windows/balance_components.cpp @@ -466,7 +466,8 @@ void RenderSharedAddressList(App* app, float listH, float availW, { const auto& starRect = rowLayout.favoriteButton; ImVec2 bMin(starRect.x, starRect.y), bMax(starRect.x + starRect.width, starRect.y + starRect.height); - bool bHov = ImGui::IsMouseHoveringRect(bMin, bMax); + // material::IsRectHovered so the button inherits overlay/popup input blocking + bool bHov = material::IsRectHovered(bMin, bMax); dl->AddRectFilled(bMin, bMax, row.favorite ? favGoldFill : (bHov ? btnFillHov : btnFill), btnRound); dl->AddRect(bMin, bMax, row.favorite ? favGoldBorder : (bHov ? btnBorderHov : btnBorder), btnRound, 0, 1.0f * dp); ImFont* iconFont = Type().iconSmall(); @@ -492,7 +493,8 @@ void RenderSharedAddressList(App* app, float listH, float availW, if (showEye) { const auto& eyeRect = rowLayout.visibilityButton; ImVec2 bMin(eyeRect.x, eyeRect.y), bMax(eyeRect.x + eyeRect.width, eyeRect.y + eyeRect.height); - bool bHov = ImGui::IsMouseHoveringRect(bMin, bMax); + // material::IsRectHovered so the button inherits overlay/popup input blocking + bool bHov = material::IsRectHovered(bMin, bMax); dl->AddRectFilled(bMin, bMax, bHov ? btnFillHov : btnFill, btnRound); dl->AddRect(bMin, bMax, bHov ? btnBorderHov : btnBorder, btnRound, 0, 1.0f * dp); ImFont* iconFont = Type().iconSmall(); @@ -539,12 +541,24 @@ void RenderSharedAddressList(App* app, float listH, float availW, snprintf(typeBuf, sizeof(typeBuf), "%s%s%s", typeLabel, hiddenTag, miningTag); dl->AddText(capFont, capFont->LegacySize, ImVec2(labelX, cy), typeCol, typeBuf); - // User label next to type + // User label next to type — clip to the gap before the right-aligned + // balance so a long custom label can't overrun the balance on this line + // (mirrors the address-line width guard below). if (!row.label.empty()) { float typeLabelW = capFont->CalcTextSizeA(capFont->LegacySize, FLT_MAX, 0, typeBuf).x; - dl->AddText(capFont, capFont->LegacySize, - ImVec2(labelX + typeLabelW + Layout::spacingLg(), cy), - OnSurfaceMedium(), row.label.c_str()); + float userLabelX = labelX + typeLabelW + Layout::spacingLg(); + // Balance is drawn right-aligned at contentRight; recompute its left edge here. + char balBufPeek[32]; + snprintf(balBufPeek, sizeof(balBufPeek), "%.8f", addr.balance); + float balW = body2->CalcTextSizeA(body2->LegacySize, FLT_MAX, 0, balBufPeek).x; + float userLabelAvailW = (contentRight - balW - Layout::spacingMd()) - userLabelX; + std::string userLabel = material::TruncateToWidth( + row.label, capFont, capFont->LegacySize, userLabelAvailW); + if (userLabelAvailW > 0.0f) { + dl->AddText(capFont, capFont->LegacySize, + ImVec2(userLabelX, cy), + OnSurfaceMedium(), userLabel.c_str()); + } } } @@ -841,7 +855,7 @@ void RenderSharedRecentTx(App* app, float recentH, float availW, float hs, float float rowW = ImGui::GetContentRegionAvail().x; ImVec2 rowEnd(rowPos.x + rowW, rowPos.y + rowH); if (material::IsRectHovered(rowPos, rowEnd)) { - dl->AddRectFilled(rowPos, rowEnd, IM_COL32(255, 255, 255, 15), S.drawElement("tabs.balance", "row-hover-rounding").sizeOr(4.0f)); + dl->AddRectFilled(rowPos, rowEnd, SurfaceOverlay(15), S.drawElement("tabs.balance", "row-hover-rounding").sizeOr(4.0f)); ImGui::SetMouseCursor(ImGuiMouseCursor_Hand); if (ImGui::IsMouseClicked(0)) app->setCurrentPage(NavPage::History); @@ -868,7 +882,7 @@ void RenderSyncBar(App* app, ImDrawList* dl, float vs) { ImVec2 barPos = ImGui::GetCursorScreenPos(); dl->AddRectFilled(barPos, ImVec2(barPos.x + barW, barPos.y + barH), - IM_COL32(255, 255, 255, 15), 1.0f * dp); + SurfaceOverlay(15), 1.0f * dp); dl->AddRectFilled(barPos, ImVec2(barPos.x + barW * prog, barPos.y + barH), WithAlpha(Warning(), 200), 1.0f * dp); diff --git a/src/ui/windows/balance_tab.cpp b/src/ui/windows/balance_tab.cpp index 1e07228..3bfde21 100644 --- a/src/ui/windows/balance_tab.cpp +++ b/src/ui/windows/balance_tab.cpp @@ -31,6 +31,7 @@ #include "imgui.h" #include #include +#include #include #include #include @@ -196,7 +197,9 @@ void RenderBalanceTab(App* app) for (const auto& l : allLayouts) { if (l.id == layoutId) { displayName = l.name; break; } } - Notifications::instance().info("Layout: " + displayName); + char layoutToast[128]; + snprintf(layoutToast, sizeof(layoutToast), TR("balance_layout_switched"), displayName.c_str()); + Notifications::instance().info(layoutToast); } } } @@ -359,8 +362,11 @@ static void RenderBalanceClassic(App* app) IM_COL32(255, 255, 255, (int)S.drawElement("tabs.balance.classic", "logo-opacity").sizeOr(180.0f))); } + std::string totalLabelUpper = TR("total_balance_label"); + std::transform(totalLabelUpper.begin(), totalLabelUpper.end(), totalLabelUpper.begin(), + [](unsigned char c){ return (char)std::toupper(c); }); dl->AddText(ovFont, ovFont->LegacySize, ImVec2(cx, cy), - OnSurfaceMedium(), "TOTAL BALANCE"); + OnSurfaceMedium(), totalLabelUpper.c_str()); cy += ovFont->LegacySize + ovGap; snprintf(buf, sizeof(buf), "%.8f", s_dispTotal); @@ -387,7 +393,7 @@ static void RenderBalanceClassic(App* app) // Sync progress or mining indicator (whichever fits) if (state.sync.syncing && state.sync.headers > 0) { float pct = static_cast(state.sync.verification_progress) * 100.0f; - snprintf(buf, sizeof(buf), "Syncing %.1f%%", pct); + snprintf(buf, sizeof(buf), TR("balance_syncing_pct"), pct); dl->AddText(capFont, capFont->LegacySize, ImVec2(cx, cy), Warning(), buf); @@ -401,7 +407,7 @@ static void RenderBalanceClassic(App* app) dl->PushClipRect(ImVec2(cMin.x, barTop), cMax, true); // Background track dl->AddRectFilled(cMin, cMax, - IM_COL32(255, 255, 255, 15), cardSpec.rounding); + SurfaceOverlay(15), cardSpec.rounding); // Progress fill — additional horizontal clip float progRight = cMin.x + (cMax.x - cMin.x) * prog; dl->PushClipRect(ImVec2(cMin.x, barTop), ImVec2(progRight, cMax.y), true); @@ -418,7 +424,11 @@ static void RenderBalanceClassic(App* app) dl->AddCircleFilled(ImVec2(cx + 4 * dp, cy + capFont->LegacySize * 0.5f), S.drawElement("tabs.balance.classic", "mining-dot-radius").sizeOr(3.0f), mineCol); double hr = state.mining.localHashrate; - snprintf(buf, sizeof(buf), " Mining %s", FormatHashrate(hr).c_str()); + // Leading indent clears the mining dot drawn at cx+4dp; the text + // itself starts at cx+12dp so keep the two spaces for spacing parity. + char mineFmt[64]; + snprintf(mineFmt, sizeof(mineFmt), " %s", TR("balance_mining_rate")); + snprintf(buf, sizeof(buf), mineFmt, FormatHashrate(hr).c_str()); dl->AddText(capFont, capFont->LegacySize, ImVec2(cx + 12 * dp, cy), WithAlpha(Success(), 200), buf); @@ -574,15 +584,18 @@ static void RenderBalanceClassic(App* app) ImVec2 usdSz = capFont->CalcTextSizeA(capFont->LegacySize, 10000, 0, "USD"); // Measure widest text line to determine sparkline left edge + std::string marketLabel = TR("market"); + std::transform(marketLabel.begin(), marketLabel.end(), marketLabel.begin(), + [](unsigned char c){ return (char)std::toupper(c); }); float textW = std::max(pSz.x + tickGap + usdSz.x, - ovFont->CalcTextSizeA(ovFont->LegacySize, 10000, 0, "MARKET").x); + ovFont->CalcTextSizeA(ovFont->LegacySize, 10000, 0, marketLabel.c_str()).x); float sparkGap = S.drawElement("tabs.balance.classic", "sparkline-gap").sizeOr(12.0f); float sparkLeft = cx + textW + sparkGap; float sparkRight = cMax.x - cardPadLg; // Left side: label + price + 24h change dl->AddText(ovFont, ovFont->LegacySize, ImVec2(cx, cy), - OnSurfaceMedium(), "MARKET"); + OnSurfaceMedium(), marketLabel.c_str()); cy += ovFont->LegacySize + ovGap; dl->AddText(sub1, sub1->LegacySize, ImVec2(cx, cy), @@ -682,7 +695,7 @@ static void RenderBalanceDonut(App* app) { else ImGui::Dummy(ImVec2(0, S.drawElement("tabs.balance.donut", "hero-pad-ratio").sizeOr(8.0f) * vs)); { - Type().textColored(TypeStyle::Overline, OnSurfaceMedium(), "TOTAL BALANCE"); + Type().textColored(TypeStyle::Overline, OnSurfaceMedium(), TR("total_balance_label")); ImGui::Dummy(ImVec2(0, 2 * dp)); snprintf(buf, sizeof(buf), "%.8f", s_dispTotal); ImFont* heroFont = Type().h2(); @@ -947,10 +960,13 @@ static void RenderBalanceConsolidated(App* app) { // Shielded bar float shieldX = cardMin.x + pad; - dl->AddText(ovFont, ovFont->LegacySize, ImVec2(shieldX, barY), Success(), "SHIELDED"); + std::string shieldLabelUpper = TR("shielded"); + std::transform(shieldLabelUpper.begin(), shieldLabelUpper.end(), shieldLabelUpper.begin(), + [](unsigned char c){ return (char)std::toupper(c); }); + dl->AddText(ovFont, ovFont->LegacySize, ImVec2(shieldX, barY), Success(), shieldLabelUpper.c_str()); barY += ovFont->LegacySize + 4 * dp; dl->AddRectFilled(ImVec2(shieldX, barY), ImVec2(shieldX + halfW, barY + barH), - IM_COL32(255, 255, 255, 15), barH * 0.5f); + SurfaceOverlay(15), barH * 0.5f); dl->AddRectFilled(ImVec2(shieldX, barY), ImVec2(shieldX + halfW * shieldRatio, barY + barH), WithAlpha(Success(), 180), barH * 0.5f); barY += barH + 2 * dp; @@ -960,10 +976,13 @@ static void RenderBalanceConsolidated(App* app) { // Transparent bar float transX = cardMin.x + pad * 2 + halfW; barY = divY + Layout::spacingSm(); - dl->AddText(ovFont, ovFont->LegacySize, ImVec2(transX, barY), Warning(), "TRANSPARENT"); + std::string transLabelUpper = TR("transparent"); + std::transform(transLabelUpper.begin(), transLabelUpper.end(), transLabelUpper.begin(), + [](unsigned char c){ return (char)std::toupper(c); }); + dl->AddText(ovFont, ovFont->LegacySize, ImVec2(transX, barY), Warning(), transLabelUpper.c_str()); barY += ovFont->LegacySize + 4 * dp; dl->AddRectFilled(ImVec2(transX, barY), ImVec2(transX + halfW, barY + barH), - IM_COL32(255, 255, 255, 15), barH * 0.5f); + SurfaceOverlay(15), barH * 0.5f); dl->AddRectFilled(ImVec2(transX, barY), ImVec2(transX + halfW * transRatio, barY + barH), WithAlpha(Warning(), 180), barH * 0.5f); barY += barH + 2 * dp; @@ -982,7 +1001,7 @@ static void RenderBalanceConsolidated(App* app) { dl->PushClipRect(ImVec2(cardMin.x, syncBarTop), cardMax, true); // Background track dl->AddRectFilled(cardMin, cardMax, - IM_COL32(255, 255, 255, 15), glassRound); + SurfaceOverlay(15), glassRound); // Progress fill — additional horizontal clip float progRight = cardMin.x + (cardMax.x - cardMin.x) * prog; dl->PushClipRect(ImVec2(cardMin.x, syncBarTop), ImVec2(progRight, cardMax.y), true); @@ -1075,11 +1094,20 @@ static void RenderBalanceDashboard(App* app) { snprintf(shBuf, sizeof(shBuf), "%.8f", s_dispShielded); snprintf(trBuf, sizeof(trBuf), "%.8f", s_dispTransparent); + // Localized captions — raw dl->AddText (no auto-uppercase), so uppercase to preserve the caption look. + auto upperTR = [](const char* key) { + std::string s = TR(key); + std::transform(s.begin(), s.end(), s.begin(), [](unsigned char c){ return (char)std::toupper(c); }); + return s; + }; + std::string lblShielded = upperTR("shielded"), lblTransparent = upperTR("transparent"); + std::string lblQuickSend = upperTR("quick_send"), lblQuickReceive = upperTR("quick_receive"); + TileInfo tiles[4] = { - {"SHIELDED", shBuf, S.resolveColor("var(--accent-shielded)", Success()), ICON_MD_SHIELD, NavPage::Receive, false}, - {"TRANSPARENT", trBuf, S.resolveColor("var(--accent-transparent)", Warning()), ICON_MD_CIRCLE, NavPage::Receive, false}, - {"QUICK SEND", "Send", S.resolveColor("var(--accent-action)", Primary()), ICON_MD_CALL_MADE, NavPage::Send, true}, - {"QUICK RECEIVE", "Receive", S.resolveColor("var(--accent-action)", Primary()), ICON_MD_CALL_RECEIVED, NavPage::Receive, true}, + {lblShielded.c_str(), shBuf, S.resolveColor("var(--accent-shielded)", Success()), ICON_MD_SHIELD, NavPage::Receive, false}, + {lblTransparent.c_str(), trBuf, S.resolveColor("var(--accent-transparent)", Warning()), ICON_MD_CIRCLE, NavPage::Receive, false}, + {lblQuickSend.c_str(), "Send", S.resolveColor("var(--accent-action)", Primary()), ICON_MD_CALL_MADE, NavPage::Send, true}, + {lblQuickReceive.c_str(), "Receive", S.resolveColor("var(--accent-action)", Primary()), ICON_MD_CALL_RECEIVED, NavPage::Receive, true}, }; for (int i = 0; i < 4; i++) { @@ -1125,7 +1153,7 @@ static void RenderBalanceDashboard(App* app) { tiles[i].accent, tiles[i].value); } else { dl->AddText(capFont, capFont->LegacySize, ImVec2(tMin.x + tilePad, py), - OnSurfaceMedium(), "Click to open"); + OnSurfaceMedium(), TR("tile_click_to_open")); } // Click @@ -1279,7 +1307,7 @@ static void RenderBalanceVerticalStack(App* app) { float barW = barRight - barLeft; float barY = rowPos.y + (rowH - barH) * 0.5f; dl->AddRectFilled(ImVec2(barLeft, barY), ImVec2(barRight, barY + barH), - IM_COL32(255, 255, 255, 15), barH * 0.5f); + SurfaceOverlay(15), barH * 0.5f); dl->AddRectFilled(ImVec2(barLeft, barY), ImVec2(barLeft + barW * rowInfos[i].ratio, barY + barH), WithAlpha(rowInfos[i].accent, 180), barH * 0.5f); @@ -1473,7 +1501,7 @@ static void RenderBalanceVertical2x2(App* app) { float barX = cellMax.x - amtSz.x - rowPad - barW - Layout::spacingSm(); float barY = cellMin.y + (rowH - barH) * 0.5f; dl->AddRectFilled(ImVec2(barX, barY), ImVec2(barX + barW, barY + barH), - IM_COL32(255, 255, 255, 15), barH * 0.5f); + SurfaceOverlay(15), barH * 0.5f); dl->AddRectFilled(ImVec2(barX, barY), ImVec2(barX + barW * cell.ratio, barY + barH), WithAlpha(cell.accent, 180), barH * 0.5f); @@ -1551,7 +1579,7 @@ static void RenderBalanceShield(App* app) { else ImGui::Dummy(ImVec2(0, S.drawElement("tabs.balance", "compact-hero-pad").sizeOr(8.0f) * vs)); { - Type().textColored(TypeStyle::Overline, OnSurfaceMedium(), "TOTAL BALANCE"); + Type().textColored(TypeStyle::Overline, OnSurfaceMedium(), TR("total_balance_label")); ImGui::Dummy(ImVec2(0, 2 * dp)); snprintf(buf, sizeof(buf), "%.8f", s_dispTotal); ImFont* heroFont = Type().h2(); @@ -1665,13 +1693,19 @@ static void RenderBalanceShield(App* app) { float infoY = panelMin.y + shieldPad; ImFont* ovFont = Type().overline(); - dl->AddText(ovFont, ovFont->LegacySize, ImVec2(infoX, infoY), Success(), "SHIELDED"); + std::string shieldLabelUpper = TR("shielded"); + std::transform(shieldLabelUpper.begin(), shieldLabelUpper.end(), shieldLabelUpper.begin(), + [](unsigned char c){ return (char)std::toupper(c); }); + std::string transLabelUpper = TR("transparent"); + std::transform(transLabelUpper.begin(), transLabelUpper.end(), transLabelUpper.begin(), + [](unsigned char c){ return (char)std::toupper(c); }); + dl->AddText(ovFont, ovFont->LegacySize, ImVec2(infoX, infoY), Success(), shieldLabelUpper.c_str()); infoY += ovFont->LegacySize + 2 * dp; snprintf(buf, sizeof(buf), "%.8f", s_dispShielded); dl->AddText(capFont, capFont->LegacySize, ImVec2(infoX, infoY), Success(), buf); infoY += capFont->LegacySize + 6 * dp; - dl->AddText(ovFont, ovFont->LegacySize, ImVec2(infoX, infoY), Warning(), "TRANSPARENT"); + dl->AddText(ovFont, ovFont->LegacySize, ImVec2(infoX, infoY), Warning(), transLabelUpper.c_str()); infoY += ovFont->LegacySize + 2 * dp; snprintf(buf, sizeof(buf), "%.8f", s_dispTransparent); dl->AddText(capFont, capFont->LegacySize, ImVec2(infoX, infoY), Warning(), buf); @@ -1727,7 +1761,7 @@ static void RenderBalanceTimeline(App* app) { else ImGui::Dummy(ImVec2(0, S.drawElement("tabs.balance", "compact-hero-pad").sizeOr(8.0f) * vs)); { - Type().textColored(TypeStyle::Overline, OnSurfaceMedium(), "TOTAL BALANCE"); + Type().textColored(TypeStyle::Overline, OnSurfaceMedium(), TR("total_balance_label")); ImGui::Dummy(ImVec2(0, 2 * dp)); snprintf(buf, sizeof(buf), "%.8f", s_dispTotal); ImFont* heroFont = Type().h2(); @@ -1816,10 +1850,16 @@ static void RenderBalanceTimeline(App* app) { spec.rounding = glassRound; struct SumCard { const char* label; ImU32 col; double val; bool isMoney; }; + auto upperTR = [](const char* key) { + std::string s = TR(key); + std::transform(s.begin(), s.end(), s.begin(), [](unsigned char c){ return (char)std::toupper(c); }); + return s; + }; + std::string cShielded = upperTR("shielded"), cTransparent = upperTR("transparent"), cMarket = upperTR("market"); SumCard cards[3] = { - {"SHIELDED", Success(), s_dispShielded, false}, - {"TRANSPARENT", Warning(), s_dispTransparent, false}, - {"MARKET", Primary(), state.market.price_usd, true}, + {cShielded.c_str(), Success(), s_dispShielded, false}, + {cTransparent.c_str(), Warning(), s_dispTransparent, false}, + {cMarket.c_str(), Primary(), state.market.price_usd, true}, }; for (int i = 0; i < 3; i++) { ImVec2 cMin(origin.x + i * (cardW + cGap), origin.y); @@ -1887,13 +1927,13 @@ static void RenderBalanceTwoRow(App* app) { ImFont* capFont = Type().caption(); if (state.sync.syncing && state.sync.headers > 0) { float pct = static_cast(state.sync.verification_progress) * 100.0f; - snprintf(buf, sizeof(buf), "Syncing %.1f%%", pct); + snprintf(buf, sizeof(buf), TR("balance_syncing_pct"), pct); Type().textColored(TypeStyle::Caption, Warning(), buf); ImGui::SameLine(); } if (state.mining.generate) { double hr = state.mining.localHashrate; - snprintf(buf, sizeof(buf), "Mining %s", FormatHashrate(hr).c_str()); + snprintf(buf, sizeof(buf), TR("balance_mining_rate"), FormatHashrate(hr).c_str()); Type().textColored(TypeStyle::Caption, WithAlpha(Success(), 200), buf); ImGui::SameLine(); } @@ -1902,11 +1942,15 @@ static void RenderBalanceTwoRow(App* app) { float btnW = S.drawElement("tabs.balance.two-row", "action-btn-width").sizeOr(80.0f); float rightEdge = ImGui::GetWindowWidth() - Layout::spacingLg(); ImGui::SameLine(rightEdge - btnW * 2 - Layout::spacingSm()); - if (TactileButton("Send", ImVec2(btnW, 0), S.resolveFont("button"))) { + // Stable ## ids keep the button identity fixed across translations. + char sendBtn[64], recvBtn[64]; + snprintf(sendBtn, sizeof(sendBtn), "%s##tworow-send", TR("send")); + snprintf(recvBtn, sizeof(recvBtn), "%s##tworow-receive", TR("receive")); + if (TactileButton(sendBtn, ImVec2(btnW, 0), S.resolveFont("button"))) { app->setCurrentPage(NavPage::Send); } ImGui::SameLine(); - if (TactileButton("Receive", ImVec2(btnW, 0), S.resolveFont("button"))) { + if (TactileButton(recvBtn, ImVec2(btnW, 0), S.resolveFont("button"))) { app->setCurrentPage(NavPage::Receive); } } diff --git a/src/ui/windows/console_tab.cpp b/src/ui/windows/console_tab.cpp index c57e04f..45e8ff0 100644 --- a/src/ui/windows/console_tab.cpp +++ b/src/ui/windows/console_tab.cpp @@ -1050,8 +1050,11 @@ void ConsoleTab::drawVisibleLines(float padX, float lineHeight, bool hasTextFilt ImVec2(cx, cy + sz * 0.7f), triCol); // ▼ expanded } // Click anywhere in the gutter cell for this line's first row toggles the fold. + // Guard against a click that is actually dismissing the ConsoleContextMenu (or any + // popup) — the same popup guard the text-selection path uses (see mouse_in_output). ImVec2 mp = ImGui::GetIO().MousePos; if (ImGui::IsMouseClicked(ImGuiMouseButton_Left) && + !ImGui::IsPopupOpen("", ImGuiPopupFlags_AnyPopup) && mp.x >= output_origin_.x - padX && mp.x < output_origin_.x && mp.y >= lineOrigin.y && mp.y < lineOrigin.y + lineHeight) { pendingFoldToggle = i; diff --git a/src/ui/windows/contacts_tab.cpp b/src/ui/windows/contacts_tab.cpp index 4cf5078..fbc4f6f 100644 --- a/src/ui/windows/contacts_tab.cpp +++ b/src/ui/windows/contacts_tab.cpp @@ -40,6 +40,7 @@ static bool s_show_edit_dialog = false; static bool s_show_contacts_settings = false; // Contacts customization modal (gear button) static bool s_focus_edit_field = false; // focus the first field the frame the add/edit dialog opens static int s_confirm_delete_idx = -1; // armed storage index; a 2nd Delete confirms +static int s_confirm_avatar_del_idx = -1; // armed avatar-library index; a 2nd badge click confirms the (irreversible) file delete static char s_edit_label[128] = ""; static char s_edit_address[512] = ""; static char s_edit_notes[512] = ""; @@ -555,7 +556,7 @@ void RenderContactsTab(App* app) sdl->AddRectFilled(ImVec2(cMin.x + 2.0f * dp, cMin.y + 2.0f * dp), ImVec2(cMax.x - 2.0f * dp, cMax.y - 2.0f * dp), material::WithAlpha(material::Primary(), 210), (segH - 4.0f * dp) * 0.5f); - ImU32 fg = active ? IM_COL32(255, 255, 255, 255) : (hov ? material::OnSurface() : material::OnSurfaceMedium()); + ImU32 fg = active ? material::OnPrimary() : (hov ? material::OnSurface() : material::OnSurfaceMedium()); float igW = segIcoF->CalcTextSizeA(segIcoF->LegacySize, FLT_MAX, 0, segIco[i]).x; float lbW = btnFont->CalcTextSizeA(btnFont->LegacySize, FLT_MAX, 0, segLbl[i]).x; float gapI = 5.0f * dp; @@ -747,12 +748,16 @@ void RenderContactsTab(App* app) float dr = std::max(7.0f * dp, cell * 0.15f); ImVec2 dcc(mx.x - dr - 3.0f * dp, mn.y + dr + 3.0f * dp); bool dhov = ImGui::IsMouseHoveringRect(ImVec2(dcc.x-dr, dcc.y-dr), ImVec2(dcc.x+dr, dcc.y+dr)); + const int libIdx = n - 1; + const bool delArmed = (s_confirm_avatar_del_idx == libIdx); ImGui::PushID(n); bool thumbClicked = ImGui::InvisibleButton("##avthumb", ImVec2(cell, cell)); bool thumbHov = ImGui::IsItemHovered(); ImGui::PopID(); - if (thumbHov || sel || hov) { // draw the delete badge - gdl->AddCircleFilled(dcc, dr, dhov ? material::ReadableError() : IM_COL32(0, 0, 0, 175)); + if (thumbHov || sel || hov || delArmed) { // draw the delete badge (persist while armed) + gdl->AddCircleFilled(dcc, dr, (dhov || delArmed) ? material::ReadableError() : IM_COL32(0, 0, 0, 175)); + // While armed, ring the badge so the "click again to delete" state is unmistakable. + if (delArmed) gdl->AddCircle(dcc, dr + 1.5f * dp, material::ReadableError(), 0, 1.5f * dp); ImFont* xf = material::Type().iconSmall(); float xsz = dr * 1.35f; ImVec2 xs = xf->CalcTextSizeA(xsz, FLT_MAX, 0, ICON_MD_CLOSE); @@ -760,11 +765,18 @@ void RenderContactsTab(App* app) } if (dhov) { // badge takes priority over selecting the thumbnail ImGui::SetMouseCursor(ImGuiMouseCursor_Hand); - material::Tooltip("%s", TR("delete")); - if (ImGui::IsMouseClicked(ImGuiMouseButton_Left)) pendingDelete = n - 1; + // Two-stage confirm: the first click arms this badge; a second click on the SAME + // badge deletes the image file (fs::remove is irreversible — no undo). + material::Tooltip("%s", delArmed ? TR("address_book_confirm_delete") : TR("delete")); + if (ImGui::IsMouseClicked(ImGuiMouseButton_Left)) { + if (delArmed) { pendingDelete = libIdx; s_confirm_avatar_del_idx = -1; } + else s_confirm_avatar_del_idx = libIdx; // arm; requires a 2nd deliberate click + } } else { if (thumbHov) ImGui::SetMouseCursor(ImGuiMouseCursor_Hand); - if (thumbClicked) s_edit_avatar = "img:" + path; + // Any click that lands off this badge (selecting the thumbnail or elsewhere) + // disarms it, so a stale armed badge can't be confirmed by an unrelated click. + if (thumbClicked) { s_edit_avatar = "img:" + path; s_confirm_avatar_del_idx = -1; } } } col = (col + 1) % cols; diff --git a/src/ui/windows/market_tab.cpp b/src/ui/windows/market_tab.cpp index 844efdd..5265d83 100644 --- a/src/ui/windows/market_tab.cpp +++ b/src/ui/windows/market_tab.cpp @@ -137,6 +137,12 @@ struct PfEditState { }; static PfEditState s_pfEdit; +// Two-stage delete arm/confirm for the master-list per-row delete icon (mirrors the +// contacts tab's s_confirm_delete_idx): first click on a row's trash arms it (icon turns +// red); a second click on the SAME row within the loop confirms the erase. Hovering/clicking +// a different row, or clicking off the icons, disarms. -1 = nothing armed. +static int s_pfConfirmDelIdx = -1; + // The pure price-series math lives in data/market_series.h; the selected chart range is // s_mkt.chartInterval (0=Live 1=1H 2=1D 3=1W 4=1M, session-scoped, default 1M). @@ -837,6 +843,7 @@ static void RenderPortfolioEditor(App* app) float rowH = 46.0f * dp; float delSlot = 36.0f * dp; // reserved trailing space for the delete icon + margin int clickedSel = -999, delRow = -1; // deferred: don't mutate `entries` mid-loop + bool armedThisFrame = false; // an arm-click also fires the row Selectable; don't let it disarm for (int vi = 0; vi < (int)vis.size(); vi++) { int i = vis[vi]; ImGui::PushID(i); @@ -877,6 +884,7 @@ static void RenderPortfolioEditor(App* app) // Per-row delete icon (larger, inset from the edge). Hit-tested manually so it is // NOT an overlapping ImGui item over the row Selectable (which asserted on hover). if (rowHov || selRow) { + bool armed = (s_pfConfirmDelIdx == i); // this row is arm-confirmed ImFont* delFont = Type().iconMed(); float ds = delFont->LegacySize; ImVec2 dc(rmx.x - Layout::spacingMd() - ds * 0.5f, rmn.y + rowH * 0.5f); @@ -884,11 +892,20 @@ static void RenderPortfolioEditor(App* app) bool dhov = ImGui::IsMouseHoveringRect(dmn, dmx); if (dhov) { ImGui::SetMouseCursor(ImGuiMouseCursor_Hand); - if (ImGui::IsMouseClicked(ImGuiMouseButton_Left)) delRow = i; + // Hovering a *different* row's trash disarms the previously armed one. + if (!armed && s_pfConfirmDelIdx >= 0) s_pfConfirmDelIdx = -1; + if (ImGui::IsMouseClicked(ImGuiMouseButton_Left)) { + if (armed) delRow = i; // 2nd click on the armed row erases + else { s_pfConfirmDelIdx = i; // 1st click arms this row... + armedThisFrame = true; } // ...and must survive the row-select this same click triggers + } } - ImVec2 isz = delFont->CalcTextSizeA(ds, FLT_MAX, 0, ICON_MD_DELETE_OUTLINE); + // A filled trash glyph while armed (vs outline) reinforces the recolor. + const char* delGlyph = armed ? ICON_MD_DELETE : ICON_MD_DELETE_OUTLINE; + ImU32 delCol = armed ? ReadableError() : (dhov ? Error() : OnSurfaceMedium()); + ImVec2 isz = delFont->CalcTextSizeA(ds, FLT_MAX, 0, delGlyph); mdl->AddText(delFont, ds, ImVec2(dc.x - isz.x * 0.5f, dc.y - isz.y * 0.5f), - dhov ? Error() : OnSurfaceMedium(), ICON_MD_DELETE_OUTLINE); + delCol, delGlyph); } ImGui::PopID(); } @@ -905,10 +922,16 @@ static void RenderPortfolioEditor(App* app) else if (delRow == s_pfEdit.sel) s_pfEdit.sel = std::min(delRow, (int)es.size() - 1); PortfolioBeginEdit(app, s_pfEdit.sel); } - } else if (clickedSel != -999) { + s_pfConfirmDelIdx = -1; // erase done — storage indices shifted, drop the arm + } else if (clickedSel != -999 && !armedThisFrame) { pfCommitIfNeeded(app); // auto-save the current group before switching PortfolioBeginEdit(app, clickedSel); + s_pfConfirmDelIdx = -1; // switching rows disarms any pending delete } + // A left-click that hit no row/action (empty list space) disarms a pending delete. + if (ImGui::IsWindowHovered() && ImGui::IsMouseClicked(ImGuiMouseButton_Left) && + !ImGui::IsAnyItemHovered()) + s_pfConfirmDelIdx = -1; } ImGui::EndChild(); ImGui::Dummy(ImVec2(0, Layout::spacingSm())); diff --git a/src/ui/windows/mining_controls.cpp b/src/ui/windows/mining_controls.cpp index a06aeeb..37b16c0 100644 --- a/src/ui/windows/mining_controls.cpp +++ b/src/ui/windows/mining_controls.cpp @@ -83,7 +83,7 @@ void RenderMiningControls(App* app, const WalletState& state, const MiningInfo& // over-estimates the grid width and lets the thread cells overflow the card (e.g. at 150%). float estControlsW = availWidth - std::min(schema::UI().drawElement("tabs.mining", "button-max-width-clamp").size * dp, miningBtnMaxW) - miningBtnGap; float innerW = estControlsW - pad * 2; - float cellSz = std::clamp(schema::UI().drawElement("tabs.mining", "cell-size").size * vs, schema::UI().drawElement("tabs.mining", "cell-min-size").size, schema::UI().drawElement("tabs.mining", "cell-max-size").sizeOr(42.0f)); + float cellSz = std::clamp(schema::UI().drawElement("tabs.mining", "cell-size").size * vs, schema::UI().drawElement("tabs.mining", "cell-min-size").size * dp, schema::UI().drawElement("tabs.mining", "cell-max-size").sizeOr(42.0f) * dp); float cellGap = std::max(schema::UI().drawElement("tabs.mining", "cell-gap-min").size, cellSz * schema::UI().drawElement("tabs.mining", "cell-gap-ratio").size); int cols = std::max(1, std::min(nOpts, (int)(innerW / (cellSz + cellGap)))); int rows = (nOpts + cols - 1) / cols; @@ -162,14 +162,35 @@ void RenderMiningControls(App* app, const WalletState& state, const MiningInfo& const float sy = curY; ImVec2 savedCur = ImGui::GetCursorScreenPos(); - material::IconButtonStyle sideStyle; - sideStyle.color = OnSurfaceMedium(); - sideStyle.hoverBg = StateHover(); + // -/+ buttons drawn in the same style as the thread tiles (rounded rect + border + centered + // glyph, same fill/border/rounding). Hit-tested with a real InvisibleButton so they stay + // popup-safe. + const float stepRound = schema::UI().drawElement("tabs.mining", "cell-rounding").size; + // atBound: the stepper can't move further (already at 1 for "-" or max for "+"). When + // at the bound the control is a no-op, so render it disabled: dim glyph/border, no hand + // cursor, no tooltip — and swallow the click so it reads as inert. + auto rectStepBtn = [&](const char* id, const char* glyph, float x, const char* tip, bool atBound) -> bool { + ImGui::SetCursorScreenPos(ImVec2(x, sy)); + ImGui::InvisibleButton(id, ImVec2(sideW, fieldH)); + const bool hov = ImGui::IsItemHovered() && !atBound; + const bool clk = ImGui::IsItemClicked() && !atBound; + const ImVec2 mn(x, sy), mx(x + sideW, sy + fieldH); + dl->AddRectFilled(mn, mx, hov ? WithAlpha(OnSurface(), 25) : WithAlpha(OnSurface(), 8), stepRound); + dl->AddRect(mn, mx, WithAlpha(OnSurface(), atBound ? 15 : (hov ? 80 : 35)), stepRound); + const ImVec2 gsz = stepFont->CalcTextSizeA(stepFont->LegacySize, FLT_MAX, 0, glyph); + dl->AddText(stepFont, stepFont->LegacySize, + ImVec2(x + (sideW - gsz.x) * 0.5f, sy + (fieldH - gsz.y) * 0.5f), + WithAlpha(OnSurface(), atBound ? 30 : (hov ? 160 : 80)), glyph); + if (hov) { + ImGui::SetMouseCursor(ImGuiMouseCursor_Hand); + if (tip && tip[0]) material::Tooltip("%s", tip); + } + return clk; + }; - // "-" button - sideStyle.tooltip = TR("mining_threads_minus_tooltip"); - ImGui::SetCursorScreenPos(ImVec2(sx, sy)); - if (material::IconButton("##ThreadMinus", ICON_MD_REMOVE, stepFont, ImVec2(sideW, fieldH), sideStyle)) + // "-" button (disabled at 1 thread) + if (rectStepBtn("##ThreadMinus", ICON_MD_REMOVE, sx, TR("mining_threads_minus_tooltip"), + s_selected_threads <= 1)) applyThreads(s_selected_threads - 1); sx += sideW + g; @@ -188,10 +209,9 @@ void RenderMiningControls(App* app, const WalletState& state, const MiningInfo& ImGui::PopStyleVar(); sx += fieldW + g; - // "+" button - sideStyle.tooltip = TR("mining_threads_plus_tooltip"); - ImGui::SetCursorScreenPos(ImVec2(sx, sy)); - if (material::IconButton("##ThreadPlus", ICON_MD_ADD, stepFont, ImVec2(sideW, fieldH), sideStyle)) + // "+" button (disabled at max_threads) + if (rectStepBtn("##ThreadPlus", ICON_MD_ADD, sx, TR("mining_threads_plus_tooltip"), + s_selected_threads >= max_threads)) applyThreads(s_selected_threads + 1); ImGui::SetCursorScreenPos(savedCur); @@ -738,15 +758,9 @@ void RenderMiningControls(App* app, const WalletState& state, const MiningInfo& dl->AddRect(cMin, cMax, WithAlpha(Primary(), (int)(160 + 60 * glow)), rounding, 0, schema::UI().drawElement("tabs.mining", "active-cell-border-thickness").size); } else if (active) { // Active but not mining: solid primary fill - ImU32 pri = Primary(); - int priR = (pri >> 0) & 0xFF; - int priG = (pri >> 8) & 0xFF; - int priB = (pri >> 16) & 0xFF; - ImU32 fillCol = hovered - ? IM_COL32(priR, priG, priB, 220) - : IM_COL32(priR, priG, priB, 180); + ImU32 fillCol = material::WithAlpha(Primary(), hovered ? 220 : 180); dl->AddRectFilled(cMin, cMax, fillCol, rounding); - dl->AddRect(cMin, cMax, IM_COL32(priR, priG, priB, 255), rounding, 0, schema::UI().drawElement("tabs.mining", "cell-border-thickness").size); + dl->AddRect(cMin, cMax, material::WithAlpha(Primary(), 255), rounding, 0, schema::UI().drawElement("tabs.mining", "cell-border-thickness").size); } else { // Inactive: dim outline ImU32 fillCol = hovered @@ -938,7 +952,7 @@ void RenderMiningControls(App* app, const WalletState& state, const MiningInfo& else if (poolBlockedBySolo) material::Tooltip("%s", TR("mining_stop_solo_for_pool")); else if (poolNeedsPayout) - material::Tooltip("%s", "Enter a payout address first (generate a Z address)"); + material::Tooltip("%s", TR("mining_pool_needs_payout_tooltip")); else material::Tooltip("%s", isMiningActive ? TR("stop_mining") : TR("start_mining")); } diff --git a/src/ui/windows/mining_mode_toggle.cpp b/src/ui/windows/mining_mode_toggle.cpp index 65f7e2c..75029fb 100644 --- a/src/ui/windows/mining_mode_toggle.cpp +++ b/src/ui/windows/mining_mode_toggle.cpp @@ -42,6 +42,20 @@ void RenderMiningModeToggle(App* app, const WalletState& state, const MiningInfo bool& s_pool_mode, char (&s_pool_url)[256], char (&s_pool_worker)[256], bool& s_pool_settings_dirty) { + // Arm/confirm for the destructive X (delete) on saved pools & workers: a first click on a + // row's X arms it (the X turns red + relabels via the trash glyph) and a second click within + // a short window actually removes it; moving to another row or letting the window lapse disarms. + // Same idiom as contacts_tab.cpp's s_confirm_delete_idx, keyed by row index within each list. + static int s_armed_pool_idx = -1; // armed saved-pool row (-1 = none) + static int s_armed_worker_idx = -1; // armed saved-worker row (-1 = none) + static double s_armed_pool_time = 0.0; + static double s_armed_worker_time = 0.0; + const double kArmWindowSecs = 3.0; // second click must land within this window + const double nowTime = ImGui::GetTime(); + // Lapse the arm if the confirm window elapsed. + if (s_armed_pool_idx >= 0 && nowTime - s_armed_pool_time > kArmWindowSecs) s_armed_pool_idx = -1; + if (s_armed_worker_idx >= 0 && nowTime - s_armed_worker_time > kArmWindowSecs) s_armed_worker_idx = -1; + const bool soloMiningAvailable = app->supportsSoloMining(); float toggleW = schema::UI().drawElement("tabs.mining", "mode-toggle-width").size * hs; float toggleH = schema::UI().drawElement("tabs.mining", "mode-toggle-height").size; @@ -296,9 +310,11 @@ void RenderMiningModeToggle(App* app, const WalletState& state, const MiningInfo ImFont* rowFont = ImGui::GetFont(); float rowFontSz = ImGui::GetFontSize(); float rowH = ImGui::GetFrameHeight(); + int rowIdx = 0; for (const auto& url : savedUrls) { ImGui::PushID(url.c_str()); bool isCurrent = (std::string(s_pool_url) == url); + bool armed = (s_armed_pool_idx == rowIdx); // this row's X is arm-confirmed ImVec2 rowMin = ImGui::GetCursorScreenPos(); ImVec2 rowMax(rowMin.x + popupInnerW, rowMin.y + rowH); ImGui::InvisibleButton("##row", ImVec2(popupInnerW, rowH)); @@ -319,40 +335,46 @@ void RenderMiningModeToggle(App* app, const WalletState& state, const MiningInfo pdl->AddText(rowFont, rowFontSz, ImVec2(rowMin.x + textPadX, textY), isCurrent ? Primary() : OnSurface(), urlDisp.c_str()); - // X button — flush with right edge, icon centered + // X (delete) button — flush with right edge, icon centered. First click on the X + // arms it (filled trash glyph + readable-error tint); a second click within the + // arm window actually removes. Armed row stays lit even when not hovered so the + // pending-delete state is visible. { ImVec2 xMin(rowMax.x - xZoneW, rowMin.y); ImVec2 xMax(rowMax.x, rowMax.y); if (inXZone) { pdl->AddRectFilled(xMin, xMax, IM_COL32(255, 80, 80, 30)); ImGui::SetMouseCursor(ImGuiMouseCursor_Hand); - material::Tooltip("%s", TR("mining_remove")); - } else if (rowHov) { - // Show faint X when row is hovered - ImFont* icoF = Type().iconSmall(); - const char* xIcon = ICON_MD_CLOSE; - ImVec2 iSz = icoF->CalcTextSizeA(icoF->LegacySize, FLT_MAX, 0, xIcon); - ImVec2 xCenter((xMin.x + xMax.x) * 0.5f, (xMin.y + xMax.y) * 0.5f); - pdl->AddText(icoF, icoF->LegacySize, - ImVec2(xCenter.x - iSz.x * 0.5f, xCenter.y - iSz.y * 0.5f), - OnSurfaceDisabled(), xIcon); + material::Tooltip("%s", armed ? TR("address_book_confirm_delete") + : TR("mining_remove")); } - // Always draw icon when hovering X zone - if (inXZone) { + if (armed || inXZone || rowHov) { ImFont* icoF = Type().iconSmall(); - const char* xIcon = ICON_MD_CLOSE; + // Filled trash while armed reinforces the recolor; otherwise a plain X. + const char* xIcon = armed ? ICON_MD_DELETE : ICON_MD_CLOSE; + ImU32 xCol = armed ? ReadableError() + : (inXZone ? Error() : OnSurfaceDisabled()); ImVec2 iSz = icoF->CalcTextSizeA(icoF->LegacySize, FLT_MAX, 0, xIcon); ImVec2 xCenter((xMin.x + xMax.x) * 0.5f, (xMin.y + xMax.y) * 0.5f); pdl->AddText(icoF, icoF->LegacySize, ImVec2(xCenter.x - iSz.x * 0.5f, xCenter.y - iSz.y * 0.5f), - Error(), xIcon); + xCol, xIcon); } } + // Hovering a *different* row's X disarms the previously armed one. + if (inXZone && !armed && s_armed_pool_idx >= 0) + s_armed_pool_idx = -1; // Click handling if (rowClk) { if (inXZone) { - urlToRemove = url; + if (armed) { + urlToRemove = url; // 2nd click on the armed row removes + } else { + s_armed_pool_idx = rowIdx; // 1st click arms this row + s_armed_pool_time = nowTime; + } } else { + s_armed_pool_idx = -1; // selecting a row disarms strncpy(s_pool_url, url.c_str(), sizeof(s_pool_url) - 1); s_pool_url[sizeof(s_pool_url) - 1] = '\0'; s_pool_settings_dirty = true; @@ -362,10 +384,12 @@ void RenderMiningModeToggle(App* app, const WalletState& state, const MiningInfo if (rowHov && !inXZone) ImGui::SetMouseCursor(ImGuiMouseCursor_Hand); ImGui::PopID(); + rowIdx++; } if (!urlToRemove.empty()) { app->settings()->removeSavedPoolUrl(urlToRemove); app->settings()->save(); + s_armed_pool_idx = -1; // removal shifts indices — drop the arm } } ImGui::EndPopup(); @@ -460,9 +484,11 @@ void RenderMiningModeToggle(App* app, const WalletState& state, const MiningInfo ImFont* wRowFont = ImGui::GetFont(); float wRowFontSz = ImGui::GetFontSize(); float wRowH = ImGui::GetFrameHeight(); + int wRowIdx = 0; for (const auto& addr : savedWorkers) { ImGui::PushID(addr.c_str()); bool isCurrent = (std::string(s_pool_worker) == addr); + bool armed = (s_armed_worker_idx == wRowIdx); // this row's X is arm-confirmed ImVec2 rowMin = ImGui::GetCursorScreenPos(); ImVec2 rowMax(rowMin.x + wPopupInnerW, rowMin.y + wRowH); ImGui::InvisibleButton("##row", ImVec2(wPopupInnerW, wRowH)); @@ -486,38 +512,46 @@ void RenderMiningModeToggle(App* app, const WalletState& state, const MiningInfo // Tooltip for long addresses if (rowHov && !inXZone) material::Tooltip("%s", addr.c_str()); - // X button — flush with right edge, icon centered + // X (delete) button — flush with right edge, icon centered. First click on the X + // arms it (filled trash glyph + readable-error tint); a second click within the + // arm window actually removes. Armed row stays lit even when not hovered so the + // pending-delete state is visible. { ImVec2 xMin(rowMax.x - wXZoneW, rowMin.y); ImVec2 xMax(rowMax.x, rowMax.y); if (inXZone) { pdl->AddRectFilled(xMin, xMax, IM_COL32(255, 80, 80, 30)); ImGui::SetMouseCursor(ImGuiMouseCursor_Hand); - material::Tooltip("%s", TR("mining_remove")); - } else if (rowHov) { - ImFont* icoF = Type().iconSmall(); - const char* xIcon = ICON_MD_CLOSE; - ImVec2 iSz = icoF->CalcTextSizeA(icoF->LegacySize, FLT_MAX, 0, xIcon); - ImVec2 xCenter((xMin.x + xMax.x) * 0.5f, (xMin.y + xMax.y) * 0.5f); - pdl->AddText(icoF, icoF->LegacySize, - ImVec2(xCenter.x - iSz.x * 0.5f, xCenter.y - iSz.y * 0.5f), - OnSurfaceDisabled(), xIcon); + material::Tooltip("%s", armed ? TR("address_book_confirm_delete") + : TR("mining_remove")); } - if (inXZone) { + if (armed || inXZone || rowHov) { ImFont* icoF = Type().iconSmall(); - const char* xIcon = ICON_MD_CLOSE; + // Filled trash while armed reinforces the recolor; otherwise a plain X. + const char* xIcon = armed ? ICON_MD_DELETE : ICON_MD_CLOSE; + ImU32 xCol = armed ? ReadableError() + : (inXZone ? Error() : OnSurfaceDisabled()); ImVec2 iSz = icoF->CalcTextSizeA(icoF->LegacySize, FLT_MAX, 0, xIcon); ImVec2 xCenter((xMin.x + xMax.x) * 0.5f, (xMin.y + xMax.y) * 0.5f); pdl->AddText(icoF, icoF->LegacySize, ImVec2(xCenter.x - iSz.x * 0.5f, xCenter.y - iSz.y * 0.5f), - Error(), xIcon); + xCol, xIcon); } } + // Hovering a *different* row's X disarms the previously armed one. + if (inXZone && !armed && s_armed_worker_idx >= 0) + s_armed_worker_idx = -1; // Click handling if (rowClk) { if (inXZone) { - addrToRemove = addr; + if (armed) { + addrToRemove = addr; // 2nd click on the armed row removes + } else { + s_armed_worker_idx = wRowIdx; // 1st click arms this row + s_armed_worker_time = nowTime; + } } else { + s_armed_worker_idx = -1; // selecting a row disarms strncpy(s_pool_worker, addr.c_str(), sizeof(s_pool_worker) - 1); s_pool_worker[sizeof(s_pool_worker) - 1] = '\0'; s_pool_settings_dirty = true; @@ -527,10 +561,12 @@ void RenderMiningModeToggle(App* app, const WalletState& state, const MiningInfo if (rowHov && !inXZone) ImGui::SetMouseCursor(ImGuiMouseCursor_Hand); ImGui::PopID(); + wRowIdx++; } if (!addrToRemove.empty()) { app->settings()->removeSavedPoolWorker(addrToRemove); app->settings()->save(); + s_armed_worker_idx = -1; // removal shifts indices — drop the arm } } ImGui::EndPopup(); diff --git a/src/ui/windows/peers_tab.cpp b/src/ui/windows/peers_tab.cpp index c823a74..8c6b118 100644 --- a/src/ui/windows/peers_tab.cpp +++ b/src/ui/windows/peers_tab.cpp @@ -665,14 +665,26 @@ void RenderPeersTab(App* app) dl->AddCircleFilled(ImVec2(cx + S.drawElement("tabs.peers", "ping-dot-x-offset").size, cy + body2->LegacySize * 0.5f), pingDotR, dotCol); float addrX = cx + S.drawElement("tabs.peers", "address-x-offset").size; + // Reserve the line-1 trailing zone (ping + direction pill live on the far right, + // the nearest being the ping at innerW - pingW - spacingXl*3). A long IPv6+port + // addr must clip before it so it can't run under those. Mirror the ping formula + // conservatively and leave a gap. + float line1RightLimit = rowPos.x + innerW - Layout::spacingXl() * 3 - + capFont->CalcTextSizeA(capFont->LegacySize, FLT_MAX, 0, "0000ms").x - + Layout::spacingSm(); + dl->PushClipRect(ImVec2(addrX, rowPos.y), ImVec2(line1RightLimit, rowEnd.y), true); dl->AddText(body2, body2->LegacySize, ImVec2(addrX, cy), OnSurface(), peer.addr.c_str()); + dl->PopClipRect(); - // Seed node icon — rendered right after the IP address + // Seed node icon — rendered right after the IP address, but never past the + // reserved trailing zone (a long addr would otherwise push it into the ping text). if (IsSeedNode(peer.addr)) { ImVec2 addrSz = body2->CalcTextSizeA(body2->LegacySize, FLT_MAX, 0, peer.addr.c_str()); ImFont* iconFont = Type().iconSmall(); float iconY = cy + (body2->LegacySize - iconFont->LegacySize) * 0.5f; - dl->AddText(iconFont, iconFont->LegacySize, ImVec2(addrX + addrSz.x + Layout::spacingSm(), iconY), WithAlpha(Success(), 200), ICON_MD_GRASS); + float seedIconX = std::min(addrX + addrSz.x + Layout::spacingSm(), + line1RightLimit - iconFont->LegacySize); + dl->AddText(iconFont, iconFont->LegacySize, ImVec2(seedIconX, iconY), WithAlpha(Success(), 200), ICON_MD_GRASS); } { @@ -696,30 +708,55 @@ void RenderPeersTab(App* app) } float cy2 = cy + body2->LegacySize + Layout::spacingXs(); - dl->AddText(capFont, capFont->LegacySize, ImVec2(cx + S.drawElement("tabs.peers", "address-x-offset").size, cy2), - OnSurfaceDisabled(), peer.subver.c_str()); + float subverX = cx + S.drawElement("tabs.peers", "address-x-offset").size; + + // Reserve the line-2 trailing widths up front so an untrusted, arbitrarily long + // remote subver cannot push the TLS badge / ban-score off the row. Order right→left: + // ban-score pinned far right, then the TLS/no-TLS badge, then the clipped subver text. + float line2RightLimit = rowPos.x + innerW - Layout::spacingLg(); + float banScoreLeftX = line2RightLimit; + char banBuf[16]; + ImU32 banCol = 0; + bool haveBanScore = peer.banscore > 0; + if (haveBanScore) { + snprintf(banBuf, sizeof(banBuf), TR("peers_ban_score"), peer.banscore); + banCol = peer.banscore > 50 ? Error() : Warning(); + float banW = capFont->CalcTextSizeA(capFont->LegacySize, FLT_MAX, 0, banBuf).x; + banScoreLeftX = line2RightLimit - banW; + // The TLS/no-TLS badge sits to the LEFT of the ban score with a gap. + line2RightLimit = banScoreLeftX - Layout::spacingLg(); + } + + float tlsBadgeW = std::max(S.drawElement("tabs.peers", "tls-badge-min-width").size, S.drawElement("tabs.peers", "tls-badge-width").size * hs); + float noTlsW = capFont->CalcTextSizeA(capFont->LegacySize, FLT_MAX, 0, TR("peers_no_tls")).x; + float badgeW = peer.tls_cipher.empty() ? noTlsW : tlsBadgeW; + // Hard right boundary for the subver text column, leaving room for the badge. + float subverMaxX = line2RightLimit - badgeW - Layout::spacingSm(); + if (subverMaxX < subverX) subverMaxX = subverX; float verW = capFont->CalcTextSizeA(capFont->LegacySize, FLT_MAX, 0, peer.subver.c_str()).x; - float tlsBadgeW = std::max(S.drawElement("tabs.peers", "tls-badge-min-width").size, S.drawElement("tabs.peers", "tls-badge-width").size * hs); + dl->PushClipRect(ImVec2(subverX, rowPos.y), ImVec2(subverMaxX, rowEnd.y), true); + dl->AddText(capFont, capFont->LegacySize, ImVec2(subverX, cy2), + OnSurfaceDisabled(), peer.subver.c_str()); + dl->PopClipRect(); + + // Pin the badge just after the (clipped) subver, but never past the reserved zone. + float badgeX = std::min(subverX + verW + Layout::spacingSm(), subverMaxX + Layout::spacingSm()); if (!peer.tls_cipher.empty()) { ImU32 tlsBg = WithAlpha(Success(), 25); ImU32 tlsFg = WithAlpha(Success(), 200); - ImVec2 tlsMin(cx + S.drawElement("tabs.peers", "address-x-offset").size + verW + Layout::spacingSm(), cy2); + ImVec2 tlsMin(badgeX, cy2); ImVec2 tlsMax(tlsMin.x + tlsBadgeW, tlsMin.y + capFont->LegacySize + 2); dl->AddRectFilled(tlsMin, tlsMax, tlsBg, S.drawElement("tabs.peers", "tls-badge-rounding").size); dl->AddText(capFont, capFont->LegacySize, ImVec2(tlsMin.x + 4, cy2 + 1), tlsFg, "TLS"); } else { - dl->AddText(capFont, capFont->LegacySize, ImVec2(cx + S.drawElement("tabs.peers", "address-x-offset").size + verW + Layout::spacingSm(), cy2), + dl->AddText(capFont, capFont->LegacySize, ImVec2(badgeX, cy2), WithAlpha(Error(), 140), TR("peers_no_tls")); } - if (peer.banscore > 0) { - char banBuf[16]; - snprintf(banBuf, sizeof(banBuf), TR("peers_ban_score"), peer.banscore); - ImU32 banCol = peer.banscore > 50 ? Error() : Warning(); - ImVec2 banSz = capFont->CalcTextSizeA(capFont->LegacySize, FLT_MAX, 0, banBuf); + if (haveBanScore) { dl->AddText(capFont, capFont->LegacySize, - ImVec2(rowPos.x + innerW - banSz.x - Layout::spacingLg(), cy2), banCol, banBuf); + ImVec2(banScoreLeftX, cy2), banCol, banBuf); } ImGui::InvisibleButton("##peerRow", ImVec2(innerW, rowH)); diff --git a/src/ui/windows/receive_tab.cpp b/src/ui/windows/receive_tab.cpp index 2269850..f4f0707 100644 --- a/src/ui/windows/receive_tab.cpp +++ b/src/ui/windows/receive_tab.cpp @@ -514,21 +514,25 @@ void RenderReceiveTab(App* app) if (state.addresses.empty()) { ImVec2 emptyMin = ImGui::GetCursorScreenPos(); - float emptyH = S.drawElement("tabs.receive", "skeleton-height").size; + // Hand-drawn skeleton geometry is absolute px — scale heights/offsets/rounding by + // dpiScale() so it doesn't render native-thin at >100% (width ratios multiply formW, leave as-is). + float dp = Layout::dpiScale(); + float emptyH = S.drawElement("tabs.receive", "skeleton-height").size * dp; ImVec2 emptyMax(emptyMin.x + formW, emptyMin.y + emptyH); DrawGlassPanel(dl, emptyMin, emptyMax, glassSpec); float alpha = (float)(schema::UI().drawElement("animations", "skeleton-base").size + schema::UI().drawElement("animations", "skeleton-amp").size * std::sin(ImGui::GetTime() * schema::UI().drawElement("animations", "pulse-speed-slow").size)); ImU32 skelCol = IM_COL32(255, 255, 255, (int)(alpha * 255)); + float skelRound = schema::UI().drawElement("tabs.receive", "skeleton-rounding").size * dp; dl->AddRectFilled( ImVec2(emptyMin.x + Layout::spacingLg(), emptyMin.y + Layout::spacingLg()), - ImVec2(emptyMin.x + formW * S.drawElement("tabs.receive", "skeleton-bar1-width-ratio").size, emptyMin.y + Layout::spacingLg() + S.drawElement("tabs.receive", "skeleton-bar1-height").size), - skelCol, schema::UI().drawElement("tabs.receive", "skeleton-rounding").size); + ImVec2(emptyMin.x + formW * S.drawElement("tabs.receive", "skeleton-bar1-width-ratio").size, emptyMin.y + Layout::spacingLg() + S.drawElement("tabs.receive", "skeleton-bar1-height").size * dp), + skelCol, skelRound); dl->AddRectFilled( - ImVec2(emptyMin.x + Layout::spacingLg(), emptyMin.y + Layout::spacingLg() + S.drawElement("tabs.receive", "skeleton-bar2-top").size), - ImVec2(emptyMin.x + formW * S.drawElement("tabs.receive", "skeleton-bar2-width-ratio").size, emptyMin.y + Layout::spacingLg() + S.drawElement("tabs.receive", "skeleton-bar2-bottom").size), - skelCol, schema::UI().drawElement("tabs.receive", "skeleton-rounding").size); + ImVec2(emptyMin.x + Layout::spacingLg(), emptyMin.y + Layout::spacingLg() + S.drawElement("tabs.receive", "skeleton-bar2-top").size * dp), + ImVec2(emptyMin.x + formW * S.drawElement("tabs.receive", "skeleton-bar2-width-ratio").size, emptyMin.y + Layout::spacingLg() + S.drawElement("tabs.receive", "skeleton-bar2-bottom").size * dp), + skelCol, skelRound); dl->AddText(capFont, capFont->LegacySize, - ImVec2(emptyMin.x + Layout::spacingLg(), emptyMin.y + emptyH - S.drawElement("tabs.receive", "skeleton-text-bottom-offset").size), + ImVec2(emptyMin.x + Layout::spacingLg(), emptyMin.y + emptyH - S.drawElement("tabs.receive", "skeleton-text-bottom-offset").size * dp), OnSurfaceDisabled(), TR("loading_addresses")); ImGui::Dummy(ImVec2(formW, emptyH)); ImGui::EndGroup(); @@ -778,7 +782,7 @@ void RenderReceiveTab(App* app) size_t memo_len = strlen(s_request_memo); size_t memoMax = (size_t)S.drawElement("business", "memo-max-length").size; bool memoAtCap = memo_len + 1 >= memoMax; - snprintf(buf, sizeof(buf), "%zu / %zu bytes", memo_len, memoMax); + snprintf(buf, sizeof(buf), TR("byte_count_fmt"), memo_len, memoMax); Type().textColored(TypeStyle::Caption, memoAtCap ? Warning() : OnSurfaceDisabled(), buf); } diff --git a/src/ui/windows/send_tab.cpp b/src/ui/windows/send_tab.cpp index f71a515..4d2940d 100644 --- a/src/ui/windows/send_tab.cpp +++ b/src/ui/windows/send_tab.cpp @@ -424,11 +424,13 @@ static void RenderAmountBar(ImDrawList* dl, double available, float innerW, ? std::clamp((float)((s_amount + s_fee) / available), 0.0f, 1.0f) : 0.0f; - float maxBtnW = schema::UI().drawElement("tabs.send", "amount-bar-max-btn-width").size; + const float dp = Layout::dpiScale(); + float maxBtnW = schema::UI().drawElement("tabs.send", "amount-bar-max-btn-width").size * dp; float gap = Layout::spacingMd(); float barW = innerW - maxBtnW - gap; - if (barW < schema::UI().drawElement("tabs.send", "progress-bar-min-width").size) barW = schema::UI().drawElement("tabs.send", "progress-bar-min-width").size; - float barH = schema::UI().drawElement("tabs.send", "amount-bar-height").size; + float minBarW = schema::UI().drawElement("tabs.send", "progress-bar-min-width").size * dp; + if (barW < minBarW) barW = minBarW; + float barH = schema::UI().drawElement("tabs.send", "amount-bar-height").size * dp; float barRound = barH * 0.5f; ImVec2 barMin = ImGui::GetCursorScreenPos(); @@ -1000,7 +1002,7 @@ static void RenderActionButtons(App* app, float width, float vScale, ImGui::BeginDisabled(!can_send); char sendId[64]; - snprintf(sendId, sizeof(sendId), "Review Send%s", suffix); + snprintf(sendId, sizeof(sendId), "%s##ReviewSend%s", TR("review_send"), suffix); if (TactileButton(sendId, ImVec2(sendBtnW, btnH), S.resolveFont(S.button("tabs.send", "send-button").font))) { s_show_confirm = true; } @@ -1020,7 +1022,7 @@ static void RenderActionButtons(App* app, float width, float vScale, else if (total > available) material::Tooltip("%s", TR("send_tooltip_exceeds_balance")); else if (!sourceSpendable) - material::Tooltip("%s", "View-only address — no spending key, cannot send"); + material::Tooltip("%s", TR("send_tooltip_view_only")); else if (s_sending) material::Tooltip("%s", TR("send_tooltip_in_progress")); } @@ -1033,7 +1035,7 @@ static void RenderActionButtons(App* app, float width, float vScale, ImGui::PushStyleColor(ImGuiCol_Border, ImGui::ColorConvertU32ToFloat4(OnSurfaceDisabled())); ImGui::PushStyleVar(ImGuiStyleVar_FrameBorderSize, S.drawElement("tabs.send", "cancel-btn-border-size").size); char clearId[64]; - snprintf(clearId, sizeof(clearId), "Cancel%s", suffix); + snprintf(clearId, sizeof(clearId), "%s##Cancel%s", TR("cancel"), suffix); if (TactileButton(clearId, ImVec2(cancelBtnW, btnH), S.resolveFont(S.button("tabs.send", "clear-button").font))) { if (FormHasData()) { s_clear_confirm_pending = true; @@ -1377,7 +1379,7 @@ void RenderSendTab(App* app) s_preview_text.c_str(), s_preview_text.c_str() + std::min(s_preview_text.size(), (size_t)S.drawElement("tabs.send", "paste-preview-max-chars").size)); } - if (TactileButton("Paste##to", ImVec2(pasteW, 0), S.resolveFont(S.button("tabs.send", "paste-button").font))) { + if (TactileButton((std::string(TR("paste")) + "##to").c_str(), ImVec2(pasteW, 0), S.resolveFont(S.button("tabs.send", "paste-button").font))) { if (s_paste_previewing) { // Commit the preview snprintf(s_to_address, sizeof(s_to_address), "%s", s_preview_text.c_str()); @@ -1547,7 +1549,7 @@ void RenderSendTab(App* app) size_t memo_len = strlen(s_memo); size_t memoMax = (size_t)S.drawElement("business", "memo-max-length").size; bool memoAtCap = memo_len + 1 >= memoMax; - snprintf(buf, sizeof(buf), "%zu / %zu bytes", memo_len, memoMax); + snprintf(buf, sizeof(buf), TR("byte_count_fmt"), memo_len, memoMax); Type().textColored(TypeStyle::Caption, memoAtCap ? Warning() : OnSurfaceDisabled(), buf); } diff --git a/src/util/i18n.cpp b/src/util/i18n.cpp index 9a126f4..46a1010 100644 --- a/src/util/i18n.cpp +++ b/src/util/i18n.cpp @@ -823,7 +823,7 @@ void I18n::loadBuiltinEnglish() strings_["confirm_reinstall_daemon_title"] = "Install Bundled Daemon"; strings_["confirm_reinstall_daemon_msg"] = "This stops the daemon, overwrites the installed dragonxd (and dragonx-cli/dragonx-tx) with the versions bundled in this wallet build, then restarts the node. Use this to recover or update the node binary."; strings_["confirm_reinstall_daemon_safe"] = "Your wallet, keys and blockchain data are not touched — only the daemon program files are replaced."; - strings_["daemon_update_title"] = "Update the node daemon?"; + strings_["daemon_update_prompt_title"] = "Update the node daemon?"; strings_["daemon_update_body"] = "This wallet build bundles a newer DragonX node than the one currently installed. Updating replaces the installed dragonxd (and dragonx-cli/dragonx-tx), then stops and restarts the node so the new version takes effect. Recommended — a newer node can add features (e.g. seed-phrase support) the old one lacks."; strings_["daemon_update_safe"] = "Your wallet, keys and blockchain data are not touched — only the daemon program files are replaced. If you deliberately run a custom node, choose Keep current."; strings_["daemon_update_now"] = "Update now"; @@ -855,6 +855,10 @@ void I18n::loadBuiltinEnglish() strings_["lite_passphrase_label"] = "Passphrase"; strings_["lite_validate"] = "Validate"; strings_["lite_working"] = "Working…"; + strings_["lite_enter_wallet_path"] = "Enter a wallet path"; + strings_["lite_enter_all_seed_words"] = "Enter all 24 seed words to restore (got %d)"; + strings_["lite_could_not_start"] = "Could not start the operation"; + strings_["lite_backend_unavailable"] = "Lite wallet backend unavailable"; strings_["lite_wallet_ready"] = "Wallet ready"; strings_["lite_backup_keys"] = "Backup & keys"; strings_["lite_show_seed"] = "Show seed"; @@ -1101,6 +1105,14 @@ void I18n::loadBuiltinEnglish() strings_["balance_history_collecting"] = "Balance history — collecting data..."; strings_["balance_shielded_fmt"] = "Shielded: %.8f"; strings_["balance_transparent_fmt"] = "Transparent: %.8f"; + strings_["total_balance_label"] = "Total Balance"; + strings_["balance_syncing_pct"] = "Syncing %.1f%%"; + strings_["balance_mining_rate"] = "Mining %s"; + strings_["balance_layout_switched"] = "Layout: %s"; + strings_["byte_count_fmt"] = "%zu / %zu bytes"; + strings_["quick_send"] = "Quick Send"; + strings_["quick_receive"] = "Quick Receive"; + strings_["tile_click_to_open"] = "Click to open"; strings_["your_addresses"] = "Your Addresses"; strings_["z_addresses"] = "Z-Addresses"; strings_["t_addresses"] = "T-Addresses"; @@ -1428,9 +1440,18 @@ void I18n::loadBuiltinEnglish() 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_["rpc_plaintext_remote_warning"] = "Remote RPC is using plaintext HTTP. Add rpctls=1 to DRAGONX.conf if your daemon supports TLS."; strings_["settings_open_log_folder"] = "Open log folder"; strings_["settings_copy_diagnostics"] = "Copy diagnostics"; strings_["settings_diagnostics_copied"] = "Diagnostics copied to clipboard"; + strings_["settings_rpc_ok"] = "RPC connection OK"; + strings_["settings_rpc_error_prefix"] = "RPC error: "; + strings_["settings_not_connected"] = "Not connected to daemon"; + strings_["settings_theme_refreshed"] = "Theme list refreshed"; + strings_["settings_saved"] = "Settings saved"; + strings_["settings_reloaded"] = "Settings reloaded from disk"; + strings_["settings_ztx_cleared"] = "Z-transaction history cleared"; + strings_["settings_ztx_not_found"] = "No history file found"; 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"; @@ -1886,6 +1907,7 @@ void I18n::loadBuiltinEnglish() strings_["mining_payout_invalid"] = "Not a valid DragonX address — fix it before starting, or mining rewards are lost."; strings_["mining_est_daily_pool_sub"] = "rough solo-equivalent, before pool fee"; strings_["mining_generate_z_address_hint"] = "Generate a Z address in the Receive tab to use as your payout address"; + strings_["mining_pool_needs_payout_tooltip"] = "Enter a payout address first (generate a Z address)"; strings_["mining_pool"] = "Pool"; strings_["mining_payout_foreign"] = "⚠ This payout address isn't in your current wallet — mined rewards would go to a different wallet. Update it if you switched wallets."; strings_["mining_pool_hashrate"] = "Pool Hashrate"; @@ -2155,6 +2177,7 @@ void I18n::loadBuiltinEnglish() strings_["send_tooltip_not_connected"] = "Not connected to daemon"; strings_["send_tooltip_select_source"] = "Select a source address first"; strings_["send_tooltip_syncing"] = "Wait for blockchain to sync"; + strings_["send_tooltip_view_only"] = "View-only address — no spending key, cannot send"; strings_["send_total"] = "Total"; strings_["send_tx_failed"] = "Transaction failed"; strings_["send_tx_sent"] = "Transaction sent!"; From 755cf22ad09876016f7d801dc0c91cb6a4c118ec Mon Sep 17 00:00:00 2001 From: DanS Date: Tue, 18 Aug 2026 20:12:01 -0500 Subject: [PATCH 53/89] =?UTF-8?q?fix(ui):=20make=20HiDPI-overflowing=20con?= =?UTF-8?q?tainers=20scrollable=20=E2=80=94=20wizard,=20overlay=20dialogs,?= =?UTF-8?q?=20balance=20recent-tx?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit At font_scale 1.5 (dpiScale 1.5) three fixed, non-scrolling containers clipped content off the bottom with no scroll escape: - First-run wizard: the hand-drawn cards grow ~1.5x past the fixed window, pushing Continue / Encrypt & Continue / Skip off-screen (a setup blocker). Inject a wheel-driven scroll offset into the layout seed + a scroll indicator; gate the wheel on !IsPopupOpen + NoPopupHierarchy so an open combo popup does not scroll the wizard behind it. No-op at 1.0x. - Overlay dialogs (BeginOverlayDialog): auto-height cards taller than the viewport (About, Request Payment) ran their footer off the bottom. Add a sticky per-open overflow flag that clamps the card to the viewport and makes the content child scrollable; short dialogs still center unchanged. Give the nested settings clear-history confirm its own idSuffix so it can't inherit the parent dialog's overflow state or collide on the child window id. - Balance Recent Transactions: the dp-scaled address card evicted the recent-tx list off the non-scrolling tab host. Cap the card inside RenderSharedAddressList against the space that actually remains (minus a caller-provided reserve) so the section below stays on-screen — covers all 10 balance layouts. Verified at font_scale 1.5 across full-node + Lite + Windows (ctest green) and an adversarial diff review (two low-severity regressions found + fixed). Co-Authored-By: Claude Opus 4.8 (1M context) --- src/app_wizard.cpp | 37 ++++++++++++++++++++++- src/ui/material/draw_helpers.h | 43 ++++++++++++++++++++------- src/ui/windows/balance_components.cpp | 10 ++++++- src/ui/windows/balance_components.h | 3 +- src/ui/windows/balance_tab.cpp | 20 ++++++------- src/ui/windows/settings_window.cpp | 7 ++++- 6 files changed, 96 insertions(+), 24 deletions(-) diff --git a/src/app_wizard.cpp b/src/app_wizard.cpp index a878c4f..fe4eaaf 100644 --- a/src/app_wizard.cpp +++ b/src/app_wizard.cpp @@ -177,8 +177,28 @@ void App::renderFirstRunWizard() { // DPI scale factor — multiply all pixel constants by dp const float dp = ui::Layout::dpiScale(); + // Vertical scroll: the wizard cards are hand-drawn at absolute Y offsets and grow ~1.5x with the + // font-scale setting, so at high scale the focused card's primary button (Continue / Encrypt & Continue + // / Skip) can fall below the fixed window. Offset the whole layout by a wheel-driven scroll, clamped to + // last frame's measured content height, so every control stays reachable. The window keeps + // NoScrollWithMouse, so ImGui doesn't consume the wheel — we read the raw delta and apply our own offset. + static float s_wizScroll = 0.0f, s_wizContentH = 0.0f; + if (ImGui::IsWindowAppearing()) s_wizScroll = 0.0f; + const float wizMaxScroll = std::max(0.0f, s_wizContentH - winSize.y); + // Don't steal the wheel from an open combo popup (e.g. the 9-item Language dropdown, which is a + // scrollable popup): NoPopupHierarchy stops the popup counting as hovering the wizard, and the + // IsPopupOpen guard ensures no wheel is consumed for the whole wizard while any popup is showing. + const bool wizPopupOpen = ImGui::IsPopupOpen("", ImGuiPopupFlags_AnyPopupId | ImGuiPopupFlags_AnyPopupLevel); + if (wizMaxScroll > 0.0f && !wizPopupOpen && + ImGui::IsWindowHovered(ImGuiHoveredFlags_ChildWindows | ImGuiHoveredFlags_NoPopupHierarchy)) { + float wheel = ImGui::GetIO().MouseWheel; + if (wheel != 0.0f) s_wizScroll -= wheel * 60.0f * dp; + } + s_wizScroll = std::max(0.0f, std::min(s_wizScroll, wizMaxScroll)); + const float scrollY = s_wizScroll; + // --- Header: Logo + Welcome --- - float headerCy = winPos.y + 20.0f * dp; + float headerCy = winPos.y - scrollY + 20.0f * dp; float logoSize = S.drawElement("screens.first-run", "logo").sizeOr(56.0f); if (logo_tex_ != 0) { float aspect = (logo_h_ > 0) ? (float)logo_w_ / (float)logo_h_ : 1.0f; @@ -1428,6 +1448,21 @@ void App::renderFirstRunWizard() { // Merge channels: backgrounds → content → overlays dl->ChannelsMerge(); + // Measure this frame's content height (feeds next frame's scroll clamp) and, when it overflows the + // window, draw a slim scroll indicator so the off-screen content is discoverable. + { + float contentBottom = std::max(card0Bot, std::max(card1Bot, card2Bot)); + s_wizContentH = (contentBottom - winPos.y + scrollY) + 24.0f * dp; + if (wizMaxScroll > 0.0f && s_wizContentH > 0.0f) { + float trackH = winSize.y - 8.0f * dp; + float thumbH = std::min(trackH, std::max(32.0f * dp, trackH * (winSize.y / s_wizContentH))); + float thumbY = winPos.y + 4.0f * dp + (trackH - thumbH) * (scrollY / wizMaxScroll); + float barX = winPos.x + winSize.x - 6.0f * dp; + dl->AddRectFilled(ImVec2(barX, thumbY), ImVec2(barX + 3.0f * dp, thumbY + thumbH), + ui::material::WithAlpha(ui::material::OnSurface(), 55), 1.5f * dp); + } + } + ImGui::End(); } diff --git a/src/ui/material/draw_helpers.h b/src/ui/material/draw_helpers.h index 0111650..fc21527 100644 --- a/src/ui/material/draw_helpers.h +++ b/src/ui/material/draw_helpers.h @@ -1403,6 +1403,7 @@ struct OverlayCardState { int stableCount = 0; // consecutive frames the height held steady (within 1px) int appearFrames = 0; // frames since (re)appearing while still hidden — a safety cap bool shown = false; // revealed (centered) at least once this open; don't re-hide after + bool overflow = false; // content once exceeded the viewport → clamp to viewport + scroll (sticky/open) }; inline std::unordered_map g_overlayCardHeights; inline std::string g_overlayCurrentKey; @@ -1528,6 +1529,7 @@ inline bool BeginOverlayDialog(const OverlayDialogSpec& spec) float cardX = vp_pos.x + (vp_size.x - cardWidth) * 0.5f; float cardY, cardBottomY; bool hideForMeasure = false; // true on an auto-height dialog's first (unmeasured) frame + bool autoOverflow = false; // auto-height content taller than the viewport → clamp + scroll const bool fixedHeight = (spec.cardHeight > 0.0f); if (fixedHeight) { float cardH = std::min(spec.cardHeight * dp, vp_size.y - 32.0f); @@ -1537,9 +1539,16 @@ inline bool BeginOverlayDialog(const OverlayDialogSpec& spec) } else { g_overlayCurrentKey = childId; OverlayCardState& cs = g_overlayCardHeights[childId]; - if (scrimAppearing) { cs.shown = false; cs.stableCount = 0; cs.appearFrames = 0; } + if (scrimAppearing) { cs.shown = false; cs.stableCount = 0; cs.appearFrames = 0; cs.overflow = false; } if (!cs.shown) cs.appearFrames++; const float measuredH = cs.height; + const float maxCardH = vp_size.y - 32.0f; + // Once the measured content is taller than the viewport, lock the card to the viewport height and + // let its content child scroll (autoOverflow) so the footer/actions stay reachable. Sticky for this + // open: clamping makes next frame's measured height the clamped value, so re-deciding from it would + // oscillate — decide once and hold until the dialog re-opens. + if (measuredH > maxCardH) cs.overflow = true; + autoOverflow = cs.overflow; // Reveal once the measured height has settled (auto-resize converges in ~2 frames) or it's // already been shown this open (don't re-hide on a mid-dialog content change); a frame cap // guarantees a pathological ever-changing height can't hide the dialog forever. @@ -1547,11 +1556,18 @@ inline bool BeginOverlayDialog(const OverlayDialogSpec& spec) (cs.shown || cs.stableCount >= 1 || cs.appearFrames >= 8); if (ready) { cs.shown = true; - // Center the measured content; if it's taller than the window, anchor at the top margin. - cardY = (measuredH < vp_size.y - 32.0f) - ? vp_pos.y + (vp_size.y - measuredH) * 0.5f - : vp_pos.y + 16.0f; - cardBottomY = cardY + measuredH; + if (autoOverflow) { + // Taller than the screen: top-anchor at the 16px margin, clamp to the viewport; the + // content child (below) becomes the scroll region so the footer/actions stay reachable. + cardY = vp_pos.y + 16.0f; + cardBottomY = cardY + maxCardH; + } else { + // Center the measured content; if it's taller than the window, anchor at the top margin. + cardY = (measuredH < maxCardH) + ? vp_pos.y + (vp_size.y - measuredH) * 0.5f + : vp_pos.y + 16.0f; + cardBottomY = cardY + measuredH; + } } else { // Still settling: lay the content out (so the auto-height child gets measured) but keep // the card hidden (hideForMeasure below) so it never flashes off-center — it appears, @@ -1584,14 +1600,21 @@ inline bool BeginOverlayDialog(const OverlayDialogSpec& spec) ImGui::PushStyleVar(ImGuiStyleVar_ChildRounding, floating ? 20.0f : 16.0f); ImGui::PushStyleVar(ImGuiStyleVar_WindowPadding, floating ? ImVec2(28, 20) : ImVec2(28, 24)); ImGui::PushStyleColor(ImGuiCol_ChildBg, ImVec4(0, 0, 0, 0)); // transparent (glass/blur behind) - ImGuiChildFlags cflags = ImGuiChildFlags_AlwaysUseWindowPadding | (fixedHeight ? 0 : ImGuiChildFlags_AutoResizeY); + // A card with a known height is a fixed frame (fixed-height dialogs, and auto-height dialogs whose + // content overflowed the viewport); otherwise the child auto-resizes to its content. + const bool clampedCard = fixedHeight || autoOverflow; + ImGuiChildFlags cflags = ImGuiChildFlags_AlwaysUseWindowPadding | (clampedCard ? 0 : ImGuiChildFlags_AutoResizeY); // NoScrollWithMouse (not just NoScrollbar): a modal is a fixed frame — the wheel must never drift // the WHOLE card. If content marginally overflows a fixed card, the wheel would otherwise scroll // the entire dialog (title + footer and all). Inner scroll regions (lists, notes) still scroll on - // their own; auto-height cards resize to content so they never overflow anyway. + // their own; auto-height cards resize to content so they normally never overflow — EXCEPT when the + // content is taller than the viewport (autoOverflow), where the card itself IS the scroll region. + ImGuiWindowFlags childScroll = autoOverflow + ? ImGuiWindowFlags_None + : (ImGuiWindowFlags_NoScrollbar | ImGuiWindowFlags_NoScrollWithMouse); bool childVisible = ImGui::BeginChild(childId.c_str(), - ImVec2(cardWidth, fixedHeight ? (cardBottomY - cardY) : 0.0f), - cflags, ImGuiWindowFlags_NoScrollbar | ImGuiWindowFlags_NoScrollWithMouse); + ImVec2(cardWidth, clampedCard ? (cardBottomY - cardY) : 0.0f), + cflags, childScroll); // Floating (portfolio-style) cards: the padding applies to this content child only, so pop it // now (nested children mustn't inherit it), and center button labels. Net style-var count stays // at 2 (ChildRounding + ButtonTextAlign) so EndOverlayDialog's PopStyleVar(2) is unchanged. diff --git a/src/ui/windows/balance_components.cpp b/src/ui/windows/balance_components.cpp index 4ef26d8..f03949f 100644 --- a/src/ui/windows/balance_components.cpp +++ b/src/ui/windows/balance_components.cpp @@ -116,7 +116,7 @@ void RenderCompactHero(App* app, ImDrawList* dl, float availW, float hs, float v // Render the shared address list section (used by all layouts) void RenderSharedAddressList(App* app, float listH, float availW, - float glassRound, float hs, float vs) { + float glassRound, float hs, float vs, float reserveBelow) { using namespace material; const auto& S = schema::UISchema::instance(); const float dp = Layout::dpiScale(); @@ -225,6 +225,14 @@ void RenderSharedAddressList(App* app, float listH, float availW, // ---- Glass panel container ---- float addrListH = listH; + // Cap the card to the space that actually remains here (measured AFTER the title + toolbar are laid + // out, so no chrome modelling is needed) minus what the caller reserves for the section below it + // (recent-tx). Without this, a fixed dp-scaled listH grows ~1.5x at high font scale and evicts the + // Recent Transactions list off the bottom of the fixed, non-scrolling tab host. + if (reserveBelow > 0.0f) { + float maxH = ImGui::GetContentRegionAvail().y - reserveBelow; + if (maxH < addrListH) addrListH = maxH; + } if (addrListH < 40.0f * dp) addrListH = 40.0f * dp; ImDrawList* dlPanel = ImGui::GetWindowDrawList(); diff --git a/src/ui/windows/balance_components.h b/src/ui/windows/balance_components.h index 427f663..fb028ac 100644 --- a/src/ui/windows/balance_components.h +++ b/src/ui/windows/balance_components.h @@ -26,7 +26,8 @@ extern bool s_generating_z_address; void UpdateBalanceLerp(App* app); void RenderCompactHero(App* app, ImDrawList* dl, float availW, float hs, float vs, float heroHeightOverride = -1.0f); -void RenderSharedAddressList(App* app, float listH, float availW, float glassRound, float hs, float vs); +void RenderSharedAddressList(App* app, float listH, float availW, float glassRound, float hs, float vs, + float reserveBelow = 0.0f); void RenderSharedRecentTx(App* app, float recentH, float availW, float hs, float vs); void RenderSyncBar(App* app, ImDrawList* dl, float vs); diff --git a/src/ui/windows/balance_tab.cpp b/src/ui/windows/balance_tab.cpp index 3bfde21..a505bf2 100644 --- a/src/ui/windows/balance_tab.cpp +++ b/src/ui/windows/balance_tab.cpp @@ -661,7 +661,7 @@ static void RenderBalanceClassic(App* app) float addrH = (classicAddrH >= 0.0f) ? classicAddrH * dp : ImGui::GetContentRegionAvail().y - recentReserve - Layout::spacingXl() - Type().h6()->LegacySize - Layout::spacingMd(); - RenderSharedAddressList(app, addrH, contentAvail.x, glassRound, hs, vs); + RenderSharedAddressList(app, addrH, contentAvail.x, glassRound, hs, vs, recentReserve); RenderSharedRecentTx(app, recentReserve, contentAvail.x, hs, vs); } } @@ -835,7 +835,7 @@ static void RenderBalanceDonut(App* app) { float addrH = (donutAddrOverride >= 0.0f) ? donutAddrOverride * dp : ImGui::GetContentRegionAvail().y - recentReserve - Layout::spacingXl() - Type().h6()->LegacySize - Layout::spacingMd(); - RenderSharedAddressList(app, addrH, availW, glassRound, hs, vs); + RenderSharedAddressList(app, addrH, availW, glassRound, hs, vs, recentReserve); RenderSharedRecentTx(app, recentReserve, availW, hs, vs); } @@ -1018,7 +1018,7 @@ static void RenderBalanceConsolidated(App* app) { float addrH = (consAddrOverride >= 0.0f) ? consAddrOverride * dp : ImGui::GetContentRegionAvail().y - recentReserve - Layout::spacingXl() - Type().h6()->LegacySize - Layout::spacingMd(); - RenderSharedAddressList(app, addrH, availW, glassRound, hs, vs); + RenderSharedAddressList(app, addrH, availW, glassRound, hs, vs, recentReserve); RenderSharedRecentTx(app, recentReserve, availW, hs, vs); } @@ -1175,7 +1175,7 @@ static void RenderBalanceDashboard(App* app) { float addrH = (dashAddrOverride >= 0.0f) ? dashAddrOverride * dp : ImGui::GetContentRegionAvail().y - recentReserve - Layout::spacingXl() - Type().h6()->LegacySize - Layout::spacingMd(); - RenderSharedAddressList(app, addrH, availW, glassRound, hs, vs); + RenderSharedAddressList(app, addrH, availW, glassRound, hs, vs, recentReserve); RenderSharedRecentTx(app, recentReserve, availW, hs, vs); } @@ -1354,7 +1354,7 @@ static void RenderBalanceVerticalStack(App* app) { float addrH = (vstackAddrOverride >= 0.0f) ? vstackAddrOverride * dp : ImGui::GetContentRegionAvail().y - recentReserve - Layout::spacingXl() - Type().h6()->LegacySize - Layout::spacingMd(); - RenderSharedAddressList(app, addrH, availW, glassRound, hs, vs); + RenderSharedAddressList(app, addrH, availW, glassRound, hs, vs, recentReserve); RenderSharedRecentTx(app, recentReserve, availW, hs, vs); } @@ -1549,7 +1549,7 @@ static void RenderBalanceVertical2x2(App* app) { float addrH = (addrOverride >= 0.0f) ? addrOverride * dp : ImGui::GetContentRegionAvail().y - recentReserve - Layout::spacingXl() - Type().h6()->LegacySize - Layout::spacingMd(); - RenderSharedAddressList(app, addrH, availW, glassRound, hs, vs); + RenderSharedAddressList(app, addrH, availW, glassRound, hs, vs, recentReserve); RenderSharedRecentTx(app, recentReserve, availW, hs, vs); } @@ -1731,7 +1731,7 @@ static void RenderBalanceShield(App* app) { float addrH = (shieldAddrOverride >= 0.0f) ? shieldAddrOverride * dp : ImGui::GetContentRegionAvail().y - recentReserve - Layout::spacingXl() - Type().h6()->LegacySize - Layout::spacingMd(); - RenderSharedAddressList(app, addrH, availW, glassRound, hs, vs); + RenderSharedAddressList(app, addrH, availW, glassRound, hs, vs, recentReserve); RenderSharedRecentTx(app, recentReserve, availW, hs, vs); } @@ -1890,7 +1890,7 @@ static void RenderBalanceTimeline(App* app) { float addrH = (tlAddrOverride >= 0.0f) ? tlAddrOverride * dp : ImGui::GetContentRegionAvail().y - recentReserve - Layout::spacingXl() - Type().h6()->LegacySize - Layout::spacingMd(); - RenderSharedAddressList(app, addrH, availW, glassRound, hs, vs); + RenderSharedAddressList(app, addrH, availW, glassRound, hs, vs, recentReserve); RenderSharedRecentTx(app, recentReserve, availW, hs, vs); } @@ -2081,7 +2081,7 @@ static void RenderBalanceTwoRow(App* app) { float addrH = (twoRowAddrOverride >= 0.0f) ? twoRowAddrOverride * dp : ImGui::GetContentRegionAvail().y - recentReserve - Layout::spacingXl() - Type().h6()->LegacySize - Layout::spacingMd(); - RenderSharedAddressList(app, addrH, availW, glassRound, hs, vs); + RenderSharedAddressList(app, addrH, availW, glassRound, hs, vs, recentReserve); RenderSharedRecentTx(app, recentReserve, availW, hs, vs); } @@ -2174,7 +2174,7 @@ static void RenderBalanceMinimal(App* app) { float addrH = (minAddrOverride >= 0.0f) ? minAddrOverride * dp : ImGui::GetContentRegionAvail().y - recentReserve - Layout::spacingXl() - Type().h6()->LegacySize - Layout::spacingMd(); - RenderSharedAddressList(app, addrH, availW, glassRound, hs, vs); + RenderSharedAddressList(app, addrH, availW, glassRound, hs, vs, recentReserve); RenderSharedRecentTx(app, recentReserve, availW, hs, vs); } diff --git a/src/ui/windows/settings_window.cpp b/src/ui/windows/settings_window.cpp index 4e40782..490c241 100644 --- a/src/ui/windows/settings_window.cpp +++ b/src/ui/windows/settings_window.cpp @@ -478,7 +478,12 @@ void RenderSettingsWindow(App* app, bool* p_open) // Confirmation dialog if (s_confirm_clear_ztx) { - if (material::BeginOverlayDialog(TR("confirm_clear_ztx_title"), &s_confirm_clear_ztx, 480.0f, 0.94f)) { + // Distinct idSuffix: this confirm renders nested inside (and the same frame as) the parent + // settings dialog, so it must not share the default ##OverlayDialogContent key — otherwise it + // inherits the parent's OverlayCardState (incl. the sticky overflow flag) and collides on the + // child window id. + if (material::BeginOverlayDialog(TR("confirm_clear_ztx_title"), &s_confirm_clear_ztx, 480.0f, + 0.94f, 0.85f, "settings_clearztx")) { material::DialogWarningHeader(TR("warning"), ImVec4(1.0f, 0.6f, 0.0f, 1.0f)); ImGui::Spacing(); From 99d1e73676922c81aa11fcacacc3e1acad32d7b0 Mon Sep 17 00:00:00 2001 From: DanS Date: Tue, 18 Aug 2026 20:53:29 -0500 Subject: [PATCH 54/89] =?UTF-8?q?fix(ui):=20scale=20unscaled=20geometry=20?= =?UTF-8?q?at=20HiDPI=20=E2=80=94=20inputs,=20send=20progress=20cards,=20c?= =?UTF-8?q?hat/pool=20overlaps,=20peer=20rows?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit At font_scale 1.5 ~13 sites read absolute geometry (schema .size/.width) straight into ImGui without ×dpiScale(), so they stayed native-size while the font grew and overlapped/clipped real text or money: - Shield/Merge fee + UTXO inputs, Request Payment amount, Block Info height input: ×dpiScale() so the value no longer clips (e.g. 0.00010000 -> 0.00010). - Send: the confirm-popup Amount Details divider (floored the row step at the scaled caption height so it no longer strikes the Fee row), the tx-progress error and sending/success cards, and the zero-balance CTA button — all ×dp. - Mining pool row: ellipsis-truncate the hostname so it can't collide with the right-aligned hashrate. - Chat conversation list: scale the pane-width clamp AND clip the peer name to the column left of the timestamp (measure-then-clip) so name and time never overlap. - Explorer block-detail label column, Peers row offsets, and DialogConfirmFooter button height — ×dp. transaction_details keeps its negative fill-sentinel widths unscaled (a content margin, not raw px). Verified at font_scale 1.5 across full-node + Lite + Windows (ctest green) and an adversarial diff review (three wrong-scale regressions fixed). Co-Authored-By: Claude Opus 4.8 (1M context) --- src/ui/material/draw_helpers.h | 2 +- src/ui/windows/block_info_dialog.cpp | 2 +- src/ui/windows/chat_tab.cpp | 16 ++++--- src/ui/windows/explorer_tab.cpp | 3 +- src/ui/windows/mining_stats.cpp | 18 ++++++-- src/ui/windows/peers_tab.cpp | 40 +++++++++-------- src/ui/windows/request_payment_dialog.cpp | 2 +- src/ui/windows/send_tab.cpp | 45 +++++++++++-------- src/ui/windows/shield_dialog.cpp | 4 +- src/ui/windows/transaction_details_dialog.cpp | 7 +-- 10 files changed, 84 insertions(+), 55 deletions(-) diff --git a/src/ui/material/draw_helpers.h b/src/ui/material/draw_helpers.h index fc21527..8212376 100644 --- a/src/ui/material/draw_helpers.h +++ b/src/ui/material/draw_helpers.h @@ -1737,7 +1737,7 @@ inline void DialogWarningHeader(const char* warningLabel, const ImVec4& col = Wa inline void DialogConfirmFooter(const char* cancelId, const char* confirmLabel, bool danger, bool& outCancel, bool& outConfirm) { - float btnH = schema::UI().drawElement("components.overlay-dialog", "confirm-btn-height").sizeOr(40.0f); + float btnH = schema::UI().drawElement("components.overlay-dialog", "confirm-btn-height").sizeOr(40.0f) * Layout::dpiScale(); float btnW = (ImGui::GetContentRegionAvail().x - ImGui::GetStyle().ItemSpacing.x) * 0.5f; if (ImGui::Button(cancelId, ImVec2(btnW, btnH))) { outCancel = true; diff --git a/src/ui/windows/block_info_dialog.cpp b/src/ui/windows/block_info_dialog.cpp index a38f3b2..6f266c8 100644 --- a/src/ui/windows/block_info_dialog.cpp +++ b/src/ui/windows/block_info_dialog.cpp @@ -112,7 +112,7 @@ void BlockInfoDialog::render(App* app) // Height input ImGui::Text("%s", TR("block_height")); - ImGui::SetNextItemWidth(heightInput.width); + ImGui::SetNextItemWidth(heightInput.width * Layout::dpiScale()); ImGui::InputInt("##Height", &s_height); if (s_height < 1) s_height = 1; // Clamp to the chain tip so navigation/typing can't request a height diff --git a/src/ui/windows/chat_tab.cpp b/src/ui/windows/chat_tab.cpp index d17e3d9..8bea45b 100644 --- a/src/ui/windows/chat_tab.cpp +++ b/src/ui/windows/chat_tab.cpp @@ -776,7 +776,7 @@ void RenderChatTab(App* app) } const ImVec2 avail = ImGui::GetContentRegionAvail(); - const float listW = std::clamp(avail.x * 0.32f, 220.0f, 360.0f); + const float listW = std::clamp(avail.x * 0.32f, 220.0f * Layout::dpiScale(), 360.0f * Layout::dpiScale()); // Row geometry is logical px — scale by dpiScale() so rows/padding grow with the (DPI-scaled) // fonts. Left raw, at higher DPI the row was too short for the enlarged text and the preview's // right margin (rowW - pad) shrank to ~zero, clipping the last glyph mid-word. @@ -895,16 +895,22 @@ void RenderChatTab(App* app) } const float textX = avC.x + avR + pad; - // Name (top). Hidden conversations (shown via "Show hidden") render dimmed. - dl->AddText(nameFont, nameSz, ImVec2(textX, p.y + pad), - c.hidden ? material::OnSurfaceMedium() : material::OnSurface(), c.peerName.c_str()); - // Time (top-right, muted) — compact relative form (Q5). + // Time (top-right, muted) — compact relative form (Q5). Measure/draw it FIRST so the name can be + // clipped to the column left of it — otherwise a long peer name overruns the timestamp (worse at + // HiDPI, where the fixed-length name grows ~1.5x). const std::string when = relativeTime(c.lastTs); + float nameRight = mx.x - pad; if (!when.empty()) { const ImVec2 wsz = metaFont->CalcTextSizeA(metaSz, FLT_MAX, 0.0f, when.c_str()); dl->AddText(metaFont, metaSz, ImVec2(mx.x - pad - wsz.x, p.y + pad + 1.0f), material::OnSurfaceMedium(), when.c_str()); + nameRight = mx.x - pad - wsz.x - pad; // reserve the timestamp column + a gap } + // Name (top), clipped to the space left of the timestamp. Hidden conversations render dimmed. + dl->PushClipRect(ImVec2(textX, p.y), ImVec2(std::max(textX, nameRight), mx.y), true); + dl->AddText(nameFont, nameSz, ImVec2(textX, p.y + pad), + c.hidden ? material::OnSurfaceMedium() : material::OnSurface(), c.peerName.c_str()); + dl->PopClipRect(); // Preview (bottom, clipped to the text column, muted). const std::string preview = previewOf(c.lastBody); dl->PushClipRect(ImVec2(textX, p.y), ImVec2(mx.x - pad, mx.y), true); diff --git a/src/ui/windows/explorer_tab.cpp b/src/ui/windows/explorer_tab.cpp index 7c45215..fd466aa 100644 --- a/src/ui/windows/explorer_tab.cpp +++ b/src/ui/windows/explorer_tab.cpp @@ -1116,8 +1116,9 @@ static void renderBlockDetailModal(App* app) { // ── Info grid ── ImDrawList* dl = ImGui::GetWindowDrawList(); + float dp = Layout::dpiScale(); float rowH = capFont->LegacySize + Layout::spacingXs() + sub1->LegacySize; - float labelW = S.drawElement("tabs.explorer", "label-column").size; + float labelW = S.drawElement("tabs.explorer", "label-column").size * dp; { ImVec2 gridPos = ImGui::GetCursorScreenPos(); float gx = gridPos.x; diff --git a/src/ui/windows/mining_stats.cpp b/src/ui/windows/mining_stats.cpp index 31fba5a..231f1f4 100644 --- a/src/ui/windows/mining_stats.cpp +++ b/src/ui/windows/mining_stats.cpp @@ -312,11 +312,11 @@ static void RenderLeftPoolCard(App* app, const WalletState& state, ImDrawList* d isCurrent ? Success() : OnSurfaceDisabled()); const float textY = rMin.y + (listRowH - capFont->LegacySize) * 0.5f; - // Show the short host label (the narrow card can't fit host:port); the - // full stratum URL is in the hover tooltip. - cdl->AddText(capFont, capFont->LegacySize, ImVec2(rMin.x + 16 * dp, textY), - isCurrent ? Primary() : OnSurface(), kp.label.c_str()); + // Build the right-side " N% fee" run first so we know its width + // and can bound (and ellipsis-truncate) the left host label to avoid a + // collision — both text runs grow ~1.5x at font_scale 1.5 while the card + // width barely does. char right[64]; std::string hrStr = haveHr ? FormatHashrate(it->second.hashrateHs) : std::string("—"); // Prefer the live fee the pool reports; fall back to the compile-time @@ -331,6 +331,16 @@ static void RenderLeftPoolCard(App* app, const WalletState& state, ImDrawList* d else snprintf(right, sizeof(right), "%s", hrStr.c_str()); ImVec2 rSz = capFont->CalcTextSizeA(capFont->LegacySize, FLT_MAX, 0, right); + + // Show the short host label (the narrow card can't fit host:port); the + // full stratum URL is in the hover tooltip. Truncate it to the gap left + // of the right-side run so a long hostname can't overlap the hashrate. + const float labelX = rMin.x + 16 * dp; + const float labelMaxW = (rMax.x - rSz.x - 6 * dp - gap) - labelX; + std::string label = TruncateToWidth(kp.label, capFont, capFont->LegacySize, labelMaxW); + cdl->AddText(capFont, capFont->LegacySize, ImVec2(labelX, textY), + isCurrent ? Primary() : OnSurface(), label.c_str()); + cdl->AddText(capFont, capFont->LegacySize, ImVec2(rMax.x - rSz.x - 6 * dp, textY), OnSurfaceMedium(), right); diff --git a/src/ui/windows/peers_tab.cpp b/src/ui/windows/peers_tab.cpp index 8c6b118..036c268 100644 --- a/src/ui/windows/peers_tab.cpp +++ b/src/ui/windows/peers_tab.cpp @@ -627,6 +627,7 @@ void RenderPeersTab(App* app) ImGui::Dummy(ImVec2(0, 20)); Type().textColored(TypeStyle::Caption, OnSurfaceDisabled(), TR("peers_no_connected")); } else { + const float dp = ui::Layout::dpiScale(); float rowH = body2->LegacySize + capFont->LegacySize + Layout::spacingLg(); float rowInset = Layout::spacingLg(); float innerW = ImGui::GetContentRegionAvail().x - rowInset * 2; @@ -643,13 +644,13 @@ void RenderPeersTab(App* app) ImVec2 rowEnd(rowPos.x + innerW, rowPos.y + rowH); if (is_selected) { - dl->AddRectFilled(rowPos, rowEnd, IM_COL32(255, 255, 255, 20), S.drawElement("tabs.peers", "row-selection-rounding").size); - dl->AddRectFilled(rowPos, ImVec2(rowPos.x + S.drawElement("tabs.peers", "row-accent-width").size, rowEnd.y), Primary(), S.drawElement("tabs.peers", "row-accent-rounding").size); + dl->AddRectFilled(rowPos, rowEnd, IM_COL32(255, 255, 255, 20), S.drawElement("tabs.peers", "row-selection-rounding").size * dp); + dl->AddRectFilled(rowPos, ImVec2(rowPos.x + S.drawElement("tabs.peers", "row-accent-width").size * dp, rowEnd.y), Primary(), S.drawElement("tabs.peers", "row-accent-rounding").size * dp); } bool hovered = material::IsRectHovered(rowPos, rowEnd); if (hovered && !is_selected) { - dl->AddRectFilled(rowPos, rowEnd, IM_COL32(255, 255, 255, 15), S.drawElement("tabs.peers", "row-selection-rounding").size); + dl->AddRectFilled(rowPos, rowEnd, IM_COL32(255, 255, 255, 15), S.drawElement("tabs.peers", "row-selection-rounding").size * dp); ImGui::SetMouseCursor(ImGuiMouseCursor_Hand); } @@ -662,9 +663,9 @@ void RenderPeersTab(App* app) else if (ping_ms < 500) dotCol = Warning(); else dotCol = Error(); float pingDotR = S.drawElement("tabs.peers", "ping-dot-radius-base").size + S.drawElement("tabs.peers", "ping-dot-radius-scale").size * hs; - dl->AddCircleFilled(ImVec2(cx + S.drawElement("tabs.peers", "ping-dot-x-offset").size, cy + body2->LegacySize * 0.5f), pingDotR, dotCol); + dl->AddCircleFilled(ImVec2(cx + S.drawElement("tabs.peers", "ping-dot-x-offset").size * dp, cy + body2->LegacySize * 0.5f), pingDotR, dotCol); - float addrX = cx + S.drawElement("tabs.peers", "address-x-offset").size; + float addrX = cx + S.drawElement("tabs.peers", "address-x-offset").size * dp; // Reserve the line-1 trailing zone (ping + direction pill live on the far right, // the nearest being the ping at innerW - pingW - spacingXl*3). A long IPv6+port // addr must clip before it so it can't run under those. Mirror the ping formula @@ -693,9 +694,9 @@ void RenderPeersTab(App* app) ImU32 dirFg = peer.inbound ? WithAlpha(Success(), 200) : WithAlpha(Secondary(), 200); ImVec2 dirSz = capFont->CalcTextSizeA(capFont->LegacySize, FLT_MAX, 0, dirLabel); float dirX = rowPos.x + innerW - dirSz.x - Layout::spacingXl(); - ImVec2 pillMin(dirX - S.drawElement("tabs.peers", "dir-pill-padding").size, cy + S.drawElement("tabs.peers", "dir-pill-y-offset").size); - ImVec2 pillMax(dirX + dirSz.x + S.drawElement("tabs.peers", "dir-pill-padding").size, cy + capFont->LegacySize + S.drawElement("tabs.peers", "dir-pill-y-bottom").size); - dl->AddRectFilled(pillMin, pillMax, dirBg, S.drawElement("tabs.peers", "dir-pill-rounding").size); + ImVec2 pillMin(dirX - S.drawElement("tabs.peers", "dir-pill-padding").size * dp, cy + S.drawElement("tabs.peers", "dir-pill-y-offset").size * dp); + ImVec2 pillMax(dirX + dirSz.x + S.drawElement("tabs.peers", "dir-pill-padding").size * dp, cy + capFont->LegacySize + S.drawElement("tabs.peers", "dir-pill-y-bottom").size * dp); + dl->AddRectFilled(pillMin, pillMax, dirBg, S.drawElement("tabs.peers", "dir-pill-rounding").size * dp); dl->AddText(capFont, capFont->LegacySize, ImVec2(dirX, cy + 2), dirFg, dirLabel); } @@ -708,7 +709,7 @@ void RenderPeersTab(App* app) } float cy2 = cy + body2->LegacySize + Layout::spacingXs(); - float subverX = cx + S.drawElement("tabs.peers", "address-x-offset").size; + float subverX = cx + S.drawElement("tabs.peers", "address-x-offset").size * dp; // Reserve the line-2 trailing widths up front so an untrusted, arbitrarily long // remote subver cannot push the TLS badge / ban-score off the row. Order right→left: @@ -747,7 +748,7 @@ void RenderPeersTab(App* app) ImU32 tlsFg = WithAlpha(Success(), 200); ImVec2 tlsMin(badgeX, cy2); ImVec2 tlsMax(tlsMin.x + tlsBadgeW, tlsMin.y + capFont->LegacySize + 2); - dl->AddRectFilled(tlsMin, tlsMax, tlsBg, S.drawElement("tabs.peers", "tls-badge-rounding").size); + dl->AddRectFilled(tlsMin, tlsMax, tlsBg, S.drawElement("tabs.peers", "tls-badge-rounding").size * dp); dl->AddText(capFont, capFont->LegacySize, ImVec2(tlsMin.x + 4, cy2 + 1), tlsFg, "TLS"); } else { dl->AddText(capFont, capFont->LegacySize, ImVec2(badgeX, cy2), @@ -815,7 +816,7 @@ void RenderPeersTab(App* app) if (i < state.peers.size() - 1) { ImVec2 divStart = ImGui::GetCursorScreenPos(); - dl->AddLine(ImVec2(divStart.x + pad + 18, divStart.y), + dl->AddLine(ImVec2(divStart.x + pad + 18 * dp, divStart.y), ImVec2(divStart.x + innerW - pad, divStart.y), IM_COL32(255, 255, 255, 15)); } @@ -832,7 +833,8 @@ void RenderPeersTab(App* app) ImGui::Dummy(ImVec2(0, 20)); Type().textColored(TypeStyle::Caption, OnSurfaceDisabled(), TR("peers_no_banned")); } else { - float rowH = capFont->LegacySize + S.drawElement("tabs.peers", "banned-row-height-padding").size; + const float dp = ui::Layout::dpiScale(); + float rowH = capFont->LegacySize + S.drawElement("tabs.peers", "banned-row-height-padding").size * dp; float rowInsetB = pad; float innerW = ImGui::GetContentRegionAvail().x - rowInsetB * 2; listScrollY = ImGui::GetScrollY(); @@ -848,21 +850,21 @@ void RenderPeersTab(App* app) ImVec2 rowEnd(rowPos.x + innerW, rowPos.y + rowH); if (is_selected) { - dl->AddRectFilled(rowPos, rowEnd, IM_COL32(255, 255, 255, 20), S.drawElement("tabs.peers", "banned-row-rounding").size); - dl->AddRectFilled(rowPos, ImVec2(rowPos.x + S.drawElement("tabs.peers", "row-accent-width").size, rowEnd.y), WithAlpha(Error(), 200), S.drawElement("tabs.peers", "banned-accent-rounding").size); + dl->AddRectFilled(rowPos, rowEnd, IM_COL32(255, 255, 255, 20), S.drawElement("tabs.peers", "banned-row-rounding").size * dp); + dl->AddRectFilled(rowPos, ImVec2(rowPos.x + S.drawElement("tabs.peers", "row-accent-width").size * dp, rowEnd.y), WithAlpha(Error(), 200), S.drawElement("tabs.peers", "banned-accent-rounding").size * dp); } if (material::IsRectHovered(rowPos, rowEnd) && !is_selected) { - dl->AddRectFilled(rowPos, rowEnd, IM_COL32(255, 255, 255, 15), S.drawElement("tabs.peers", "banned-row-rounding").size); + dl->AddRectFilled(rowPos, rowEnd, IM_COL32(255, 255, 255, 15), S.drawElement("tabs.peers", "banned-row-rounding").size * dp); } float cx = rowPos.x + pad; float cy = rowPos.y + Layout::spacingXs(); float banDotR = S.drawElement("tabs.peers", "ban-dot-radius-base").size + S.drawElement("tabs.peers", "ban-dot-radius-scale").size * hs; - dl->AddCircleFilled(ImVec2(cx + S.drawElement("tabs.peers", "ban-dot-x-offset").size, cy + capFont->LegacySize * 0.4f), banDotR, WithAlpha(Error(), 200)); + dl->AddCircleFilled(ImVec2(cx + S.drawElement("tabs.peers", "ban-dot-x-offset").size * dp, cy + capFont->LegacySize * 0.4f), banDotR, WithAlpha(Error(), 200)); - dl->AddText(capFont, capFont->LegacySize, ImVec2(cx + S.drawElement("tabs.peers", "banned-address-x-offset").size, cy), + dl->AddText(capFont, capFont->LegacySize, ImVec2(cx + S.drawElement("tabs.peers", "banned-address-x-offset").size * dp, cy), OnSurfaceDisabled(), banned.address.c_str()); std::string banUntil = banned.getBannedUntilString(); @@ -878,7 +880,7 @@ void RenderPeersTab(App* app) } ImGui::SetCursorScreenPos(rowPos); - ImGui::InvisibleButton("##bannedRow", ImVec2(innerW - S.drawElement("tabs.peers", "banned-row-btn-reserve").size, rowH)); + ImGui::InvisibleButton("##bannedRow", ImVec2(innerW - S.drawElement("tabs.peers", "banned-row-btn-reserve").size * dp, rowH)); if (ImGui::IsItemClicked(0)) { s_selected_banned_idx = static_cast(i); } @@ -898,7 +900,7 @@ void RenderPeersTab(App* app) if (i < state.bannedPeers.size() - 1) { ImVec2 divStart = ImGui::GetCursorScreenPos(); - dl->AddLine(ImVec2(divStart.x + pad + 8, divStart.y), + dl->AddLine(ImVec2(divStart.x + pad + 8 * dp, divStart.y), ImVec2(divStart.x + innerW - pad, divStart.y), IM_COL32(255, 255, 255, 15)); } diff --git a/src/ui/windows/request_payment_dialog.cpp b/src/ui/windows/request_payment_dialog.cpp index d61bbbe..67dc271 100644 --- a/src/ui/windows/request_payment_dialog.cpp +++ b/src/ui/windows/request_payment_dialog.cpp @@ -146,7 +146,7 @@ void RequestPaymentDialog::render(App* app) // Amount (optional) ImGui::Text("%s", TR("request_amount")); - ImGui::SetNextItemWidth(amountInput.width); + ImGui::SetNextItemWidth(amountInput.width * Layout::dpiScale()); if (ImGui::InputDouble("##Amount", &s_amount, 0.1, 1.0, "%.8f")) { s_uri_dirty = true; } diff --git a/src/ui/windows/send_tab.cpp b/src/ui/windows/send_tab.cpp index 4d2940d..343a632 100644 --- a/src/ui/windows/send_tab.cpp +++ b/src/ui/windows/send_tab.cpp @@ -539,6 +539,8 @@ static void RenderTxProgress(ImDrawList* dl, float x, float y, float w, } if (s_tx_status.empty() && !s_sending) return; + const float dp = Layout::dpiScale(); + // Drive error styling from the authoritative result flag, not English substrings in a // (translatable) status string — otherwise a failed send renders as a green success // under a non-English locale. @@ -547,8 +549,8 @@ static void RenderTxProgress(ImDrawList* dl, float x, float y, float w, // ---- ERROR: absolute-positioned overlay, does not displace layout ---- if (is_error) { float pad = Layout::spacingLg(); - float btnH = std::max(schema::UI().drawElement("tabs.send", "error-btn-min-height").size, schema::UI().drawElement("tabs.send", "error-btn-height").size); - float textWrapW = w - pad * 2 - schema::UI().drawElement("tabs.send", "error-icon-inset").size; // icon space + float btnH = std::max(schema::UI().drawElement("tabs.send", "error-btn-min-height").size, schema::UI().drawElement("tabs.send", "error-btn-height").size) * dp; + float textWrapW = w - pad * 2 - schema::UI().drawElement("tabs.send", "error-icon-inset").size * dp; // icon space ImVec2 textSz = body2->CalcTextSizeA(body2->LegacySize, FLT_MAX, textWrapW, s_tx_status.c_str()); float contentH = textSz.y + Layout::spacingMd() + btnH + pad * 2; @@ -572,7 +574,7 @@ static void RenderTxProgress(ImDrawList* dl, float x, float y, float w, DrawGlassPanel(fgDl, pMin, pMax, errGlass); // Red accent bar on left - fgDl->AddRectFilled(pMin, ImVec2(pMin.x + schema::UI().drawElement("tabs.send", "error-accent-bar-width").size, pMax.y), Error(), errGlass.rounding); + fgDl->AddRectFilled(pMin, ImVec2(pMin.x + schema::UI().drawElement("tabs.send", "error-accent-bar-width").size * dp, pMax.y), Error(), errGlass.rounding); float ix = pMin.x + pad; float iy = pMin.y + pad; @@ -583,18 +585,18 @@ static void RenderTxProgress(ImDrawList* dl, float x, float y, float w, const char* errIcon = ICON_MD_ERROR; ImVec2 iSz = iconFont->CalcTextSizeA(iconFont->LegacySize, 1000.0f, 0.0f, errIcon); fgDl->AddText(iconFont, iconFont->LegacySize, - ImVec2(ix + schema::UI().drawElement("tabs.send", "error-icon-x-offset").size, iy + body2->LegacySize * 0.5f - iSz.y * 0.5f), + ImVec2(ix + schema::UI().drawElement("tabs.send", "error-icon-x-offset").size * dp, iy + body2->LegacySize * 0.5f - iSz.y * 0.5f), Error(), errIcon); } // Error text (wrapped) - fgDl->AddText(body2, body2->LegacySize, ImVec2(ix + schema::UI().drawElement("tabs.send", "error-text-x-offset").size, iy), Error(), + fgDl->AddText(body2, body2->LegacySize, ImVec2(ix + schema::UI().drawElement("tabs.send", "error-text-x-offset").size * dp, iy), Error(), s_tx_status.c_str(), s_tx_status.c_str() + s_tx_status.size(), textWrapW); // Buttons row — use invisible window for interactive widgets on top of overlay float btnY = iy + textSz.y + Layout::spacingMd(); ImGui::SetNextWindowPos(ImVec2(ix, btnY)); - ImGui::SetNextWindowSize(ImVec2(w - pad * 2, btnH + schema::UI().drawElement("tabs.send", "error-btn-area-padding").size)); + ImGui::SetNextWindowSize(ImVec2(w - pad * 2, btnH + schema::UI().drawElement("tabs.send", "error-btn-area-padding").size * dp)); ImGui::PushStyleColor(ImGuiCol_WindowBg, ImVec4(0, 0, 0, 0)); ImGui::PushStyleColor(ImGuiCol_Border, ImVec4(0, 0, 0, 0)); ImGui::PushStyleVar(ImGuiStyleVar_WindowPadding, ImVec2(0, 0)); @@ -606,7 +608,7 @@ static void RenderTxProgress(ImDrawList* dl, float x, float y, float w, ImGuiWindowFlags_NoBringToFrontOnFocus); ImGui::PushStyleColor(ImGuiCol_Button, ImGui::ColorConvertU32ToFloat4(IM_COL32(255, 255, 255, (int)schema::UI().drawElement("tabs.send", "error-btn-bg-alpha").size))); ImGui::PushStyleColor(ImGuiCol_ButtonHovered, ImGui::ColorConvertU32ToFloat4(IM_COL32(255, 255, 255, (int)schema::UI().drawElement("tabs.send", "error-btn-hover-alpha").size))); - ImGui::PushStyleVar(ImGuiStyleVar_FrameRounding, schema::UI().drawElement("tabs.send", "error-btn-rounding").size); + ImGui::PushStyleVar(ImGuiStyleVar_FrameRounding, schema::UI().drawElement("tabs.send", "error-btn-rounding").size * dp); if (TactileSmallButton(TR("send_copy_error"), schema::UI().resolveFont("button"))) { ImGui::SetClipboardText(s_tx_status.c_str()); Notifications::instance().info(TR("send_error_copied")); @@ -629,8 +631,8 @@ static void RenderTxProgress(ImDrawList* dl, float x, float y, float w, } // ---- SENDING / SUCCESS: inline progress card ---- - float progCardH = schema::UI().drawElement("tabs.send", "progress-card-height").size; - float progCardHTxid = schema::UI().drawElement("tabs.send", "progress-card-height-txid").size; + float progCardH = schema::UI().drawElement("tabs.send", "progress-card-height").size * dp; + float progCardHTxid = schema::UI().drawElement("tabs.send", "progress-card-height-txid").size * dp; float progH = s_result_txid.empty() ? progCardH : progCardHTxid; ImVec2 pMin(x, y); ImVec2 pMax(x + w, y + progH); @@ -639,8 +641,8 @@ static void RenderTxProgress(ImDrawList* dl, float x, float y, float w, progGlass.rounding = Layout::glassRounding() * schema::UI().drawElement("tabs.send", "progress-glass-rounding-ratio").size; DrawGlassPanel(dl, pMin, pMax, progGlass); - float progPadX = schema::UI().drawElement("tabs.send", "progress-card-pad-x").size; - float progPadY = schema::UI().drawElement("tabs.send", "progress-card-pad-y").size; + float progPadX = schema::UI().drawElement("tabs.send", "progress-card-pad-x").size * dp; + float progPadY = schema::UI().drawElement("tabs.send", "progress-card-pad-y").size * dp; float ix = pMin.x + progPadX; float iy = pMin.y + progPadY; char buf[128]; @@ -654,7 +656,7 @@ static void RenderTxProgress(ImDrawList* dl, float x, float y, float w, ImVec2(ix, iy), Primary(), spinIcon); double elapsed = ImGui::GetTime() - s_send_start_time; snprintf(buf, sizeof(buf), TR("send_submitting"), elapsed); - dl->AddText(body2, body2->LegacySize, ImVec2(ix + iSz.x + schema::UI().drawElement("tabs.send", "progress-icon-text-gap").size, iy), OnSurface(), buf); + dl->AddText(body2, body2->LegacySize, ImVec2(ix + iSz.x + schema::UI().drawElement("tabs.send", "progress-icon-text-gap").size * dp, iy), OnSurface(), buf); } else { // Success checkmark ImFont* iconFont = material::Type().iconMed(); @@ -662,19 +664,19 @@ static void RenderTxProgress(ImDrawList* dl, float x, float y, float w, ImVec2 iSz = iconFont->CalcTextSizeA(iconFont->LegacySize, 1000.0f, 0.0f, checkIcon); dl->AddText(iconFont, iconFont->LegacySize, ImVec2(ix, iy), Success(), checkIcon); - dl->AddText(body2, body2->LegacySize, ImVec2(ix + iSz.x + schema::UI().drawElement("tabs.send", "progress-icon-text-gap").size, iy), Success(), TR("send_tx_sent")); + dl->AddText(body2, body2->LegacySize, ImVec2(ix + iSz.x + schema::UI().drawElement("tabs.send", "progress-icon-text-gap").size * dp, iy), Success(), TR("send_tx_sent")); if (!s_result_txid.empty()) { - float txY = iy + body2->LegacySize + schema::UI().drawElement("tabs.send", "txid-y-offset").size; + float txY = iy + body2->LegacySize + schema::UI().drawElement("tabs.send", "txid-y-offset").size * dp; int txidThreshold = (int)schema::UI().drawElement("tabs.send", "txid-display-threshold").size; int txidTruncLen = (int)schema::UI().drawElement("tabs.send", "txid-trunc-len").size; std::string dispTxid = (int)s_result_txid.length() > txidThreshold ? s_result_txid.substr(0, txidTruncLen) + "..." + s_result_txid.substr(s_result_txid.length() - txidTruncLen) : s_result_txid; snprintf(buf, sizeof(buf), TR("send_txid_label"), dispTxid.c_str()); - dl->AddText(capFont, capFont->LegacySize, ImVec2(ix + schema::UI().drawElement("tabs.send", "txid-label-x-offset").size, txY), + dl->AddText(capFont, capFont->LegacySize, ImVec2(ix + schema::UI().drawElement("tabs.send", "txid-label-x-offset").size * dp, txY), OnSurfaceDisabled(), buf); - ImGui::SetCursorScreenPos(ImVec2(pMax.x - schema::UI().drawElement("tabs.send", "txid-copy-btn-right-offset").size, txY - schema::UI().drawElement("tabs.send", "txid-copy-btn-y-offset").size)); + ImGui::SetCursorScreenPos(ImVec2(pMax.x - schema::UI().drawElement("tabs.send", "txid-copy-btn-right-offset").size * dp, txY - schema::UI().drawElement("tabs.send", "txid-copy-btn-y-offset").size * dp)); if (TactileSmallButton(TR("copy"), schema::UI().resolveFont("button"))) { ImGui::SetClipboardText(s_result_txid.c_str()); Notifications::instance().info(TR("send_txid_copied")); @@ -726,6 +728,7 @@ void RenderSendConfirmPopup(App* app) { float popupAvailW = ImGui::GetMainViewport()->Size.x * S.drawElement("tabs.send", "confirm-popup-width-ratio").size; float popupW = std::min(schema::UI().drawElement("tabs.send", "confirm-popup-max-width").size, popupAvailW); float popVs = Layout::vScale(); + const float dp = Layout::dpiScale(); material::OverlayDialogSpec ov; ov.title = TR("confirm_send"); ov.p_open = nullptr; ov.style = material::OverlayStyle::BlurFloat; @@ -797,7 +800,12 @@ void RenderSendConfirmPopup(App* app) { Type().textColored(TypeStyle::Overline, OnSurfaceMedium(), TR("send_amount_details")); ImVec2 cMin = ImGui::GetCursorScreenPos(); + // Floor the row step at the *actual* scaled caption-row height (+ a small dp-scaled + // gap) so the Fee/Total divider — drawn at rowStep*0.5 below the Fee baseline — + // clears the (already-DPI-scaled) fee text instead of striking through it at HiDPI. + // capFont->LegacySize is already DPI-scaled; do not scale it again. float rowStep = std::max(schema::UI().drawElement("tabs.send", "confirm-row-step-min").size, schema::UI().drawElement("tabs.send", "confirm-row-step").size * popVs); + rowStep = std::max(rowStep, capFont->LegacySize + 6.0f * dp); float configuredH = std::max(schema::UI().drawElement("tabs.send", "confirm-amount-card-min-height").size, schema::UI().drawElement("tabs.send", "confirm-amount-card-height").size * popVs); float contentH = Layout::spacingMd() * 2.0f + capFont->LegacySize * 2.0f + sub1->LegacySize + rowStep * 2.0f; float cH = std::max(configuredH, contentH); @@ -936,9 +944,10 @@ static bool RenderZeroBalanceCTA(App* app, ImDrawList* dl, float width) { ImFont* sub1 = Type().subtitle1(); ImFont* capFont = Type().caption(); + const float dp = Layout::dpiScale(); ImVec2 ctaMin = ImGui::GetCursorScreenPos(); - float ctaH = schema::UI().drawElement("tabs.send", "cta-height").size; + float ctaH = schema::UI().drawElement("tabs.send", "cta-height").size * dp; ImVec2 ctaMax(ctaMin.x + width, ctaMin.y + ctaH); GlassPanelSpec ctaGlass; ctaGlass.rounding = Layout::glassRounding(); @@ -952,7 +961,7 @@ static bool RenderZeroBalanceCTA(App* app, ImDrawList* dl, float width) { TR("send_switch_to_receive")); cy += capFont->LegacySize + Layout::spacingMd(); ImGui::SetCursorScreenPos(ImVec2(cx, cy)); - if (TactileButton(TR("send_go_to_receive"), ImVec2(schema::UI().drawElement("tabs.send", "cta-button-width").size, schema::UI().drawElement("tabs.send", "cta-button-height").size), schema::UI().resolveFont("button"))) { + if (TactileButton(TR("send_go_to_receive"), ImVec2(schema::UI().drawElement("tabs.send", "cta-button-width").size * dp, schema::UI().drawElement("tabs.send", "cta-button-height").size * dp), schema::UI().resolveFont("button"))) { app->setCurrentPage(NavPage::Receive); } ImGui::SetCursorScreenPos(ImVec2(ctaMin.x, ctaMax.y + Layout::spacingLg())); diff --git a/src/ui/windows/shield_dialog.cpp b/src/ui/windows/shield_dialog.cpp index 50a0699..488f524 100644 --- a/src/ui/windows/shield_dialog.cpp +++ b/src/ui/windows/shield_dialog.cpp @@ -148,7 +148,7 @@ void ShieldDialog::render(App* app) // Fee ImGui::Text("%s", TR("fee_label")); - ImGui::SetNextItemWidth(feeInput.width); + ImGui::SetNextItemWidth(feeInput.width * Layout::dpiScale()); ImGui::InputDouble("##Fee", &s_fee, 0.0001, 0.001, "%.8f"); if (s_fee < 0.0) s_fee = 0.0; // no negative fee if (s_fee > 1.0) s_fee = 1.0; // guard a fat-fingered huge fee (mirrors utxo clamp) @@ -159,7 +159,7 @@ void ShieldDialog::render(App* app) // UTXO limit ImGui::Text("%s", TR("shield_utxo_limit")); - ImGui::SetNextItemWidth(utxoInput.width); + ImGui::SetNextItemWidth(utxoInput.width * Layout::dpiScale()); ImGui::InputInt("##Limit", &s_utxo_limit); ImGui::SameLine(); ImGui::TextDisabled("%s", TR("shield_max_utxos")); diff --git a/src/ui/windows/transaction_details_dialog.cpp b/src/ui/windows/transaction_details_dialog.cpp index 031b337..d1f4635 100644 --- a/src/ui/windows/transaction_details_dialog.cpp +++ b/src/ui/windows/transaction_details_dialog.cpp @@ -121,7 +121,7 @@ void TransactionDetailsDialog::render(App* app) char txid_buf[128]; strncpy(txid_buf, tx.txid.c_str(), sizeof(txid_buf) - 1); txid_buf[sizeof(txid_buf) - 1] = '\0'; - ImGui::SetNextItemWidth(txidInput.width); + ImGui::SetNextItemWidth(txidInput.width); // negative = fill, reserving |width| px for the Copy button (a content-region margin, not raw px — must NOT be dpi-scaled) ImGui::InputText("##TxID", txid_buf, sizeof(txid_buf), ImGuiInputTextFlags_ReadOnly); ImGui::SameLine(); if (material::StyledButton("Copy##TxID", ImVec2(copyBtn.width, 0), S.resolveFont(copyBtn.font))) { @@ -139,13 +139,14 @@ void TransactionDetailsDialog::render(App* app) char addr_buf[512]; strncpy(addr_buf, tx.address.c_str(), sizeof(addr_buf) - 1); addr_buf[sizeof(addr_buf) - 1] = '\0'; + // width is a negative fill-with-right-margin sentinel — keep unscaled; only height is raw px. ImGui::InputTextMultiline("##Address", addr_buf, sizeof(addr_buf), - ImVec2(addrInput.width, addrInput.height > 0 ? addrInput.height : 50), ImGuiInputTextFlags_ReadOnly); + ImVec2(addrInput.width, (addrInput.height > 0 ? addrInput.height : 50) * Layout::dpiScale()), ImGuiInputTextFlags_ReadOnly); } else { char addr_buf[128]; strncpy(addr_buf, tx.address.c_str(), sizeof(addr_buf) - 1); addr_buf[sizeof(addr_buf) - 1] = '\0'; - ImGui::SetNextItemWidth(addrInput.width); + ImGui::SetNextItemWidth(addrInput.width); // negative fill sentinel — must NOT be dpi-scaled ImGui::InputText("##Address", addr_buf, sizeof(addr_buf), ImGuiInputTextFlags_ReadOnly); } ImGui::SameLine(); From ce8c7696d443ebbfefc4c4a3bb48ecc21edce5a0 Mon Sep 17 00:00:00 2001 From: DanS Date: Tue, 18 Aug 2026 21:29:10 -0500 Subject: [PATCH 55/89] =?UTF-8?q?fix(ui):=20finish=20HiDPI=20pass=20?= =?UTF-8?q?=E2=80=94=20cosmetic=20=C3=97dpiScale,=20narrow-width=20reflow,?= =?UTF-8?q?=20recent-list=20reserves?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit The tail of the DPI/font-scale/responsiveness audit — ~26 remaining findings. Container / recent-list (Theme-1 leftovers): - Send: drop NoScrollbar|NoScrollWithMouse on ##SendFormScroll so Recent Sends is reachable at font_scale 1.5 (parity with receive). - Receive: cap the QR/form card via std::min(mainCardTargetH, availH - recentReserve) so RECENT RECEIVED stays on-screen (identity at 1.0x). - Wallets dialog: size the capped-mode list to whole rows so it no longer clips a partial row / crowds "Create a new wallet". Narrow-width (1024px) reflow: - Console toolbar reserves space for ALL trailing controls (both icon toggles + zoom buttons) so the +/- zoom no longer runs off-window. - History sort combo sized to its measured widest localized label ("Newest first"). - Settings Theme/Layout/Language row: scale the wide→stacked breakpoint by dpiScale so it drops to full-width stacked combos at 1.5x (Consolidated Card no longer clips). - Recent-tx type label: derive the address column X from the measured label width so it can't collide at narrow widths. - Mining Recent Pool Payouts: floor the panel height to fit the empty-state caption. Cosmetic ×dpiScale() on absolute geometry (no-ops at 1.0x): mining SOLO|POOL toggle & idle combos, market pair-chips, password/PIN strength bars, receive/send currency toggles, explorer search bar/rows/rounding, About-card logo, chat empty-state wrap, recent-list address/time offsets, address-toolbar & two-row action buttons, console line-gap/status-dot/pane rounding. Verified at font_scale 1.5 and at 1024px across full-node + Lite + Windows (ctest green) and an adversarial diff review (one over-reserve regression fixed). Co-Authored-By: Claude Opus 4.8 (1M context) --- src/app_security.cpp | 6 +++--- src/ui/pages/settings_page.cpp | 6 ++++-- src/ui/windows/balance_components.cpp | 12 ++++++++---- src/ui/windows/balance_tab.cpp | 2 +- src/ui/windows/chat_tab.cpp | 2 +- src/ui/windows/console_tab.cpp | 20 ++++++++++++++------ src/ui/windows/explorer_tab.cpp | 14 +++++++------- src/ui/windows/market_tab.cpp | 7 ++++--- src/ui/windows/mining_controls.cpp | 6 +++--- src/ui/windows/mining_earnings.cpp | 13 ++++++++++++- src/ui/windows/mining_mode_toggle.cpp | 4 ++-- src/ui/windows/receive_tab.cpp | 27 +++++++++++++++++++-------- src/ui/windows/send_tab.cpp | 16 ++++++++++------ src/ui/windows/transactions_tab.cpp | 14 ++++++++++++-- src/ui/windows/wallets_dialog.h | 23 ++++++++++++++++++----- 15 files changed, 118 insertions(+), 54 deletions(-) diff --git a/src/app_security.cpp b/src/app_security.cpp index 845894b..838bba2 100644 --- a/src/app_security.cpp +++ b/src/app_security.cpp @@ -1265,7 +1265,7 @@ void App::renderEncryptWalletDialog() { else if (tier == 1) { strengthLabel = TR("wiz_strength_fair"); strengthCol = ImVec4(1,0.7f,0.3f,1); strengthPct = 0.5f; } float barW = ImGui::GetContentRegionAvail().x; - float barH = 4.0f; + float barH = 4.0f * ui::Layout::dpiScale(); ImVec2 p = ImGui::GetCursorScreenPos(); ImDrawList* dl = ImGui::GetWindowDrawList(); dl->AddRectFilled(p, ImVec2(p.x + barW, p.y + barH), @@ -1315,7 +1315,7 @@ void App::renderEncryptWalletDialog() { // Indeterminate progress bar { float barW = ImGui::GetContentRegionAvail().x; - float barH = 6.0f; + float barH = 6.0f * ui::Layout::dpiScale(); ImVec2 p = ImGui::GetCursorScreenPos(); ImDrawList* dl = ImGui::GetWindowDrawList(); dl->AddRectFilled(p, ImVec2(p.x + barW, p.y + barH), @@ -1815,7 +1815,7 @@ void App::renderDecryptWalletDialog() { // Indeterminate progress bar { float barW = ImGui::GetContentRegionAvail().x; - float barH = 6.0f; + float barH = 6.0f * ui::Layout::dpiScale(); ImVec2 p = ImGui::GetCursorScreenPos(); ImDrawList* dl = ImGui::GetWindowDrawList(); dl->AddRectFilled(p, ImVec2(p.x + barW, p.y + barH), diff --git a/src/ui/pages/settings_page.cpp b/src/ui/pages/settings_page.cpp index 21b65c8..e7e1793 100644 --- a/src/ui/pages/settings_page.cpp +++ b/src/ui/pages/settings_page.cpp @@ -664,7 +664,7 @@ void RenderSettingsPage(App* app) { float contentW = availWidth - pad * 2; float comboGap = S.drawElement("components.settings-page", "combo-row-gap").size; float compactBP = S.drawElement("components.settings-page", "compact-breakpoint").size; - bool wideLayout = availWidth >= compactBP; + bool wideLayout = availWidth >= compactBP * dp; // scale the breakpoint so the 3-combo row drops to the stacked layout at high font scale (else the combos clip) float refreshBtnW = S.drawElement("components.settings-page", "refresh-btn-width").size; // --- Skin data --- @@ -762,6 +762,8 @@ void RenderSettingsPage(App* app) { float lblThemeW = ImGui::CalcTextSize(TR("theme")).x + lblGap; float lblLayoutW = ImGui::CalcTextSize(TR("balance_layout")).x + lblGap; float lblLangW = ImGui::CalcTextSize(TR("language")).x + lblGap; + // Budget matches the RAW draws below (SameLine(0, comboGap) and ImVec2(refreshBtnW, 0)) — + // don't dpi-scale these terms or the budget over-reserves and the combos shrink needlessly. float totalFixed = lblThemeW + lblLayoutW + lblLangW + comboGap * 2 + Layout::spacingSm() + refreshBtnW; float comboW = std::max(80.0f, (contentW - totalFixed) / 3.0f); @@ -2533,7 +2535,7 @@ void RenderSettingsPage(App* app) { ImVec2 logoPos = ImGui::GetCursorScreenPos(); float logoAspect = (app->getLogoHeight() > 0) ? (float)app->getLogoWidth() / (float)app->getLogoHeight() : 1.0f; - float logoReserveH = schema::UI().drawElement("components.settings-page", "about-logo-size").sizeOr(150.0f); + float logoReserveH = schema::UI().drawElement("components.settings-page", "about-logo-size").sizeOr(150.0f) * dp; if (logoTex != 0) { logoAreaW = logoReserveH * logoAspect + Layout::spacingLg(); ImGui::Indent(logoAreaW); diff --git a/src/ui/windows/balance_components.cpp b/src/ui/windows/balance_components.cpp index f03949f..fb607ed 100644 --- a/src/ui/windows/balance_components.cpp +++ b/src/ui/windows/balance_components.cpp @@ -188,8 +188,8 @@ void RenderSharedAddressList(App* app, float listH, float availW, } } - float buttonWidth = (addrBtn.width > 0) ? addrBtn.width : 140.0f; - float spacing = (addrBtn.gap > 0) ? addrBtn.gap : 8.0f; + float buttonWidth = ((addrBtn.width > 0) ? addrBtn.width : 140.0f) * dp; + float spacing = ((addrBtn.gap > 0) ? addrBtn.gap : 8.0f) * dp; float totalButtonsWidth = buttonWidth * 2 + spacing; float kMinButtonsPosition = std::max(S.drawElement("tabs.balance", "min-buttons-position").size, S.drawElement("tabs.balance", "buttons-position").size * hs); @@ -842,7 +842,11 @@ 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) * hs; + // Start the address column past the MEASURED type-label width (plus a fixed gap) so it can + // never overlap the label — a fixed schema offset shrinks below the label width at narrow + // widths (hs < 1) and collides. Mirrors how amtX/agoSz measure their own text below. + ImVec2 typeSz = capFont->CalcTextSizeA(capFont->LegacySize, 10000, 0, display.typeText.c_str()); + float addrX = tx_x + typeSz.x + Layout::spacingMd(); dl->AddText(capFont, capFont->LegacySize, ImVec2(addrX, rowPos.y + 2 * dp), OnSurfaceDisabled(), display.addressText.c_str()); @@ -857,7 +861,7 @@ void RenderSharedRecentTx(App* app, float recentH, float availW, float hs, float ImVec2 agoSz = capFont->CalcTextSizeA(capFont->LegacySize, 10000, 0, display.timeText.c_str()); dl->AddText(capFont, capFont->LegacySize, - ImVec2(rightEdge - agoSz.x - S.drawElement("tabs.balance", "recent-tx-time-margin").sizeOr(4.0f), rowPos.y + 2 * dp), + ImVec2(rightEdge - agoSz.x - S.drawElement("tabs.balance", "recent-tx-time-margin").sizeOr(4.0f) * hs, rowPos.y + 2 * dp), OnSurfaceDisabled(), display.timeText.c_str()); float rowW = ImGui::GetContentRegionAvail().x; diff --git a/src/ui/windows/balance_tab.cpp b/src/ui/windows/balance_tab.cpp index a505bf2..c84be7e 100644 --- a/src/ui/windows/balance_tab.cpp +++ b/src/ui/windows/balance_tab.cpp @@ -1939,7 +1939,7 @@ static void RenderBalanceTwoRow(App* app) { } // Action buttons right-aligned - float btnW = S.drawElement("tabs.balance.two-row", "action-btn-width").sizeOr(80.0f); + float btnW = S.drawElement("tabs.balance.two-row", "action-btn-width").sizeOr(80.0f) * dp; float rightEdge = ImGui::GetWindowWidth() - Layout::spacingLg(); ImGui::SameLine(rightEdge - btnW * 2 - Layout::spacingSm()); // Stable ## ids keep the button identity fixed across translations. diff --git a/src/ui/windows/chat_tab.cpp b/src/ui/windows/chat_tab.cpp index 8bea45b..e4e4142 100644 --- a/src/ui/windows/chat_tab.cpp +++ b/src/ui/windows/chat_tab.cpp @@ -547,7 +547,7 @@ void centeredEmptyState(const char* icon, const char* title, const char* hint) { ImFont* titleF = material::Type().subtitle1(); ImFont* hintF = material::Type().body2(); const float gap = 8.0f * Layout::dpiScale(); - const float wrap = std::min(avail.x - 40.0f, 360.0f); + const float wrap = std::min(avail.x - 40.0f * Layout::dpiScale(), 360.0f * Layout::dpiScale()); const float iconSz = iconF ? scaledSize(iconF) : 40.0f; const float iconH = iconF ? iconF->CalcTextSizeA(iconSz, FLT_MAX, 0.0f, icon).y : 0.0f; const float titleH = titleF->CalcTextSizeA(scaledSize(titleF), FLT_MAX, 0.0f, title).y; diff --git a/src/ui/windows/console_tab.cpp b/src/ui/windows/console_tab.cpp index 45e8ff0..4648df9 100644 --- a/src/ui/windows/console_tab.cpp +++ b/src/ui/windows/console_tab.cpp @@ -617,7 +617,7 @@ void ConsoleTab::drawToolbarStatus(ConsoleCommandExecutor& exec) ConsoleStatusLine st = exec.toolbarStatus(); if (!st.text.empty()) { ImVec2 cp = ImGui::GetCursorScreenPos(); - float dotR = schema::UI().drawElement("tabs.console", "status-dot-radius-base").size + schema::UI().drawElement("tabs.console", "status-dot-radius-scale").size * Layout::hScale(); + float dotR = (schema::UI().drawElement("tabs.console", "status-dot-radius-base").size + schema::UI().drawElement("tabs.console", "status-dot-radius-scale").size) * Layout::hScale(); float dotY = cp.y + ImGui::GetTextLineHeight() * 0.5f; float dotX = cp.x + dotR + 2.0f * Layout::dpiScale(); @@ -687,9 +687,14 @@ void ConsoleTab::drawLogFilterToggles(const ConsoleLogFilterCaps& caps) void ConsoleTab::drawFilterInput() { using namespace material; - float zoomBtnSpace = ImGui::GetFrameHeight() * 2.0f + Layout::spacingSm() * 3.0f; - float filterAvail = ImGui::GetContentRegionAvail().x - zoomBtnSpace; - float filterW = std::min(schema::UI().drawElement("tabs.console", "filter-max-width").size, filterAvail * schema::UI().drawElement("tabs.console", "filter-width-ratio").size); + // Reserve room for EVERY trailing same-line control drawn AFTER this filter on the toolbar + // row: the two icon toggles (accent-fill + text-color) and the two zoom buttons, plus the + // group spacers between them. Otherwise the filter eats the row and the trailing controls + // run off-window (worst at 1024px / font_scale 1.5). All four are GetFrameHeight() wide. + float trailingBtnSpace = ImGui::GetFrameHeight() * 4.0f + Layout::spacingSm() * 7.0f; + float filterAvail = ImGui::GetContentRegionAvail().x - trailingBtnSpace; + float filterMaxW = schema::UI().drawElement("tabs.console", "filter-max-width").size * Layout::dpiScale(); + float filterW = std::min(filterMaxW, filterAvail * schema::UI().drawElement("tabs.console", "filter-width-ratio").size); ImGui::SetNextItemWidth(filterW); ImGui::InputTextWithHint("##ConsoleFilter", TR("console_filter_hint"), filter_text_, sizeof(filter_text_)); if (filter_text_[0] != '\0') { @@ -768,7 +773,10 @@ void ConsoleTab::renderOutput() // height. The inter-line gap is added explicitly to layout_.heights // so that layout_.cumulativeY stays perfectly in sync with actual // cursor positions (avoiding selection-offset drift). - float interLineGap = S.drawElement("tabs.console", "output").getFloat("line-spacing", 0.0f); + // Raw logical px from the schema; scale it so the inter-line gap grows at font_scale 1.5 + // (it is added to the already-DPI-scaled GetTextLineHeight in BuildConsoleLayout — scale the + // gap only, never the line height). + float interLineGap = S.drawElement("tabs.console", "output").getFloat("line-spacing", 0.0f) * Layout::dpiScale(); ImGui::PushStyleVar(ImGuiStyleVar_ItemSpacing, ImVec2(0, 0)); // Inner padding for glass panel @@ -1894,7 +1902,7 @@ void ConsoleTab::renderCommandsPopup(ConsoleCommandExecutor& exec) // Both panes sit on soft Material glass surfaces (no hard 1px child border) with inner padding. GlassPanelSpec paneGlass; - paneGlass.rounding = 14.0f; + paneGlass.rounding = 14.0f * dp; paneGlass.fillAlpha = 30; paneGlass.borderAlpha = 30; diff --git a/src/ui/windows/explorer_tab.cpp b/src/ui/windows/explorer_tab.cpp index fd466aa..efe4c29 100644 --- a/src/ui/windows/explorer_tab.cpp +++ b/src/ui/windows/explorer_tab.cpp @@ -446,10 +446,10 @@ static void renderSearchBar(App* app, float availWidth) { float navW = navBtnSz * 2.0f + pageW + navGap * 2.0f; float inputW = std::min( - S.drawElement("tabs.explorer", "search-input-width").size, + S.drawElement("tabs.explorer", "search-input-width").size * Layout::dpiScale(), availWidth * 0.65f); - float btnW = S.drawElement("tabs.explorer", "search-button-width").size; - float barH = S.drawElement("tabs.explorer", "search-bar-height").size; + float btnW = S.drawElement("tabs.explorer", "search-button-width").size * Layout::dpiScale(); + float barH = S.drawElement("tabs.explorer", "search-bar-height").size * Layout::dpiScale(); // Clamp so search bar never overflows float maxInputW = availWidth - btnW - navW - pad * 4 - Type().iconMed()->LegacySize; @@ -755,8 +755,8 @@ static void renderRecentBlocks(App* app, float availWidth) { ImFont* body2 = Type().body2(); ImFont* sub1 = Type().subtitle1(); - float baseRowH = S.drawElement("tabs.explorer", "row-height").size; - float rowRound = S.drawElement("tabs.explorer", "row-rounding").size; + float baseRowH = S.drawElement("tabs.explorer", "row-height").size * dp; + float rowRound = S.drawElement("tabs.explorer", "row-rounding").size * dp; float headerH = ovFont->LegacySize + Layout::spacingSm() + pad * 0.5f; // Stretch card to fill the remaining tab height; rows scroll inside. @@ -989,7 +989,7 @@ static void renderRecentBlocks(App* app, float availWidth) { ImGui::EndChild(); - float fadeZone = S.drawElement("tabs.explorer", "scroll-fade-zone").size; + float fadeZone = S.drawElement("tabs.explorer", "scroll-fade-zone").size * dp; ApplyScrollEdgeMask(dl, parentVtx, childDL, childVtx, rowAreaTop, rowAreaTop + rowAreaH, fadeZone, scrollY, scrollMaxY); @@ -1179,7 +1179,7 @@ static void renderBlockDetailModal(App* app) { ImGui::Spacing(); - float txRowH = S.drawElement("tabs.explorer", "tx-row-height").size; + float txRowH = S.drawElement("tabs.explorer", "tx-row-height").size * dp; ImU32 linkCol = schema::UI().resolveColor("var(--secondary-light)"); for (int i = 0; i < (int)s_detail_txids.size(); i++) { diff --git a/src/ui/windows/market_tab.cpp b/src/ui/windows/market_tab.cpp index 5265d83..cdc2ffe 100644 --- a/src/ui/windows/market_tab.cpp +++ b/src/ui/windows/market_tab.cpp @@ -1347,9 +1347,10 @@ static void mktDrawPairSelector(App* app, const std::vector& ImGui::Dummy(ImVec2(0, S.drawElement("tabs.market", "exchange-top-gap").size)); { - float chipH = S.drawElement("tabs.market", "pair-chip-height").height; - float chipR = S.drawElement("tabs.market", "pair-chip-radius").radius; - float chipSpacing = S.drawElement("tabs.market", "pair-chip-spacing").size; + float dp = Layout::dpiScale(); + float chipH = S.drawElement("tabs.market", "pair-chip-height").height * dp; + float chipR = S.drawElement("tabs.market", "pair-chip-radius").radius * dp; + float chipSpacing = S.drawElement("tabs.market", "pair-chip-spacing").size * dp; float innerGap = Layout::spacingSm(); float sidePad = Layout::spacingMd(); diff --git a/src/ui/windows/mining_controls.cpp b/src/ui/windows/mining_controls.cpp index 37b16c0..7e7e2a7 100644 --- a/src/ui/windows/mining_controls.cpp +++ b/src/ui/windows/mining_controls.cpp @@ -293,7 +293,7 @@ void RenderMiningControls(App* app, const WalletState& state, const MiningInfo& for (const auto& d : delays) { if (d.seconds == curDelay) { previewLabel = d.label; break; } } - float comboW = schema::UI().drawElement("components.settings-page", "idle-combo-width").sizeOr(64.0f); + float comboW = schema::UI().drawElement("components.settings-page", "idle-combo-width").sizeOr(64.0f) * dp; float comboX = idleRightEdge - comboW; float comboY = curY + (headerH - ImGui::GetFrameHeight()) * 0.5f; ImGui::SetCursorScreenPos(ImVec2(comboX, comboY)); @@ -332,7 +332,7 @@ void RenderMiningControls(App* app, const WalletState& state, const MiningInfo& if (curVal <= 0) curVal = hwThreads; char previewBuf[16]; snprintf(previewBuf, sizeof(previewBuf), "%d", curVal); - float comboW = schema::UI().drawElement("components.settings-page", "idle-combo-width").sizeOr(64.0f); + float comboW = schema::UI().drawElement("components.settings-page", "idle-combo-width").sizeOr(64.0f) * dp; float comboX = idleRightEdge - comboW; float comboY = curY + (headerH - ImGui::GetFrameHeight()) * 0.5f; ImGui::SetCursorScreenPos(ImVec2(comboX, comboY)); @@ -371,7 +371,7 @@ void RenderMiningControls(App* app, const WalletState& state, const MiningInfo& if (curVal <= 0) curVal = std::max(1, hwThreads / 2); char previewBuf[16]; snprintf(previewBuf, sizeof(previewBuf), "%d", curVal); - float comboW = schema::UI().drawElement("components.settings-page", "idle-combo-width").sizeOr(64.0f); + float comboW = schema::UI().drawElement("components.settings-page", "idle-combo-width").sizeOr(64.0f) * dp; float comboX = idleRightEdge - comboW; float comboY = curY + (headerH - ImGui::GetFrameHeight()) * 0.5f; ImGui::SetCursorScreenPos(ImVec2(comboX, comboY)); diff --git a/src/ui/windows/mining_earnings.cpp b/src/ui/windows/mining_earnings.cpp index 2bccb17..b7f3d31 100644 --- a/src/ui/windows/mining_earnings.cpp +++ b/src/ui/windows/mining_earnings.cpp @@ -533,7 +533,18 @@ void RenderMiningEarnings(App* app, const WalletState& state, const MiningInfo& float recentAvailH = ImGui::GetContentRegionAvail().y - sHdr - gapOver; float minRows = recentMined.empty() ? 2.0f : (float)recentMined.size(); float contentH_blocks = rowH_blocks * minRows + pad * 2.5f; - float recentH = std::clamp(contentH_blocks, 30.0f * dp, std::max(30.0f * dp, recentAvailH)); + // Lower bound for the panel height. When the list is empty the centred empty-state + // (top pad + icon + gap + caption + bottom pad) needs more vertical room than the bare + // 30*dp floor, otherwise the caption is clipped once the thread-tile grid wraps to two + // rows and recentAvailH shrinks (font metrics/Layout helpers are already DPI-scaled — do + // not multiply them by dp; pad is a scaled param). + float recentMinH = 30.0f * dp; + if (recentMined.empty()) { + recentMinH = std::max(recentMinH, + pad * 0.5f + Type().iconMed()->LegacySize + Layout::spacingXs() + + capFont->LegacySize + pad * 0.5f); + } + float recentH = std::clamp(contentH_blocks, recentMinH, std::max(recentMinH, recentAvailH)); // Glass panel wrapping the list + scroll-edge mask state ImVec2 recentPanelMin = ImGui::GetCursorScreenPos(); diff --git a/src/ui/windows/mining_mode_toggle.cpp b/src/ui/windows/mining_mode_toggle.cpp index 75029fb..2e70ba2 100644 --- a/src/ui/windows/mining_mode_toggle.cpp +++ b/src/ui/windows/mining_mode_toggle.cpp @@ -58,8 +58,8 @@ void RenderMiningModeToggle(App* app, const WalletState& state, const MiningInfo const bool soloMiningAvailable = app->supportsSoloMining(); float toggleW = schema::UI().drawElement("tabs.mining", "mode-toggle-width").size * hs; - float toggleH = schema::UI().drawElement("tabs.mining", "mode-toggle-height").size; - float toggleRnd = schema::UI().drawElement("tabs.mining", "mode-toggle-rounding").size; + float toggleH = schema::UI().drawElement("tabs.mining", "mode-toggle-height").size * hs; + float toggleRnd = schema::UI().drawElement("tabs.mining", "mode-toggle-rounding").size * hs; float totalW = soloMiningAvailable ? (toggleW * 2) : toggleW; ImVec2 tMin = ImGui::GetCursorScreenPos(); diff --git a/src/ui/windows/receive_tab.cpp b/src/ui/windows/receive_tab.cpp index f4f0707..fff979e 100644 --- a/src/ui/windows/receive_tab.cpp +++ b/src/ui/windows/receive_tab.cpp @@ -405,7 +405,7 @@ static void RenderRecentReceived(const AddressInfo& /* addr */, ImVec2(txX, rowPos.y + 2.0f * dp), OnSurfaceMedium(), typeText); // Address (second line) - float addrX = txX + S.drawElement("tabs.balance", "recent-tx-addr-offset").sizeOr(65.0f); + float addrX = txX + S.drawElement("tabs.balance", "recent-tx-addr-offset").sizeOr(65.0f) * hs; std::string addrDisplay = util::truncateMiddle(tx.address, (int)S.drawElement("tabs.balance", "recent-tx-addr-trunc").sizeOr(20.0f)); rowDL->AddText(capFont, capFont->LegacySize, @@ -424,7 +424,7 @@ static void RenderRecentReceived(const AddressInfo& /* addr */, std::string ago = recvTimeAgo(tx.timestamp); ImVec2 agoSz = capFont->CalcTextSizeA(capFont->LegacySize, 10000.0f, 0.0f, ago.c_str()); rowDL->AddText(capFont, capFont->LegacySize, - ImVec2(rightEdge - agoSz.x - S.drawElement("tabs.balance", "recent-tx-time-margin").sizeOr(4.0f), + ImVec2(rightEdge - agoSz.x - S.drawElement("tabs.balance", "recent-tx-time-margin").sizeOr(4.0f) * hs, rowPos.y + 2.0f * dp), OnSurfaceDisabled(), ago.c_str()); @@ -488,6 +488,16 @@ void RenderReceiveTab(App* app) float groupStartY = ImGui::GetCursorPosY(); float contentStartY = ImGui::GetCursorPosY(); + // Reserve a slice of the available height for RECENT RECEIVED (ratio — mirrors + // balance_tab's recent-tx-reserve). The main card's target height is capped so it can + // never grow past (available - reserve): a no-op at 1.0x (mainCardTargetH already fits + // well within scrollAvailH there), but at HiDPI it prevents the card — whose QR (280*dp) + // and pads scale with dp while scrollAvailH is physical px — from eating the whole child + // and evicting the list. + float recvReserveRatio = S.drawElement("tabs.balance", "recent-tx-reserve-ratio").sizeOr(0.18f); + float recvRecentReserve = std::max(0.0f, scrollAvailH) * recvReserveRatio; + float recvCardCapH = std::max(0.0f, scrollAvailH - recvRecentReserve); + float formAvailW = ImGui::GetContentRegionAvail().x; float formW = formAvailW; ImGui::BeginGroup(); @@ -603,7 +613,7 @@ void RenderReceiveTab(App* app) ImGui::Dummy(ImVec2(0, Layout::spacingSm())); // Amount input with currency toggle - float toggleW = S.drawElement("tabs.receive", "currency-toggle-width").size; + float toggleW = S.drawElement("tabs.receive", "currency-toggle-width").size * Layout::dpiScale(); float amtInputW = addrColW - toggleW - Layout::spacingMd(); if (amtInputW < S.drawElement("tabs.receive", "amount-input-min-width").size) amtInputW = S.drawElement("tabs.receive", "amount-input-min-width").size; double usd_price = state.market.price_usd; @@ -667,8 +677,8 @@ void RenderReceiveTab(App* app) float bH = bMax.y - bMin.y; ImFont* font = ImGui::GetFont(); ImVec2 textSz = font->CalcTextSizeA(font->LegacySize, 10000, 0, currLabel); - float iconW = schema::UI().drawElement("tabs.receive", "currency-icon-width").size; - float iconGap2 = schema::UI().drawElement("tabs.receive", "currency-icon-gap").size; + float iconW = schema::UI().drawElement("tabs.receive", "currency-icon-width").size * Layout::dpiScale(); + float iconGap2 = schema::UI().drawElement("tabs.receive", "currency-icon-gap").size * Layout::dpiScale(); float totalW2 = iconW + iconGap2 + textSz.x; float startX = bMin.x + ((bMax.x - bMin.x) - totalW2) * 0.5f; float cy = bMin.y + bH * 0.5f; @@ -866,7 +876,7 @@ void RenderReceiveTab(App* app) S.drawElement("tabs.receive", "action-btn-height").size * vScale); float footerH = innerGap + actionBtnH + pad; float currentCardH = ImGui::GetCursorScreenPos().y - containerMin.y; - float targetCardH = Layout::mainCardTargetH(formW, vScale); + float targetCardH = std::min(Layout::mainCardTargetH(formW, vScale), recvCardCapH); float footerTopH = targetCardH - footerH; if (currentCardH < footerTopH) { ImGui::Dummy(ImVec2(0, footerTopH - currentCardH)); @@ -959,10 +969,11 @@ void RenderReceiveTab(App* app) ImGui::Dummy(ImVec2(0, pad)); ImGui::Unindent(pad); - // Enforce shared card height (matches QR-driven target) + // Enforce shared card height (matches QR-driven target), capped so the reserved + // RECENT RECEIVED slice below stays on-screen at HiDPI. { float currentCardH = ImGui::GetCursorScreenPos().y - containerMin.y; - float targetCardH = Layout::mainCardTargetH(formW, vScale); + float targetCardH = std::min(Layout::mainCardTargetH(formW, vScale), recvCardCapH); if (currentCardH < targetCardH) ImGui::Dummy(ImVec2(0, targetCardH - currentCardH)); } diff --git a/src/ui/windows/send_tab.cpp b/src/ui/windows/send_tab.cpp index 343a632..6a92a54 100644 --- a/src/ui/windows/send_tab.cpp +++ b/src/ui/windows/send_tab.cpp @@ -1154,7 +1154,7 @@ static void RenderRecentSends(const WalletState& state, float width, ImFont* cap ImVec2(txX, rowPos.y + 2.0f * dp), OnSurfaceMedium(), TR("sent_type")); // Address (second line) - float addrX = txX + S.drawElement("tabs.balance", "recent-tx-addr-offset").sizeOr(65.0f); + float addrX = txX + S.drawElement("tabs.balance", "recent-tx-addr-offset").sizeOr(65.0f) * hs; std::string addrDisplay = util::truncateMiddle(tx.address, (int)S.drawElement("tabs.balance", "recent-tx-addr-trunc").sizeOr(20.0f)); rowDL->AddText(capFont, capFont->LegacySize, @@ -1173,7 +1173,7 @@ static void RenderRecentSends(const WalletState& state, float width, ImFont* cap std::string ago = timeAgo(tx.timestamp); ImVec2 agoSz = capFont->CalcTextSizeA(capFont->LegacySize, 10000.0f, 0.0f, ago.c_str()); rowDL->AddText(capFont, capFont->LegacySize, - ImVec2(rightEdge - agoSz.x - S.drawElement("tabs.balance", "recent-tx-time-margin").sizeOr(4.0f), + ImVec2(rightEdge - agoSz.x - S.drawElement("tabs.balance", "recent-tx-time-margin").sizeOr(4.0f) * hs, rowPos.y + 2.0f * dp), OnSurfaceDisabled(), ago.c_str()); @@ -1251,8 +1251,12 @@ void RenderSendTab(App* app) // SCROLLABLE CONTENT // ================================================================ ImVec2 formAvail = ImGui::GetContentRegionAvail(); + // NOTE: no NoScrollbar/NoScrollWithMouse here (mirrors receive_tab's ##ReceiveScroll). + // At font_scale 1.5 the form card grows to mainCardTargetH and pushes the appended + // "Recent Sends" list below the fold; letting this child scroll keeps it reachable. + // No-op at 1.0x where the content already fits (no scrollbar appears). ImGui::BeginChild("##SendFormScroll", formAvail, false, - ImGuiWindowFlags_NoBackground | ImGuiWindowFlags_NoScrollbar | ImGuiWindowFlags_NoScrollWithMouse); + ImGuiWindowFlags_NoBackground); dl = ImGui::GetWindowDrawList(); // Top-aligned content — consistent vertical position across all tabs @@ -1428,7 +1432,7 @@ void RenderSendTab(App* app) ImGui::Dummy(ImVec2(0, Layout::spacingSm())); // Toggle between DRGX and USD input - float toggleW = schema::UI().drawElement("tabs.send", "toggle-currency-width").size; + float toggleW = schema::UI().drawElement("tabs.send", "toggle-currency-width").size * Layout::dpiScale(); float amtInputW = colW - toggleW - Layout::spacingMd(); if (amtInputW < schema::UI().drawElement("tabs.send", "amount-input-min-width").size) amtInputW = schema::UI().drawElement("tabs.send", "amount-input-min-width").size; @@ -1501,8 +1505,8 @@ void RenderSendTab(App* app) float bH = bMax.y - bMin.y; ImFont* font = ImGui::GetFont(); ImVec2 textSz = font->CalcTextSizeA(font->LegacySize, 10000, 0, currLabel); - float iconW = schema::UI().drawElement("tabs.send", "swap-icon-width").size; - float iconGap = schema::UI().drawElement("tabs.send", "swap-icon-gap").size; + float iconW = schema::UI().drawElement("tabs.send", "swap-icon-width").size * Layout::dpiScale(); + float iconGap = schema::UI().drawElement("tabs.send", "swap-icon-gap").size * Layout::dpiScale(); float totalW = iconW + iconGap + textSz.x; float startX = bMin.x + ((bMax.x - bMin.x) - totalW) * 0.5f; float cy = bMin.y + bH * 0.5f; diff --git a/src/ui/windows/transactions_tab.cpp b/src/ui/windows/transactions_tab.cpp index 6f57f83..728d2f9 100644 --- a/src/ui/windows/transactions_tab.cpp +++ b/src/ui/windows/transactions_tab.cpp @@ -293,11 +293,21 @@ void RenderTransactionsTab(App* app) TR("mined_filter"), TR("chat_filter") }; ImGui::Combo("##TxType", &type_filter, types, IM_ARRAYSIZE(types)); - // Sort selector + // Sort selector — the sort labels ("Newest first"/localized) run longer than the type + // labels, so this combo needs its own width. Size it to the widest localized sort option + // measured with the active (default) font — the same font Combo renders with — plus ImGui's + // combo chrome (2x horizontal frame padding + the dropdown arrow button, GetFrameHeight()). + // CalcTextSize and the style paddings are already DPI-scaled, so this grows at font_scale 1.5 + // without any hs multiply; clamp to at least the shared type-filter comboW. ImGui::SameLine(0, filterGap); - ImGui::SetNextItemWidth(comboW); const char* sorts[] = { TR("sort_date_newest"), TR("sort_date_oldest"), TR("sort_amount_high"), TR("sort_amount_low") }; + float sortTextW = 0.0f; + for (const char* s : sorts) sortTextW = std::max(sortTextW, ImGui::CalcTextSize(s).x); + float sortComboW = std::max(comboW, + sortTextW + ImGui::GetStyle().FramePadding.x * 2.0f + + ImGui::GetFrameHeight()); + ImGui::SetNextItemWidth(sortComboW); ImGui::Combo("##TxSort", &s_sort_mode, sorts, IM_ARRAYSIZE(sorts)); ImGui::SameLine(0, filterGap); diff --git a/src/ui/windows/wallets_dialog.h b/src/ui/windows/wallets_dialog.h index 66494b8..7d0ffd4 100644 --- a/src/ui/windows/wallets_dialog.h +++ b/src/ui/windows/wallets_dialog.h @@ -200,7 +200,20 @@ public: // create/scan/footer controls so it scrolls internally and those stay visible. Uncapped, // it equals the content height exactly (no spurious scrollbar — the common case). float listHFit = listH; - if (capped) listHFit = std::max(walRowH, ImGui::GetContentRegionAvail().y - belowH); + if (capped) { + // Fill the height left above the pinned controls, but clip on a CLEAN row boundary: + // floor the available space to a whole number of card strides (walRowH + cardGap, the + // per-card advance from the loop) so the list never ends mid-row. Keep the same bottom + // pad as the uncapped listH so the last visible card stays off the clip edge. + const float stride = walRowH + cardGap; + const float avail = ImGui::GetContentRegionAvail().y - belowH; + // N rows occupy N*walRowH + (N-1)*cardGap = N*stride - cardGap; solve for the most whole + // rows that fit (a non-negative cast truncates toward zero = floor here), clamped to at + // least one so a tiny viewport still shows a row. + int nRows = stride > 0.0f ? (int)((avail + cardGap) / stride) : 1; + if (nRows < 1) nRows = 1; + listHFit = (float)nRows * stride - cardGap + Layout::spacingSm(); + } ImGui::PushStyleVar(ImGuiStyleVar_WindowPadding, ImVec2(0, 0)); // NoScrollWithMouse + ApplySmoothScroll gives the wheel the same eased scrolling as the // Settings page (ApplySmoothScroll handles the wheel itself, so let it own that input). @@ -253,13 +266,13 @@ public: bool hov = ImGui::IsWindowHovered() && ImGui::IsMouseHoveringRect(rMin, rMax); // Card background + state - GlassPanelSpec g; g.rounding = 10.0f; g.fillAlpha = hov ? 40 : 26; g.borderAlpha = 45; + GlassPanelSpec g; g.rounding = 10.0f * dp; g.fillAlpha = hov ? 40 : 26; g.borderAlpha = 45; DrawGlassPanel(dl, rMin, rMax, g); if (isCurrent) { - dl->AddRectFilled(rMin, rMax, WithAlpha(Success(), 16), 10.0f); - dl->AddRect(rMin, rMax, WithAlpha(Success(), 130), 10.0f, 0, 1.6f * dp); + dl->AddRectFilled(rMin, rMax, WithAlpha(Success(), 16), 10.0f * dp); + dl->AddRect(rMin, rMax, WithAlpha(Success(), 130), 10.0f * dp, 0, 1.6f * dp); } else if (hov) { - dl->AddRect(rMin, rMax, WithAlpha(OnSurface(), 70), 10.0f, 0, 1.0f); + dl->AddRect(rMin, rMax, WithAlpha(OnSurface(), 70), 10.0f * dp, 0, 1.0f); } const float padX = Layout::spacingMd(); From 9205addf55cf43bac764066127ad1f2ab1a66e9f Mon Sep 17 00:00:00 2001 From: DanS Date: Tue, 18 Aug 2026 23:15:39 -0500 Subject: [PATCH 56/89] =?UTF-8?q?feat(ui):=20width-responsiveness=20?= =?UTF-8?q?=E2=80=94=20content=20max-width=20cap=20+=20per-surface=20form/?= =?UTF-8?q?input=20clamps?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Wide/ultrawide (1440-3440px) responsiveness was unhealthy: no page/content-level max-width cap existed, and every card/form/table derived width from raw GetContentRegionAvail().x with floor-only clamps, so surfaces stretched edge-to-edge (2000-3000px inputs, ballooning cards, giant grid cells, 2000px+ dead row-voids). Root cause: adopt the (previously dead-code) clamp helpers. - New Layout::kContentMaxWidth() (~1600dp, tunable via ui.toml [layout] content-max-width; <=0 disables). Cap ##ContentArea to it and center the column in wider windows — every tab derives from this child, so one change tames the app at wide widths. No-op below the cap (fills as before), so 1080p/1440p are unaffected. Per-surface upper-clamps (std::min(cap*dp, expr), floors preserved) where a single element is still too wide even within the capped column: - Settings: Theme/Layout/Language combos, the font-scale slider (~3000px -> 360dp), the effect sliders, Explorer URL and RPC credential fields. - Send / Receive: cap the compose / receive cards to a readable form width and center them (Indent(pad+offset) so the auto-layout fields align with the hand-drawn card); the recent-tx lists below keep the full column width. - Chat message bubbles + composer, mining pool URL/payout inputs + stats left/right split, contacts search, and the lite-network add-server row / server cards / status panel (capped + centered). - Wizard: vertically center the cards when they fit (was top-anchored, leaving a void on tall monitors), compensating the content-height measurement so it can't oscillate. The 1600 cap also subsumes the fixed-4-column balance grids (~400px cards) and the right-anchored row dead-gaps (voids shrink from ~2700px to ~800px), so those are left to the cap rather than blind column/row redesigns. Verified at 1024/1280 (and via a temporary 900dp cap to exercise the cap+center path, since the test display clamps to 1280) across full-node + Lite + Windows (ctest green) and an adversarial diff review (clean). The true wide/ultrawide look and the 1600dp cap value still want eyes on a real wide monitor. Co-Authored-By: Claude Opus 4.8 (1M context) --- src/app.cpp | 15 ++++++++++-- src/app_wizard.cpp | 15 ++++++++++-- src/ui/layout.h | 6 +++++ src/ui/pages/settings_page.cpp | 16 ++++++------- src/ui/windows/chat_tab.cpp | 5 ++-- src/ui/windows/contacts_tab.cpp | 2 +- src/ui/windows/mining_mode_toggle.cpp | 11 ++++++--- src/ui/windows/mining_stats.cpp | 19 +++++++++++---- src/ui/windows/network_tab.cpp | 22 ++++++++++++------ src/ui/windows/receive_tab.cpp | 33 +++++++++++++++++++-------- src/ui/windows/send_tab.cpp | 25 ++++++++++++++++---- 11 files changed, 127 insertions(+), 42 deletions(-) diff --git a/src/app.cpp b/src/app.cpp index e8b7f55..7a73ec2 100644 --- a/src/app.cpp +++ b/src/app.cpp @@ -1875,10 +1875,21 @@ void App::render() float caPadY = caWin.padding[1] > 0.0f ? caWin.padding[1] : ImGui::GetStyle().WindowPadding.y; ImGui::PushStyleVar(ImGuiStyleVar_WindowPadding, ImVec2(caPadX, caPadY)); - // Capture content area screen position for edge fade mask + // Cap the content column to a readable max width and center it in wider windows. Every tab derives + // its cards/forms/tables from this child's width, so an uncapped fill stretches them edge-to-edge on + // wide/ultrawide displays. No-op below the cap (fills as before). + float caAvailW = ImGui::GetContentRegionAvail().x; + float caMaxW = ui::Layout::kContentMaxWidth(); + float caChildW = 0.0f; // 0 -> fill remaining width (default, and whenever the window is below the cap) + if (caMaxW > 0.0f && caAvailW > caMaxW) { + caChildW = caMaxW; + ImGui::SetCursorPosX(ImGui::GetCursorPosX() + (caAvailW - caMaxW) * 0.5f); + } + + // Capture content area screen position for edge fade mask (after any centering offset) ImVec2 caScreenPos = ImGui::GetCursorScreenPos(); - ImGui::BeginChild("##ContentArea", ImVec2(0, contentH), false, contentFlags); + ImGui::BeginChild("##ContentArea", ImVec2(caChildW, contentH), false, contentFlags); // Persistent node/RPC error banner — drawn first (before the edge-fade vertex capture below, // so it stays fully opaque) and above every page / overlay in the content column. It renders diff --git a/src/app_wizard.cpp b/src/app_wizard.cpp index fe4eaaf..398964b 100644 --- a/src/app_wizard.cpp +++ b/src/app_wizard.cpp @@ -198,7 +198,15 @@ void App::renderFirstRunWizard() { const float scrollY = s_wizScroll; // --- Header: Logo + Welcome --- - float headerCy = winPos.y - scrollY + 20.0f * dp; + // Vertically center the content when it fits (mirrors the horizontal centering below): on a tall + // monitor top-anchoring leaves a large void under the cards. Using last frame's measured block + // height, when the content fits inside the window (and we're NOT overflowing, so this doesn't + // fight the scroll), push everything down by half the leftover space. No-op once content + // fills/exceeds the window (s_wizContentH >= winSize.y ⇒ wizMaxScroll > 0 ⇒ vCenter skipped). + float vCenter = 0.0f; + if (wizMaxScroll == 0.0f && s_wizContentH > 0.0f && s_wizContentH < winSize.y) + vCenter = std::max(0.0f, (winSize.y - s_wizContentH) * 0.5f); + float headerCy = winPos.y - scrollY + 20.0f * dp + vCenter; float logoSize = S.drawElement("screens.first-run", "logo").sizeOr(56.0f); if (logo_tex_ != 0) { float aspect = (logo_h_ > 0) ? (float)logo_w_ / (float)logo_h_ : 1.0f; @@ -1452,7 +1460,10 @@ void App::renderFirstRunWizard() { // window, draw a slim scroll indicator so the off-screen content is discoverable. { float contentBottom = std::max(card0Bot, std::max(card1Bot, card2Bot)); - s_wizContentH = (contentBottom - winPos.y + scrollY) + 24.0f * dp; + // Subtract vCenter back out: everything below the header was shifted down by it, so the raw + // span includes it. We want s_wizContentH to be the true (un-centered) content height, or the + // vertical-centering above would feed on itself and oscillate frame-to-frame. + s_wizContentH = (contentBottom - winPos.y + scrollY - vCenter) + 24.0f * dp; if (wizMaxScroll > 0.0f && s_wizContentH > 0.0f) { float trackH = winSize.y - 8.0f * dp; float thumbH = std::min(trackH, std::max(32.0f * dp, trackH * (winSize.y / s_wizContentH))); diff --git a/src/ui/layout.h b/src/ui/layout.h index 4c0169e..83bbf52 100644 --- a/src/ui/layout.h +++ b/src/ui/layout.h @@ -173,6 +173,12 @@ inline float kSidePanelMinWidth() { return schema::UI().drawElement("panels", inline float kSidePanelMaxWidth() { return schema::UI().drawElement("panels", "side-panel").getFloat("max-width", 450.0f) * dpiScale(); } inline float kSidePanelWidthRatio() { return schema::UI().drawElement("panels", "side-panel").getFloat("width-ratio", 0.4f); } +// Overall content-column cap: the max width a tab's content should occupy before it is centered in wider +// windows. Prevents cards/forms/tables (which all derive their size from the content child's width) from +// stretching edge-to-edge at wide/ultrawide widths. <= 0 disables (fill full width). Tunable via ui.toml +// [layout] content-max-width; default is generous so data-dense screens stay comfortable. +inline float kContentMaxWidth() { return schema::UI().drawElement("layout", "content-max-width").sizeOr(1600.0f) * dpiScale(); } + inline float kTableMinHeight() { return schema::UI().drawElement("panels", "table").getFloat("min-height", 150.0f) * dpiScale(); } inline float kTableHeightRatio() { return schema::UI().drawElement("panels", "table").getFloat("height-ratio", 0.45f); } diff --git a/src/ui/pages/settings_page.cpp b/src/ui/pages/settings_page.cpp index e7e1793..8eecbee 100644 --- a/src/ui/pages/settings_page.cpp +++ b/src/ui/pages/settings_page.cpp @@ -766,7 +766,7 @@ void RenderSettingsPage(App* app) { // don't dpi-scale these terms or the budget over-reserves and the combos shrink needlessly. float totalFixed = lblThemeW + lblLayoutW + lblLangW + comboGap * 2 + Layout::spacingSm() + refreshBtnW; - float comboW = std::max(80.0f, (contentW - totalFixed) / 3.0f); + float comboW = std::min(std::max(80.0f, (contentW - totalFixed) / 3.0f), 300.0f * dp); ImGui::AlignTextToFramePadding(); ImGui::TextUnformatted(TR("theme")); @@ -856,7 +856,7 @@ void RenderSettingsPage(App* app) { { ImGui::PushFont(body2); ImGui::TextUnformatted(TR("font_scale")); - float fontSliderW = std::max(S.drawElement("components.settings-page", "effects-input-min-width").size, contentW); + float fontSliderW = std::min(std::max(S.drawElement("components.settings-page", "effects-input-min-width").size, contentW), 360.0f * dp); ImGui::SetNextItemWidth(fontSliderW); s_settingsState.font_scale = Layout::userFontScale(); float prev_font_scale = s_settingsState.font_scale; @@ -956,7 +956,7 @@ void RenderSettingsPage(App* app) { // Row 1: Acrylic preset slider + Noise slider (side by side, labels above) float effCtrlMinW = S.drawElement("components.settings-page", "effects-input-min-width").size; float halfW = (contentW - Layout::spacingLg()) * 0.5f; - float ctrlW = std::max(effCtrlMinW, halfW); + float ctrlW = std::min(std::max(effCtrlMinW, halfW), 360.0f * dp); float baseX = ImGui::GetCursorScreenPos().x; float rightX = baseX + ctrlW + Layout::spacingLg(); @@ -1153,8 +1153,8 @@ void RenderSettingsPage(App* app) { { ImGui::PushFont(body2); ImGui::TextUnformatted(TR("font_scale")); - float fontSliderW = std::max(S.drawElement("components.settings-page", "effects-input-min-width").size, - availWidth - pad * 2); + float fontSliderW = std::min(std::max(S.drawElement("components.settings-page", "effects-input-min-width").size, + availWidth - pad * 2), 360.0f * dp); ImGui::SetNextItemWidth(fontSliderW); s_settingsState.font_scale = Layout::userFontScale(); float prev_font_scale = s_settingsState.font_scale; @@ -2218,7 +2218,7 @@ void RenderSettingsPage(App* app) { if (fourAcross) { // fieldW = (contentW - labels - per-field label gaps - 3 inter-field gaps) / 4 float inputTotal = contentW - labelsW - Layout::spacingXs() * 4 - spMd * 3; - float inputW = std::max(60.0f, std::floor(inputTotal / 4.0f)); + float inputW = std::min(std::max(60.0f, std::floor(inputTotal / 4.0f)), 220.0f * dp); field(hostLbl, "##RPCHost", s_settingsState.rpc_host, sizeof(s_settingsState.rpc_host), inputW, false); if (ImGui::IsItemHovered()) material::Tooltip("%s", TR("tt_rpc_host")); ImGui::SameLine(0, spMd); @@ -2453,8 +2453,8 @@ void RenderSettingsPage(App* app) { float halfW = (contentW - Layout::spacingLg()) * 0.5f; float lblTxW = ImGui::CalcTextSize("Transaction URL").x + Layout::spacingXs(); float lblAddrW = ImGui::CalcTextSize("Address URL").x + Layout::spacingXs(); - float inputTxW = std::max(80.0f, halfW - lblTxW); - float inputAddrW = std::max(80.0f, halfW - lblAddrW); + float inputTxW = std::min(std::max(80.0f, halfW - lblTxW), 460.0f * dp); + float inputAddrW = std::min(std::max(80.0f, halfW - lblAddrW), 460.0f * dp); // Row start X (indent-inclusive) — the Address column is placed relative // to it, not to a fixed `pad`, so it lands correctly in the right column. diff --git a/src/ui/windows/chat_tab.cpp b/src/ui/windows/chat_tab.cpp index e4e4142..191dc59 100644 --- a/src/ui/windows/chat_tab.cpp +++ b/src/ui/windows/chat_tab.cpp @@ -1313,7 +1313,7 @@ void RenderChatTab(App* app) } const float availW = ImGui::GetContentRegionAvail().x; - const float maxBubbleW = std::max(140.0f * dp, availW * 0.72f); + const float maxBubbleW = std::clamp(availW * 0.72f, 140.0f * dp, 560.0f * dp); const float innerW = maxBubbleW - 2.0f * bpad; // ── Date separator (once per calendar day): a centered pill. @@ -1599,7 +1599,8 @@ void RenderChatTab(App* app) const float ringR = std::max(7.0f, lineH * 0.42f); const float ringPad = 9.0f * tdp; const float ringSlot = 2.0f * ringR + ringPad * 1.6f; - const float inputW = std::max(ringSlot + 48.0f * tdp, cw - emojiBtn - 2.0f * inGap - sendW); + const float inputW = std::min(720.0f * tdp, + std::max(ringSlot + 48.0f * tdp, cw - emojiBtn - 2.0f * inGap - sendW)); const float sendX = inputX + inputW + inGap; const float textW = std::max(40.0f * tdp, inputW - ringSlot); // input area, left of the ring const ImVec2 ringC(inputX + inputW - ringPad - ringR, rowY + composerBoxH - ringPad - ringR); diff --git a/src/ui/windows/contacts_tab.cpp b/src/ui/windows/contacts_tab.cpp index fbc4f6f..ff61a36 100644 --- a/src/ui/windows/contacts_tab.cpp +++ b/src/ui/windows/contacts_tab.cpp @@ -960,7 +960,7 @@ void RenderContactsTab(App* app) } // Search / filter (tight against the toolbar row above — no extra spacer) - ImGui::SetNextItemWidth(ImGui::GetContentRegionAvail().x); + ImGui::SetNextItemWidth(std::min(ImGui::GetContentRegionAvail().x, 700.0f * dp)); ImGui::InputTextWithHint("##ContactSearch", TR("contacts_search_placeholder"), s_search, sizeof(s_search)); bool searchActive = ImGui::IsItemActive(); diff --git a/src/ui/windows/mining_mode_toggle.cpp b/src/ui/windows/mining_mode_toggle.cpp index 2e70ba2..198a640 100644 --- a/src/ui/windows/mining_mode_toggle.cpp +++ b/src/ui/windows/mining_mode_toggle.cpp @@ -189,8 +189,11 @@ void RenderMiningModeToggle(App* app, const WalletState& state, const MiningInfo float perGroupExtra = iconBtnW * 2; // dropdown + bookmark float remainW = contentEndX - inputsStartX - Layout::spacingSm() - resetBtnW - Layout::spacingSm() - perGroupExtra * 2; - float urlW = std::max(60.0f, remainW * 0.30f); - float wrkW = std::max(40.0f, remainW * 0.70f); + // Floor keeps the inputs usable when cramped; the ceiling stops a + // single input sprawling absurdly wide on a large window (leftover + // space becomes right-side margin). Caps are logical px * dp. + float urlW = std::min(std::max(60.0f, remainW * 0.30f), 420.0f * dp); + float wrkW = std::min(std::max(40.0f, remainW * 0.70f), 560.0f * dp); // Track positions for popup alignment float urlGroupStartX = ImGui::GetCursorScreenPos().x; @@ -451,7 +454,9 @@ void RenderMiningModeToggle(App* app, const WalletState& state, const MiningInfo // --- Worker: Popup positioned below the input group --- // Popup sized to fit full z-addresses without truncation; // zero horizontal padding so item highlights are flush with edges. - float addrPopupW = std::max(wrkGroupW, availWidth * 0.55f); + // Wide enough for full z-addresses, but ceiling it so it doesn't span + // the whole window on a large display (leftover -> unused margin). + float addrPopupW = std::min(std::max(wrkGroupW, availWidth * 0.55f), 640.0f * dp); ImGui::SetNextWindowPos(ImVec2(wrkGroupStartX, wrkGroupStartY + inputFrameH2)); ImGui::SetNextWindowSize(ImVec2(addrPopupW, 0)); ImGui::PushStyleVar(ImGuiStyleVar_WindowRounding, 4.0f * dp); diff --git a/src/ui/windows/mining_stats.cpp b/src/ui/windows/mining_stats.cpp index 231f1f4..f705bd5 100644 --- a/src/ui/windows/mining_stats.cpp +++ b/src/ui/windows/mining_stats.cpp @@ -399,7 +399,9 @@ void RenderMiningStats(const WalletState& state, const MiningInfo& mining, ImVec2 cardMin = ImGui::GetCursorScreenPos(); // A bit wider than the old 25%/180dp so the pool rows fit the " N% fee" text. - float leftW = std::clamp(availWidth * 0.30f, 210.0f * dp, availWidth * 0.45f); + // Ratio ceiling (0.45) never binds on a wide window, so give leftW an + // absolute cap too — the pool card doesn't need to be enormous. + float leftW = std::clamp(availWidth * 0.30f, 210.0f * dp, 440.0f * dp); float colGap = gap; float rightW = availWidth - leftW - colGap; @@ -414,6 +416,15 @@ void RenderMiningStats(const WalletState& state, const MiningInfo& mining, RenderLeftPoolCard(app, state, dl, capFont, sub1, ovFont, dp, gap, pad, leftMin, leftMax, s_pool_url, s_pool_settings_dirty); + // rightW is uncapped, so the chart/hint band it draws would sprawl the + // full panel on a wide window. Constrain just the drawn content to a + // centered ~1000dp band inside the panel's padded content region; the + // glass panel itself still fills rightW, leftover -> side margin. + const float rightContentW = rightW - pad * 2.0f; + const float chartBandW = std::min(rightContentW, 1000.0f * dp); + const float chartBandX = rightMin.x + pad + + std::max(0.0f, (rightContentW - chartBandW) * 0.5f); + // Right panel: live log (if toggled + available) else the sparkline. if (showLogView) { float logPad = pad * 0.5f; @@ -422,14 +433,14 @@ void RenderMiningStats(const WalletState& state, const MiningInfo& mining, state.pool_mining.log_lines, "##PoolLogText"); } else if (hasChartContent) { DrawHashrateSparkline(dl, - ImVec2(rightMin.x + pad, rightMin.y + statRowH * 0.5f), - ImVec2(rightMax.x - pad, rightMax.y), + ImVec2(chartBandX, rightMin.y + statRowH * 0.5f), + ImVec2(chartBandX + chartBandW, rightMax.y), chartHistory, capFont, dp); } else { const char* hint = TR("mining_chart_start"); ImVec2 hs = capFont->CalcTextSizeA(capFont->LegacySize, FLT_MAX, 0, hint); dl->AddText(capFont, capFont->LegacySize, - ImVec2((rightMin.x + rightMax.x - hs.x) * 0.5f, + ImVec2(chartBandX + (chartBandW - hs.x) * 0.5f, (rightMin.y + rightMax.y - hs.y) * 0.5f), OnSurfaceDisabled(), hint); } diff --git a/src/ui/windows/network_tab.cpp b/src/ui/windows/network_tab.cpp index 8ad4e2e..b12de3a 100644 --- a/src/ui/windows/network_tab.cpp +++ b/src/ui/windows/network_tab.cpp @@ -93,9 +93,12 @@ void RenderLiteNetworkTab(App* app) const bool connected = ws.connected; ImDrawList* sdl = ImGui::GetWindowDrawList(); const float panelH = 56.0f * dp; - const float panelW = ImGui::GetContentRegionAvail().x; + const float availPanelW = ImGui::GetContentRegionAvail().x; + const float panelW = std::min(1000.0f * dp, availPanelW); + const float panelOffsetX = std::max(0.0f, (availPanelW - panelW) * 0.5f); const float pad2 = 12.0f * dp; ImVec2 pMin = ImGui::GetCursorScreenPos(); + pMin.x += panelOffsetX; ImVec2 pMax(pMin.x + panelW, pMin.y + panelH); GlassPanelSpec sspec; sspec.rounding = 8.0f * dp; DrawGlassPanel(sdl, pMin, pMax, sspec); @@ -150,7 +153,7 @@ void RenderLiteNetworkTab(App* app) Primary(), barH * 0.5f); } - ImGui::Dummy(ImVec2(panelW, panelH)); // reserve the panel (proper boundary growth) + ImGui::Dummy(ImVec2(availPanelW, panelH)); // reserve the full row (proper boundary growth) ImGui::Spacing(); } @@ -174,8 +177,8 @@ void RenderLiteNetworkTab(App* app) { const float availW = ImGui::GetContentRegionAvail().x; const float addBtnW = 80.0f * dp; - const float urlW = (availW - addBtnW - 16.0f * dp) * 0.6f; - const float lblW = (availW - addBtnW - 16.0f * dp) * 0.4f; + const float urlW = std::min(550.0f * dp, (availW - addBtnW - 16.0f * dp) * 0.6f); + const float lblW = std::min(300.0f * dp, (availW - addBtnW - 16.0f * dp) * 0.4f); ImGui::SetNextItemWidth(urlW); ImGui::InputTextWithHint("##LiteAddUrl", TR("lite_net_add_url_hint"), s_addUrl, sizeof(s_addUrl)); ImGui::SameLine(); @@ -236,8 +239,11 @@ void RenderLiteNetworkTab(App* app) auto it = probe.find(sv.url); if (it != probe.end()) pr = it->second; - const float cardW = ImGui::GetContentRegionAvail().x; + const float availCardW = ImGui::GetContentRegionAvail().x; + const float cardW = std::min(1000.0f * dp, availCardW); + const float cardOffsetX = std::max(0.0f, (availCardW - cardW) * 0.5f); ImVec2 cardMin = ImGui::GetCursorScreenPos(); + cardMin.x += cardOffsetX; ImVec2 cardMax(cardMin.x + cardW, cardMin.y + cardH); const float rnd = 8.0f * dp; const float cardBtnW = cardW - hideW; @@ -326,8 +332,10 @@ void RenderLiteNetworkTab(App* app) // Advance to the next card via a real item (Dummy) below the card, so the scroll region's // content height actually grows — ImGui won't extend bounds from a bare SetCursorScreenPos. - ImGui::SetCursorScreenPos(ImVec2(cardMin.x, cardMax.y)); - ImGui::Dummy(ImVec2(cardW, gap)); + // Reset X to the (unshifted) region origin so next card's GetContentRegionAvail() isn't + // cumulatively narrowed by this card's centering offset. + ImGui::SetCursorScreenPos(ImVec2(cardMin.x - cardOffsetX, cardMax.y)); + ImGui::Dummy(ImVec2(availCardW, gap)); }; // ── Visible servers ──────────────────────────────────────────────────────── diff --git a/src/ui/windows/receive_tab.cpp b/src/ui/windows/receive_tab.cpp index fff979e..8acecc3 100644 --- a/src/ui/windows/receive_tab.cpp +++ b/src/ui/windows/receive_tab.cpp @@ -581,21 +581,34 @@ void RenderReceiveTab(App* app) // MAIN CARD — single glass panel (channel split like Send tab) // ================================================================ { + // Cap + center the card so the address/amount column stops stretching while the + // QR plateaus. cardW never exceeds formW (only shrinks); leftover becomes margin. + // The RECENT RECEIVED list below stays on the uncapped formW (handled separately). + float cardDp = Layout::dpiScale(); + float cardW = std::min(formW, 860.0f * cardDp); + float cardLeftX = ImGui::GetCursorScreenPos().x; + float cardOffsetX = std::max(0.0f, (formW - cardW) * 0.5f); + if (cardOffsetX > 0.0f) + ImGui::SetCursorPosX(ImGui::GetCursorPosX() + cardOffsetX); + ImVec2 containerMin = ImGui::GetCursorScreenPos(); float pad = Layout::spacingLg(); - float innerW = formW - pad * 2; + float innerW = cardW - pad * 2; float innerGap = Layout::spacingLg(); // Channel split: content on ch1, glass background on ch0 dl->ChannelsSplit(2); dl->ChannelsSetCurrent(1); - ImGui::Indent(pad); + // Indent carries the centering offset too, so ImGui auto-layout content (the address + // dropdown/inputs/chips) lands at containerMin.x + pad — matching the hand-drawn geometry + // (glass panel / QR column) that keys off the offset containerMin.x. + ImGui::Indent(pad + cardOffsetX); ImGui::Dummy(ImVec2(0, pad)); // top padding // ---- ADDRESS DROPDOWN + QR CODE — side by side ---- { - float qrColW = innerW * schema::UI().drawElement("tabs.receive", "qr-col-width-ratio").size; + float qrColW = std::min(innerW * schema::UI().drawElement("tabs.receive", "qr-col-width-ratio").size, 340.0f * cardDp); float colGap = Layout::spacingLg(); float addrColW = innerW - qrColW - colGap; float qrColX = containerMin.x + pad + addrColW + colGap; @@ -876,7 +889,7 @@ void RenderReceiveTab(App* app) S.drawElement("tabs.receive", "action-btn-height").size * vScale); float footerH = innerGap + actionBtnH + pad; float currentCardH = ImGui::GetCursorScreenPos().y - containerMin.y; - float targetCardH = std::min(Layout::mainCardTargetH(formW, vScale), recvCardCapH); + float targetCardH = std::min(Layout::mainCardTargetH(cardW, vScale), recvCardCapH); float footerTopH = targetCardH - footerH; if (currentCardH < footerTopH) { ImGui::Dummy(ImVec2(0, footerTopH - currentCardH)); @@ -887,7 +900,7 @@ void RenderReceiveTab(App* app) { ImVec2 divPos = ImGui::GetCursorScreenPos(); dl->AddLine(ImVec2(containerMin.x + pad, divPos.y), - ImVec2(containerMin.x + formW - pad, divPos.y), + ImVec2(containerMin.x + cardW - pad, divPos.y), ImGui::GetColorU32(Divider()), S.drawElement("tabs.receive", "divider-thickness").size); } ImGui::Dummy(ImVec2(0, innerGap * 0.5f)); @@ -967,24 +980,26 @@ void RenderReceiveTab(App* app) // Bottom padding ImGui::Dummy(ImVec2(0, pad)); - ImGui::Unindent(pad); + ImGui::Unindent(pad + cardOffsetX); // Enforce shared card height (matches QR-driven target), capped so the reserved // RECENT RECEIVED slice below stays on-screen at HiDPI. { float currentCardH = ImGui::GetCursorScreenPos().y - containerMin.y; - float targetCardH = std::min(Layout::mainCardTargetH(formW, vScale), recvCardCapH); + float targetCardH = std::min(Layout::mainCardTargetH(cardW, vScale), recvCardCapH); if (currentCardH < targetCardH) ImGui::Dummy(ImVec2(0, targetCardH - currentCardH)); } // Draw glass panel background on channel 0 - ImVec2 containerMax(containerMin.x + formW, ImGui::GetCursorScreenPos().y); + ImVec2 containerMax(containerMin.x + cardW, ImGui::GetCursorScreenPos().y); dl->ChannelsSetCurrent(0); DrawGlassPanel(dl, containerMin, containerMax, glassSpec); dl->ChannelsMerge(); - ImGui::SetCursorScreenPos(ImVec2(containerMin.x, containerMax.y)); + // Restore the original (uncapped) left edge so RECENT RECEIVED below renders + // full-width as-is, unaffected by the card's centering offset. + ImGui::SetCursorScreenPos(ImVec2(cardLeftX, containerMax.y)); ImGui::Dummy(ImVec2(formW, 0)); ImGui::Dummy(ImVec2(0, Layout::spacingSm())); } diff --git a/src/ui/windows/send_tab.cpp b/src/ui/windows/send_tab.cpp index 6a92a54..834d48a 100644 --- a/src/ui/windows/send_tab.cpp +++ b/src/ui/windows/send_tab.cpp @@ -1266,6 +1266,12 @@ void RenderSendTab(App* app) float contentStartY = ImGui::GetCursorPosY(); float formAvailW = ImGui::GetContentRegionAvail().x; + // The compose form reads best as a centered fixed-width column, not edge-to-edge. + // Cap the card to a readable form width and center it; the recent-sends list below + // deliberately keeps the full column width (formAvailW). + const float sendDp = Layout::dpiScale(); + float formCardW = std::min(formAvailW, 760.0f * sendDp); + float formOffsetX = std::max(0.0f, (formAvailW - formCardW) * 0.5f); float formW = formAvailW; ImGui::BeginGroup(); @@ -1280,7 +1286,15 @@ void RenderSendTab(App* app) // ================================================================ // COMPOSE FORM — single container for all fields // ================================================================ + // Full-column left edge, restored after the centered card so the recent-sends + // list below spans the full width again. + float formLeftX = ImGui::GetCursorPosX(); { + // Center the capped compose card: offset the cursor by the leftover half-margin, + // then derive every field/divider/button from the card width (not the full column). + float formW = formCardW; + if (formOffsetX > 0.0f) + ImGui::SetCursorPosX(ImGui::GetCursorPosX() + formOffsetX); ImVec2 containerMin = ImGui::GetCursorScreenPos(); float pad = Layout::spacingLg(); float innerW = formW - pad * 2; @@ -1293,8 +1307,10 @@ void RenderSendTab(App* app) dl->ChannelsSplit(2); dl->ChannelsSetCurrent(1); - // Indent content by pad so every line is inset from the card edges - ImGui::Indent(pad); + // Indent content by pad so every line is inset from the card edges. Fold in formOffsetX so the + // auto-layout fields land inside the centered card (Indent() positions from the window's left, so + // without this the fields would sit at the un-offset column while the glass card is centered). + ImGui::Indent(pad + formOffsetX); ImGui::Dummy(ImVec2(0, pad * vScale)); // top padding // ---- SOURCE ADDRESS ---- @@ -1593,7 +1609,7 @@ void RenderSendTab(App* app) // Add bottom padding ImGui::Dummy(ImVec2(0, pad * vScale)); - ImGui::Unindent(pad); + ImGui::Unindent(pad + formOffsetX); // Enforce shared card height (matches receive tab) { @@ -1626,7 +1642,8 @@ void RenderSendTab(App* app) } } - // ---- RECENT SENDS ---- + // ---- RECENT SENDS ---- (full column width; reset X off the centered card) + ImGui::SetCursorPosX(formLeftX); RenderRecentSends(state, formW, capFont, app); ImGui::EndGroup(); From a598217975f9170661e6522230aec604c6f7c1ae Mon Sep 17 00:00:00 2001 From: DanS Date: Wed, 19 Aug 2026 10:11:55 -0500 Subject: [PATCH 57/89] =?UTF-8?q?fix(ui):=20cut-off/clipping=20=E2=80=94?= =?UTF-8?q?=20recent-tx=20collisions,=20updater=20note=20wrap,=20request-p?= =?UTF-8?q?ayment=20URI,=20console=20filter,=20icon-grid=20scroll?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Fixes the cut-off/clipping bugs from the layout audit (all visible at the default 1280/1024 window sizes): - Receive "Recent Received" rows: the amount collided with the relative-time ("+15.7500 DRGX14 days ago") and the type label touched the address at narrow widths. Use the shared short time format (formatTimeAgoShort, matching Overview), chain the amount's right edge off the measured time width, and start the address after the measured type-label width — so neither pair can collide. - Daemon & xmrig updater verify-note: drawn unwrapped and clipped at the card's right edge; wrap it (PushTextWrapPos) within the already-reserved height. - Request Payment: the three footer buttons shared one fixed width (clipping "Copy Full Address"); size each to its own label. The Payment URI overflowed a plain field; render it in a bordered read-only box (bounded, un-chunked). - Console: the filter input shrank below its own placeholder (gone entirely at 1024); give it a min width >= the placeholder and drop the "N lines" count when the row can't fit both. - Address-label "Choose Icon" grid: had NoScrollbar hiding most of the catalog with no cue; give it a real scrollbar. - Overview "Recent Transactions": drop the 4th row at 1024 (it clipped off-screen) by capping to rows that fully fit the reserved height. - Sidebar: reserve the unread-badge width in the nav-label centering so History/Chat labels no longer collide with their badge. Verified at 1024 and 1280 across full-node + Lite + Windows (ctest green) and an adversarial diff review (clean). Skipped the legacy settings_window overlay footer (dead code / removal candidate). Co-Authored-By: Claude Opus 4.8 (1M context) --- src/ui/sidebar.h | 20 +++++++- src/ui/windows/address_label_dialog.h | 8 +++- src/ui/windows/balance_components.cpp | 9 +++- src/ui/windows/console_tab.cpp | 32 +++++++++++-- src/ui/windows/daemon_download_dialog.h | 2 + src/ui/windows/receive_tab.cpp | 50 +++++++++---------- src/ui/windows/request_payment_dialog.cpp | 58 ++++++++++++++++------- src/ui/windows/xmrig_download_dialog.h | 2 + 8 files changed, 128 insertions(+), 53 deletions(-) diff --git a/src/ui/sidebar.h b/src/ui/sidebar.h index e07ada9..b6d53fa 100644 --- a/src/ui/sidebar.h +++ b/src/ui/sidebar.h @@ -676,17 +676,33 @@ inline bool RenderSidebar(NavPage& current, float sidebarWidth, float contentHei ImU32 textCol = selected ? Primary() : (pageNeedsUnlock ? OnSurfaceDisabled() : OnSurfaceMedium()); if (showLabels) { + // Reserve room for a badge (if this item will draw one) so the + // label centers in the space to the left of it instead of + // running underneath the badge circle. + bool itemHasBadge = + (item.page == NavPage::History && status.unconfirmedTxCount > 0) || + (item.page == NavPage::Mining && status.miningActive) || + (item.page == NavPage::Peers && status.peerCount > 0) || + (item.page == NavPage::Chat && status.chatUnreadCount > 0); + float badgeReserve = 0.0f; + if (itemHasBadge) { + bool dotOnlyReserve = (item.page == NavPage::Mining); + float badgeRReserve = dotOnlyReserve ? badgeRadiusDot : badgeRadiusNumber; + float badgeInsetXReserve = sde("badge-inset-x", 6.0f); + badgeReserve = badgeRReserve * 2.0f + badgeInsetXReserve; + } + ImFont* font = selected ? Type().subtitle2() : Type().body2(); float lblFsz = ScaledFontSize(font); float btnW = indMax.x - indMin.x; - float maxLabelW = btnW - iconS * 2.0f - iconLabelGap - Layout::spacingXs() * 2; + float maxLabelW = btnW - iconS * 2.0f - iconLabelGap - Layout::spacingXs() * 2 - badgeReserve; ImVec2 labelSz = font->CalcTextSizeA(lblFsz, 1000.0f, 0.0f, NavLabel(item)); if (labelSz.x > maxLabelW && maxLabelW > 0) { lblFsz *= maxLabelW / labelSz.x; labelSz = font->CalcTextSizeA(lblFsz, 1000.0f, 0.0f, NavLabel(item)); } float totalW = iconS * 2.0f + iconLabelGap + labelSz.x; - float btnCX = (indMin.x + indMax.x) * 0.5f; + float btnCX = (indMin.x + indMax.x - badgeReserve) * 0.5f; float startX = btnCX - totalW * 0.5f; DrawNavIcon(dl, item.page, startX + iconS, iconCY, iconS, textCol); diff --git a/src/ui/windows/address_label_dialog.h b/src/ui/windows/address_label_dialog.h index 9e56bb5..e8f9a17 100644 --- a/src/ui/windows/address_label_dialog.h +++ b/src/ui/windows/address_label_dialog.h @@ -138,8 +138,13 @@ public: const float controlsTopY = std::max(gridStartY + cellSz * 2.0f, buttonY - preButtonReserve); const float gridMaxH = std::max(cellSz * 2.0f, controlsTopY - gridStartY); ImGui::PushStyleColor(ImGuiCol_ChildBg, IM_COL32(0, 0, 0, 0)); + ImGui::PushStyleVar(ImGuiStyleVar_ScrollbarSize, 11.0f * dp); + ImGui::PushStyleVar(ImGuiStyleVar_ScrollbarRounding, 5.5f * dp); + // Scrollbar visible (not NoScrollbar) — the icon set exceeds the fixed-height + // grid, so a real scrollbar is the discoverable way to reach the rest. ImGui::BeginChild("##IconGrid", ImVec2(avail, gridMaxH), ImGuiChildFlags_None, - ImGuiWindowFlags_NoScrollbar); + ImGuiWindowFlags_NoScrollWithMouse); + ApplySmoothScroll(); ImDrawList* dl = ImGui::GetWindowDrawList(); @@ -185,6 +190,7 @@ public: } ImGui::EndChild(); + ImGui::PopStyleVar(2); // ScrollbarSize + ScrollbarRounding ImGui::PopStyleColor(); if (ImGui::GetCursorPosY() < controlsTopY) { diff --git a/src/ui/windows/balance_components.cpp b/src/ui/windows/balance_components.cpp index fb607ed..34849fc 100644 --- a/src/ui/windows/balance_components.cpp +++ b/src/ui/windows/balance_components.cpp @@ -805,6 +805,7 @@ void RenderSharedRecentTx(App* app, float recentH, float availW, float hs, float const float kRecentTxRowHeight = S.drawElement("tabs.balance", "recent-tx-row-height").sizeOr(22.0f); const auto& state = app->state(); + float headerStartY = ImGui::GetCursorPosY(); ImGui::Dummy(ImVec2(0, Layout::spacingSm())); Type().textColored(TypeStyle::Overline, OnSurfaceMedium(), TR("recent_transactions")); ImGui::SameLine(); @@ -812,6 +813,7 @@ void RenderSharedRecentTx(App* app, float recentH, float availW, float hs, float app->setCurrentPage(NavPage::History); } ImGui::Spacing(); + float headerHeight = ImGui::GetCursorPosY() - headerStartY; float scaledRowH = std::max(S.drawElement("tabs.balance", "recent-tx-row-min-height").size, kRecentTxRowHeight * vs); float availableListH = ImGui::GetContentRegionAvail().y; @@ -820,14 +822,17 @@ void RenderSharedRecentTx(App* app, float recentH, float availW, float hs, float ImGuiWindowFlags_NoBackground); const auto& txs = state.transactions; - int count = std::min(4, (int)txs.size()); // show only the 4 most recent (state.transactions is newest-first) + float rowH = std::max(18.0f * dp, kRecentTxRowHeight * vs); + // Only draw as many rows as fully fit within the reserved section height (header + rows); + // dropping the overflow row is fine since "View All" already links to full History. + int maxRows = std::max(1, (int)((recentH - headerHeight) / rowH)); + int count = std::min({4, maxRows, (int)txs.size()}); // show only the most recent (state.transactions is newest-first) if (count == 0) { Type().textColored(TypeStyle::Caption, OnSurfaceDisabled(), TR("no_transactions_yet")); } else { ImDrawList* dl = ImGui::GetWindowDrawList(); ImFont* capFont = Type().caption(); - float rowH = std::max(18.0f * dp, kRecentTxRowHeight * vs); float iconSz = std::max(S.drawElement("tabs.balance", "recent-tx-icon-min-size").size, S.drawElement("tabs.balance", "recent-tx-icon-size").size * hs); diff --git a/src/ui/windows/console_tab.cpp b/src/ui/windows/console_tab.cpp index 4648df9..d6246c8 100644 --- a/src/ui/windows/console_tab.cpp +++ b/src/ui/windows/console_tab.cpp @@ -564,12 +564,27 @@ void ConsoleTab::renderToolbar(ConsoleCommandExecutor& exec) ImGui::SameLine(); } - // Line count - ImGui::TextDisabled(TR("console_line_count"), model_.size()); + // Line count — the least-critical trailing element. When the row is too narrow to fit the + // filter box (at its placeholder-sized minimum) AND its trailing controls, drop the line count + // rather than starve/hide the filter (worst at 1024px). Mirror the reservation formula in + // drawFilterInput(): trailing = 4 frame-height buttons + the group spacers, and the filter's + // hard floor = its placeholder width + frame padding. + { + char lineCountBuf[64]; + snprintf(lineCountBuf, sizeof(lineCountBuf), TR("console_line_count"), model_.size()); + float lineCountW = ImGui::CalcTextSize(lineCountBuf).x + Layout::spacingSm() * 2.0f; // text + its trailing spacer + float trailingW = ImGui::GetFrameHeight() * 4.0f + Layout::spacingSm() * 7.0f; + float filterMinW = ImGui::CalcTextSize(TR("console_filter_hint")).x + + ImGui::GetStyle().FramePadding.x * 2.0f + 8.0f * Layout::dpiScale(); + bool showLineCount = ImGui::GetContentRegionAvail().x >= lineCountW + trailingW + filterMinW; - ImGui::SameLine(); - ImGui::Spacing(); - ImGui::SameLine(); + if (showLineCount) { + ImGui::TextDisabled(TR("console_line_count"), model_.size()); + ImGui::SameLine(); + ImGui::Spacing(); + ImGui::SameLine(); + } + } // Output filter input drawFilterInput(); @@ -695,6 +710,13 @@ void ConsoleTab::drawFilterInput() float filterAvail = ImGui::GetContentRegionAvail().x - trailingBtnSpace; float filterMaxW = schema::UI().drawElement("tabs.console", "filter-max-width").size * Layout::dpiScale(); float filterW = std::min(filterMaxW, filterAvail * schema::UI().drawElement("tabs.console", "filter-width-ratio").size); + // Never shrink below the placeholder — otherwise the hint clips to "Filter outp" (or the box + // vanishes) at narrow widths. Floor = placeholder text + frame padding + a little breathing room. + // (drawToolbar() drops the "NNN lines" count when even this floor won't fit alongside the row's + // trailing controls, so this max() doesn't push the zoom/color buttons off-window.) + float filterMinW = ImGui::CalcTextSize(TR("console_filter_hint")).x + + ImGui::GetStyle().FramePadding.x * 2.0f + 8.0f * Layout::dpiScale(); + filterW = std::max(filterMinW, filterW); ImGui::SetNextItemWidth(filterW); ImGui::InputTextWithHint("##ConsoleFilter", TR("console_filter_hint"), filter_text_, sizeof(filter_text_)); if (filter_text_[0] != '\0') { diff --git a/src/ui/windows/daemon_download_dialog.h b/src/ui/windows/daemon_download_dialog.h index ebfb9ce..3a7d15d 100644 --- a/src/ui/windows/daemon_download_dialog.h +++ b/src/ui/windows/daemon_download_dialog.h @@ -408,7 +408,9 @@ private: // ---- Below the info card (outside the surface): verify note + install button ---- ImGui::Dummy(ImVec2(0, Layout::spacingSm())); + ImGui::PushTextWrapPos(ImGui::GetCursorPosX() + ImGui::GetContentRegionAvail().x); Type().textColored(TypeStyle::Caption, downgrade ? Warning() : OnSurfaceMedium(), noteStr); + ImGui::PopTextWrapPos(); ImGui::Spacing(); // Install button sized to its text and centered in the pane. const float bw = ImGui::CalcTextSize(label).x + ImGui::GetStyle().FramePadding.x * 2.0f + Layout::spacingLg(); diff --git a/src/ui/windows/receive_tab.cpp b/src/ui/windows/receive_tab.cpp index 8acecc3..21dc2a7 100644 --- a/src/ui/windows/receive_tab.cpp +++ b/src/ui/windows/receive_tab.cpp @@ -324,20 +324,9 @@ static void RenderAddressDropdown(App* app, float width) { } // ============================================================================ -// Helpers: timeAgo / DrawRecvIcon (local copies — originals are static in send_tab) +// Helpers: DrawRecvIcon (local copy — original is static in send_tab). +// Relative time uses the shared util::formatTimeAgoShort ("14d ago"), matching Overview/Send. // ============================================================================ -static std::string recvTimeAgo(int64_t timestamp) { - if (timestamp <= 0) return ""; - int64_t now = (int64_t)std::time(nullptr); - int64_t diff = now - timestamp; - if (diff < 0) diff = 0; - char buf[32]; - if (diff < 60) { snprintf(buf, sizeof(buf), TR("time_seconds_ago"), (long long)diff); return buf; } - if (diff < 3600) { snprintf(buf, sizeof(buf), TR("time_minutes_ago"), (long long)(diff / 60)); return buf; } - if (diff < 86400) { snprintf(buf, sizeof(buf), TR("time_hours_ago"), (long long)(diff / 3600)); return buf; } - snprintf(buf, sizeof(buf), TR("time_days_ago"), (long long)(diff / 86400)); return buf; -} - static void DrawRecvIcon(ImDrawList* dl, float cx, float cy, float s, ImU32 col) { dl->AddTriangleFilled( ImVec2(cx, cy + s), @@ -404,30 +393,37 @@ static void RenderRecentReceived(const AddressInfo& /* addr */, rowDL->AddText(capFont, capFont->LegacySize, ImVec2(txX, rowPos.y + 2.0f * dp), OnSurfaceMedium(), typeText); - // Address (second line) - float addrX = txX + S.drawElement("tabs.balance", "recent-tx-addr-offset").sizeOr(65.0f) * hs; + // Address — start it AFTER the measured type-label width (not a fixed offset that shrinks below + // the label at narrow widths), mirroring Overview's recent-tx list. The schema offset is a floor. + float typeW = capFont->CalcTextSizeA(capFont->LegacySize, 10000.0f, 0.0f, typeText).x; + float addrX = txX + std::max(S.drawElement("tabs.balance", "recent-tx-addr-offset").sizeOr(65.0f) * hs, + typeW + Layout::spacingSm()); std::string addrDisplay = util::truncateMiddle(tx.address, (int)S.drawElement("tabs.balance", "recent-tx-addr-trunc").sizeOr(20.0f)); rowDL->AddText(capFont, capFont->LegacySize, ImVec2(addrX, rowPos.y + 2.0f * dp), OnSurfaceDisabled(), addrDisplay.c_str()); - // Amount (right-aligned, first line) + // Time ago — short "14d ago" form (shared helper, matches Overview/Send). Measure it + // first so the amount can chain its right edge off this width and never overlap. + std::string ago = util::formatTimeAgoShort(tx.timestamp); + ImVec2 agoSz = capFont->CalcTextSizeA(capFont->LegacySize, 10000.0f, 0.0f, ago.c_str()); + float rightEdge = rowPos.x + ImGui::GetContentRegionAvail().x; + float agoMargin = S.drawElement("tabs.balance", "recent-tx-time-margin").sizeOr(4.0f) * hs; + rowDL->AddText(capFont, capFont->LegacySize, + ImVec2(rightEdge - agoSz.x - agoMargin, rowPos.y + 2.0f * dp), + OnSurfaceDisabled(), ago.c_str()); + + // Amount (right-aligned, first line) — anchored to the LEFT of the time-ago text + // (measured width + a gap) so the two columns can never collide, whatever the strings. snprintf(buf, sizeof(buf), "+%.4f %s", std::abs(tx.amount), DRAGONX_TICKER); ImVec2 amtSz = capFont->CalcTextSizeA(capFont->LegacySize, 10000.0f, 0.0f, buf); - float rightEdge = rowPos.x + ImGui::GetContentRegionAvail().x; - float amtX = rightEdge - amtSz.x - std::max(S.drawElement("tabs.balance", "amount-right-min-margin").size, - S.drawElement("tabs.balance", "amount-right-margin").size * hs); + float amtGap = std::max(S.drawElement("tabs.balance", "amount-right-min-margin").size, + S.drawElement("tabs.balance", "amount-right-margin").size * hs); + float amtRightEdge = rightEdge - agoSz.x - agoMargin - amtGap; + float amtX = amtRightEdge - amtSz.x; rowDL->AddText(capFont, capFont->LegacySize, ImVec2(amtX, rowPos.y + 2.0f * dp), recvCol, buf); - // Time ago - std::string ago = recvTimeAgo(tx.timestamp); - ImVec2 agoSz = capFont->CalcTextSizeA(capFont->LegacySize, 10000.0f, 0.0f, ago.c_str()); - rowDL->AddText(capFont, capFont->LegacySize, - ImVec2(rightEdge - agoSz.x - S.drawElement("tabs.balance", "recent-tx-time-margin").sizeOr(4.0f) * hs, - rowPos.y + 2.0f * dp), - OnSurfaceDisabled(), ago.c_str()); - // Clickable row — hover highlight + navigate to History float rowW = ImGui::GetContentRegionAvail().x; ImVec2 rowEnd(rowPos.x + rowW, rowPos.y + rowH); diff --git a/src/ui/windows/request_payment_dialog.cpp b/src/ui/windows/request_payment_dialog.cpp index 67dc271..ccaae6e 100644 --- a/src/ui/windows/request_payment_dialog.cpp +++ b/src/ui/windows/request_payment_dialog.cpp @@ -9,6 +9,7 @@ #include "../notifications.h" #include "../schema/ui_schema.h" #include "../widgets/qr_code.h" +#include "../widgets/copy_field.h" #include "../material/draw_helpers.h" #include "imgui.h" @@ -198,33 +199,58 @@ void RequestPaymentDialog::render(App* app) // Payment URI display if (!s_payment_uri.empty()) { - // Use a selectable text area for the URI - char uri_buf[1024]; - strncpy(uri_buf, s_payment_uri.c_str(), sizeof(uri_buf) - 1); - material::LabeledInput(TR("request_payment_uri"), "##URI", uri_buf, sizeof(uri_buf), - -1.0f, nullptr, ImGuiInputTextFlags_ReadOnly); - + ImGui::Text("%s", TR("request_payment_uri")); + // Bordered read-only field: bounds the raw drgx: URI within a box (it horizontal-scrolls if + // long) rather than 4-char-chunking it like an address or letting a plain field overflow. + // The "Copy URI" button below copies the full value. + { + char uriBuf[2048]; + snprintf(uriBuf, sizeof(uriBuf), "%s", s_payment_uri.c_str()); + ImGui::SetNextItemWidth(ImGui::GetContentRegionAvail().x); + ImGui::InputText("##URI", uriBuf, sizeof(uriBuf), ImGuiInputTextFlags_ReadOnly); + } + ImGui::Spacing(); - - // Copy button - if (material::TactileButton(TR("request_copy_uri"), ImVec2(actionBtn.width, 0), S.resolveFont(actionBtn.font))) { + + // Footer buttons: size each to ITS OWN label (action-button.width is a floor, not the size) + // so "Copy Full Address" never clips its final letter — mirrors qr_popup_dialog's per-label + // sizing. Font metrics are already DPI-scaled, so don't multiply by dpiScale() here. + ImFont* btnFont = S.resolveFont(actionBtn.font); + ImGui::PushFont(btnFont); + const float btnPad = ImGui::GetStyle().FramePadding.x * 2.0f + 12.0f; // small margin + float w_uri = ImGui::CalcTextSize(TR("request_copy_uri")).x + btnPad; + float w_addr = ImGui::CalcTextSize(TR("copy_address")).x + btnPad; + ImGui::PopFont(); + if (w_uri < actionBtn.width) w_uri = actionBtn.width; + if (w_addr < actionBtn.width) w_addr = actionBtn.width; + + // Copy URI button + if (material::TactileButton(TR("request_copy_uri"), ImVec2(w_uri, 0), btnFont)) { ImGui::SetClipboardText(s_payment_uri.c_str()); Notifications::instance().success(TR("request_uri_copied")); } - + ImGui::SameLine(); - - if (material::TactileButton(TR("copy_address"), ImVec2(actionBtn.width, 0), S.resolveFont(actionBtn.font))) { + + if (material::TactileButton(TR("copy_address"), ImVec2(w_addr, 0), btnFont)) { ImGui::SetClipboardText(s_address); Notifications::instance().success(TR("address_copied")); } } ImGui::Spacing(); - - // Close button - if (material::TactileButton(TR("close"), ImVec2(actionBtn.width, 0), S.resolveFont(actionBtn.font))) { - s_open = false; + + // Close button — sized to its own label with the same floor. + { + ImFont* btnFont = S.resolveFont(actionBtn.font); + ImGui::PushFont(btnFont); + const float btnPad = ImGui::GetStyle().FramePadding.x * 2.0f + 12.0f; + float w_close = ImGui::CalcTextSize(TR("close")).x + btnPad; + ImGui::PopFont(); + if (w_close < actionBtn.width) w_close = actionBtn.width; + if (material::TactileButton(TR("close"), ImVec2(w_close, 0), btnFont)) { + s_open = false; + } } material::EndOverlayDialog(); } diff --git a/src/ui/windows/xmrig_download_dialog.h b/src/ui/windows/xmrig_download_dialog.h index 06a7668..4f815a0 100644 --- a/src/ui/windows/xmrig_download_dialog.h +++ b/src/ui/windows/xmrig_download_dialog.h @@ -368,7 +368,9 @@ private: // ---- Below the info card: verify / stop-mining note + install button (centered, text-fit) ---- ImGui::Dummy(ImVec2(0, Layout::spacingSm())); + ImGui::PushTextWrapPos(ImGui::GetCursorPosX() + ImGui::GetContentRegionAvail().x); Type().textColored(TypeStyle::Caption, (mining || downgrade) ? Warning() : OnSurfaceMedium(), noteStr); + ImGui::PopTextWrapPos(); ImGui::Spacing(); const float bw = ImGui::CalcTextSize(label).x + ImGui::GetStyle().FramePadding.x * 2.0f + Layout::spacingLg(); ImGui::SetCursorPosX(ImGui::GetCursorPosX() + std::max(0.0f, (ImGui::GetContentRegionAvail().x - bw) * 0.5f)); From d5c30237d28bb13d8cc193b931339a98a69e7598 Mon Sep 17 00:00:00 2001 From: DanS Date: Wed, 19 Aug 2026 11:23:49 -0500 Subject: [PATCH 58/89] refactor(ui): consolidate dialog footers + shared empty-state, unify buttons/rounding MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Addresses the cross-screen inconsistencies from the layout audit by routing screens onto the design system's own (previously under-used) shared helpers: - Dialog footers: migrate ~9 overlay dialogs off hand-rolled placement onto the shared helpers — DialogActionFooter (primary+Close), DialogConfirmFooter, or BeginOverlayDialogFooter for custom/multi-button rows — so footers share one centered treatment. All footer/action buttons now use TactileButton (glass press) instead of the bare StyledButton some dialogs used. - Empty states: add a shared material::DrawEmptyState(icon, title, hint) (centered icon + title + wrapped hint) and adopt it in Peers, Transactions, and Market-portfolio, which previously showed a bare left-aligned caption. - Security dialogs: add the missing Cancel to Change Passphrase and Set PIN so the whole security family shares a two-button footer (Cancel dismisses without applying). - Transactions pager: shared TactileButton helpers (matching Explorer). - Frosted-pane rounding: Contacts/Chat use Layout::glassRounding() instead of hardcoded 12/10/8px literals, matching Peers. - "Set Label..." title loses its stray trailing ellipsis. Preserves every button's label and action; the transfer footer's order becomes [Confirm][Cancel] to match the shared helper's primary-first convention. Verified at 1280 across full-node + Lite + Windows (ctest green) and an adversarial diff review (clean). Co-Authored-By: Claude Opus 4.8 (1M context) --- res/lang/de.json | 2 +- res/lang/es.json | 2 +- res/lang/fr.json | 2 +- res/lang/ja.json | 2 +- res/lang/ko.json | 2 +- res/lang/pt.json | 2 +- res/lang/ru.json | 2 +- res/lang/zh.json | 2 +- src/app_security.cpp | 23 +++++++- src/ui/material/draw_helpers.h | 57 +++++++++++++++++++ src/ui/windows/about_dialog.cpp | 27 ++++----- src/ui/windows/address_transfer_dialog.h | 28 ++++----- src/ui/windows/block_info_dialog.cpp | 13 +++-- src/ui/windows/chat_tab.cpp | 8 +-- src/ui/windows/contacts_tab.cpp | 6 +- src/ui/windows/key_export_dialog.cpp | 8 +-- src/ui/windows/market_tab.cpp | 3 +- src/ui/windows/peers_tab.cpp | 12 ++-- src/ui/windows/qr_popup_dialog.cpp | 16 +++--- src/ui/windows/request_payment_dialog.cpp | 7 +++ src/ui/windows/shield_dialog.cpp | 11 +++- src/ui/windows/transaction_details_dialog.cpp | 19 ++----- src/ui/windows/transactions_tab.cpp | 40 ++++--------- src/ui/windows/validate_address_dialog.cpp | 7 +-- src/util/i18n.cpp | 2 +- 25 files changed, 177 insertions(+), 126 deletions(-) diff --git a/res/lang/de.json b/res/lang/de.json index 91bdd68..8f9f4fa 100644 --- a/res/lang/de.json +++ b/res/lang/de.json @@ -1312,7 +1312,7 @@ "sent_filter": "Gesendet", "sent_type": "Gesendet", "sent_upper": "GESENDET", - "set_label": "Label setzen...", + "set_label": "Label setzen", "settings": "Einstellungen", "settings_about_text": "Eine geschirmte Kryptowährungs-Wallet für DragonX (DRGX), erstellt mit Dear ImGui für ein leichtes, portables Erlebnis.", "settings_acrylic_level": "Acrylstufe:", diff --git a/res/lang/es.json b/res/lang/es.json index 3a948d0..f9ef36f 100644 --- a/res/lang/es.json +++ b/res/lang/es.json @@ -1312,7 +1312,7 @@ "sent_filter": "Enviado", "sent_type": "Enviado", "sent_upper": "ENVIADO", - "set_label": "Establecer Etiqueta...", + "set_label": "Establecer Etiqueta", "settings": "Ajustes", "settings_about_text": "Una billetera de criptomonedas blindada para DragonX (DRGX), creada con Dear ImGui para una experiencia ligera y portátil.", "settings_acrylic_level": "Nivel de acrílico:", diff --git a/res/lang/fr.json b/res/lang/fr.json index ee412c0..2dbf5b3 100644 --- a/res/lang/fr.json +++ b/res/lang/fr.json @@ -1312,7 +1312,7 @@ "sent_filter": "Envoyé", "sent_type": "Envoyé", "sent_upper": "ENVOYÉ", - "set_label": "Définir le libellé...", + "set_label": "Définir le libellé", "settings": "Paramètres", "settings_about_text": "Un portefeuille de cryptomonnaie blindé pour DragonX (DRGX), construit avec Dear ImGui pour une expérience légère et portable.", "settings_acrylic_level": "Niveau acrylique :", diff --git a/res/lang/ja.json b/res/lang/ja.json index 24396ce..d5c42c3 100644 --- a/res/lang/ja.json +++ b/res/lang/ja.json @@ -1309,7 +1309,7 @@ "sent_filter": "送信済み", "sent_type": "送信済み", "sent_upper": "送信済み", - "set_label": "ラベルを設定...", + "set_label": "ラベルを設定", "settings": "設定", "settings_about_text": "DragonX (DRGX) 用のシールド暗号通貨ウォレット。Dear ImGui で構築された軽量でポータブルな体験。", "settings_acrylic_level": "アクリルレベル：", diff --git a/res/lang/ko.json b/res/lang/ko.json index 4c5c018..a015d8d 100644 --- a/res/lang/ko.json +++ b/res/lang/ko.json @@ -1311,7 +1311,7 @@ "sent_filter": "전송됨", "sent_type": "전송됨", "sent_upper": "전송됨", - "set_label": "라벨 설정...", + "set_label": "라벨 설정", "settings": "설정", "settings_about_text": "DragonX (DRGX)용 차폐 암호화폐 지갑으로, Dear ImGui로 제작되어 가볍고 휴대 가능합니다.", "settings_acrylic_level": "아크릴 레벨:", diff --git a/res/lang/pt.json b/res/lang/pt.json index f0c8b62..97a95e5 100644 --- a/res/lang/pt.json +++ b/res/lang/pt.json @@ -1312,7 +1312,7 @@ "sent_filter": "Enviado", "sent_type": "Enviado", "sent_upper": "ENVIADO", - "set_label": "Definir Rótulo...", + "set_label": "Definir Rótulo", "settings": "Ajustes", "settings_about_text": "Uma carteira de criptomoeda blindada para DragonX (DRGX), criada com Dear ImGui para uma experiência leve e portátil.", "settings_acrylic_level": "Nível acrílico:", diff --git a/res/lang/ru.json b/res/lang/ru.json index 8622246..deef9a3 100644 --- a/res/lang/ru.json +++ b/res/lang/ru.json @@ -1312,7 +1312,7 @@ "sent_filter": "Отправлено", "sent_type": "Отправлено", "sent_upper": "ОТПРАВЛЕНО", - "set_label": "Установить метку...", + "set_label": "Установить метку", "settings": "Настройки", "settings_about_text": "Защищённый криптовалютный кошелёк для DragonX (DRGX), созданный на Dear ImGui для лёгкого и портативного использования.", "settings_acrylic_level": "Уровень акрила:", diff --git a/res/lang/zh.json b/res/lang/zh.json index 1e2691a..461352f 100644 --- a/res/lang/zh.json +++ b/res/lang/zh.json @@ -1310,7 +1310,7 @@ "sent_filter": "已发送", "sent_type": "已发送", "sent_upper": "已发送", - "set_label": "设置标签...", + "set_label": "设置标签", "settings": "设置", "settings_about_text": "DragonX (DRGX) 屏蔽加密货币钱包，使用 Dear ImGui 构建，提供轻量、便携的体验。", "settings_acrylic_level": "亚克力级别：", diff --git a/src/app_security.cpp b/src/app_security.cpp index 838bba2..36be4c7 100644 --- a/src/app_security.cpp +++ b/src/app_security.cpp @@ -1476,12 +1476,22 @@ void App::renderEncryptWalletDialog() { bool valid = strlen(change_old_pass_buf_) > 0 && strlen(change_new_pass_buf_) >= 8 && strcmp(change_new_pass_buf_, change_confirm_buf_) == 0; + + // Two-button footer (primary + Cancel) to match the encrypt/decrypt siblings. + float btnW = (ImGui::GetContentRegionAvail().x - ImGui::GetStyle().ItemSpacing.x) * 0.5f; ImGui::BeginDisabled(!valid || encrypt_in_progress_); - if (ui::material::TactileButton(TR("change_pass_title"), ImVec2(-1, 40))) { + if (ui::material::TactileButton(TR("change_pass_title"), ImVec2(btnW, 40))) { changePassphrase(std::string(change_old_pass_buf_), std::string(change_new_pass_buf_)); } ImGui::EndDisabled(); + + ImGui::SameLine(); + // Cancel does what Esc/close does — dismiss without applying. Buffers are wiped by + // the !show_change_passphrase_ cleanup block below. + if (ui::material::TactileButton(TR("cancel"), ImVec2(btnW, 40))) { + show_change_passphrase_ = false; + } EndOverlayDialog(); } @@ -1945,8 +1955,10 @@ void App::renderPinDialogs() { util::SecureVault::isValidPin(pinStr) && strcmp(pin_buf_, pin_confirm_buf_) == 0; + // Two-button footer (primary + Cancel) to match the encrypt/decrypt siblings. + float btnW = (ImGui::GetContentRegionAvail().x - ImGui::GetStyle().ItemSpacing.x) * 0.5f; ImGui::BeginDisabled(!valid || pin_in_progress_); - if (ui::material::TactileButton(TR("settings_set_pin"), ImVec2(-1, 40))) { + if (ui::material::TactileButton(TR("settings_set_pin"), ImVec2(btnW, 40))) { pin_in_progress_ = true; pin_status_ = "Verifying passphrase..."; @@ -2005,6 +2017,13 @@ void App::renderPinDialogs() { } } ImGui::EndDisabled(); + + ImGui::SameLine(); + // Cancel does what Esc/close does — dismiss without applying. Buffers are wiped by + // the !show_pin_setup_ cleanup block below. + if (ui::material::TactileButton(TR("cancel"), ImVec2(btnW, 40))) { + show_pin_setup_ = false; + } EndOverlayDialog(); } // Wipe the passphrase/PIN buffers if the dialog was dismissed (X / Esc / diff --git a/src/ui/material/draw_helpers.h b/src/ui/material/draw_helpers.h index 8212376..697729f 100644 --- a/src/ui/material/draw_helpers.h +++ b/src/ui/material/draw_helpers.h @@ -79,6 +79,63 @@ inline const char* LoadingDots() { return kDots[n]; } +// ── Centered empty state ───────────────────────────────────────────────── +// A big muted icon + title + optional wrapped hint, centered on BOTH axes within +// GetContentRegionAvail(). Mirrors chat_tab's centeredEmptyState so list-empty states +// read the same across tabs. Call at the start of the region you want it centered in +// (e.g. right after a BeginChild / a leading Dummy). Font metrics use the live font +// scale (LegacySize * FontScaleMain) and PushFont draws at that same scale, so this is +// crisp at HiDPI / font_scale 1.5 without any manual dpiScale multiply on the metrics. +inline void DrawEmptyState(const char* iconGlyph, const char* title, const char* hint = nullptr) +{ + auto scaled = [](ImFont* f) { return f->LegacySize * ImGui::GetStyle().FontScaleMain; }; + const ImVec2 avail = ImGui::GetContentRegionAvail(); + const ImVec2 origin = ImGui::GetCursorPos(); + ImFont* iconF = Type().iconXL(); + ImFont* titleF = Type().subtitle1(); + ImFont* hintF = Type().body2(); + const float dp = Layout::dpiScale(); + const float gap = 8.0f * dp; + const float wrap = std::min(avail.x - 40.0f * dp, 360.0f * dp); + const float iconSz = iconF ? scaled(iconF) : 40.0f; + const float iconH = (iconF && iconGlyph) ? iconF->CalcTextSizeA(iconSz, FLT_MAX, 0.0f, iconGlyph).y : 0.0f; + const float titleH = titleF->CalcTextSizeA(scaled(titleF), FLT_MAX, 0.0f, title).y; + const float hintH = hint ? hintF->CalcTextSizeA(scaled(hintF), wrap, wrap, hint).y : 0.0f; + const float totalH = iconH + (iconH > 0.0f ? gap : 0.0f) + titleH + (hint ? gap + hintH : 0.0f); + float y = origin.y + std::max(0.0f, (avail.y - totalH) * 0.5f); + + if (iconF && iconGlyph && iconGlyph[0]) { + const float iw = iconF->CalcTextSizeA(iconSz, FLT_MAX, 0.0f, iconGlyph).x; + ImGui::SetCursorPos(ImVec2(origin.x + (avail.x - iw) * 0.5f, y)); + ImGui::PushFont(iconF); + ImGui::PushStyleColor(ImGuiCol_Text, WithAlpha(OnSurface(), 70)); + ImGui::TextUnformatted(iconGlyph); + ImGui::PopStyleColor(); + ImGui::PopFont(); + y += iconH + gap; + } + { + const float tw = titleF->CalcTextSizeA(scaled(titleF), FLT_MAX, 0.0f, title).x; + ImGui::SetCursorPos(ImVec2(origin.x + (avail.x - tw) * 0.5f, y)); + ImGui::PushFont(titleF); + ImGui::PushStyleColor(ImGuiCol_Text, OnSurfaceMedium()); + ImGui::TextUnformatted(title); + ImGui::PopStyleColor(); + ImGui::PopFont(); + y += titleH + gap; + } + if (hint) { + ImGui::SetCursorPos(ImVec2(origin.x + (avail.x - wrap) * 0.5f, y)); + ImGui::PushFont(hintF); + ImGui::PushStyleColor(ImGuiCol_Text, WithAlpha(OnSurface(), 120)); + ImGui::PushTextWrapPos(ImGui::GetCursorPos().x + wrap); + ImGui::TextUnformatted(hint); + ImGui::PopTextWrapPos(); + ImGui::PopStyleColor(); + ImGui::PopFont(); + } +} + // ============================================================================ // Text Drop Shadow // ============================================================================ diff --git a/src/ui/windows/about_dialog.cpp b/src/ui/windows/about_dialog.cpp index d7c5205..f58ce5c 100644 --- a/src/ui/windows/about_dialog.cpp +++ b/src/ui/windows/about_dialog.cpp @@ -125,29 +125,26 @@ void RenderAboutDialog(App* app, bool* p_open) ImGui::Spacing(); ImGui::TextWrapped("%s", TR("about_license_text")); - ImGui::Spacing(); - ImGui::Separator(); - ImGui::Spacing(); - - // Links - if (material::StyledButton(TR("about_website"), ImVec2(linkW, 0), S.resolveFont(linkBtn.font))) { + // Links — 3-button action row, centered via the shared footer helper (draws its own + // Spacing/Separator/Spacing above the row, replacing the hand-rolled divider block). + const float linksTotalW = linkW * 3.0f + ImGui::GetStyle().ItemSpacing.x * 2.0f; + material::BeginOverlayDialogFooter(linksTotalW); + if (material::TactileButton(TR("about_website"), ImVec2(linkW, 0), S.resolveFont(linkBtn.font))) { util::Platform::openUrl("https://dragonx.is"); } ImGui::SameLine(); - if (material::StyledButton(TR("about_github"), ImVec2(linkW, 0), S.resolveFont(linkBtn.font))) { + if (material::TactileButton(TR("about_github"), ImVec2(linkW, 0), S.resolveFont(linkBtn.font))) { util::Platform::openUrl("https://git.dragonx.is/dragonx/ObsidianDragon"); } ImGui::SameLine(); - if (material::StyledButton(TR("about_block_explorer"), ImVec2(linkW, 0), S.resolveFont(linkBtn.font))) { + if (material::TactileButton(TR("about_block_explorer"), ImVec2(linkW, 0), S.resolveFont(linkBtn.font))) { util::Platform::openUrl("https://explorer.dragonx.is"); } - - ImGui::Spacing(); - - // Close button - float button_width = closeW; - ImGui::SetCursorPosX((ImGui::GetWindowWidth() - button_width) * 0.5f); - if (material::StyledButton(TR("close"), ImVec2(button_width, 0), S.resolveFont(closeBtn.font))) { + + // Close button — lone dismiss action, centered via the shared footer helper (no extra + // divider above it, so it sits directly under the links row). + material::BeginOverlayDialogFooter(closeW, false); + if (material::TactileButton(TR("close"), ImVec2(closeW, 0), S.resolveFont(closeBtn.font))) { *p_open = false; } diff --git a/src/ui/windows/address_transfer_dialog.h b/src/ui/windows/address_transfer_dialog.h index 5c78d2a..c6baad1 100644 --- a/src/ui/windows/address_transfer_dialog.h +++ b/src/ui/windows/address_transfer_dialog.h @@ -180,16 +180,14 @@ public: const char* sendingLabel = TR("sending"); ImFont* buttonFont = Type().button(); float buttonFontSize = ScaledFontSize(buttonFont); - float minBtnW = 120.0f * dp; float confirmMinW = 160.0f * dp; float buttonPadW = ImGui::GetStyle().FramePadding.x * 2.0f + 24.0f * dp; - float cancelW = std::max(minBtnW, - buttonFont->CalcTextSizeA(buttonFontSize, 1000.0f, 0.0f, cancelLabel).x + buttonPadW); + // Both footer buttons share one width (equal-width primary/Close pair), sized to fit the + // widest label — the "Sending…" swap label included — so nothing clips. float confirmTextW = std::max( buttonFont->CalcTextSizeA(buttonFontSize, 1000.0f, 0.0f, confirmLabel).x, buttonFont->CalcTextSizeA(buttonFontSize, 1000.0f, 0.0f, sendingLabel).x); - float confirmW = std::max(confirmMinW, confirmTextW + buttonPadW); - float totalW = cancelW + confirmW + Layout::spacingMd(); + float btnW = std::max(confirmMinW, confirmTextW + buttonPadW); float footerH = ImGui::GetFrameHeight() + ImGui::GetStyle().ItemSpacing.y * 3.0f; // footer divider removed ImGuiViewport* vp = ImGui::GetMainViewport(); float cardBottomY = vp->Pos.y + vp->Size.y * 0.85f; @@ -201,19 +199,18 @@ public: ImGui::Spacing(); } - ImGui::Spacing(); + // Standardized primary + Close footer (centered, no divider). The primary is the + // Confirm/"Sending…" action; the Close button dismisses the dialog. + bool outConfirm = false; + bool outClose = false; + DialogActionFooter(s_sending ? sendingLabel : confirmLabel, + amountValid && !s_sending, + cancelLabel, outConfirm, outClose, btnW); - float rowStartX = ImGui::GetCursorPosX(); - float contentW = ImGui::GetContentRegionAvail().x; - ImGui::SetCursorPosX(rowStartX + std::max(0.0f, (contentW - totalW) * 0.5f)); - - if (TactileButton(cancelLabel, ImVec2(cancelW, 0), buttonFont)) { + if (outClose) { s_open = false; } - ImGui::SameLine(0, Layout::spacingMd()); - - ImGui::BeginDisabled(!amountValid || s_sending); - if (TactileButton(s_sending ? sendingLabel : confirmLabel, ImVec2(confirmW, 0), buttonFont)) { + if (outConfirm) { s_sending = true; s_app->sendTransaction(s_info.fromAddr, s_info.toAddr, amount, s_fee, "", @@ -231,7 +228,6 @@ public: // state, and when the async callback sets s_resultMsg the in-dialog result screen shows // (with its own Close button). Previously closing here made that result screen dead code. } - ImGui::EndDisabled(); EndOverlayDialog(); } diff --git a/src/ui/windows/block_info_dialog.cpp b/src/ui/windows/block_info_dialog.cpp index 6f266c8..7ce979c 100644 --- a/src/ui/windows/block_info_dialog.cpp +++ b/src/ui/windows/block_info_dialog.cpp @@ -135,7 +135,7 @@ void BlockInfoDialog::render(App* app) ImGui::BeginDisabled(); } - if (material::StyledButton(TR("block_get_info"), ImVec2(0,0), S.resolveFont(closeBtn.font))) { + if (material::TactileButton(TR("block_get_info"), ImVec2(0,0), S.resolveFont(closeBtn.font))) { if (rpc && rpc->isConnected() && app->worker()) { s_loading = true; s_error.clear(); @@ -303,7 +303,7 @@ void BlockInfoDialog::render(App* app) // Navigation buttons if (s_has_data) { if (s_height > 1) { - if (material::StyledButton(TR("block_nav_prev"), ImVec2(0,0), S.resolveFont(closeBtn.font))) { + if (material::TactileButton(TR("block_nav_prev"), ImVec2(0,0), S.resolveFont(closeBtn.font))) { s_height--; s_has_data = false; s_error.clear(); @@ -315,7 +315,7 @@ void BlockInfoDialog::render(App* app) // nextblockhash, so this stays hidden there). if (!s_next_hash.empty() && (state.sync.blocks <= 0 || s_height < state.sync.blocks)) { - if (material::StyledButton(TR("block_nav_next"), ImVec2(0,0), S.resolveFont(closeBtn.font))) { + if (material::TactileButton(TR("block_nav_next"), ImVec2(0,0), S.resolveFont(closeBtn.font))) { s_height++; s_has_data = false; s_error.clear(); @@ -323,9 +323,10 @@ void BlockInfoDialog::render(App* app) } } - // Close button at bottom - ImGui::SetCursorPosY(ImGui::GetWindowHeight() - 40); - if (material::StyledButton(TR("close"), ImVec2(closeBtn.width, 0), S.resolveFont(closeBtn.font))) { + // Close button at bottom — centered via the shared footer helper (no separator, matching + // the prior hand-rolled placement). + material::BeginOverlayDialogFooter(closeBtn.width, /*drawSeparator=*/false); + if (material::TactileButton(TR("close"), ImVec2(closeBtn.width, 0), S.resolveFont(closeBtn.font))) { s_open = false; } material::EndOverlayDialog(); diff --git a/src/ui/windows/chat_tab.cpp b/src/ui/windows/chat_tab.cpp index 191dc59..6dbbb16 100644 --- a/src/ui/windows/chat_tab.cpp +++ b/src/ui/windows/chat_tab.cpp @@ -451,7 +451,7 @@ void RenderChatSettingsPreview(App* app, float width) { totalH += padIn; const ImVec2 origin = ImGui::GetCursorScreenPos(); - material::GlassPanelSpec g; g.rounding = 10.0f * dp; g.fillAlpha = 16; g.borderAlpha = 36; + material::GlassPanelSpec g; g.rounding = Layout::glassRounding(); g.fillAlpha = 16; g.borderAlpha = 36; material::DrawGlassPanel(dl, origin, ImVec2(origin.x + width, origin.y + totalH), g); const float leftX = origin.x + padIn; @@ -795,7 +795,7 @@ void RenderChatTab(App* app) { ImDrawList* paneDL = ImGui::GetWindowDrawList(); const ImVec2 pMin = ImGui::GetCursorScreenPos(); - material::GlassPanelSpec g; g.rounding = 12.0f * Layout::dpiScale(); g.fillAlpha = 20; g.borderAlpha = 34; + material::GlassPanelSpec g; g.rounding = Layout::glassRounding(); g.fillAlpha = 20; g.borderAlpha = 34; material::DrawGlassPanel(paneDL, pMin, ImVec2(pMin.x + listW, pMin.y + avail.y), g); } // Inner padding so the list content (buttons, search, conversation cards) doesn't hug the glass @@ -973,7 +973,7 @@ void RenderChatTab(App* app) ImDrawList* paneDL = ImGui::GetWindowDrawList(); const ImVec2 pMin = ImGui::GetCursorScreenPos(); const float pW = ImGui::GetContentRegionAvail().x; - material::GlassPanelSpec g; g.rounding = 12.0f * tdp; g.fillAlpha = 12; g.borderAlpha = 34; + material::GlassPanelSpec g; g.rounding = Layout::glassRounding(); g.fillAlpha = 12; g.borderAlpha = 34; material::DrawGlassPanel(paneDL, pMin, ImVec2(pMin.x + pW, pMin.y + (avail.y - composerAreaH)), g); } // Inner padding so the header + messages don't hug the glass card's edges (the message child @@ -1622,7 +1622,7 @@ void RenderChatTab(App* app) // FrameBg); a flat FrameBg showed the sharp texture. { ImDrawList* cdl = ImGui::GetWindowDrawList(); - material::GlassPanelSpec g; g.rounding = 8.0f * tdp; g.fillAlpha = 16; g.borderAlpha = 34; + material::GlassPanelSpec g; g.rounding = Layout::glassRounding(); g.fillAlpha = 16; g.borderAlpha = 34; material::DrawGlassPanel(cdl, ImVec2(inputX, rowY), ImVec2(inputX + inputW, rowY + composerBoxH), g); } diff --git a/src/ui/windows/contacts_tab.cpp b/src/ui/windows/contacts_tab.cpp index ff61a36..79f2206 100644 --- a/src/ui/windows/contacts_tab.cpp +++ b/src/ui/windows/contacts_tab.cpp @@ -1026,7 +1026,7 @@ void RenderContactsTab(App* app) const float tpW = ImGui::GetContentRegionAvail().x; const float tIpad = 12.0f * dp, tVpad = 10.0f * dp; { - material::GlassPanelSpec g; g.rounding = 12.0f * dp; g.fillAlpha = 14; g.borderAlpha = 34; + material::GlassPanelSpec g; g.rounding = Layout::glassRounding(); g.fillAlpha = 14; g.borderAlpha = 34; material::DrawGlassPanel(tpdl, tpMin, ImVec2(tpMin.x + tpW, tpMin.y + listH), g); } ImGui::SetCursorScreenPos(ImVec2(tpMin.x + tIpad, tpMin.y + tVpad)); @@ -1129,7 +1129,7 @@ void RenderContactsTab(App* app) ImDrawList* pdl = ImGui::GetWindowDrawList(); const ImVec2 pMin = ImGui::GetCursorScreenPos(); const float pW = ImGui::GetContentRegionAvail().x; - material::GlassPanelSpec g; g.rounding = 12.0f * dp; g.fillAlpha = 14; g.borderAlpha = 34; + material::GlassPanelSpec g; g.rounding = Layout::glassRounding(); g.fillAlpha = 14; g.borderAlpha = 34; material::DrawGlassPanel(pdl, pMin, ImVec2(pMin.x + pW, pMin.y + listH), g); } // AlwaysUseWindowPadding: a borderless child ignores WindowPadding without it, so the rows @@ -1390,7 +1390,7 @@ void RenderContactsTab(App* app) const float rowH = avR * 2.0f + 16.0f * dp; const float panelH = 2.0f * rowH + gap + 2.0f * padIn; const ImVec2 pOrigin = ImGui::GetCursorScreenPos(); - material::GlassPanelSpec g; g.rounding = 12.0f * dp; g.fillAlpha = 14; g.borderAlpha = 34; + material::GlassPanelSpec g; g.rounding = Layout::glassRounding(); g.fillAlpha = 14; g.borderAlpha = 34; material::DrawGlassPanel(pdl, pOrigin, ImVec2(pOrigin.x + w, pOrigin.y + panelH), g); const ImVec2 rmn(pOrigin.x + padIn, pOrigin.y + padIn); const float rowW = w - 2.0f * padIn; diff --git a/src/ui/windows/key_export_dialog.cpp b/src/ui/windows/key_export_dialog.cpp index fa3f01c..cb65482 100644 --- a/src/ui/windows/key_export_dialog.cpp +++ b/src/ui/windows/key_export_dialog.cpp @@ -309,12 +309,10 @@ void KeyExportDialog::render(App* app) } } - ImGui::Spacing(); - - // Close button + // Close button — centered via the shared footer helper (no divider, matching the + // dialog's prior leading-Spacing placement) instead of hand-computing the offset. float button_width = closeBtn.width; - float avail_width = ImGui::GetContentRegionAvail().x; - ImGui::SetCursorPosX(ImGui::GetCursorPosX() + (avail_width - button_width) / 2.0f); + material::BeginOverlayDialogFooter(button_width, /*drawSeparator=*/false); if (material::TactileButton(TR("close"), ImVec2(button_width, 0), S.resolveFont(closeBtn.font))) { s_open = false; diff --git a/src/ui/windows/market_tab.cpp b/src/ui/windows/market_tab.cpp index cdc2ffe..d064ae0 100644 --- a/src/ui/windows/market_tab.cpp +++ b/src/ui/windows/market_tab.cpp @@ -2149,8 +2149,7 @@ static void mktDrawPortfolio(const MktCtx& cx) ImDrawList* rdl = ImGui::GetWindowDrawList(); float rowW = ImGui::GetContentRegionAvail().x; // narrows automatically if a scrollbar shows if (vis.empty()) { - ImGui::Dummy(ImVec2(0, Layout::spacingSm())); - Type().textColored(TypeStyle::Caption, OnSurfaceDisabled(), TR("portfolio_no_entries")); + material::DrawEmptyState(ICON_MD_PIE_CHART, TR("portfolio_no_entries")); } else { // TABLE column-header strip (style 0): a thin static header labelling the numeric columns — // a signature the card styles don't have. Uses the shared pfTableCols so it aligns with rows. diff --git a/src/ui/windows/peers_tab.cpp b/src/ui/windows/peers_tab.cpp index 036c268..b1ecb62 100644 --- a/src/ui/windows/peers_tab.cpp +++ b/src/ui/windows/peers_tab.cpp @@ -621,11 +621,9 @@ void RenderPeersTab(App* app) if (!s_show_banned) { // ---- Connected Peers ---- if (!app->isConnected()) { - ImGui::Dummy(ImVec2(0, 20)); - Type().textColored(TypeStyle::Caption, OnSurfaceDisabled(), TR("not_connected")); + material::DrawEmptyState(ICON_MD_CLOUD_OFF, TR("not_connected")); } else if (state.peers.empty()) { - ImGui::Dummy(ImVec2(0, 20)); - Type().textColored(TypeStyle::Caption, OnSurfaceDisabled(), TR("peers_no_connected")); + material::DrawEmptyState(ICON_MD_WIFI_TETHERING, TR("peers_no_connected")); } else { const float dp = ui::Layout::dpiScale(); float rowH = body2->LegacySize + capFont->LegacySize + Layout::spacingLg(); @@ -827,11 +825,9 @@ void RenderPeersTab(App* app) } else { // ---- Banned Peers ---- if (!app->isConnected()) { - ImGui::Dummy(ImVec2(0, 20)); - Type().textColored(TypeStyle::Caption, OnSurfaceDisabled(), TR("not_connected")); + material::DrawEmptyState(ICON_MD_CLOUD_OFF, TR("not_connected")); } else if (state.bannedPeers.empty()) { - ImGui::Dummy(ImVec2(0, 20)); - Type().textColored(TypeStyle::Caption, OnSurfaceDisabled(), TR("peers_no_banned")); + material::DrawEmptyState(ICON_MD_BLOCK, TR("peers_no_banned")); } else { const float dp = ui::Layout::dpiScale(); float rowH = capFont->LegacySize + S.drawElement("tabs.peers", "banned-row-height-padding").size * dp; diff --git a/src/ui/windows/qr_popup_dialog.cpp b/src/ui/windows/qr_popup_dialog.cpp index 7e40ea3..809b852 100644 --- a/src/ui/windows/qr_popup_dialog.cpp +++ b/src/ui/windows/qr_popup_dialog.cpp @@ -120,8 +120,10 @@ void QRPopupDialog::render(App* app) widgets::AddressCopyField("##QRAddress", s_address); ImGui::Spacing(); - - // Buttons — size each to its label (so "Copy address" never clips), then center the pair. + + // Footer — a primary "Copy address" + "Close" pair, placed via the shared design-system helper. + // Size both buttons to the wider label (so "Copy address" never clips) and hand that width to + // DialogActionFooter, which centers the pair. ImFont* btnFont = S.resolveFont(actionBtn.font); ImGui::PushFont(btnFont); const float btnPad = ImGui::GetStyle().FramePadding.x * 2.0f + 24.0f; @@ -130,14 +132,14 @@ void QRPopupDialog::render(App* app) ImGui::PopFont(); if (w_copy < actionBtn.width) w_copy = actionBtn.width; if (w_close < actionBtn.width) w_close = actionBtn.width; - const float total_width = w_copy + w_close + ImGui::GetStyle().ItemSpacing.x; - ImGui::SetCursorPosX((window_width - total_width) / 2.0f); + const float btnW = (w_copy > w_close ? w_copy : w_close); - if (material::TactileButton(TR("copy_address"), ImVec2(w_copy, 0), btnFont)) { + bool doCopy = false, doClose = false; + material::DialogActionFooter(TR("copy_address"), true, TR("close"), doCopy, doClose, btnW); + if (doCopy) { ImGui::SetClipboardText(s_address.c_str()); } - ImGui::SameLine(); - if (material::TactileButton(TR("close"), ImVec2(w_close, 0), btnFont)) { + if (doClose) { close(); } material::EndOverlayDialog(); diff --git a/src/ui/windows/request_payment_dialog.cpp b/src/ui/windows/request_payment_dialog.cpp index ccaae6e..f63293c 100644 --- a/src/ui/windows/request_payment_dialog.cpp +++ b/src/ui/windows/request_payment_dialog.cpp @@ -224,6 +224,10 @@ void RequestPaymentDialog::render(App* app) if (w_uri < actionBtn.width) w_uri = actionBtn.width; if (w_addr < actionBtn.width) w_addr = actionBtn.width; + // Center the two-button copy row via the shared helper (no extra divider; the Separator + // above already frames this region). Total = both button widths + the ItemSpacing between. + material::BeginOverlayDialogFooter(w_uri + w_addr + ImGui::GetStyle().ItemSpacing.x, false); + // Copy URI button if (material::TactileButton(TR("request_copy_uri"), ImVec2(w_uri, 0), btnFont)) { ImGui::SetClipboardText(s_payment_uri.c_str()); @@ -248,6 +252,9 @@ void RequestPaymentDialog::render(App* app) float w_close = ImGui::CalcTextSize(TR("close")).x + btnPad; ImGui::PopFont(); if (w_close < actionBtn.width) w_close = actionBtn.width; + // Center the lone Close button via the shared helper (no extra divider — matches the + // existing tight spacing above it). + material::BeginOverlayDialogFooter(w_close, false); if (material::TactileButton(TR("close"), ImVec2(w_close, 0), btnFont)) { s_open = false; } diff --git a/src/ui/windows/shield_dialog.cpp b/src/ui/windows/shield_dialog.cpp index 488f524..e3477f8 100644 --- a/src/ui/windows/shield_dialog.cpp +++ b/src/ui/windows/shield_dialog.cpp @@ -184,9 +184,16 @@ void ShieldDialog::render(App* app) bool sh_syncing = state.sync.syncing; bool can_submit = !s_operation_pending && s_to_address[0] != '\0' && sh_connected && !sh_syncing; - if (!can_submit) ImGui::BeginDisabled(); - + // Center the primary + Cancel action row via the shared footer helper. We can't use + // DialogActionFooter here because the primary button carries a disabled-hover tooltip that must + // fire on ITS item (the helper draws primary+Close internally, leaving no hook between them), so + // we keep the two TactileButtons + the interleaved tooltip and only standardize the placement. const char* btn_label = (s_mode == Mode::ShieldCoinbase) ? TR("shield_funds") : TR("merge_funds"); + float footerBtnW = shieldBtn.width + cancelBtn.width + ImGui::GetStyle().ItemSpacing.x; + material::BeginOverlayDialogFooter(footerBtnW, /*drawSeparator=*/false); + + if (!can_submit) ImGui::BeginDisabled(); + if (material::TactileButton(btn_label, ImVec2(shieldBtn.width, 0), S.resolveFont(shieldBtn.font))) { s_operation_pending = true; s_status_message = TR("shield_submitting"); diff --git a/src/ui/windows/transaction_details_dialog.cpp b/src/ui/windows/transaction_details_dialog.cpp index d1f4635..77121d6 100644 --- a/src/ui/windows/transaction_details_dialog.cpp +++ b/src/ui/windows/transaction_details_dialog.cpp @@ -174,25 +174,18 @@ void TransactionDetailsDialog::render(App* app) ImGui::Separator(); ImGui::Spacing(); - // Buttons - float button_width = bottomBtn.width; - float total_width = button_width * 2 + ImGui::GetStyle().ItemSpacing.x; - float start_x = (ImGui::GetWindowWidth() - total_width) / 2.0f; - ImGui::SetCursorPosX(start_x); - + // Buttons — centered primary + Close pair via the shared footer helper. // Guard against an empty/whitespace explorer URL so we never open a garbage link. std::string explorerBase = app->settings()->getTxExplorerUrl(); bool explorerValid = explorerBase.find_first_not_of(" \t\r\n") != std::string::npos; - if (!explorerValid) ImGui::BeginDisabled(); - if (material::StyledButton(TR("tx_view_explorer"), ImVec2(button_width, 0), S.resolveFont(bottomBtn.font))) { + bool doExplorer = false, doClose = false; + material::DialogActionFooter(TR("tx_view_explorer"), explorerValid, TR("close"), + doExplorer, doClose, bottomBtn.width); + if (doExplorer) { std::string url = explorerBase + tx.txid; util::Platform::openUrl(url); } - if (!explorerValid) ImGui::EndDisabled(); - - ImGui::SameLine(); - - if (material::StyledButton(TR("close"), ImVec2(button_width, 0), S.resolveFont(bottomBtn.font))) { + if (doClose) { s_open = false; } material::EndOverlayDialog(); diff --git a/src/ui/windows/transactions_tab.cpp b/src/ui/windows/transactions_tab.cpp index 728d2f9..21fbc9f 100644 --- a/src/ui/windows/transactions_tab.cpp +++ b/src/ui/windows/transactions_tab.cpp @@ -541,32 +541,22 @@ void RenderTransactionsTab(App* app) float startX = ImGui::GetContentRegionMax().x - totalPagW; ImGui::SetCursorPosX(startX); - ImGui::PushStyleVar(ImGuiStyleVar_FrameRounding, Layout::spacingSm()); - ImGui::PushStyleVar(ImGuiStyleVar_ButtonTextAlign, ImVec2(0.5f, 0.5f)); - ImGui::PushStyleColor(ImGuiCol_Button, ImGui::ColorConvertU32ToFloat4(IM_COL32(255, 255, 255, 15))); - ImGui::PushStyleColor(ImGuiCol_ButtonHovered, ImGui::ColorConvertU32ToFloat4(IM_COL32(255, 255, 255, 30))); - ImGui::PushStyleColor(ImGuiCol_ButtonActive, ImGui::ColorConvertU32ToFloat4(IM_COL32(255, 255, 255, 45))); - - // First page + // First page — TactileButton (shared glass press, matches the explorer pager) ImGui::BeginDisabled(s_current_page == 0); - ImGui::PushFont(Type().iconSmall()); - if (ImGui::Button(ICON_MD_FIRST_PAGE "##txFirst", ImVec2(btnW, btnW))) { + if (TactileButton(ICON_MD_FIRST_PAGE "##txFirst", ImVec2(btnW, btnW), Type().iconSmall())) { s_current_page = 0; s_expanded_row = -1; } - ImGui::PopFont(); ImGui::EndDisabled(); ImGui::SameLine(0, gap); // Previous page ImGui::BeginDisabled(s_current_page == 0); - ImGui::PushFont(Type().iconSmall()); - if (ImGui::Button(ICON_MD_CHEVRON_LEFT "##txPrev", ImVec2(btnW, btnW))) { + if (TactileButton(ICON_MD_CHEVRON_LEFT "##txPrev", ImVec2(btnW, btnW), Type().iconSmall())) { s_current_page--; s_expanded_row = -1; } - ImGui::PopFont(); ImGui::EndDisabled(); ImGui::SameLine(0, gap); @@ -590,28 +580,21 @@ void RenderTransactionsTab(App* app) // Next page ImGui::BeginDisabled(s_current_page >= totalPages - 1); - ImGui::PushFont(Type().iconSmall()); - if (ImGui::Button(ICON_MD_CHEVRON_RIGHT "##txNext", ImVec2(btnW, btnW))) { + if (TactileButton(ICON_MD_CHEVRON_RIGHT "##txNext", ImVec2(btnW, btnW), Type().iconSmall())) { s_current_page++; s_expanded_row = -1; } - ImGui::PopFont(); ImGui::EndDisabled(); ImGui::SameLine(0, gap); // Last page ImGui::BeginDisabled(s_current_page >= totalPages - 1); - ImGui::PushFont(Type().iconSmall()); - if (ImGui::Button(ICON_MD_LAST_PAGE "##txLast", ImVec2(btnW, btnW))) { + if (TactileButton(ICON_MD_LAST_PAGE "##txLast", ImVec2(btnW, btnW), Type().iconSmall())) { s_current_page = totalPages - 1; s_expanded_row = -1; } - ImGui::PopFont(); ImGui::EndDisabled(); - - ImGui::PopStyleColor(3); - ImGui::PopStyleVar(2); } } ImGui::Dummy(ImVec2(0, Layout::spacingXs())); @@ -641,20 +624,17 @@ void RenderTransactionsTab(App* app) ImGui::Dummy(ImVec2(0, Layout::spacingSm())); { if (!app->isConnected()) { - ImGui::Dummy(ImVec2(0, 20)); - Type().textColored(TypeStyle::Caption, OnSurfaceDisabled(), - TR(app->isLiteBuild() ? "lite_no_wallet" : "not_connected")); + material::DrawEmptyState(ICON_MD_CLOUD_OFF, + TR(app->isLiteBuild() ? "lite_no_wallet" : "not_connected")); } else if (state.transactions.empty()) { - ImGui::Dummy(ImVec2(0, 20)); if (txLoading) { snprintf(buf, sizeof(buf), "%s%s", txLoadingText.c_str(), material::LoadingDots()); - Type().textColored(TypeStyle::Caption, OnSurfaceDisabled(), buf); + material::DrawEmptyState(ICON_MD_HOURGLASS_EMPTY, buf); } else { - Type().textColored(TypeStyle::Caption, OnSurfaceDisabled(), TR("no_transactions")); + material::DrawEmptyState(ICON_MD_RECEIPT_LONG, TR("no_transactions")); } } else if (filtered_indices.empty()) { - ImGui::Dummy(ImVec2(0, 20)); - Type().textColored(TypeStyle::Caption, OnSurfaceDisabled(), TR("no_matching")); + material::DrawEmptyState(ICON_MD_SEARCH_OFF, TR("no_matching")); } else { float rowH = body2->LegacySize + capFont->LegacySize + Layout::spacingLg() + Layout::spacingMd(); float innerW = ImGui::GetContentRegionAvail().x; diff --git a/src/ui/windows/validate_address_dialog.cpp b/src/ui/windows/validate_address_dialog.cpp index 5a17f96..7f7ad4a 100644 --- a/src/ui/windows/validate_address_dialog.cpp +++ b/src/ui/windows/validate_address_dialog.cpp @@ -210,11 +210,10 @@ void ValidateAddressDialog::render(App* app) ImGui::TextColored(ImVec4(1.0f, 0.6f, 0.0f, 1.0f), "%s", TR("not_connected")); } - ImGui::Spacing(); - - // Close button at bottom + // Close button at bottom — centered via the shared footer helper (no separator, matching + // the prior hand-rolled placement). float button_width = closeBtn.width; - ImGui::SetCursorPosX((ImGui::GetWindowWidth() - button_width) / 2.0f); + material::BeginOverlayDialogFooter(button_width, /*drawSeparator=*/false); if (material::TactileButton(TR("close"), ImVec2(button_width, 0), S.resolveFont(closeBtn.font))) { s_open = false; } diff --git a/src/util/i18n.cpp b/src/util/i18n.cpp index 46a1010..641cab8 100644 --- a/src/util/i18n.cpp +++ b/src/util/i18n.cpp @@ -951,7 +951,7 @@ void I18n::loadBuiltinEnglish() strings_["filter"] = "Filter..."; strings_["no_addresses_yet"] = "No addresses yet"; strings_["showing_x_of_y"] = "Showing %d of %d addresses"; - strings_["set_label"] = "Set Label..."; + strings_["set_label"] = "Set Label"; strings_["copied"] = "Copied!"; strings_["hidden_tag"] = " (hidden)"; strings_["z_address"] = "Z-Address"; From 8778398d31272a7dbbb4fc748db3f46db8cff5cd Mon Sep 17 00:00:00 2001 From: DanS Date: Wed, 19 Aug 2026 13:56:13 -0500 Subject: [PATCH 59/89] =?UTF-8?q?feat(ui):=20layout=20polish=20=E2=80=94?= =?UTF-8?q?=20fill=20dead=20space,=20pair/box/collapse,=20warning=20weight?= =?UTF-8?q?,=20dialog=20glass?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Implements the layout-improvement suggestions from the layout audit (visual arrangement only; no functionality added or removed): - Send/Receive: the recent-activity list now grows to fill the space below the fixed compose/receive card (more history visible), with a centered empty-state when there is none — instead of leaving dead canvas. - Shield/Merge: pair the Fee and UTXO-Limit fields on one row to tighten vertical rhythm. - Market: extend + frame the portfolio group-list as one contained panel (with a bottom edge) and center its empty-state, closing the previously un-anchored gap. - Overlay dialogs: raise the card glass fill/border alpha (35/50 -> 60/90 of 255) so the dialog card reads as a distinct surface over busy backdrops (global, all overlays). - Wallets: size the list height to the actual wallet count instead of always reserving 7 rows, removing the large gap before the scan/create prompts (still scrolls when many). - Contacts: width-aware address truncation shows more of the address on wide rows. - Transfer Funds: give the "sends the full balance" warning a warning icon + color so the stakes stand out from the neutral result-preview lines. - First-run wizard: collapse a completed Step 1 (Appearance) to the compact pill like Step 2, so a finished step is no longer taller than the active one. - Explorer: distribute the Chain card's two stats to match the density of the sibling metrics grid. - Validate Address: a "Results will appear here" caption fills the pre-interaction blank. - Change Passphrase: add the warning banner its sibling security dialogs have. - Migration ShowSeed: box the 24-word mnemonic grid (a GlassSectionScope behind the existing RenderSeedWordGrid) so the critical secret reads as a distinct artifact — purely visual, no seed/logic/state change. Verified at 1280 across full-node + Lite + Windows (ctest green) and an adversarial diff review (clean). New i18n key backfilled into all 8 languages. Co-Authored-By: Claude Opus 4.8 (1M context) --- res/lang/de.json | 3 +- res/lang/es.json | 3 +- res/lang/fr.json | 3 +- res/lang/ja.json | 3 +- res/lang/ko.json | 3 +- res/lang/pt.json | 3 +- res/lang/ru.json | 3 +- res/lang/zh.json | 3 +- src/app.cpp | 7 ++- src/app_security.cpp | 5 ++ src/app_wizard.cpp | 71 +++++++++++++++------- src/ui/material/draw_helpers.h | 5 +- src/ui/windows/address_transfer_dialog.h | 6 +- src/ui/windows/contacts_tab.cpp | 29 ++++++++- src/ui/windows/explorer_tab.cpp | 13 +++- src/ui/windows/market_tab.cpp | 22 ++++++- src/ui/windows/receive_tab.cpp | 12 +++- src/ui/windows/send_tab.cpp | 12 +++- src/ui/windows/shield_dialog.cpp | 17 ++++-- src/ui/windows/validate_address_dialog.cpp | 8 +++ src/ui/windows/wallets_dialog.h | 16 +++-- src/util/i18n.cpp | 1 + 22 files changed, 189 insertions(+), 59 deletions(-) diff --git a/res/lang/de.json b/res/lang/de.json index 8f9f4fa..8d643cc 100644 --- a/res/lang/de.json +++ b/res/lang/de.json @@ -1672,6 +1672,7 @@ "validate_not_mine": "Nicht im Besitz dieser Wallet", "validate_ownership": "Eigentum:", "validate_results": "Ergebnisse:", + "validate_results_placeholder": "Ergebnisse erscheinen hier", "validate_shielded_type": "Abgeschirmt (z-Adresse)", "validate_status": "Status:", "validate_title": "Adresse validieren", @@ -1830,4 +1831,4 @@ "your_addresses": "Ihre Adressen", "z_address": "Z-Adresse", "z_addresses": "Z-Adressen" -} +} \ No newline at end of file diff --git a/res/lang/es.json b/res/lang/es.json index f9ef36f..848663e 100644 --- a/res/lang/es.json +++ b/res/lang/es.json @@ -1672,6 +1672,7 @@ "validate_not_mine": "No es propiedad de esta cartera", "validate_ownership": "Propiedad:", "validate_results": "Resultados:", + "validate_results_placeholder": "Los resultados aparecerán aquí", "validate_shielded_type": "Protegida (dirección z)", "validate_status": "Estado:", "validate_title": "Validar Dirección", @@ -1830,4 +1831,4 @@ "your_addresses": "Sus Direcciones", "z_address": "Dirección Z", "z_addresses": "Direcciones Z" -} +} \ No newline at end of file diff --git a/res/lang/fr.json b/res/lang/fr.json index 2dbf5b3..e25216a 100644 --- a/res/lang/fr.json +++ b/res/lang/fr.json @@ -1672,6 +1672,7 @@ "validate_not_mine": "N'appartient pas à ce portefeuille", "validate_ownership": "Propriété :", "validate_results": "Résultats :", + "validate_results_placeholder": "Les résultats apparaîtront ici", "validate_shielded_type": "Blindée (z-adresse)", "validate_status": "Statut :", "validate_title": "Valider l'adresse", @@ -1830,4 +1831,4 @@ "your_addresses": "Vos adresses", "z_address": "Adresse Z", "z_addresses": "Adresses Z" -} +} \ No newline at end of file diff --git a/res/lang/ja.json b/res/lang/ja.json index d5c42c3..7588451 100644 --- a/res/lang/ja.json +++ b/res/lang/ja.json @@ -1669,6 +1669,7 @@ "validate_not_mine": "このウォレットに属していません", "validate_ownership": "所有者：", "validate_results": "結果：", + "validate_results_placeholder": "ここに結果が表示されます", "validate_shielded_type": "シールド（zアドレス）", "validate_status": "ステータス：", "validate_title": "アドレスを検証", @@ -1827,4 +1828,4 @@ "your_addresses": "あなたのアドレス", "z_address": "Zアドレス", "z_addresses": "Zアドレス" -} +} \ No newline at end of file diff --git a/res/lang/ko.json b/res/lang/ko.json index a015d8d..d95957e 100644 --- a/res/lang/ko.json +++ b/res/lang/ko.json @@ -1671,6 +1671,7 @@ "validate_not_mine": "이 지갑에 속하지 않음", "validate_ownership": "소유자:", "validate_results": "결과:", + "validate_results_placeholder": "결과가 여기에 표시됩니다", "validate_shielded_type": "차폐 (z 주소)", "validate_status": "상태:", "validate_title": "주소 검증", @@ -1829,4 +1830,4 @@ "your_addresses": "내 주소", "z_address": "Z 주소", "z_addresses": "Z 주소" -} +} \ No newline at end of file diff --git a/res/lang/pt.json b/res/lang/pt.json index 97a95e5..8b97cdf 100644 --- a/res/lang/pt.json +++ b/res/lang/pt.json @@ -1672,6 +1672,7 @@ "validate_not_mine": "Não pertence a esta carteira", "validate_ownership": "Propriedade:", "validate_results": "Resultados:", + "validate_results_placeholder": "Os resultados aparecerão aqui", "validate_shielded_type": "Blindado (z-endereço)", "validate_status": "Status:", "validate_title": "Validar Endereço", @@ -1830,4 +1831,4 @@ "your_addresses": "Seus Endereços", "z_address": "Endereço Z", "z_addresses": "Endereços Z" -} +} \ No newline at end of file diff --git a/res/lang/ru.json b/res/lang/ru.json index deef9a3..b4defbe 100644 --- a/res/lang/ru.json +++ b/res/lang/ru.json @@ -1672,6 +1672,7 @@ "validate_not_mine": "Не принадлежит этому кошельку", "validate_ownership": "Принадлежность:", "validate_results": "Результаты:", + "validate_results_placeholder": "Результаты появятся здесь", "validate_shielded_type": "Экранированный (z-адрес)", "validate_status": "Статус:", "validate_title": "Проверить адрес", @@ -1830,4 +1831,4 @@ "your_addresses": "Ваши адреса", "z_address": "Z-адрес", "z_addresses": "Z-адреса" -} +} \ No newline at end of file diff --git a/res/lang/zh.json b/res/lang/zh.json index 461352f..615a6c5 100644 --- a/res/lang/zh.json +++ b/res/lang/zh.json @@ -1670,6 +1670,7 @@ "validate_not_mine": "不属于此钱包", "validate_ownership": "所有权：", "validate_results": "结果：", + "validate_results_placeholder": "结果将显示在此处", "validate_shielded_type": "屏蔽（z 地址）", "validate_status": "状态：", "validate_title": "验证地址", @@ -1828,4 +1829,4 @@ "your_addresses": "您的地址", "z_address": "Z 地址", "z_addresses": "Z 地址" -} +} \ No newline at end of file diff --git a/src/app.cpp b/src/app.cpp index 7a73ec2..9de781f 100644 --- a/src/app.cpp +++ b/src/app.cpp @@ -4174,7 +4174,12 @@ void App::renderSeedMigrationDialog() case SeedMigrationStep::ShowSeed: { ui::material::DialogWarningHeader(TR("mig_seed_warning")); ImGui::Spacing(); - ui::RenderSeedWordGrid(ui::SplitSeedWords(seed_migration_seed_)); + // Box the 24-word grid in a glass panel so the wallet's most critical secret reads as a + // distinct artifact, not body copy. Purely visual — the words/derivation/logic are untouched. + { + ui::material::GlassSectionScope seedPanel; + ui::RenderSeedWordGrid(ui::SplitSeedWords(seed_migration_seed_)); + } ImGui::Spacing(); ImGui::TextColored(kMedium, "%s", TR("mig_receive_addr")); ImGui::TextWrapped("%s", seed_migration_dest_.c_str()); diff --git a/src/app_security.cpp b/src/app_security.cpp index 36be4c7..07731ea 100644 --- a/src/app_security.cpp +++ b/src/app_security.cpp @@ -1450,6 +1450,11 @@ void App::renderEncryptWalletDialog() { ov.cardWidth = 460.0f; ov.idSuffix = "changepass"; if (BeginOverlayDialog(ov)) { + // Same fund-loss consequence as Encrypt/Remove Encryption if the new + // passphrase is lost — reuse their warning string/header for consistency. + DialogWarningHeader(TR("wiz_encrypt_warning")); + ImGui::Spacing(); + ImGui::TextUnformatted(TR("change_pass_current")); ImGui::PushItemWidth(-1); ImGui::InputText("##chg_old", change_old_pass_buf_, sizeof(change_old_pass_buf_), diff --git a/src/app_wizard.cpp b/src/app_wizard.cpp index 398964b..2b30807 100644 --- a/src/app_wizard.cpp +++ b/src/app_wizard.cpp @@ -294,29 +294,43 @@ void App::renderFirstRunWizard() { { int state = cardState(0); bool isFocused = (state == 1); + bool isCollapsed = (state == 2); // Completed: minimize to a compact pill (mirrors Card 1) float cx = leftX + cardPad; float cy = card0Top + cardPad; float contentW = colW - 2 * cardPad; - // Step indicator - { + // Step indicator + title (inline when collapsed) + if (isCollapsed) { + // Compact single-line: check icon + "Step 1" + "Appearance" float iconW = iconFont->CalcTextSizeA(iconFont->LegacySize, FLT_MAX, 0, stepIcon(state)).x; dl->AddText(iconFont, iconFont->LegacySize, ImVec2(cx, cy), dimCol, stepIcon(state)); - dl->AddText(captionFont, captionFont->LegacySize, ImVec2(cx + iconW + 4.0f * dp, cy), dimCol, TR("wiz_step1")); - cy += captionFont->LegacySize + 6.0f * dp; - } + float labelX = cx + iconW + 4.0f * dp; + dl->AddText(captionFont, captionFont->LegacySize, ImVec2(labelX, cy), dimCol, TR("wiz_step1")); + float step1W = captionFont->CalcTextSizeA(captionFont->LegacySize, FLT_MAX, 0, TR("wiz_step1")).x; + float titleX = labelX + step1W + 12.0f * dp; + dl->AddText(bodyFont, bodyFont->LegacySize, ImVec2(titleX, cy), dimCol, TR("wiz_appearance")); + cy += captionFont->LegacySize + 4.0f * dp; + } else { + // Step indicator + { + float iconW = iconFont->CalcTextSizeA(iconFont->LegacySize, FLT_MAX, 0, stepIcon(state)).x; + dl->AddText(iconFont, iconFont->LegacySize, ImVec2(cx, cy), dimCol, stepIcon(state)); + dl->AddText(captionFont, captionFont->LegacySize, ImVec2(cx + iconW + 4.0f * dp, cy), dimCol, TR("wiz_step1")); + cy += captionFont->LegacySize + 6.0f * dp; + } - // Title - { - const char* t = TR("wiz_appearance"); - dl->AddText(titleFont, titleFont->LegacySize, ImVec2(cx, cy), textCol, t); - cy += titleFont->LegacySize + 10.0f * dp; - } + // Title + { + const char* t = TR("wiz_appearance"); + dl->AddText(titleFont, titleFont->LegacySize, ImVec2(cx, cy), textCol, t); + cy += titleFont->LegacySize + 10.0f * dp; + } - // Separator - dl->AddLine(ImVec2(cx, cy), ImVec2(cx + contentW, cy), - (textCol & 0x00FFFFFF) | IM_COL32(0,0,0,40), 1.0f * dp); - cy += 14.0f * dp; + // Separator + dl->AddLine(ImVec2(cx, cy), ImVec2(cx + contentW, cy), + (textCol & 0x00FFFFFF) | IM_COL32(0,0,0,40), 1.0f * dp); + cy += 14.0f * dp; + } float& wiz_blur_amount = wizardUi.blur_amount; bool& wiz_theme_effects = wizardUi.theme_effects; @@ -352,6 +366,9 @@ void App::renderFirstRunWizard() { wiz_appearance_init = true; } + // Controls: rendered for the focused and upcoming states so content is visible under + // the dim overlay; skipped entirely once completed so the card shrinks to a compact pill. + if (!isCollapsed) { // Render controls always so content is visible under the dim // overlay when not focused; disable interaction when not active. ImGui::BeginDisabled(!isFocused); @@ -668,13 +685,21 @@ void App::renderFirstRunWizard() { cy += btnH; } - cy += cardPad; - // Lock card height to the tallest content ever seen - float& card0MaxH = wizardUi.card0_max_h; - card0MaxH = std::max(card0MaxH, cy - card0Top); - card0Bot = card0Top + card0MaxH; + } // if (!isCollapsed) - // Card 0 finalization deferred until after cards 1+2 are sized + cy += cardPad; + // Lock card height to the tallest content ever seen (but not when collapsed) + float& card0MaxH = wizardUi.card0_max_h; + if (isCollapsed) { + // Completed: finalize immediately as a compact pill (do not stretch to the + // right column height, and skip the deferred stretch below). + card0Bot = card0Top + (cy - card0Top); + finalizeCard(leftX, colW, card0Top, card0Bot, state); + } else { + card0MaxH = std::max(card0MaxH, cy - card0Top); + card0Bot = card0Top + card0MaxH; + // Card 0 finalization deferred until after cards 1+2 are sized + } } @@ -1447,7 +1472,9 @@ void App::renderFirstRunWizard() { } // --- Deferred Card 0 finalization: match right column total height --- - { + // Only for the focused/upcoming Appearance card; a completed one was already finalized + // above as a compact pill and must not be re-stretched. + if (cardState(0) != 2) { float rightColBot = card2Bot; if (rightColBot > card0Bot) card0Bot = rightColBot; finalizeCard(leftX, colW, card0Top, card0Bot, cardState(0)); diff --git a/src/ui/material/draw_helpers.h b/src/ui/material/draw_helpers.h index 697729f..3d8dbf1 100644 --- a/src/ui/material/draw_helpers.h +++ b/src/ui/material/draw_helpers.h @@ -1640,7 +1640,10 @@ inline bool BeginOverlayDialog(const OverlayDialogSpec& spec) // the measuring frame (its geometry is a placeholder; the whole card is hidden until centered). if (!floating && !hideForMeasure) { GlassPanelSpec cardGlass; - cardGlass.rounding = 16.0f; cardGlass.fillAlpha = 35; cardGlass.borderAlpha = 50; cardGlass.borderWidth = 1.0f; + // Fill/border alpha govern every overlay dialog's card boundary — kept well above the default + // glass panel so the card reads as a distinct surface over busy backdrops (tx lists, mining + // tiles, chat) while staying translucent rather than opaque. + cardGlass.rounding = 16.0f; cardGlass.fillAlpha = 60; cardGlass.borderAlpha = 90; cardGlass.borderWidth = 1.0f; DrawGlassPanel(dl, cardMin, cardMax, cardGlass); } diff --git a/src/ui/windows/address_transfer_dialog.h b/src/ui/windows/address_transfer_dialog.h index c6baad1..ede349d 100644 --- a/src/ui/windows/address_transfer_dialog.h +++ b/src/ui/windows/address_transfer_dialog.h @@ -169,9 +169,9 @@ public: } if (amountValid && newFromBal < 1e-9) { ImGui::Spacing(); - ImGui::PushStyleColor(ImGuiCol_Text, ImGui::ColorConvertU32ToFloat4(Warning())); - ImGui::TextWrapped("%s", TR("sends_full_balance_warning")); - ImGui::PopStyleColor(); + // Full-balance send: same warning-icon treatment as the de-shielding header above, + // so this stakes-bearing line reads as distinct from the neutral preview text. + DialogWarningHeader(TR("sends_full_balance_warning")); } // Buttons diff --git a/src/ui/windows/contacts_tab.cpp b/src/ui/windows/contacts_tab.cpp index 79f2206..43d9770 100644 --- a/src/ui/windows/contacts_tab.cpp +++ b/src/ui/windows/contacts_tab.cpp @@ -207,6 +207,28 @@ static bool isShieldedAddr(const std::string& a) { return !a.empty() && a[0] == 'z'; } +// Width-aware middle-ellipsis truncation (mirrors the add/edit dialog's local fitMiddle lambda, but +// file-scope so the Cards/List rows can share it too): keeps head + tail, shrinking symmetrically +// until the rendered width fits maxW. minFront/minBack are the schema-configured floor — below that +// the fixed-length util::truncateMiddle result is used instead, so very cramped rows still read as +// "front...back" rather than collapsing to a near-empty stub. Addresses are ASCII, so byte-wise +// trimming is safe. +static std::string truncateAddressToWidth(const std::string& s, ImFont* f, float size, float maxW, + int minFront, int minBack) { + const std::string floor = util::truncateMiddle(s, minFront, minBack); + auto w = [&](const std::string& t){ return f->CalcTextSizeA(size, FLT_MAX, 0, t.c_str()).x; }; + if (w(s) <= maxW) return s; // fits in full — no truncation needed at all + if (maxW <= 0.0f) return floor; // no room to measure against — fall back to the floor + const std::string ell = "\xE2\x80\xA6"; + size_t head = s.size() / 2, tail = s.size() - head; + while (head + tail > static_cast(minFront + minBack)) { + std::string cand = s.substr(0, head) + ell + s.substr(s.size() - tail); + if (w(cand) <= maxW) return cand; + if (head >= tail) --head; else --tail; + } + return floor; // couldn't fit even at the configured floor — use the fixed-length result +} + // Accent colour for a contact's address type (Z = shielded/green, T = transparent/amber), tuned per // theme. File-scope so both the list rows and the edit-dialog preview share one source of truth. static ImU32 contactTypeColor(bool shielded, bool light) { @@ -1219,10 +1241,13 @@ void RenderContactsTab(App* app) dl->AddText(lblF, lblSz, ImVec2(tx, ty), material::OnSurface(), entry.label.c_str()); dl->PopClipRect(); // Un-collapse to the full address on hover (clipped to the text column so it never - // runs under the trailing actions); middle-truncated otherwise. + // runs under the trailing actions); otherwise middle-truncated to FIT the actual text + // column width (tx..textMaxX) rather than a fixed char count — wide rows show more of + // the address instead of leaving a dead gap before the action-icon cluster. std::string addr = rowHovered ? entry.address - : util::truncateMiddle(entry.address, addrFrontLbl.truncate, addrBackLbl.truncate); + : truncateAddressToWidth(entry.address, adrF, adrSz, textMaxX - tx, + addrFrontLbl.truncate, addrBackLbl.truncate); dl->PushClipRect(ImVec2(tx, mn.y), ImVec2(textMaxX, mx.y), true); dl->AddText(adrF, adrSz, ImVec2(tx, ty + lblSz + 3.0f * dp), material::OnSurfaceMedium(), addr.c_str()); diff --git a/src/ui/windows/explorer_tab.cpp b/src/ui/windows/explorer_tab.cpp index efe4c29..266fb1c 100644 --- a/src/ui/windows/explorer_tab.cpp +++ b/src/ui/windows/explorer_tab.cpp @@ -620,7 +620,16 @@ static void renderChainStats(App* app, float availWidth) { ImVec2(cardMin.x + pad, cardMin.y + pad * 0.5f), Primary(), TR("explorer_chain_stats")); drawStatusPill(cardMin, cardW); - float labelY = cardMin.y + pad * 0.5f + headerH + Layout::spacingLg(); + // Distribute the two stat blocks (Height, Best Block) evenly through the + // content region so the card matches the density of the sibling 2x2 metric + // grid instead of pinning Height to the top and Best Block to the bottom + // edge with a large empty gap between them. + float contentTop = cardMin.y + pad * 0.5f + headerH; + float contentBottom = cardMax.y - pad; + float blockGap = std::max(Layout::spacingMd(), + (contentBottom - contentTop - heroLineH - hashLineH) / 3.0f); + + float labelY = contentTop + blockGap; dl->AddText(capFont, capFont->LegacySize, ImVec2(cardMin.x + pad, labelY), OnSurfaceMedium(), TR("explorer_block_height")); @@ -640,7 +649,7 @@ static void renderChainStats(App* app, float availWidth) { ImVec2(cardMin.x + pad + barW * progress, barY + barH), WithAlpha(Warning(), 180), barH * 0.5f); } - float hashLabelY = cardMax.y - pad - hashLineH; + float hashLabelY = labelY + heroLineH + blockGap; dl->AddText(capFont, capFont->LegacySize, ImVec2(cardMin.x + pad, hashLabelY), OnSurfaceMedium(), TR("peers_best_block")); diff --git a/src/ui/windows/market_tab.cpp b/src/ui/windows/market_tab.cpp index d064ae0..2a5008b 100644 --- a/src/ui/windows/market_tab.cpp +++ b/src/ui/windows/market_tab.cpp @@ -2136,11 +2136,29 @@ static void mktDrawPortfolio(const MktCtx& cx) float rowGap = pfRowGapFor(style, mktDp); float rowsH = std::max(rowH, portfolioH - pfSummaryH); + // Anchor the bottom of the portfolio: the group list otherwise ends at its content height, + // leaving un-anchored dead space between the last row and the content-area bottom. Grow the + // rows region to fill the remaining vertical space (down to the scroll area's bottom, less a + // small margin) and wrap it in a contained glass panel — so it reads as one framed table with + // a real bottom edge (like Explorer's block-list card) instead of trailing off into nothing. + // The empty state then centres in this full-height panel rather than in a one-row band. ImGui::SetCursorScreenPos(ImVec2(cardMin.x, cardMin.y + pfSummaryH)); + float floorH = ImGui::GetContentRegionAvail().y - gap; // to the scroll bottom, keep a margin + float panelH = std::max(rowsH, floorH); + { + ImVec2 pMin(cardMin.x, cardMin.y + pfSummaryH); + ImVec2 pMax(rightEdge, pMin.y + panelH); + GlassPanelSpec pg; + pg.rounding = Layout::glassRounding(); + pg.fillAlpha = 12; pg.borderAlpha = 24; // faint container: frames without competing with the per-row cards + DrawGlassPanel(dl, pMin, pMax, pg); + } // Flush-left child (no window padding) so rows align with the summary; a scrollbar appears - // only when the visible groups overflow the bounded height. + // only when the visible groups overflow the bounded height. NoBackground so the contained + // glass panel drawn above is the sole surface — otherwise the opaque ChildBg (non-acrylic + // mode) would paint over the panel fill + border. ImGui::PushStyleVar(ImGuiStyleVar_WindowPadding, ImVec2(0, 0)); - ImGui::BeginChild("##pfRows", ImVec2(availWidth, rowsH), false); + ImGui::BeginChild("##pfRows", ImVec2(availWidth, panelH), false, ImGuiWindowFlags_NoBackground); ImGui::PopStyleVar(); // Zero item-spacing INSIDE the child: each row emits an InvisibleButton + a gap Dummy, and // ImGui's default ItemSpacing.y between those items would inflate the content past rowsH and diff --git a/src/ui/windows/receive_tab.cpp b/src/ui/windows/receive_tab.cpp index 21dc2a7..3f209a1 100644 --- a/src/ui/windows/receive_tab.cpp +++ b/src/ui/windows/receive_tab.cpp @@ -362,9 +362,14 @@ static void RenderRecentReceived(const AddressInfo& /* addr */, if (tx.type != "receive" && tx.type != "mined") continue; recvs.push_back(&tx); } - if (recvs.size() > 4) recvs.resize(4); // show only the 4 most recent (newest-first) + // Grow the list to fill the dead space beneath the (fixed-height) receive card: + // fit as many newest-first rows as the remaining region can show, instead of a + // fixed 4. The child scrolls if the real history exceeds what fits, so nothing is + // lost. A floor of 4 keeps the section substantial when the region is short. float listH = std::max(rowH, ImGui::GetContentRegionAvail().y); + size_t maxRows = std::max(4, (size_t)std::floor(listH / rowH)); + if (recvs.size() > maxRows) recvs.resize(maxRows); // newest-first ImGui::BeginChild("##RecentReceivedRows", ImVec2(width, listH), false, ImGuiWindowFlags_NoBackground); @@ -372,8 +377,9 @@ static void RenderRecentReceived(const AddressInfo& /* addr */, char buf[64]; if (recvs.empty()) { - ImGui::SetCursorPosY(Layout::spacingMd()); - Type().textColored(TypeStyle::Caption, OnSurfaceDisabled(), TR("no_recent_receives")); + // Fill the empty canvas with a centered material empty-state (icon + title) + // rather than a lone left-aligned caption stranded at the top of dead space. + material::DrawEmptyState(ICON_MD_CALL_RECEIVED, TR("no_recent_receives")); ImGui::EndChild(); return; } diff --git a/src/ui/windows/send_tab.cpp b/src/ui/windows/send_tab.cpp index 834d48a..3d30188 100644 --- a/src/ui/windows/send_tab.cpp +++ b/src/ui/windows/send_tab.cpp @@ -1123,9 +1123,14 @@ static void RenderRecentSends(const WalletState& state, float width, ImFont* cap if (tx.type != "send" && tx.type != "shield") continue; sends.push_back(&tx); } - if (sends.size() > 4) sends.resize(4); // show only the 4 most recent (newest-first) + // Grow the list to fill the dead space beneath the (fixed-height) compose card: + // fit as many newest-first rows as the remaining region can show, instead of a + // fixed 4. The child scrolls if the real history exceeds what fits, so nothing is + // lost. A floor of 4 keeps the section substantial when the region is short. float listH = std::max(rowH, ImGui::GetContentRegionAvail().y); + size_t maxRows = std::max(4, (size_t)std::floor(listH / rowH)); + if (sends.size() > maxRows) sends.resize(maxRows); // newest-first ImGui::BeginChild("##RecentSendRows", ImVec2(width, listH), false, ImGuiWindowFlags_NoBackground); @@ -1133,8 +1138,9 @@ static void RenderRecentSends(const WalletState& state, float width, ImFont* cap char buf[64]; if (sends.empty()) { - ImGui::SetCursorPosY(Layout::spacingMd()); - Type().textColored(TypeStyle::Caption, OnSurfaceDisabled(), TR("send_no_recent")); + // Fill the empty canvas with a centered material empty-state (icon + title) + // rather than a lone left-aligned caption stranded at the top of dead space. + material::DrawEmptyState(ICON_MD_CALL_MADE, TR("send_no_recent")); ImGui::EndChild(); return; } diff --git a/src/ui/windows/shield_dialog.cpp b/src/ui/windows/shield_dialog.cpp index e3477f8..ae9b979 100644 --- a/src/ui/windows/shield_dialog.cpp +++ b/src/ui/windows/shield_dialog.cpp @@ -146,7 +146,10 @@ void ShieldDialog::render(App* app) ImGui::Spacing(); - // Fee + // Fee + UTXO limit share one row (two columns) to tighten vertical rhythm. + float pairColX = ImGui::GetContentRegionAvail().x * 0.5f; + + // Fee (left column) ImGui::Text("%s", TR("fee_label")); ImGui::SetNextItemWidth(feeInput.width * Layout::dpiScale()); ImGui::InputDouble("##Fee", &s_fee, 0.0001, 0.001, "%.8f"); @@ -154,17 +157,19 @@ void ShieldDialog::render(App* app) if (s_fee > 1.0) s_fee = 1.0; // guard a fat-fingered huge fee (mirrors utxo clamp) ImGui::SameLine(); ImGui::TextDisabled("DRGX"); - - ImGui::Spacing(); - // UTXO limit + // UTXO limit (right column) — hint drops under the input (rather than beside it) since + // "Max UTXOs per operation" is too long to share the narrower half-width column with "DRGX". + ImGui::SameLine(pairColX); + ImGui::BeginGroup(); ImGui::Text("%s", TR("shield_utxo_limit")); ImGui::SetNextItemWidth(utxoInput.width * Layout::dpiScale()); ImGui::InputInt("##Limit", &s_utxo_limit); - ImGui::SameLine(); - ImGui::TextDisabled("%s", TR("shield_max_utxos")); if (s_utxo_limit < 1) s_utxo_limit = 1; if (s_utxo_limit > 100) s_utxo_limit = 100; + material::Type().textColored(material::TypeStyle::Caption, material::OnSurfaceMedium(), + TR("shield_max_utxos")); + ImGui::EndGroup(); ImGui::Spacing(); diff --git a/src/ui/windows/validate_address_dialog.cpp b/src/ui/windows/validate_address_dialog.cpp index 7f7ad4a..c0228a2 100644 --- a/src/ui/windows/validate_address_dialog.cpp +++ b/src/ui/windows/validate_address_dialog.cpp @@ -208,6 +208,14 @@ void ValidateAddressDialog::render(App* app) } } else if (!app->isConnected()) { ImGui::TextColored(ImVec4(1.0f, 0.6f, 0.0f, 1.0f), "%s", TR("not_connected")); + } else { + // Pre-interaction placeholder: keeps the results area from reading as a large + // dead gap between the Validate/Paste row and the Close button until a result exists. + ImGui::Spacing(); + float cw = ImGui::GetContentRegionAvail().x; + ImVec2 ts = ImGui::CalcTextSize(TR("validate_results_placeholder")); + ImGui::SetCursorPosX(ImGui::GetCursorPosX() + (cw - ts.x) * 0.5f); + ImGui::TextDisabled("%s", TR("validate_results_placeholder")); } // Close button at bottom — centered via the shared footer helper (no separator, matching diff --git a/src/ui/windows/wallets_dialog.h b/src/ui/windows/wallets_dialog.h index 7d0ffd4..a5a66b7 100644 --- a/src/ui/windows/wallets_dialog.h +++ b/src/ui/windows/wallets_dialog.h @@ -71,9 +71,12 @@ public: const int kMaxVisibleRows = 7; ImFont* nameFont = Type().subtitle1(); ImFont* metaFont = Type().caption(); - // The list is always sized to its MAX height (kMaxVisibleRows) for a consistent modal size — it - // does not shrink to fit a few wallets; fewer rows leave empty space, more than 7 scroll. - const int visRows = kMaxVisibleRows; + // Size the list to the ACTUAL wallet count so a few wallets sit tight against the controls below + // instead of stranding ~200px of empty rows before the create/scan prompts; cap at kMaxVisibleRows + // (more than that scrolls within the cap). An empty list keeps two rows of height so the centered + // empty-state hint (drawn inside the list child) still has room to show. + const int numWallets = (int)s_rows.size(); + const int visRows = numWallets <= 0 ? 2 : std::min(numWallets, kMaxVisibleRows); const float cardPadY = Layout::spacingMd(); // roomier cards (was spacingSm) const float walRowH = cardPadY * 2.0f + nameFont->LegacySize + Layout::spacingSm() + metaFont->LegacySize; const float cardGap = Layout::spacingMd(); // more breathing room between wallet cards @@ -421,9 +424,10 @@ public: ImGui::Dummy(ImVec2(rowW, walRowH)); if (i + 1 < s_rows.size()) ImGui::Dummy(ImVec2(rowW, cardGap)); } - // Empty-state nudge: the list sits at a fixed max height, so a handful of wallets leave blank - // space below. When there's real room to spare, fill it with a subtle centered hint (a folder - // glyph + one line) instead of dead space; it's purely decorative — the actions live below. + // Empty-state nudge: the list is now sized to the actual wallet count, so a populated list has + // no room to spare and this draws nothing (the cards butt up against the controls below). It + // fires only when the list is EMPTY (the reserved rows leave room): a subtle centered hint (a + // folder glyph + one line) instead of a blank box; purely decorative — the actions live below. { const float remainY = ImGui::GetContentRegionAvail().y; if (remainY > walRowH * 1.6f) { diff --git a/src/util/i18n.cpp b/src/util/i18n.cpp index 641cab8..779269e 100644 --- a/src/util/i18n.cpp +++ b/src/util/i18n.cpp @@ -2242,6 +2242,7 @@ void I18n::loadBuiltinEnglish() strings_["validate_not_mine"] = "Not owned by this wallet"; strings_["validate_ownership"] = "Ownership:"; strings_["validate_results"] = "Results:"; + strings_["validate_results_placeholder"] = "Results will appear here"; strings_["validate_shielded_type"] = "Shielded (z-address)"; strings_["validate_status"] = "Status:"; strings_["validate_title"] = "Validate Address"; From b37d3d97b63b42df8b90a0070ad7daf8af15bf79 Mon Sep 17 00:00:00 2001 From: DanS Date: Wed, 19 Aug 2026 16:10:02 -0500 Subject: [PATCH 60/89] fix(send/receive): unify card width, justify receive footer, fix recipient-row button height/clip/glyph MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Send and Receive are now consistent in layout, and the Send recipient row's buttons render correctly. Card envelope (Send ⇄ Receive consistency): - Add Layout::mainComposeCardBox(availW) — a single shared source for the compose card's width + centering (fill the available column up to content-max-width, then center). Both tabs derive their card from it, so they can't drift again. Previously Send capped at 760dp and Receive at 860dp, so the Send card rendered ~150px narrower on any window wider than ~860dp; now they fill available width identically. Receive: - Justify the footer buttons edge-to-edge (equal shares over the live count) instead of left-clustering with dead space, matching Send's full-width footer rhythm. - Build the address-dropdown preview to the combo's real pixel width so the trailing balance ("— 12.00000000 DRGX") no longer hard-clips at 150% (was char-count truncation). Send recipient row (input | Paste | contacts-icon): - Pin the contacts icon button to the frame height so the larger iconMed font doesn't auto-size it taller than Paste/the input. - Reserve the real ItemSpacing.x gaps (not the smaller spacingSm token) so the row no longer overshoots the card and clips the icon's right border. draw_helpers (root cause, app-wide): - TactileButton's icon path measured/drew the label INCLUDING the "##id" suffix (which CalcTextSizeA/AddText don't strip the way ImGui's text render does), shoving the glyph off-center-left. Strip at "##" before measuring/drawing. Corrects any icon button that passes an explicit size and a "##id" label; no-op for labels without "##". Verified via headless sweeps at 1.0x and 1.5x, plus a real 3800px-wide render (both cards byte-identical at L=1174/R=2773). ctest 1/1. Co-Authored-By: Claude Opus 4.8 (1M context) --- src/ui/layout.h | 11 +++++++++ src/ui/material/draw_helpers.h | 11 ++++++--- src/ui/windows/receive_tab.cpp | 44 +++++++++++++++++++++++++--------- src/ui/windows/send_tab.cpp | 25 ++++++++++++------- 4 files changed, 68 insertions(+), 23 deletions(-) diff --git a/src/ui/layout.h b/src/ui/layout.h index 83bbf52..397e65e 100644 --- a/src/ui/layout.h +++ b/src/ui/layout.h @@ -179,6 +179,17 @@ inline float kSidePanelWidthRatio() { return schema::UI().drawElement("panels", // [layout] content-max-width; default is generous so data-dense screens stay comfortable. inline float kContentMaxWidth() { return schema::UI().drawElement("layout", "content-max-width").sizeOr(1600.0f) * dpiScale(); } +// Shared compose-card envelope for the Send + Receive tabs (and any tab wanting the same box): fill the +// available column up to the content-max-width cap, then center the leftover as margin. Both tabs MUST +// derive their card width/offset from this so the two envelopes stay byte-for-byte identical — they +// previously drifted (Send capped at 760dp, Receive at 860dp), so the Send card rendered narrower than +// Receive on any window wider than ~860dp. Returns {width, offsetX} in the same units as availW. +struct CardBox { float width; float offsetX; }; +inline CardBox mainComposeCardBox(float availW) { + float w = std::min(availW, kContentMaxWidth()); + return CardBox{ w, std::max(0.0f, (availW - w) * 0.5f) }; +} + inline float kTableMinHeight() { return schema::UI().drawElement("panels", "table").getFloat("min-height", 150.0f) * dpiScale(); } inline float kTableHeightRatio() { return schema::UI().drawElement("panels", "table").getFloat("height-ratio", 0.45f); } diff --git a/src/ui/material/draw_helpers.h b/src/ui/material/draw_helpers.h index 3d8dbf1..688fcfd 100644 --- a/src/ui/material/draw_helpers.h +++ b/src/ui/material/draw_helpers.h @@ -544,11 +544,16 @@ inline bool TactileButton(const char* label, const ImVec2& size = ImVec2(0, 0), ImVec2 bMin = ImGui::GetItemRectMin(); ImVec2 bMax = ImGui::GetItemRectMax(); - // For icon fonts, manually draw centered icon after getting button rect + // For icon fonts, manually draw centered icon after getting button rect. Measure/draw only the + // VISIBLE label (up to the "##id" separator): CalcTextSizeA/AddText don't strip "##" the way + // ImGui's own text render does, so an id suffix like "##pickContact" would inflate textSz and + // shove the glyph left off-center (and try to draw the notdef id chars). if (isIconFont && size.x > 0 && size.y > 0) { - ImVec2 textSz = useFont->CalcTextSizeA(useFont->LegacySize, FLT_MAX, 0, label); + const char* labelEnd = label; + while (*labelEnd && !(labelEnd[0] == '#' && labelEnd[1] == '#')) ++labelEnd; + ImVec2 textSz = useFont->CalcTextSizeA(useFont->LegacySize, FLT_MAX, 0, label, labelEnd); ImVec2 textPos(bMin.x + (size.x - textSz.x) * 0.5f, bMin.y + (size.y - textSz.y) * 0.5f); - dl->AddText(useFont, useFont->LegacySize, textPos, ImGui::GetColorU32(ImGuiCol_Text), label); + dl->AddText(useFont, useFont->LegacySize, textPos, ImGui::GetColorU32(ImGuiCol_Text), label, labelEnd); } float rounding = ImGui::GetStyle().FrameRounding; diff --git a/src/ui/windows/receive_tab.cpp b/src/ui/windows/receive_tab.cpp index 3f209a1..6464539 100644 --- a/src/ui/windows/receive_tab.cpp +++ b/src/ui/windows/receive_tab.cpp @@ -175,6 +175,11 @@ static void RenderAddressDropdown(App* app, float width) { } } + // Combo/button widths first — the preview truncates to the combo's real pixel width below. + float copyBtnW = std::max(schema::UI().drawElement("tabs.receive", "copy-btn-min-width").size, schema::UI().drawElement("tabs.receive", "copy-btn-width").size * Layout::hScale(width)); + float newBtnW = std::max(schema::UI().drawElement("tabs.receive", "new-btn-min-width").size, schema::UI().drawElement("tabs.receive", "new-btn-width").size * Layout::hScale(width)); + float dropdownW = width - copyBtnW - newBtnW - Layout::spacingSm() * 2; + // Build preview string if (!app->isConnected()) { s_source_preview = TR(app->isLiteBuild() ? "lite_no_wallet_short" : "not_connected"); @@ -183,18 +188,27 @@ static void RenderAddressDropdown(App* app, float width) { const auto& addr = state.addresses[s_selected_address_idx]; bool isZ = addr.type == "shielded"; const char* tag = isZ ? "[Z]" : "[T]"; - std::string trunc = util::truncateMiddle(addr.address, - static_cast(std::max(schema::UI().drawElement("tabs.receive", "addr-preview-trunc-min").size, width / schema::UI().drawElement("tabs.receive", "addr-preview-trunc-divisor").size))); - snprintf(buf, sizeof(buf), "%s %s \xe2\x80\x94 %.8f %s", - tag, trunc.c_str(), addr.balance, DRAGONX_TICKER); + // Reserve pixel room for the tag prefix and the trailing balance, then middle-truncate the + // address to whatever remains — measured with the combo's own Body2 font. Char-count + // truncation kept MORE chars as the column widened, so at 150% the scaled font overflowed + // and the combo hard-clipped "— 12.00000000 DRGX" to "— 1"; measuring in pixels keeps the + // balance visible at any scale. + ImFont* comboFont = Type().getFont(TypeStyle::Body2); + float comboFontSz = comboFont->LegacySize; + char prefix[16]; snprintf(prefix, sizeof(prefix), "%s ", tag); + char suffix[64]; snprintf(suffix, sizeof(suffix), " \xe2\x80\x94 %.8f %s", addr.balance, DRAGONX_TICKER); + float fixedW = comboFont->CalcTextSizeA(comboFontSz, FLT_MAX, 0.0f, prefix).x + + comboFont->CalcTextSizeA(comboFontSz, FLT_MAX, 0.0f, suffix).x; + // Combo interior = dropdownW minus its dropdown-arrow button (~frame height) and both frame paddings. + float addrBudget = dropdownW - ImGui::GetFrameHeight() - ImGui::GetStyle().FramePadding.x * 2.0f - fixedW; + if (addrBudget < 24.0f) addrBudget = 24.0f; // floor: truncate to a stub rather than overflow + std::string trunc = material::TruncateToWidth(addr.address, comboFont, comboFontSz, addrBudget); + snprintf(buf, sizeof(buf), "%s%s%s", prefix, trunc.c_str(), suffix); s_source_preview = buf; } else { s_source_preview = TR("select_receiving_address"); } - float copyBtnW = std::max(schema::UI().drawElement("tabs.receive", "copy-btn-min-width").size, schema::UI().drawElement("tabs.receive", "copy-btn-width").size * Layout::hScale(width)); - float newBtnW = std::max(schema::UI().drawElement("tabs.receive", "new-btn-min-width").size, schema::UI().drawElement("tabs.receive", "new-btn-width").size * Layout::hScale(width)); - float dropdownW = width - copyBtnW - newBtnW - Layout::spacingSm() * 2; ImGui::SetNextItemWidth(dropdownW); ImGui::PushFont(Type().getFont(TypeStyle::Body2)); if (ImGui::BeginCombo("##RecvAddr", s_source_preview.c_str())) { @@ -584,12 +598,14 @@ void RenderReceiveTab(App* app) // ================================================================ { // Cap + center the card so the address/amount column stops stretching while the - // QR plateaus. cardW never exceeds formW (only shrinks); leftover becomes margin. + // QR plateaus. Shared with the Send tab via mainComposeCardBox() so the two card + // envelopes are identical (they must never drift in width/position again). // The RECENT RECEIVED list below stays on the uncapped formW (handled separately). float cardDp = Layout::dpiScale(); - float cardW = std::min(formW, 860.0f * cardDp); + Layout::CardBox cardBox = Layout::mainComposeCardBox(formW); + float cardW = cardBox.width; float cardLeftX = ImGui::GetCursorScreenPos().x; - float cardOffsetX = std::max(0.0f, (formW - cardW) * 0.5f); + float cardOffsetX = cardBox.offsetX; if (cardOffsetX > 0.0f) ImGui::SetCursorPosX(ImGui::GetCursorPosX() + cardOffsetX); @@ -911,7 +927,13 @@ void RenderReceiveTab(App* app) { float btnGap = Layout::spacingMd(); float btnH = std::max(schema::UI().drawElement("tabs.receive", "action-btn-min-height").size, schema::UI().drawElement("tabs.receive", "action-btn-height").size * vScale); - float otherBtnW = std::max(S.drawElement("tabs.receive", "action-btn-min-width").size, innerW * S.drawElement("tabs.receive", "action-btn-width-ratio").size); + // Justify the footer edge-to-edge like Send's [Review Send][Cancel] row instead of packing + // fixed-width buttons from the left (which left a large dead gap on the right). Split innerW + // into equal shares over the live button count: 2 by default (Clear Request + Explorer), + // 4 when an amount is requested (+ Copy URI + Share). + int nBtns = (s_request_amount > 0 ? 2 : 0) + 2; + float otherBtnW = std::max(S.drawElement("tabs.receive", "action-btn-min-width").size, + (innerW - (nBtns - 1) * btnGap) / (float)nBtns); bool firstBtn = true; diff --git a/src/ui/windows/send_tab.cpp b/src/ui/windows/send_tab.cpp index 3d30188..b9609ec 100644 --- a/src/ui/windows/send_tab.cpp +++ b/src/ui/windows/send_tab.cpp @@ -1272,12 +1272,13 @@ void RenderSendTab(App* app) float contentStartY = ImGui::GetCursorPosY(); float formAvailW = ImGui::GetContentRegionAvail().x; - // The compose form reads best as a centered fixed-width column, not edge-to-edge. - // Cap the card to a readable form width and center it; the recent-sends list below - // deliberately keeps the full column width (formAvailW). - const float sendDp = Layout::dpiScale(); - float formCardW = std::min(formAvailW, 760.0f * sendDp); - float formOffsetX = std::max(0.0f, (formAvailW - formCardW) * 0.5f); + // Fill the available column up to the content-max-width cap, then center. Shared with the + // Receive tab via mainComposeCardBox() so the two card envelopes are identical in width and + // position (Send previously capped at 760dp vs Receive's 860dp, so Send rendered narrower). + // The recent-sends list below deliberately keeps the full column width (formAvailW). + Layout::CardBox formBox = Layout::mainComposeCardBox(formAvailW); + float formCardW = formBox.width; + float formOffsetX = formBox.offsetX; float formW = formAvailW; ImGui::BeginGroup(); @@ -1367,7 +1368,10 @@ void RenderSendTab(App* app) float pasteW = std::max(schema::UI().drawElement("tabs.send", "paste-btn-min-width").size, colW * schema::UI().drawElement("tabs.send", "paste-btn-width-ratio").size); float contactsW = ImGui::GetFrameHeight(); // compact square icon button for the contact picker - ImGui::PushItemWidth(colW - pasteW - contactsW - Layout::spacingSm() * 2.0f); + // Reserve the TWO real SameLine gaps (each = ItemSpacing.x) between input|Paste|icon. + // Reserving spacingSm (a smaller token) under-counted the gap, so the row overshot colW by + // ~2*(ItemSpacing.x - spacingSm) and the icon's right border clipped past the card edge. + ImGui::PushItemWidth(colW - pasteW - contactsW - ImGui::GetStyle().ItemSpacing.x * 2.0f); // Show clipboard preview as transparent overlay when paste button is hovered bool paste_hovered = false; @@ -1425,9 +1429,12 @@ void RenderSendTab(App* app) } } - // Contact picker — pick a saved contact's address as the recipient. + // Contact picker — pick a saved contact's address as the recipient. Pin the height to the + // frame height (== the input + Paste height) so the larger iconMed font doesn't auto-size + // this square button taller than its row-mates. (Passing a non-zero size also routes + // TactileButton through its precise InvisibleButton + centered-glyph path.) ImGui::SameLine(); - if (material::TactileButton(ICON_MD_CONTACTS "##pickContact", ImVec2(contactsW, 0), + if (material::TactileButton(ICON_MD_CONTACTS "##pickContact", ImVec2(contactsW, ImGui::GetFrameHeight()), material::Type().iconMed())) ImGui::OpenPopup("##ContactPickerPopup"); if (ImGui::IsItemHovered()) material::Tooltip("%s", TR("send_contacts_button")); From d0bd55b9c1d982074d2e1f8102a41ceb2aebdf7a Mon Sep 17 00:00:00 2001 From: DanS Date: Thu, 20 Aug 2026 16:59:03 -0500 Subject: [PATCH 61/89] =?UTF-8?q?feat(ui):=20settings=20polish=20=E2=80=94?= =?UTF-8?q?=20button=20retune,=20daemon=20card,=20RPC=202-row,=20chat=20pr?= =?UTF-8?q?eview?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Settings tabs brought closer to the approved mockup: - ActionButton/renderCardButton retune (settings-scoped): 7px radius, 9px padX, Primary → accent-outline chip, Secondary/card buttons more defined. - Daemon-binary card: compact status right-aligned on the DAEMON BINARY heading (Up to date / Version differs / Not installed), filled/rounded status box, neutral danger divider (was alarming red), roomier spacing. - RPC Connection: two-row column-aligned layout (Host | Port, then Username | Password) so the password no longer clips off the card edge. - Chat settings tab: live conversation preview below the Appearance / Messaging cards; "Focus input on open" checkbox reflowed onto the console color-toggle row. - Debug Options: "Current theme only" toggle restricts either screenshot sweep to the active theme instead of cycling every skin. - Tabs fill the full content width (content-max-width cap disabled) and the sidebar nav panel centers within the true visible area. - i18n: new keys for the above (untranslated keys fall back to English). Co-Authored-By: Claude Opus 4.8 (1M context) --- res/fonts/NotoSansCJK-Subset.ttf | Bin 671376 -> 675232 bytes res/lang/de.json | 41 +- res/lang/es.json | 41 +- res/lang/fr.json | 41 +- res/lang/ja.json | 37 +- res/lang/ko.json | 41 +- res/lang/pt.json | 41 +- res/lang/ru.json | 41 +- res/lang/zh.json | 37 +- src/app.cpp | 37 +- src/app.h | 4 + src/app_sweep.cpp | 4 + src/ui/layout.h | 13 +- src/ui/material/settings_controls.h | 14 +- src/ui/pages/settings_page.cpp | 1554 +++++++++++++-------------- src/ui/sidebar.h | 12 +- src/ui/windows/chat_tab.cpp | 55 +- src/ui/windows/chat_tab.h | 2 +- src/util/i18n.cpp | 57 +- 19 files changed, 1082 insertions(+), 990 deletions(-) diff --git a/res/fonts/NotoSansCJK-Subset.ttf b/res/fonts/NotoSansCJK-Subset.ttf index 2bb3213d7758faa87984afefe439eeadac89efdc..e2694514c82bc0f11ce283022ed0ec1ed8bed44a 100644 GIT binary patch delta 20765 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 ss&4V{KTy6YFz ztmXNs^&&~TJddc9zhBGN-d9tW3?c3BM?^(po3*U&*!5QT)0a?u_rqxW4Y>A3g+tD~RnXrV@5}TaFl5Bt z3-6|pnM@E+`A7e-Ze3h=R#S=E%!ben1G7SM9QW!i$=YriTf|9Lpwnx%(zeaeR|7(#dn% z0Vh|xZJ%6TG5d*wHz&NRSv4WQdxdRY?yjbU$ai+>~>hY%sx;d!Xf@WuT?6rH`e%rHiHF+#`$H zB&=vy&)k1z!*pPs&V`j+Xdr!SwrczXBg{_*qT z=f=;7_mB6AuN_}4zEXUJ_>%Djrahk4V4C+d_i2@ltEL%ru3WAdW!#)dQ<98DL$p}lsuDDCSRI-X!6X-6DCJY4lqxyH`#4+@yP`y z=brR-(wj*)CtaR&deR@0JSOqDFL57;;*#Tz##!QK#>K>qh#L|&C@ws%b6nfFHgSG& zb>eEr<(-&{|63E!Pn%?6}z8u{~q`Czx+exG~}Kgi{mdPnbC&enQ;|l_!)O|6%-V{AVW`cV*n{ zaS7wbj|(1GZtVWCA!DwL2^v#p^uzHVNBf)4j`}|G^2mcD{~Wn*Wc0{xBLhd4joBQt zA!c37?=dT4md4DEnH)1RCMG62CMsrdO!t_^F+MRKF|}gK#FUCDjDIEi@8~phbXxS4 z==0I1qW4AbjouWU7+oa#w`jYln^7rISE4RNor*dcbu8*=)ZwT@QTwCzMeT^%6tzBT zZPd!B6;TVL=0(kn8XPq+s#fIt$k&k%BX8q>bmWl8@W`H#bt7FOD@2wZ@ngj65!bE% zmq(l%aeBm@5&4E68@^z8r{V2}hYU9d4i6aKXn5V>Zo~89Klkt)!zI!1Y{MOf>%--+ z55wLO4SPH6<**mSo(+3C>B{zI}2 zK09dTpe2Lm4w^lv(ICG;H3k)lcpY&q;(WyMh+`4^BbG(f{7w(g_Q{_ z8CEbXTbLTg24)*DbAa=JLIdpkU+jIU_q5Q>p&LV2gf0tR9J(;HQE02}fWI=2gH=N7)^=Un@@)$QFAkm;JUw_~a6oXAV839`VE5o!!Op=ogDVAB2zF@myv@Tl7u$?# z)1&p@t^2m_)w+A@wyj-Tmv3FPb)nV;TIXz?y|vnEN2^7x7Pe~K%Da_Yt6D8TxBS@h zy}4yt%i}G#wj9#3UQ4%@wOUqhskQjj;$w?9Ev~j0)gpIu=b*Jg3xg~{GlSxT#s!TH ziVW%*)F8+!sB%!npj<%?L8fN+n%!u2vDx%yLz;y&YaI9@@KNB!z~sO)fky+E1TG4k zA2=&;df=qMiGi_!69NYX77r{ESTK+Wd4WD`029nt&PsRs9qF!~A>u zxAzbA5B6{4-`c;Wzn{NX)7MSYn%-}Et?A{a7n<&Fy0ht~rt6zdYC5s$_@<^NKbm}P z@}fy(lR-^%#&@j2-8J~kbfBNk4+2#}BGtg&%Pk)~tK3#n} z__X&4@bU4f;gj7*_fGfz;r+?`gZCZpTiz+&7rf7TpYYz`z1BO?d$spc?>XMHyvKQW z_U_>A>+R@W#k-<+G4G<@dA)Oa=kWUGmFAV|b;;|b*DA#6TDy6>)o`m&=WU%=bzaozT>DP#o3*dk zUQ>Hs?fBZ}+R?R#*6vliZ0&rt^;+L+?WvVmtA^`p*A=cyUBg}bxOQ>v=-Sq`p38HW z^DbLlHo7c#S?Ds_CCX*6OCIO9&X1kLoO?Uhadvbr?p(yVpmQ$g9L}24N2gm(yPeiK znVl*Qb_#b2baHcYc5-y8?o`^zBjcz^%|XNE zHS8an{%pZYPglzCL2V~8ep>Iz6LkX@aM)&Q@Q)u|ZO)lO||jHjr+Y7@M# zVW$?s!O>2np`T{~fs2aRB(`LVvmM1MoUC6$^vTXzQrvz?W-lDC2!VLdxrnH1FtxKC+6Nc2h6emfF zb3syEAjj2%lv*uFsU1v89n`t?C8h3OQrr)aQtvV;W{<+8c!ZPUi3VOZ!8cO8p@`2K zQX1gcuoo%57{qrHDSjN7!ADXW%_pVtSW=q!kkT|4ct(o(J~HU&wf z#JK>tdeQ8d-8BliS2~rXucy>!t<_sof?mSW~f08oqDk<|{ zld=$=TI5Q~;y6;4tR-cs`3Nb?9+R>hE?IGgl$94rS>1w^#NDKaoq0&BMRA!U09Qg%S$ojplO0=xDjfeVweHy_79>@V6l5!C854|Pj z2)ulB3@OK+lX3#*%qR1cata;9{gFf6$%A@0?Jb~b+@ZPf^Ql38}CG9dPuM$al15drZ zPRjd0Qa*en<>M>F|8qrBzCinL80-f$PJc3PyB(b6si4_kZRs!cr z%_3I%4zV&v%*4vBAy#fWvGS9MRhUMsqBFQktkPg&mC>O}8StK1)lS8WMAZvhKyeT4MF0iPhgq%wrKT&+Wv#ptO&< zFtG+pi1|7a^GhJsxIM9^?T7``CDsfUH=9Q+r~-f$&7To#S&&$(9>iLsKDafpw(vx| z5yV0T_>)-sIAR@IfosG%E+f`y9I?)U#JZFQ$;7&jA=WLNSa*1@M_Xd%o-2v86-8&w-ZdlMVIk=U3`#KxW=HV$E&00m>A@WeyJCe~~oE`(0vdkXLJ+h^>P%>rN9}KM(QWfWjtw0Btv;;}*E*4w zd|)TBZE)FkXuhKfv7I<3A!JFNxF7jI z>}Wc%k#;`H7u1mmqcyE=`6-=h5f_1YClZmtpzU#>B26ky2U` zyK$4)Ehu;EDY4tI`c7$LcOAerV)u|g_gfHq(4AN+Li7;lAJroE7y~{&PwWXSf4Y{~ zU+~y78220=eSus^`+-osJV)%+8e*>}6MF;Kz1>Uf-9BO;vV(8LK0@dx#P2hd_%eXl z*G0s>Eg<%NAh93Fmvlj#vJp4cAZ|C1xcv^|${phD5pjN-xcEd|T|ivBPF&|;HF1Zf z#Ix-souzKybmQ#0%#mUZe`~ zqHTy5Ye~F#C*mb4fakCtf#{xO+F^^OPZ944rF%i4 zKF-AZV!(c@h!21w14|GOt4ur`?IL;*AJmKZV7PwBLE=Nd5g%TLxOqe@@kqEe>K*YI zxN4+7@lnHZVjc0(4~UP2fN==HgzCg&!NmH+Q1+wZx|!AU@53czjdh)A4@B zSK_l^?d<%-=RirzV&e0m*n*qH7p)<_WDN18Fm5@FSg`}~UkTx>_7Govo_OMG;=g|+ zzLtou%SL>CBjOt%Y$M#c32in*na%fzZ-D}TG$X#XF!5~(#CPN-zVj&YT`2DkA-*So z_+A*YZz1vh$cFp>GpU*@50+R2-BjOjK>}8a%^d)|EC-G}A1Di(_q=lCd6O;L;Ur3;&0N3zlHnX-6Z}2 z0zMWX{t1KplTQ2#tow?b_%?v}_v6HWU}mI0Ct<1pzLK!d1NM?oB1y0VBzRkZ_redH zAfbi=w3Am!m>ph_$hLz-_SqzItS9l?M-n-|k;t8&M4rYZ@~$G0Un5aq0*ON9z&;X% zhma`ZO`>Qm62$^Z6mLSJL=O@rr;;emNtD5WW!{n~x0OWs>m(}HCs7&gD?cDnWh{xR z7^8Ym5;dlhS=78k!toIarz&7PxQA`L7g$5W#TQ&A;pztB0fg0Z0`mcstQ`$5kf<{f zoFU;>87wAIw-LZ#?&#+}4xnv4^so1YM16RrK8_v%V1^kluSs}@fs-V>1PB7_z;_bf z!C($}O2P-q_^cq&fWRp57m0>w+Ym1GZ4Ne*@GApgM5CqvE^q7%V!#y=P3nQAB$_H< z61Yvm-|T^xKS%@=0dQYnT>y)l6$NM%R1rYQAh@!54loy-1D{E>fcsla1n)_-tO;Og z%SR+y!9%SQ0Ak#_A3&Vj_<-{yg3E#7;5CW12%EX>E))=}5X3PAR<|n!Mu1cjp`8Fa zw{HR9z77l^ZXMs1y2kxaH4lvfVlRl4pxxpn;#4VPf7HH0{!9U{%AiyfDYgo ziGj$UflzYbO%h?Hz!Y$cL^!Mrj|109MAQMZ!QUhXLD4}g;o8BlYA`Gw{Fua$V1VOL z3@~&kI8I_1&JDXkVt8rL8EhsoB0E6a5&K9)+JUwJ9>H!%L~R7=B%+&vQzUSsA!49p z%p7o*#7Km6Ml|U@` zKw>-;8jnPrPz8(yP&C#X!1~ySByjU0CL+Hkz9bQc5XDUcP!wA*F=+?Jn_Q5@L=uv97nIy}ki_mGB=$hgo(ClM!aKM<6Z@dxpH+bw@!XHX z{zMW7%7RrS4mJW1b_g*#w3EbPxa{yz5=Z)zI2r=(kT}+p#BuaHj-)z)S#SatVF42- zN0K;I3``?&nt^bDJUD}XXYP?W+aBO}ZZvp<_$Lo0k&J0|emjW^$nXnGNn9)pFyJL5 z)aBoR8GI&j1;?vU@+zj&)vqM3LCE!z0PU{7CXoW+DYr=6XbCQoxH*u-tvp~qiQApQ zX%cq=!QUkAE+TR7H^l!QG{5%`iTfD%fgdsY%|LO-Wk$Bb+947G`9(X>H#0$ju1^T8509k3rNW82BmXUbn06M~=R~YCu zta=>@FqPhTfImpQg|N53lX#aO%p&m~mb@PT?vnW63AT~=yC#4K|As{$-2rmrBRu!1 z3_$%Su3B1k6)Nd~*it0KD+M6@Y*rNRl6;!7CE!NT&2Z zNu@Gi6!=K0DVkKfTwnvK_TJz&smd%;SqW0P0*;U>Mw6d z9VU=!&gM*Nw#TGqPb4+RI8uKr22jpf66_>3mpj-@YVJy;=BY<&-YcZ$J4R~$m!uZV zNopYmpitr6q!!suYB3C0+zEt%`QR<7CF+9(07{k&1W>5t7g9_0BC}cwT9%pzl1VKM zVWsiD^mkIrlm<;e4A=;sky^Gq2mnJt0{8=@l3Fe|fFb4D01G%xYWa#_E2$Nlk&3;) zS`kWB>+8b53Z3~wF7{AtJMWZNUi=G zz`5$Ms`^0y*VaIrnyz3ZctENnT<#bNAj|OrsZO;(4-gMdfFGnfn~UHDF?Bvlstc@h zfl!wZq`G>6QvhzR9sS12SXK;&Dw+3JZsdZs_ zU4*snSyJ5*M)&um)~f<00EEn3?;WZ2L%?EEJqYvxS4s8E2d05LqM3CALp7Nbesvi_<%t>uhlhmfD_peQAzyMMM%aPg)a+^VB5IoUb zLHwIvC$+^*Qd>SFwbcevTO%ZG%90wK4cs8LZ7iuFB}i=tE7~&vr8;;6SlRJ4shxI_ z+IbnNU1pHlH3&dnH-xhX`t-zry}FRv8y@VvjnqEpNbMI)YJcS00OZxc6&Nh64XNS7 zNsYkZgW!e1V8}gEhwdPC*gvF>5Tr(;O%z-j4Z$NFNgai7jowe{SXe&}@f;89Ce$M} z7D*gemDEWE@EjcRpE3|n#d`s`ecBUJIbC$4zK+V!D}4A5CD&?`J2?WIY4ay zkF32w>N*|Z{kri0hOG|(J4xM80rB6k6ooV36R8_>g34ecfNM9w(oNmKZ19}a&4}G* zxO2-OQvZOLww3{jq;7+tZBTGKjM(u9sXPB9HR%+oyS9+J8w%`!xAvm{J{bCEF_2E` zfs!B|@jqCDR6H_K4`IN=aP#3eq#l8gqpL_gwvN=}4@o@%!6zZ?6qG%En$$CxR%hXz zvj<5%hZvuOSCW0fH&V|dPcC?ndeMp0OLnAQM!d0bsaNxodd;2G>kCP}p#aFfISwao z^(6InT~hD(k$M-_-n~oeJy?9dJ*f{8NKO4r>Z87-K5j+olMbXl#o&JpBlQ`k;`96f z3cvV^)U;QmzFa}-EA)Hyfz;PyNPPoOz3oTpJ9zHhBU0ZVCiMft_OUdnpOB!R%vVVL zXBMfSp~M$x{Ur`uBlT-30GEF24{-i_C4hwckqf}`bOLKhqg)_{G*dRPhBUigq}g{O zO{qv4s|+@f#!<)9NE4e#Q-1?EYRyTLIB%BgNz=Q7kEA&qBrRJ<(z4^b8QGVTmZKp+ z$KTG7ma{!+x$qs1To9PM4){u1p82HZ4F}1j~`E=8kjqU^%X! zn#WnvJP{5rSn3Tgdha342cByHISqlY8%QV35A7O3nZ`MrlGdaEI7V7i4CKFf+?DYY zuZ%YVJ7Ax5WxTSfc+$B(6nm&uuY6SdB=gHyG7+8&rt=>TDCs6e`%~Mm z9nr37*JS}YQjU_Na06Xf6Y6ZBy{TusPaAq^Hs#FqtaQ z-1Ic`NyXkK8(ytvq2(YjnTlncO~yE>q@cwfjAM)eB``7`KSEk}&;txi--9z~YpL;6 z%WFDm@qMa|ff6aGIr~(rilTAy$5X9zRcjG_>}e7t&x0i=@y?K!iV;##o0d^)bP4=R z%b(xY1)q&%HbNIebj)8`^WrBlcBV!tkdQ(F=^rVS@?p^ED>EhIyg+0QhW zjAHULt!VC(=^wSzu-u;7!gV%J{=f+r+t?{&vJPU0Q?}vksXvq*U~QZR&HAJB0FpRw zs2%iN%UjX#tpbmyz~d=21S%UfEURX4X00XuxmLVj=19gEuns4Uk|FK*bFHd}tumGD zjCdO-vfS}8qeChQYg7;?8VxUw!DwTx3K~KjUuf0gNkf5bkZmMQm{nicV;S*6^FrA6 zywDcHD@LBROVj#f#46b;_b9p?rCsQ@8$8RDYp7|As-3jFNz)1gRw)=4V5OX16xB&EYN9K_J42E41G7TFVQw zj2u7xS}Pi2i~X;&WCMJc)gCc0WLmETh62{iu!R`@M2)Sdp^l+!az^yFK)mN0tphuW zJUDGx@kXnOt3?`|f=_QC&*qd3Sq}Nv@l)wlroL!zM~C5_Bf#isGu&n~?6GQe7p}ht z?t^z|VM4}uzO`Pfj7ScAt2NJ<=*D!i1OaPrz)&C8e{xOf`s8>bDI8J7;jT{Yfm zHQ_F!*z=us*)+l8_FgM*o**Z{FUA)c?a6`Ms13?0R&wJSoKst>Ez_23ziS(`P1+W1 ztF~R+sqNDCX#3w2+y{UQe%2k-Dc@_n~OLiQWX?A62xah}$xFYkB$}JkTI_Ld_OyjiL0v*6cCjpP5{?ZieX0nqms3nj0Q4 zlrlWn$-*zP^nxWFK78?fr zY`4gm|Fa}k-3&kcYea4CGiFF;jDL2uIkc#C+WibiW;yv#{#T=0^~ zY{K#(vrc4QuYO)IjA3jGO=joJHi^~%{JdIvTdhsCUDwdd2#4+ZnU%WMA&t~FW`*^N ziw6$SDf1dI3$glWXsSEFBiMzagH09V3U4Hg;pU&p8TJ`%Y*W{0^HW`87~{OrBgHz3 zVY$^K2y7aHnx+>|H>c?(P{E(cElfn^=h;iTdNxMr|zgb(|+AmccnvmZEUa(V}s>Q$Mpt! zLprPb>3)=qU6wzc#~!g6UD8|Xt?07eLGMUc_1=1Kx{iQg2bz8nN0Z*3>@2hFWKuUf z=^(SoymG2sCKKg4xnAy&`{bYUfIKLV$fNSOJRvV(XLv*2myhKW`M3Nmf9Q5P)3fVE z^wN4+y}Djgcfp>|NB7lR=&kioy;H_ee_4mhXW3vcy~^85RW6mQYeE~NS<-|vZzrN4g*Qm`n&yoH{E0I-aNBGJaWJk&<8I4g) zcxQ)u8HO3E|I#WKaXB30|7^!`7A-Ats?6JLt+vLvbCFYVr?C_F8{2Weu?u$`dvN!$ z755-pa5wTh=32a*E@#M@n0u4(KT9TH=FO3~5s~w7BeDRuA&cZAmG-IYnEgtWkTO{6@v}?cAxu!d1y)%+j$yA~O zs*Oi&c+7@N*e|hxH;qh=l@rO%KHRh;X|yiWP3AAkccw6vWoN&!ysQu_%1W{_tOBdX z9GNq7WA&IP^JWd0FKfb@vF5B53ud9L1M9?kuzqYX8^%Vm(QE>n$!4>;Y(87Wma^q+ zC0osYXKUF8wux4Yc{m@; zhw>5J!WZzxd?!pM4)X@^NM)iKpGd6;}m0j3s7N)GwfWd5rB zV2o)j2g}LwvBInvE5*vPimW(7R; z;cOHe!(!PiHiuc*0=AefV=LGymdMtyb!;Qs%>H28*bbJ&_OOfW3cJQ`vODY{`-{Cb zep6t^_wnpG<0{Y2^Y8+^Brn6u@d~^Wufl8a+Pp5W#~X4#-k3M#0lXP+&Rg==GN@u0J(p%}LgvkJ9m=Y-i6|)knOjf2U)0J7u z9A%-hTv?_3uB=lw${blvWD_)tG38||+mx5Bf1UEO zjWOkAaORZP78sLWTPWL_f6jc{#FrueY2s^({@cWt?Q9cYhRXJt6JK`7ocOXMUo1QE zO|r|c6JK`amt{A8Q+Ai;9b=v>?q~D)8>63os#eU&`G2I*e*9kv{ zjl+bW`oEa+Db`7Um)$r2ocaG>CcgRS%>Tcc_>Q91|8DYQ;v3Wc-zL3XA(J$A=q5i) zY(ZJp3+E15_Efoq$CsR{P`$E#k{7p$`oH<~IRAaSR9p=t_Weeud zTCz4Qgmq=zSufUy4Pb-VP&R@^Gcy~@#_J}=U z&)5t0ioIihvrp_hH*t+S@EklB&&!MOs=Ow5vaWPpc@I9&%m?w|Jc`ffi}-TBN_Iv@ zALQrxC4QCP;J5ibp32ks8~&bueCtRN0(T|ZMJ|zF6c)urX;Ds86jg<@a21_I zZ!u5|6(ht*VHRV>cqHw5{3dRmU6^sR!V6`sQ6`hbckHv9l9m_7buc4Obu38LnJcS} zg~*Q?8EIR9y0C6oetKg8im)z0QPxGs$V%gS>u2XVvF;SMt~QR=mBv_62AHv!WG*Gku#{}TQgVnV|Hmcd-xJCB zUEI(0!%4Vc)#!!w!dNY0#3(UFjKhkt&bCq*pFbjLGCqAIJJWHxk5n;@vg|J^OCnS5 z7nQw`H;szP=D(yyaqC{G8mp=IL4tT%Q^ZJ+b{PrMHzPqJS&TJ7W*{vtvFpDi#B25* z$?yZoAb&}QYDflWTmg-ZkC6^x8M&~)$OALq{cox8kiYyT6-*hakOQeuAS)Fr{gMj( zt%)!iiC|5G%p_2fex?E4x28cIldq|nsfVebDcm&JG{Q8-6l=09EH01#k{PzGN_AGl znjc=)4Edk(!^nz@)(uEzJ{Z~X-*Tbu&uqv_1*Ab&Y$*O;Ga)k%Y*{crBL}iB8W!J@ zxJb-N>R(cx&u#H>k*h54U1WGtKUbNiSi04fCzGnXOGTK*TRJzCr7cq$N(YPC6EDSm Sr9+b02cL!{>5b$Z_J05gtT4|2 diff --git a/res/lang/de.json b/res/lang/de.json index 8d643cc..672d636 100644 --- a/res/lang/de.json +++ b/res/lang/de.json @@ -74,6 +74,9 @@ "av_title": "Windows Defender hat den Miner blockiert", "available": "Verfügbar", "backup_backing_up": "Sicherung läuft...", + "backup_col_backup": "SICHERUNG", + "backup_col_export": "EXPORTIEREN", + "backup_col_import": "IMPORTIEREN & WIEDERHERSTELLEN", "backup_create": "Sicherung erstellen", "backup_created": "Wallet-Sicherung erstellt", "backup_data": "SICHERUNG & DATEN", @@ -423,6 +426,7 @@ "daemon_bundled": "Gebündelt", "daemon_install_bundled": "Gebündelten installieren", "daemon_installed": "Installiert", + "daemon_maintenance_label": "WARTUNG", "daemon_none_bundled": "keiner in diesem Build", "daemon_not_installed": "nicht installiert", "daemon_status_differ": "Installierte Binärdatei unterscheidet sich von der gebündelten Version.", @@ -458,6 +462,7 @@ "daemon_update_verify_note": "Der Download wird vor der Installation anhand der veröffentlichten SHA-256-Prüfsumme des Releases und einer fest hinterlegten ed25519-Signatur verifiziert.", "daemon_update_verifying": "Wird verifiziert…", "daemon_update_version": "Version:", + "daemon_updates_label": "AKTUALISIERUNGEN", "daemon_version": "Daemon", "dark": "Dunkel", "data_stale_prefix": "Aktualisiert", @@ -1228,6 +1233,7 @@ "sb_waiting_daemon_err": "Warten auf dragonxd — %s", "sb_warming_up": "Aufwärmen...", "sb_witness_cache": "Zeugen werden neu aufgebaut", + "scale_effects": "SKALIERUNG & EFFEKTE", "screenshot_open_dir": "Speicherort öffnen", "screenshot_sweep": "Screenshot-Durchlauf ausführen", "screenshot_sweep_desc": "Durchläuft jedes Design über jeden Tab und speichert von jedem einen Screenshot in tab-spezifischen Unterordnern im Screenshots-Ordner des Konfigurationsverzeichnisses (überschreibt den vorherigen Durchlauf). Läuft einige Sekunden.", @@ -1316,12 +1322,12 @@ "settings": "Einstellungen", "settings_about_text": "Eine geschirmte Kryptowährungs-Wallet für DragonX (DRGX), erstellt mit Dear ImGui für ein leichtes, portables Erlebnis.", "settings_acrylic_level": "Acrylstufe:", - "settings_address_book": "Adressbuch...", + "settings_address_book": "Adressbuch…", "settings_auto_detected": "Automatisch erkannt aus DRAGONX.conf", "settings_auto_lock": "AUTO-SPERRE", "settings_auto_shield_desc": "Transparente Guthaben automatisch an geschirmte Adressen verschieben", "settings_auto_shield_funds": "Transparente Guthaben automatisch abschirmen", - "settings_backup": "Sicherung...", + "settings_backup": "Sicherung…", "settings_block_explorer_urls": "Block-Explorer-URLs", "settings_builtin": "Integriert", "settings_change_passphrase": "Passphrase ändern", @@ -1335,7 +1341,7 @@ "settings_copy_diagnostics": "Diagnose kopieren", "settings_copyright": "Copyright 2024-2026 DragonX-Entwickler | GPLv3-Lizenz", "settings_custom": "Benutzerdefiniert", - "settings_data_dir": "Datenverzeichnis:", + "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).", @@ -1343,18 +1349,18 @@ "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.", - "settings_export_all": "Alle exportieren...", - "settings_export_csv": "CSV exportieren...", - "settings_export_key": "Schlüssel exportieren...", + "settings_export_all": "Alle exportieren…", + "settings_export_csv": "CSV exportieren…", + "settings_export_key": "Schlüssel exportieren…", "settings_gradient_bg": "Hintergrund-Verlauf", "settings_gradient_desc": "Strukturierte Hintergründe durch sanfte Verläufe ersetzen", "settings_idle_after": "nach", - "settings_import_key": "Privaten Schlüssel importieren...", - "settings_import_viewkey": "Anzeigeschlüssel importieren...", + "settings_import_key": "Privaten Schlüssel importieren…", + "settings_import_viewkey": "Anzeigeschlüssel importieren…", "settings_language_note": "Hinweis: Manche Texte erfordern einen Neustart zur Aktualisierung", "settings_lock_now": "Jetzt sperren", "settings_locked": "Gesperrt", - "settings_merge_to_address": "An Adresse zusammenführen...", + "settings_merge_to_address": "An Adresse zusammenführen…", "settings_noise_opacity": "Rauschdichte:", "settings_not_connected": "Nicht mit dem Daemon verbunden", "settings_not_encrypted": "Nicht verschlüsselt", @@ -1370,7 +1376,7 @@ "settings_reloaded": "Einstellungen von der Festplatte neu geladen", "settings_remove_encryption": "Verschlüsselung entfernen", "settings_remove_pin": "PIN entfernen", - "settings_request_payment": "Zahlung anfordern...", + "settings_request_payment": "Zahlung anfordern…", "settings_rescan_desc": "Blockchain nach fehlenden Transaktionen neu scannen", "settings_restart_daemon": "Daemon neu starten", "settings_rpc_connection": "RPC-Verbindung", @@ -1381,20 +1387,20 @@ "settings_save_shielded_local": "Geschirmten Transaktionsverlauf lokal speichern", "settings_saved": "Einstellungen gespeichert", "settings_set_pin": "PIN festlegen", - "settings_shield_mining": "Mining abschirmen...", + "settings_shield_mining": "Mining abschirmen…", "settings_solid_colors_desc": "Feste Farben anstelle von Unschärfe-Effekten verwenden (Barrierefreiheit)", "settings_theme_refreshed": "Themenliste aktualisiert", "settings_tor_desc": "Alle Verbindungen für erhöhte Privatsphäre über Tor leiten", "settings_unlocked": "Entsperrt", "settings_use_tor_network": "Tor für Netzwerkverbindungen verwenden", - "settings_validate_address": "Adresse überprüfen...", + "settings_validate_address": "Adresse überprüfen…", "settings_visual_effects": "Visuelle Effekte", "settings_wallet_file_size": "Wallet-Dateigröße: %s", "settings_wallet_info": "Wallet-Informationen", "settings_wallet_location": "Wallet-Speicherort: %s", "settings_wallet_maintenance": "Wallet-Wartung", "settings_wallet_not_found": "Wallet-Datei nicht gefunden", - "settings_wallet_size_label": "Wallet-Größe:", + "settings_wallet_size_label": "Wallet-Größe", "settings_ztx_cleared": "Z-Transaktionsverlauf gelöscht", "settings_ztx_not_found": "Keine Verlaufsdatei gefunden", "setup_wizard": "Einrichtungsassistent", @@ -1494,6 +1500,7 @@ "to_upper": "AN", "tools": "WERKZEUGE", "tools_actions": "Werkzeuge & Aktionen...", + "tools_actions_hdr": "WERKZEUGE & AKTIONEN", "total": "Gesamt", "total_balance_label": "Gesamtguthaben", "transaction_id": "TRANSAKTIONS-ID", @@ -1517,7 +1524,7 @@ "tt_auto_shield": "Transparentes Guthaben automatisch an geschirmte Adressen für Datenschutz verschieben", "tt_backup": "Eine Sicherungskopie Ihrer wallet.dat erstellen", "tt_block_explorer": "Den DragonX Block-Explorer im Browser öffnen", - "tt_blur": "Unschärfe-Stärke (0%% = aus, 100%% = maximum)", + "tt_blur": "Unschärfe-Stärke (0% = aus, 100% = maximum)", "tt_change_pass": "Die Wallet-Verschlüsselungspassphrase ändern", "tt_change_pin": "Ihre Entsperr-PIN ändern", "tt_chat_bubble_accent": "Akzentfarbe für deine ausgehenden Nachrichtenblasen (oder dem aktuellen Theme folgen)", @@ -1580,7 +1587,7 @@ "tt_low_spec": "Alle aufwendigen visuellen Effekte deaktivieren\\nHotkey: Ctrl+Shift+Down", "tt_merge": "Mehrere UTXOs einer Adresse zusammenführen", "tt_mine_idle": "Mining automatisch starten, wenn das\\nSystem inaktiv ist (keine Tastatur-/Mauseingabe)", - "tt_noise": "Körnungstextur-Intensität (0%% = aus, 100%% = maximum)", + "tt_noise": "Körnungstextur-Intensität (0% = aus, 100% = maximum)", "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", @@ -1619,7 +1626,7 @@ "tt_theme_hotkey": "Hotkey: Ctrl+Links/Rechts zum Wechseln der Themes", "tt_tor": "Daemon-Verbindungen für Anonymität über das Tor-Netzwerk leiten", "tt_tx_url": "Basis-URL zum Anzeigen von Transaktionen in einem Block-Explorer", - "tt_ui_opacity": "Karten- und Seitenleisten-Deckkraft (100%% = vollständig undurchsichtig, niedriger = durchsichtiger)", + "tt_ui_opacity": "Karten- und Seitenleisten-Deckkraft (100% = vollständig undurchsichtig, niedriger = durchsichtiger)", "tt_validate": "Prüfen, ob eine DragonX-Adresse gültig ist", "tt_verbose": "Detaillierte Verbindungsdiagnosen,\\nDaemon-Status und Port-Besitzer-Info\\nin der Konsolen-Registerkarte protokollieren", "tt_wallets_button": "Ihre Wallet-Dateien auflisten und zwischen ihnen wechseln", @@ -1831,4 +1838,4 @@ "your_addresses": "Ihre Adressen", "z_address": "Z-Adresse", "z_addresses": "Z-Adressen" -} \ No newline at end of file +} diff --git a/res/lang/es.json b/res/lang/es.json index 848663e..85dbccf 100644 --- a/res/lang/es.json +++ b/res/lang/es.json @@ -74,6 +74,9 @@ "av_title": "Windows Defender bloqueó el minero", "available": "Disponible", "backup_backing_up": "Respaldando...", + "backup_col_backup": "COPIA DE SEGURIDAD", + "backup_col_export": "EXPORTAR", + "backup_col_import": "IMPORTAR Y RESTAURAR", "backup_create": "Crear Respaldo", "backup_created": "Respaldo de cartera creado", "backup_data": "RESPALDO Y DATOS", @@ -423,6 +426,7 @@ "daemon_bundled": "Incluido", "daemon_install_bundled": "Instalar integrado", "daemon_installed": "Instalado", + "daemon_maintenance_label": "MANTENIMIENTO", "daemon_none_bundled": "ninguno en esta compilación", "daemon_not_installed": "no instalado", "daemon_status_differ": "El binario instalado difiere de la versión incluida.", @@ -458,6 +462,7 @@ "daemon_update_verify_note": "La descarga se verifica frente al SHA-256 publicado de la versión y una firma ed25519 fijada antes de instalarla.", "daemon_update_verifying": "Verificando…", "daemon_update_version": "Versión:", + "daemon_updates_label": "ACTUALIZACIONES", "daemon_version": "Daemon", "dark": "Oscuro", "data_stale_prefix": "Actualizado", @@ -1228,6 +1233,7 @@ "sb_waiting_daemon_err": "Esperando a dragonxd — %s", "sb_warming_up": "Calentando...", "sb_witness_cache": "Reconstruyendo testigos", + "scale_effects": "ESCALA Y EFECTOS", "screenshot_open_dir": "Abrir ubicación", "screenshot_sweep": "Ejecutar barrido de capturas", "screenshot_sweep_desc": "Recorre cada tema en cada pestaña y guarda una captura de pantalla de cada una en subcarpetas por pestaña dentro de la carpeta de capturas del directorio de configuración (sobrescribiendo el barrido anterior). Se ejecuta durante unos segundos.", @@ -1316,12 +1322,12 @@ "settings": "Ajustes", "settings_about_text": "Una billetera de criptomonedas blindada para DragonX (DRGX), creada con Dear ImGui para una experiencia ligera y portátil.", "settings_acrylic_level": "Nivel de acrílico:", - "settings_address_book": "Libreta de direcciones...", + "settings_address_book": "Libreta de direcciones…", "settings_auto_detected": "Autodetectado de DRAGONX.conf", "settings_auto_lock": "BLOQUEO AUTOMÁTICO", "settings_auto_shield_desc": "Mover automáticamente fondos transparentes a direcciones blindadas", "settings_auto_shield_funds": "Blindar fondos transparentes automáticamente", - "settings_backup": "Respaldo...", + "settings_backup": "Respaldo…", "settings_block_explorer_urls": "URLs del explorador de bloques", "settings_builtin": "Integrado", "settings_change_passphrase": "Cambiar contraseña", @@ -1335,7 +1341,7 @@ "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_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=).", @@ -1343,18 +1349,18 @@ "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.", - "settings_export_all": "Exportar todo...", - "settings_export_csv": "Exportar CSV...", - "settings_export_key": "Exportar clave...", + "settings_export_all": "Exportar todo…", + "settings_export_csv": "Exportar CSV…", + "settings_export_key": "Exportar clave…", "settings_gradient_bg": "Fondo degradado", "settings_gradient_desc": "Reemplazar fondos con texturas por degradados suaves", "settings_idle_after": "después de", - "settings_import_key": "Importar Clave Privada...", - "settings_import_viewkey": "Importar clave de visualización...", + "settings_import_key": "Importar Clave Privada…", + "settings_import_viewkey": "Importar clave de visualización…", "settings_language_note": "Nota: Parte del texto requiere reinicio para actualizarse", "settings_lock_now": "Bloquear ahora", "settings_locked": "Bloqueado", - "settings_merge_to_address": "Fusionar a dirección...", + "settings_merge_to_address": "Fusionar a dirección…", "settings_noise_opacity": "Opacidad de ruido:", "settings_not_connected": "No conectado al daemon", "settings_not_encrypted": "Sin cifrar", @@ -1370,7 +1376,7 @@ "settings_reloaded": "Configuración recargada desde el disco", "settings_remove_encryption": "Quitar cifrado", "settings_remove_pin": "Quitar PIN", - "settings_request_payment": "Solicitar pago...", + "settings_request_payment": "Solicitar pago…", "settings_rescan_desc": "Reescanear la cadena de bloques en busca de transacciones faltantes", "settings_restart_daemon": "Reiniciar daemon", "settings_rpc_connection": "Conexión RPC", @@ -1381,20 +1387,20 @@ "settings_save_shielded_local": "Guardar historial de transacciones blindadas localmente", "settings_saved": "Configuración guardada", "settings_set_pin": "Establecer PIN", - "settings_shield_mining": "Blindar minería...", + "settings_shield_mining": "Blindar minería…", "settings_solid_colors_desc": "Usar colores sólidos en lugar de efectos de desenfoque (accesibilidad)", "settings_theme_refreshed": "Lista de temas actualizada", "settings_tor_desc": "Enrutar todas las conexiones a través de Tor para mayor privacidad", "settings_unlocked": "Desbloqueado", "settings_use_tor_network": "Usar Tor para conexiones de red", - "settings_validate_address": "Validar dirección...", + "settings_validate_address": "Validar dirección…", "settings_visual_effects": "Efectos visuales", "settings_wallet_file_size": "Tamaño del archivo de billetera: %s", "settings_wallet_info": "Información de billetera", "settings_wallet_location": "Ubicación de billetera: %s", "settings_wallet_maintenance": "Mantenimiento de billetera", "settings_wallet_not_found": "Archivo de billetera no encontrado", - "settings_wallet_size_label": "Tamaño de billetera:", + "settings_wallet_size_label": "Tamaño de billetera", "settings_ztx_cleared": "Historial de transacciones Z borrado", "settings_ztx_not_found": "No se encontró archivo de historial", "setup_wizard": "Asistente de Configuración", @@ -1494,6 +1500,7 @@ "to_upper": "PARA", "tools": "HERRAMIENTAS", "tools_actions": "Herramientas y Acciones...", + "tools_actions_hdr": "HERRAMIENTAS Y ACCIONES", "total": "Total", "total_balance_label": "Saldo Total", "transaction_id": "ID DE TRANSACCIÓN", @@ -1517,7 +1524,7 @@ "tt_auto_shield": "Mover automáticamente el saldo transparente a direcciones blindadas para privacidad", "tt_backup": "Crear una copia de seguridad de su wallet.dat", "tt_block_explorer": "Abrir el explorador de bloques DragonX en su navegador", - "tt_blur": "Cantidad de desenfoque (0%% = apagado, 100%% = máximo)", + "tt_blur": "Cantidad de desenfoque (0% = apagado, 100% = máximo)", "tt_change_pass": "Cambiar la contraseña de cifrado de la billetera", "tt_change_pin": "Cambiar su PIN de desbloqueo", "tt_chat_bubble_accent": "Color de acento para tus burbujas de mensaje salientes (o sigue el tema actual)", @@ -1580,7 +1587,7 @@ "tt_low_spec": "Desactivar todos los efectos visuales pesados\\nAtajo: Ctrl+Shift+Down", "tt_merge": "Consolidar múltiples UTXOs en una dirección", "tt_mine_idle": "Iniciar minería automáticamente cuando el\\nsistema esté inactivo (sin entrada de teclado/ratón)", - "tt_noise": "Intensidad de textura granulada (0%% = apagado, 100%% = máximo)", + "tt_noise": "Intensidad de textura granulada (0% = apagado, 100% = máximo)", "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", @@ -1619,7 +1626,7 @@ "tt_theme_hotkey": "Atajo: Ctrl+Izquierda/Derecha para cambiar temas", "tt_tor": "Enrutar conexiones del daemon a través de la red Tor para anonimato", "tt_tx_url": "URL base para ver transacciones en un explorador de bloques", - "tt_ui_opacity": "Opacidad de tarjetas y barra lateral (100%% = totalmente opaco, menor = más transparente)", + "tt_ui_opacity": "Opacidad de tarjetas y barra lateral (100% = totalmente opaco, menor = más transparente)", "tt_validate": "Comprobar si una dirección DragonX es válida", "tt_verbose": "Registrar diagnósticos detallados de conexión,\\nestado del daemon e info de propietario de puerto\\nen la pestaña de Consola", "tt_wallets_button": "Enumera tus archivos de cartera y cambia entre ellos", @@ -1831,4 +1838,4 @@ "your_addresses": "Sus Direcciones", "z_address": "Dirección Z", "z_addresses": "Direcciones Z" -} \ No newline at end of file +} diff --git a/res/lang/fr.json b/res/lang/fr.json index e25216a..d878f78 100644 --- a/res/lang/fr.json +++ b/res/lang/fr.json @@ -74,6 +74,9 @@ "av_title": "Windows Defender a bloqué le mineur", "available": "Disponible", "backup_backing_up": "Sauvegarde en cours...", + "backup_col_backup": "SAUVEGARDE", + "backup_col_export": "EXPORTER", + "backup_col_import": "IMPORTER ET RESTAURER", "backup_create": "Créer une sauvegarde", "backup_created": "Sauvegarde du portefeuille créée", "backup_data": "SAUVEGARDE & DONNÉES", @@ -423,6 +426,7 @@ "daemon_bundled": "Intégré", "daemon_install_bundled": "Installer la version intégrée", "daemon_installed": "Installé", + "daemon_maintenance_label": "MAINTENANCE", "daemon_none_bundled": "aucun dans cette version", "daemon_not_installed": "non installé", "daemon_status_differ": "Le binaire installé diffère de la version intégrée.", @@ -458,6 +462,7 @@ "daemon_update_verify_note": "Le téléchargement est vérifié par rapport au SHA-256 publié de la version et à une signature ed25519 épinglée avant l'installation.", "daemon_update_verifying": "Vérification…", "daemon_update_version": "Version :", + "daemon_updates_label": "MISES À JOUR", "daemon_version": "Daemon", "dark": "Sombre", "data_stale_prefix": "Mis à jour", @@ -1228,6 +1233,7 @@ "sb_waiting_daemon_err": "En attente de dragonxd — %s", "sb_warming_up": "Démarrage...", "sb_witness_cache": "Reconstruction des témoins", + "scale_effects": "ÉCHELLE ET EFFETS", "screenshot_open_dir": "Ouvrir l'emplacement", "screenshot_sweep": "Lancer la capture d'écran", "screenshot_sweep_desc": "Parcourt chaque thème sur chaque onglet et enregistre une capture d'écran de chacun dans des sous-dossiers par onglet, sous le dossier screenshots du répertoire de configuration (en écrasant le balayage précédent). Dure quelques secondes.", @@ -1316,12 +1322,12 @@ "settings": "Paramètres", "settings_about_text": "Un portefeuille de cryptomonnaie blindé pour DragonX (DRGX), construit avec Dear ImGui pour une expérience légère et portable.", "settings_acrylic_level": "Niveau acrylique :", - "settings_address_book": "Carnet d'adresses...", + "settings_address_book": "Carnet d'adresses…", "settings_auto_detected": "Détecté automatiquement depuis DRAGONX.conf", "settings_auto_lock": "VERROUILLAGE AUTO", "settings_auto_shield_desc": "Déplacer automatiquement les fonds transparents vers des adresses blindées", "settings_auto_shield_funds": "Blindage automatique des fonds transparents", - "settings_backup": "Sauvegarde...", + "settings_backup": "Sauvegarde…", "settings_block_explorer_urls": "URLs de l'explorateur de blocs", "settings_builtin": "Intégré", "settings_change_passphrase": "Changer la phrase secrète", @@ -1335,7 +1341,7 @@ "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_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=).", @@ -1343,18 +1349,18 @@ "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é.", - "settings_export_all": "Tout exporter...", - "settings_export_csv": "Exporter CSV...", - "settings_export_key": "Exporter la clé...", + "settings_export_all": "Tout exporter…", + "settings_export_csv": "Exporter CSV…", + "settings_export_key": "Exporter la clé…", "settings_gradient_bg": "Fond dégradé", "settings_gradient_desc": "Remplacer les arrière-plans texturés par des dégradés lisses", "settings_idle_after": "après", - "settings_import_key": "Importer une clé privée...", - "settings_import_viewkey": "Importer la clé de visualisation...", + "settings_import_key": "Importer une clé privée…", + "settings_import_viewkey": "Importer la clé de visualisation…", "settings_language_note": "Remarque : Certains textes nécessitent un redémarrage pour se mettre à jour", "settings_lock_now": "Verrouiller maintenant", "settings_locked": "Verrouillé", - "settings_merge_to_address": "Fusionner vers l'adresse...", + "settings_merge_to_address": "Fusionner vers l'adresse…", "settings_noise_opacity": "Opacité du bruit :", "settings_not_connected": "Non connecté au démon", "settings_not_encrypted": "Non chiffré", @@ -1370,7 +1376,7 @@ "settings_reloaded": "Paramètres rechargés depuis le disque", "settings_remove_encryption": "Supprimer le chiffrement", "settings_remove_pin": "Supprimer le PIN", - "settings_request_payment": "Demander un paiement...", + "settings_request_payment": "Demander un paiement…", "settings_rescan_desc": "Rescanner la blockchain pour les transactions manquantes", "settings_restart_daemon": "Redémarrer le daemon", "settings_rpc_connection": "Connexion RPC", @@ -1381,20 +1387,20 @@ "settings_save_shielded_local": "Enregistrer l'historique des transactions blindées localement", "settings_saved": "Paramètres enregistrés", "settings_set_pin": "Définir le PIN", - "settings_shield_mining": "Blindage minage...", + "settings_shield_mining": "Blindage minage…", "settings_solid_colors_desc": "Utiliser des couleurs unies au lieu des effets de flou (accessibilité)", "settings_theme_refreshed": "Liste des thèmes actualisée", "settings_tor_desc": "Acheminer toutes les connexions via Tor pour une confidentialité renforcée", "settings_unlocked": "Déverrouillé", "settings_use_tor_network": "Utiliser Tor pour les connexions réseau", - "settings_validate_address": "Valider l'adresse...", + "settings_validate_address": "Valider l'adresse…", "settings_visual_effects": "Effets visuels", "settings_wallet_file_size": "Taille du fichier portefeuille : %s", "settings_wallet_info": "Informations du portefeuille", "settings_wallet_location": "Emplacement du portefeuille : %s", "settings_wallet_maintenance": "Maintenance du portefeuille", "settings_wallet_not_found": "Fichier portefeuille introuvable", - "settings_wallet_size_label": "Taille du portefeuille :", + "settings_wallet_size_label": "Taille du portefeuille ", "settings_ztx_cleared": "Historique des transactions Z effacé", "settings_ztx_not_found": "Aucun fichier d'historique trouvé", "setup_wizard": "Assistant de configuration", @@ -1494,6 +1500,7 @@ "to_upper": "À", "tools": "OUTILS", "tools_actions": "Outils & Actions...", + "tools_actions_hdr": "OUTILS ET ACTIONS", "total": "Total", "total_balance_label": "Solde total", "transaction_id": "ID DE TRANSACTION", @@ -1517,7 +1524,7 @@ "tt_auto_shield": "Déplacer automatiquement le solde transparent vers des adresses blindées pour la confidentialité", "tt_backup": "Créer une sauvegarde de votre wallet.dat", "tt_block_explorer": "Ouvrir l'explorateur de blocs DragonX dans votre navigateur", - "tt_blur": "Quantité de flou (0%% = désactivé, 100%% = maximum)", + "tt_blur": "Quantité de flou (0% = désactivé, 100% = maximum)", "tt_change_pass": "Changer la phrase secrète de chiffrement du portefeuille", "tt_change_pin": "Changer votre PIN de déverrouillage", "tt_chat_bubble_accent": "Couleur d'accent de vos bulles de message sortantes (ou suivre le thème actuel)", @@ -1580,7 +1587,7 @@ "tt_low_spec": "Désactiver tous les effets visuels lourds\\nRaccourci : Ctrl+Shift+Down", "tt_merge": "Consolider plusieurs UTXOs vers une adresse", "tt_mine_idle": "Démarrer le minage automatiquement quand le\\nsystème est inactif (aucune entrée clavier/souris)", - "tt_noise": "Intensité de texture grainée (0%% = désactivé, 100%% = maximum)", + "tt_noise": "Intensité de texture grainée (0% = désactivé, 100% = maximum)", "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", @@ -1619,7 +1626,7 @@ "tt_theme_hotkey": "Raccourci : Ctrl+Gauche/Droite pour changer de thème", "tt_tor": "Acheminer les connexions du daemon via le réseau Tor pour l'anonymat", "tt_tx_url": "URL de base pour consulter les transactions dans un explorateur de blocs", - "tt_ui_opacity": "Opacité des cartes et de la barre latérale (100%% = entièrement opaque, plus bas = plus transparent)", + "tt_ui_opacity": "Opacité des cartes et de la barre latérale (100% = entièrement opaque, plus bas = plus transparent)", "tt_validate": "Vérifier si une adresse DragonX est valide", "tt_verbose": "Journaliser les diagnostics de connexion détaillés,\\nl'état du daemon et les informations de propriétaire de port\\ndans l'onglet Console", "tt_wallets_button": "Répertoriez vos fichiers de portefeuille et passez de l'un à l'autre", @@ -1831,4 +1838,4 @@ "your_addresses": "Vos adresses", "z_address": "Adresse Z", "z_addresses": "Adresses Z" -} \ No newline at end of file +} diff --git a/res/lang/ja.json b/res/lang/ja.json index 7588451..dac35d6 100644 --- a/res/lang/ja.json +++ b/res/lang/ja.json @@ -74,6 +74,9 @@ "av_title": "Windows Defender がマイナーをブロックしました", "available": "利用可能", "backup_backing_up": "バックアップ中...", + "backup_col_backup": "バックアップ", + "backup_col_export": "エクスポート", + "backup_col_import": "インポートと復元", "backup_create": "バックアップを作成", "backup_created": "ウォレットのバックアップを作成しました", "backup_data": "バックアップとデータ", @@ -423,6 +426,7 @@ "daemon_bundled": "バンドル版", "daemon_install_bundled": "バンドル版をインストール", "daemon_installed": "インストール済み", + "daemon_maintenance_label": "メンテナンス", "daemon_none_bundled": "このビルドにはなし", "daemon_not_installed": "未インストール", "daemon_status_differ": "インストール済みのバイナリはバンドル版と異なります。", @@ -458,6 +462,7 @@ "daemon_update_verify_note": "ダウンロードは、インストール前にリリースで公開された SHA-256 と固定された ed25519 署名で検証されます。", "daemon_update_verifying": "検証中…", "daemon_update_version": "バージョン：", + "daemon_updates_label": "アップデート", "daemon_version": "デーモン", "dark": "ダーク", "data_stale_prefix": "更新", @@ -1225,6 +1230,7 @@ "sb_waiting_daemon_err": "dragonxd を待機中 — %s", "sb_warming_up": "ウォームアップ中...", "sb_witness_cache": "ウィットネスを再構築中", + "scale_effects": "スケールとエフェクト", "screenshot_open_dir": "場所を開く", "screenshot_sweep": "スクリーンショットスイープを実行", "screenshot_sweep_desc": "すべてのテーマをすべてのタブで巡回し、それぞれのスクリーンショットを設定ディレクトリの screenshots フォルダ内のタブごとのサブフォルダに保存します（前回のスイープを上書きします）。数秒間実行されます。", @@ -1313,12 +1319,12 @@ "settings": "設定", "settings_about_text": "DragonX (DRGX) 用のシールド暗号通貨ウォレット。Dear ImGui で構築された軽量でポータブルな体験。", "settings_acrylic_level": "アクリルレベル：", - "settings_address_book": "アドレス帳...", + "settings_address_book": "アドレス帳…", "settings_auto_detected": "DRAGONX.conf から自動検出", "settings_auto_lock": "オートロック", "settings_auto_shield_desc": "透明資金を自動的にシールドアドレスに移動", "settings_auto_shield_funds": "透明資金を自動シールド", - "settings_backup": "バックアップ...", + "settings_backup": "バックアップ…", "settings_block_explorer_urls": "ブロックエクスプローラーURL", "settings_builtin": "内蔵", "settings_change_passphrase": "パスフレーズを変更", @@ -1340,18 +1346,18 @@ "settings_encrypt_first_pin": "PIN を有効にするには、まずウォレットを暗号化してください", "settings_encrypt_wallet": "ウォレットを暗号化", "settings_explorer_hint": "URLには末尾のスラッシュを含めてください。txid/アドレスが追加されます。", - "settings_export_all": "すべてエクスポート...", - "settings_export_csv": "CSV エクスポート...", - "settings_export_key": "鍵をエクスポート...", + "settings_export_all": "すべてエクスポート…", + "settings_export_csv": "CSV エクスポート…", + "settings_export_key": "鍵をエクスポート…", "settings_gradient_bg": "グラデーション背景", "settings_gradient_desc": "テクスチャ背景を滑らかなグラデーションに置換", "settings_idle_after": "経過後", - "settings_import_key": "秘密鍵をインポート...", - "settings_import_viewkey": "閲覧鍵をインポート...", + "settings_import_key": "秘密鍵をインポート…", + "settings_import_viewkey": "閲覧鍵をインポート…", "settings_language_note": "注意：一部のテキストは更新に再起動が必要です", "settings_lock_now": "今すぐロック", "settings_locked": "ロック済み", - "settings_merge_to_address": "アドレスにマージ...", + "settings_merge_to_address": "アドレスにマージ…", "settings_noise_opacity": "ノイズ不透明度：", "settings_not_connected": "デーモンに接続されていません", "settings_not_encrypted": "暗号化されていません", @@ -1367,7 +1373,7 @@ "settings_reloaded": "ディスクから設定を再読み込みしました", "settings_remove_encryption": "暗号化を解除", "settings_remove_pin": "PIN を削除", - "settings_request_payment": "支払い請求...", + "settings_request_payment": "支払い請求…", "settings_rescan_desc": "欠落したトランザクションのためにブロックチェーンを再スキャン", "settings_restart_daemon": "デーモンを再起動", "settings_rpc_connection": "RPC 接続", @@ -1378,13 +1384,13 @@ "settings_save_shielded_local": "シールドトランザクション履歴をローカルに保存", "settings_saved": "設定を保存しました", "settings_set_pin": "PIN を設定", - "settings_shield_mining": "マイニングシールド...", + "settings_shield_mining": "マイニングシールド…", "settings_solid_colors_desc": "ぼかし効果の代わりに単色を使用（アクセシビリティ）", "settings_theme_refreshed": "テーマ一覧を更新しました", "settings_tor_desc": "プライバシー向上のため全接続を Tor 経由にする", "settings_unlocked": "ロック解除", "settings_use_tor_network": "ネットワーク接続に Tor を使用", - "settings_validate_address": "アドレス検証...", + "settings_validate_address": "アドレス検証…", "settings_visual_effects": "視覚効果", "settings_wallet_file_size": "ウォレットファイルサイズ：%s", "settings_wallet_info": "ウォレット情報", @@ -1491,6 +1497,7 @@ "to_upper": "宛先", "tools": "ツール", "tools_actions": "ツールとアクション...", + "tools_actions_hdr": "ツールと操作", "total": "合計", "total_balance_label": "総残高", "transaction_id": "取引ID", @@ -1514,7 +1521,7 @@ "tt_auto_shield": "プライバシーのため透明残高を自動的にシールドアドレスに移動", "tt_backup": "wallet.dat のバックアップを作成", "tt_block_explorer": "ブラウザで DragonX ブロックエクスプローラーを開く", - "tt_blur": "ぼかし量（0%% = オフ、100%% = 最大）", + "tt_blur": "ぼかし量（0% = オフ、100% = 最大）", "tt_change_pass": "ウォレットの暗号化パスフレーズを変更", "tt_change_pin": "アンロック PIN を変更", "tt_chat_bubble_accent": "送信メッセージの吹き出しのアクセントカラー（または現在のテーマに従う）", @@ -1577,7 +1584,7 @@ "tt_low_spec": "すべての重い視覚効果を無効化\\nホットキー：Ctrl+Shift+Down", "tt_merge": "複数の UTXO を一つのアドレスに統合", "tt_mine_idle": "システムがアイドル状態（キーボード/マウス入力なし）\\nのとき自動的にマイニングを開始", - "tt_noise": "グレインテクスチャ強度（0%% = オフ、100%% = 最大）", + "tt_noise": "グレインテクスチャ強度（0% = オフ、100% = 最大）", "tt_open_app_dir": "ObsidianDragon フォルダ（設定、テーマ、ログ）をファイルマネージャーで開く", "tt_open_data_dir": "ファイルマネージャーでウォレットとブロックチェーンデータのフォルダを開きます", "tt_open_dir": "クリックしてファイルエクスプローラーで開く", @@ -1616,7 +1623,7 @@ "tt_theme_hotkey": "ホットキー：Ctrl+左/右でテーマを切り替え", "tt_tor": "匿名性のためにデーモン接続を Tor ネットワーク経由でルーティング", "tt_tx_url": "ブロックエクスプローラーでトランザクションを表示するためのベース URL", - "tt_ui_opacity": "カードとサイドバーの不透明度（100%% = 完全不透明、低い = より透過）", + "tt_ui_opacity": "カードとサイドバーの不透明度（100% = 完全不透明、低い = より透過）", "tt_validate": "DragonX アドレスが有効かどうかを確認", "tt_verbose": "詳細な接続診断、デーモン状態、\\nポート所有者情報をコンソールタブに記録", "tt_wallets_button": "ウォレットファイルを一覧表示して切り替えます", @@ -1828,4 +1835,4 @@ "your_addresses": "あなたのアドレス", "z_address": "Zアドレス", "z_addresses": "Zアドレス" -} \ No newline at end of file +} diff --git a/res/lang/ko.json b/res/lang/ko.json index d95957e..0fab8e7 100644 --- a/res/lang/ko.json +++ b/res/lang/ko.json @@ -74,6 +74,9 @@ "av_title": "Windows Defender가 채굴기를 차단했습니다", "available": "사용 가능", "backup_backing_up": "백업 중...", + "backup_col_backup": "백업", + "backup_col_export": "내보내기", + "backup_col_import": "가져오기 및 복원", "backup_create": "백업 생성", "backup_created": "지갑 백업이 생성되었습니다", "backup_data": "백업 및 데이터", @@ -423,6 +426,7 @@ "daemon_bundled": "번들", "daemon_install_bundled": "번들 버전 설치", "daemon_installed": "설치됨", + "daemon_maintenance_label": "유지 관리", "daemon_none_bundled": "이 빌드에 없음", "daemon_not_installed": "설치되지 않음", "daemon_status_differ": "설치된 바이너리가 번들 버전과 다릅니다.", @@ -458,6 +462,7 @@ "daemon_update_verify_note": "다운로드는 설치 전에 릴리스에 게시된 SHA-256과 고정된 ed25519 서명으로 검증됩니다.", "daemon_update_verifying": "확인 중…", "daemon_update_version": "버전:", + "daemon_updates_label": "업데이트", "daemon_version": "데몬", "dark": "다크", "data_stale_prefix": "업데이트", @@ -1227,6 +1232,7 @@ "sb_waiting_daemon_err": "dragonxd 대기 중 — %s", "sb_warming_up": "워밍업 중...", "sb_witness_cache": "증인 재구축 중", + "scale_effects": "배율 및 효과", "screenshot_open_dir": "위치 열기", "screenshot_sweep": "스크린샷 스윕 실행", "screenshot_sweep_desc": "모든 탭에 대해 모든 테마를 순회하며 각각의 스크린샷을 설정 디렉터리의 screenshots 폴더 아래 탭별 하위 폴더에 저장합니다(이전 스윕을 덮어씀). 몇 초 동안 실행됩니다.", @@ -1315,12 +1321,12 @@ "settings": "설정", "settings_about_text": "DragonX (DRGX)용 차폐 암호화폐 지갑으로, Dear ImGui로 제작되어 가볍고 휴대 가능합니다.", "settings_acrylic_level": "아크릴 레벨:", - "settings_address_book": "주소록...", + "settings_address_book": "주소록…", "settings_auto_detected": "DRAGONX.conf에서 자동 감지", "settings_auto_lock": "자동 잠금", "settings_auto_shield_desc": "투명 자금을 자동으로 차폐 주소로 이동", "settings_auto_shield_funds": "투명 자금 자동 차폐", - "settings_backup": "백업...", + "settings_backup": "백업…", "settings_block_explorer_urls": "블록 탐색기 URL", "settings_builtin": "내장", "settings_change_passphrase": "비밀번호 변경", @@ -1334,7 +1340,7 @@ "settings_copy_diagnostics": "진단 정보 복사", "settings_copyright": "Copyright 2024-2026 DragonX 개발자 | GPLv3 라이선스", "settings_custom": "사용자 지정", - "settings_data_dir": "데이터 디렉터리:", + "settings_data_dir": "데이터 디렉터리", "settings_debug_changed": "디버그 카테고리가 변경되었습니다 — 데몬을 재시작하여 적용", "settings_debug_restart_note": "변경 사항은 데몬을 다시 시작한 후에 적용됩니다.", "settings_debug_select": "데몬 디버그 로깅을 활성화할 카테고리를 선택하세요 (-debug= 플래그).", @@ -1342,18 +1348,18 @@ "settings_encrypt_first_pin": "PIN을 활성화하려면 먼저 지갑을 암호화하세요", "settings_encrypt_wallet": "지갑 암호화", "settings_explorer_hint": "URL에 후행 슬래시를 포함해야 합니다. txid/주소가 추가됩니다.", - "settings_export_all": "모두 내보내기...", - "settings_export_csv": "CSV 내보내기...", - "settings_export_key": "키 내보내기...", + "settings_export_all": "모두 내보내기…", + "settings_export_csv": "CSV 내보내기…", + "settings_export_key": "키 내보내기…", "settings_gradient_bg": "그라데이션 배경", "settings_gradient_desc": "텍스처 배경을 부드러운 그라데이션으로 교체", "settings_idle_after": "후", - "settings_import_key": "개인 키 가져오기...", - "settings_import_viewkey": "조회 키 가져오기...", + "settings_import_key": "개인 키 가져오기…", + "settings_import_viewkey": "조회 키 가져오기…", "settings_language_note": "참고: 일부 텍스트는 업데이트하려면 다시 시작해야 합니다", "settings_lock_now": "지금 잠금", "settings_locked": "잠김", - "settings_merge_to_address": "주소로 병합...", + "settings_merge_to_address": "주소로 병합…", "settings_noise_opacity": "노이즈 불투명도:", "settings_not_connected": "데몬에 연결되지 않음", "settings_not_encrypted": "암호화되지 않음", @@ -1369,7 +1375,7 @@ "settings_reloaded": "디스크에서 설정을 다시 불러왔습니다", "settings_remove_encryption": "암호화 제거", "settings_remove_pin": "PIN 제거", - "settings_request_payment": "결제 요청...", + "settings_request_payment": "결제 요청…", "settings_rescan_desc": "누락된 거래를 찾기 위해 블록체인 재스캔", "settings_restart_daemon": "데몬 재시작", "settings_rpc_connection": "RPC 연결", @@ -1380,20 +1386,20 @@ "settings_save_shielded_local": "차폐 거래 기록을 로컬에 저장", "settings_saved": "설정이 저장되었습니다", "settings_set_pin": "PIN 설정", - "settings_shield_mining": "채굴 차폐...", + "settings_shield_mining": "채굴 차폐…", "settings_solid_colors_desc": "블러 효과 대신 단색 사용 (접근성)", "settings_theme_refreshed": "테마 목록을 새로고침했습니다", "settings_tor_desc": "향상된 개인 정보 보호를 위해 모든 연결을 Tor를 통해 라우팅", "settings_unlocked": "잠금 해제", "settings_use_tor_network": "네트워크 연결에 Tor 사용", - "settings_validate_address": "주소 확인...", + "settings_validate_address": "주소 확인…", "settings_visual_effects": "시각 효과", "settings_wallet_file_size": "지갑 파일 크기: %s", "settings_wallet_info": "지갑 정보", "settings_wallet_location": "지갑 위치: %s", "settings_wallet_maintenance": "지갑 유지보수", "settings_wallet_not_found": "지갑 파일을 찾을 수 없음", - "settings_wallet_size_label": "지갑 크기:", + "settings_wallet_size_label": "지갑 크기", "settings_ztx_cleared": "Z-거래 내역이 삭제되었습니다", "settings_ztx_not_found": "내역 파일을 찾을 수 없습니다", "setup_wizard": "설정 마법사", @@ -1493,6 +1499,7 @@ "to_upper": "받는 곳", "tools": "도구", "tools_actions": "도구 및 작업...", + "tools_actions_hdr": "도구 및 작업", "total": "합계", "total_balance_label": "총 잔액", "transaction_id": "거래 ID", @@ -1516,7 +1523,7 @@ "tt_auto_shield": "개인 정보 보호를 위해 투명 잔액을 자동으로 차폐 주소로 이동", "tt_backup": "wallet.dat 백업 만들기", "tt_block_explorer": "브라우저에서 DragonX 블록 탐색기 열기", - "tt_blur": "블러 양 (0%% = 끔, 100%% = 최대)", + "tt_blur": "블러 양 (0% = 끔, 100% = 최대)", "tt_change_pass": "지갑 암호화 비밀번호 변경", "tt_change_pin": "잠금 해제 PIN 변경", "tt_chat_bubble_accent": "보내는 메시지 말풍선의 강조 색상(또는 현재 테마를 따름)", @@ -1579,7 +1586,7 @@ "tt_low_spec": "모든 고부하 시각 효과 비활성화\\n단축키: Ctrl+Shift+Down", "tt_merge": "여러 UTXO를 하나의 주소로 통합", "tt_mine_idle": "시스템이 유휴 상태(키보드/마우스 입력 없음)일 때\\n자동으로 채굴 시작", - "tt_noise": "그레인 텍스처 강도 (0%% = 끔, 100%% = 최대)", + "tt_noise": "그레인 텍스처 강도 (0% = 끔, 100% = 최대)", "tt_open_app_dir": "파일 관리자에서 ObsidianDragon 폴더(설정, 테마, 로그)를 엽니다", "tt_open_data_dir": "지갑 및 블록체인 데이터가 있는 폴더를 파일 탐색기에서 엽니다", "tt_open_dir": "파일 탐색기에서 열려면 클릭", @@ -1618,7 +1625,7 @@ "tt_theme_hotkey": "단축키: Ctrl+왼쪽/오른쪽으로 테마 전환", "tt_tor": "익명성을 위해 데몬 연결을 Tor 네트워크를 통해 라우팅", "tt_tx_url": "블록 탐색기에서 거래를 보기 위한 기본 URL", - "tt_ui_opacity": "카드 및 사이드바 불투명도 (100%% = 완전 불투명, 낮을수록 더 투명)", + "tt_ui_opacity": "카드 및 사이드바 불투명도 (100% = 완전 불투명, 낮을수록 더 투명)", "tt_validate": "DragonX 주소가 유효한지 확인", "tt_verbose": "콘솔 탭에 상세 연결 진단,\\n데몬 상태 및 포트 소유자 정보 기록", "tt_wallets_button": "지갑 파일 목록을 보고 전환합니다", @@ -1830,4 +1837,4 @@ "your_addresses": "내 주소", "z_address": "Z 주소", "z_addresses": "Z 주소" -} \ No newline at end of file +} diff --git a/res/lang/pt.json b/res/lang/pt.json index 8b97cdf..c770a5c 100644 --- a/res/lang/pt.json +++ b/res/lang/pt.json @@ -74,6 +74,9 @@ "av_title": "Windows Defender bloqueou o minerador", "available": "Disponível", "backup_backing_up": "Fazendo backup...", + "backup_col_backup": "BACKUP", + "backup_col_export": "EXPORTAR", + "backup_col_import": "IMPORTAR E RESTAURAR", "backup_create": "Criar Backup", "backup_created": "Backup da carteira criado", "backup_data": "BACKUP & DADOS", @@ -423,6 +426,7 @@ "daemon_bundled": "Empacotado", "daemon_install_bundled": "Instalar incluído", "daemon_installed": "Instalado", + "daemon_maintenance_label": "MANUTENÇÃO", "daemon_none_bundled": "nenhum nesta build", "daemon_not_installed": "não instalado", "daemon_status_differ": "O binário instalado difere da versão empacotada.", @@ -458,6 +462,7 @@ "daemon_update_verify_note": "O download é verificado contra o SHA-256 publicado do lançamento e uma assinatura ed25519 fixada antes da instalação.", "daemon_update_verifying": "Verificando…", "daemon_update_version": "Versão:", + "daemon_updates_label": "ATUALIZAÇÕES", "daemon_version": "Daemon", "dark": "Escuro", "data_stale_prefix": "Atualizado", @@ -1228,6 +1233,7 @@ "sb_waiting_daemon_err": "Aguardando dragonxd — %s", "sb_warming_up": "Aquecendo...", "sb_witness_cache": "Reconstruindo testemunhas", + "scale_effects": "ESCALA E EFEITOS", "screenshot_open_dir": "Abrir local", "screenshot_sweep": "Executar varredura de capturas de tela", "screenshot_sweep_desc": "Percorre cada tema em cada aba e salva uma captura de tela de cada um em subpastas por aba dentro da pasta de capturas de tela do diretório de configuração (sobrescrevendo a varredura anterior). É executado por alguns segundos.", @@ -1316,12 +1322,12 @@ "settings": "Ajustes", "settings_about_text": "Uma carteira de criptomoeda blindada para DragonX (DRGX), criada com Dear ImGui para uma experiência leve e portátil.", "settings_acrylic_level": "Nível acrílico:", - "settings_address_book": "Livro de endereços...", + "settings_address_book": "Livro de endereços…", "settings_auto_detected": "Detectado automaticamente de DRAGONX.conf", "settings_auto_lock": "BLOQUEIO AUTOMÁTICO", "settings_auto_shield_desc": "Mover automaticamente fundos transparentes para endereços blindados", "settings_auto_shield_funds": "Blindar fundos transparentes automaticamente", - "settings_backup": "Backup...", + "settings_backup": "Backup…", "settings_block_explorer_urls": "URLs do explorador de blocos", "settings_builtin": "Integrado", "settings_change_passphrase": "Alterar frase secreta", @@ -1335,7 +1341,7 @@ "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_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=).", @@ -1343,18 +1349,18 @@ "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.", - "settings_export_all": "Exportar tudo...", - "settings_export_csv": "Exportar CSV...", - "settings_export_key": "Exportar chave...", + "settings_export_all": "Exportar tudo…", + "settings_export_csv": "Exportar CSV…", + "settings_export_key": "Exportar chave…", "settings_gradient_bg": "Fundo gradiente", "settings_gradient_desc": "Substituir fundos texturizados por gradientes suaves", "settings_idle_after": "após", - "settings_import_key": "Importar Chave Privada...", - "settings_import_viewkey": "Importar chave de visualização...", + "settings_import_key": "Importar Chave Privada…", + "settings_import_viewkey": "Importar chave de visualização…", "settings_language_note": "Nota: Alguns textos requerem reinício para atualizar", "settings_lock_now": "Bloquear agora", "settings_locked": "Bloqueado", - "settings_merge_to_address": "Fundir para endereço...", + "settings_merge_to_address": "Fundir para endereço…", "settings_noise_opacity": "Opacidade do ruído:", "settings_not_connected": "Não conectado ao daemon", "settings_not_encrypted": "Não encriptado", @@ -1370,7 +1376,7 @@ "settings_reloaded": "Configurações recarregadas do disco", "settings_remove_encryption": "Remover encriptação", "settings_remove_pin": "Remover PIN", - "settings_request_payment": "Solicitar pagamento...", + "settings_request_payment": "Solicitar pagamento…", "settings_rescan_desc": "Reescanear a blockchain em busca de transações ausentes", "settings_restart_daemon": "Reiniciar daemon", "settings_rpc_connection": "Conexão RPC", @@ -1381,20 +1387,20 @@ "settings_save_shielded_local": "Salvar histórico de transações blindadas localmente", "settings_saved": "Configurações salvas", "settings_set_pin": "Definir PIN", - "settings_shield_mining": "Blindar mineração...", + "settings_shield_mining": "Blindar mineração…", "settings_solid_colors_desc": "Usar cores sólidas em vez de efeitos de desfoque (acessibilidade)", "settings_theme_refreshed": "Lista de temas atualizada", "settings_tor_desc": "Rotear todas as conexões através do Tor para maior privacidade", "settings_unlocked": "Desbloqueado", "settings_use_tor_network": "Usar Tor para conexões de rede", - "settings_validate_address": "Validar endereço...", + "settings_validate_address": "Validar endereço…", "settings_visual_effects": "Efeitos visuais", "settings_wallet_file_size": "Tamanho do arquivo da carteira: %s", "settings_wallet_info": "Informações da carteira", "settings_wallet_location": "Localização da carteira: %s", "settings_wallet_maintenance": "Manutenção da carteira", "settings_wallet_not_found": "Arquivo da carteira não encontrado", - "settings_wallet_size_label": "Tamanho da carteira:", + "settings_wallet_size_label": "Tamanho da carteira", "settings_ztx_cleared": "Histórico de transações Z limpo", "settings_ztx_not_found": "Nenhum arquivo de histórico encontrado", "setup_wizard": "Assistente de Configuração", @@ -1494,6 +1500,7 @@ "to_upper": "PARA", "tools": "FERRAMENTAS", "tools_actions": "Ferramentas e Ações...", + "tools_actions_hdr": "FERRAMENTAS E AÇÕES", "total": "Total", "total_balance_label": "Saldo Total", "transaction_id": "ID DA TRANSAÇÃO", @@ -1517,7 +1524,7 @@ "tt_auto_shield": "Mover automaticamente o saldo transparente para endereços blindados para privacidade", "tt_backup": "Criar um backup do seu wallet.dat", "tt_block_explorer": "Abrir o explorador de blocos DragonX no seu navegador", - "tt_blur": "Quantidade de desfoque (0%% = desligado, 100%% = máximo)", + "tt_blur": "Quantidade de desfoque (0% = desligado, 100% = máximo)", "tt_change_pass": "Alterar a frase secreta de encriptação da carteira", "tt_change_pin": "Alterar seu PIN de desbloqueio", "tt_chat_bubble_accent": "Cor de destaque para seus balões de mensagem enviados (ou seguir o tema atual)", @@ -1580,7 +1587,7 @@ "tt_low_spec": "Desativar todos os efeitos visuais pesados\\nAtalho: Ctrl+Shift+Down", "tt_merge": "Consolidar múltiplos UTXOs em um endereço", "tt_mine_idle": "Iniciar mineração automaticamente quando o\\nsistema estiver ocioso (sem entrada de teclado/mouse)", - "tt_noise": "Intensidade de textura granulada (0%% = desligado, 100%% = máximo)", + "tt_noise": "Intensidade de textura granulada (0% = desligado, 100% = máximo)", "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", @@ -1619,7 +1626,7 @@ "tt_theme_hotkey": "Atalho: Ctrl+Esquerda/Direita para alternar temas", "tt_tor": "Rotear conexões do daemon através da rede Tor para anonimato", "tt_tx_url": "URL base para visualizar transações em um explorador de blocos", - "tt_ui_opacity": "Opacidade de cartões e barra lateral (100%% = totalmente opaco, menor = mais transparente)", + "tt_ui_opacity": "Opacidade de cartões e barra lateral (100% = totalmente opaco, menor = mais transparente)", "tt_validate": "Verificar se um endereço DragonX é válido", "tt_verbose": "Registrar diagnósticos detalhados de conexão,\\nestado do daemon e info de proprietário de porta\\nna aba Console", "tt_wallets_button": "Liste os arquivos de carteira e alterne entre eles", @@ -1831,4 +1838,4 @@ "your_addresses": "Seus Endereços", "z_address": "Endereço Z", "z_addresses": "Endereços Z" -} \ No newline at end of file +} diff --git a/res/lang/ru.json b/res/lang/ru.json index b4defbe..f4d147e 100644 --- a/res/lang/ru.json +++ b/res/lang/ru.json @@ -74,6 +74,9 @@ "av_title": "Windows Defender заблокировал майнер", "available": "Доступно", "backup_backing_up": "Создание резервной копии...", + "backup_col_backup": "РЕЗЕРВНАЯ КОПИЯ", + "backup_col_export": "ЭКСПОРТ", + "backup_col_import": "ИМПОРТ И ВОССТАНОВЛЕНИЕ", "backup_create": "Создать резервную копию", "backup_created": "Резервная копия кошелька создана", "backup_data": "РЕЗЕРВНОЕ КОПИРОВАНИЕ И ДАННЫЕ", @@ -423,6 +426,7 @@ "daemon_bundled": "Встроенный", "daemon_install_bundled": "Установить встроенную", "daemon_installed": "Установлено", + "daemon_maintenance_label": "ОБСЛУЖИВАНИЕ", "daemon_none_bundled": "нет в этой сборке", "daemon_not_installed": "не установлен", "daemon_status_differ": "Установленный бинарный файл отличается от встроенной версии.", @@ -458,6 +462,7 @@ "daemon_update_verify_note": "Перед установкой загрузка проверяется по опубликованному для релиза SHA-256 и закреплённой подписи ed25519.", "daemon_update_verifying": "Проверка…", "daemon_update_version": "Версия:", + "daemon_updates_label": "ОБНОВЛЕНИЯ", "daemon_version": "Демон", "dark": "Тёмная", "data_stale_prefix": "Обновлено", @@ -1228,6 +1233,7 @@ "sb_waiting_daemon_err": "Ожидание dragonxd — %s", "sb_warming_up": "Прогрев...", "sb_witness_cache": "Перестроение свидетелей", + "scale_effects": "МАСШТАБ И ЭФФЕКТЫ", "screenshot_open_dir": "Открыть расположение", "screenshot_sweep": "Запустить прогон скриншотов", "screenshot_sweep_desc": "Перебирает каждую тему по всем вкладкам и сохраняет скриншот каждой в подпапки по вкладкам внутри папки screenshots в каталоге конфигурации (перезаписывая предыдущий проход). Выполняется несколько секунд.", @@ -1316,12 +1322,12 @@ "settings": "Настройки", "settings_about_text": "Защищённый криптовалютный кошелёк для DragonX (DRGX), созданный на Dear ImGui для лёгкого и портативного использования.", "settings_acrylic_level": "Уровень акрила:", - "settings_address_book": "Адресная книга...", + "settings_address_book": "Адресная книга…", "settings_auto_detected": "Автоопределено из DRAGONX.conf", "settings_auto_lock": "АВТОБЛОКИРОВКА", "settings_auto_shield_desc": "Автоматически перемещать прозрачные средства на экранированные адреса", "settings_auto_shield_funds": "Автоматически экранировать прозрачные средства", - "settings_backup": "Резервная копия...", + "settings_backup": "Резервная копия…", "settings_block_explorer_urls": "URL-адреса обозревателя блоков", "settings_builtin": "Встроенные", "settings_change_passphrase": "Сменить пароль", @@ -1335,7 +1341,7 @@ "settings_copy_diagnostics": "Копировать диагностику", "settings_copyright": "Copyright 2024-2026 Разработчики DragonX | Лицензия GPLv3", "settings_custom": "Пользовательские", - "settings_data_dir": "Каталог данных:", + "settings_data_dir": "Каталог данных", "settings_debug_changed": "Категории отладки изменены — перезапустите демон для применения", "settings_debug_restart_note": "Изменения вступают в силу после перезапуска демона.", "settings_debug_select": "Выберите категории для включения журнала отладки демона (флаги -debug=).", @@ -1343,18 +1349,18 @@ "settings_encrypt_first_pin": "Сначала зашифруйте кошелёк, чтобы включить PIN", "settings_encrypt_wallet": "Зашифровать кошелёк", "settings_explorer_hint": "URL-адреса должны заканчиваться косой чертой. Txid/адрес будет добавлен.", - "settings_export_all": "Экспортировать все...", - "settings_export_csv": "Экспорт CSV...", - "settings_export_key": "Экспортировать ключ...", + "settings_export_all": "Экспортировать все…", + "settings_export_csv": "Экспорт CSV…", + "settings_export_key": "Экспортировать ключ…", "settings_gradient_bg": "Градиент фона", "settings_gradient_desc": "Заменить текстурные фоны плавными градиентами", "settings_idle_after": "через", - "settings_import_key": "Импорт приватного ключа...", - "settings_import_viewkey": "Импортировать ключ просмотра...", + "settings_import_key": "Импорт приватного ключа…", + "settings_import_viewkey": "Импортировать ключ просмотра…", "settings_language_note": "Примечание: Некоторый текст требует перезапуска для обновления", "settings_lock_now": "Заблокировать сейчас", "settings_locked": "Заблокирован", - "settings_merge_to_address": "Объединить на адрес...", + "settings_merge_to_address": "Объединить на адрес…", "settings_noise_opacity": "Непрозрачность шума:", "settings_not_connected": "Нет соединения с демоном", "settings_not_encrypted": "Не зашифрован", @@ -1370,7 +1376,7 @@ "settings_reloaded": "Настройки перезагружены с диска", "settings_remove_encryption": "Удалить шифрование", "settings_remove_pin": "Удалить PIN", - "settings_request_payment": "Запросить платёж...", + "settings_request_payment": "Запросить платёж…", "settings_rescan_desc": "Пересканировать блокчейн для поиска пропущенных транзакций", "settings_restart_daemon": "Перезапустить демон", "settings_rpc_connection": "RPC-соединение", @@ -1381,20 +1387,20 @@ "settings_save_shielded_local": "Сохранять историю защищённых транзакций локально", "settings_saved": "Настройки сохранены", "settings_set_pin": "Установить PIN", - "settings_shield_mining": "Экранировать майнинг...", + "settings_shield_mining": "Экранировать майнинг…", "settings_solid_colors_desc": "Использовать сплошные цвета вместо эффектов размытия (доступность)", "settings_theme_refreshed": "Список тем обновлён", "settings_tor_desc": "Маршрутизировать все соединения через Tor для повышения конфиденциальности", "settings_unlocked": "Разблокирован", "settings_use_tor_network": "Использовать Tor для сетевых подключений", - "settings_validate_address": "Проверить адрес...", + "settings_validate_address": "Проверить адрес…", "settings_visual_effects": "Визуальные эффекты", "settings_wallet_file_size": "Размер файла кошелька: %s", "settings_wallet_info": "Информация о кошельке", "settings_wallet_location": "Расположение кошелька: %s", "settings_wallet_maintenance": "Обслуживание кошелька", "settings_wallet_not_found": "Файл кошелька не найден", - "settings_wallet_size_label": "Размер кошелька:", + "settings_wallet_size_label": "Размер кошелька", "settings_ztx_cleared": "История Z-транзакций очищена", "settings_ztx_not_found": "Файл истории не найден", "setup_wizard": "Мастер настройки", @@ -1494,6 +1500,7 @@ "to_upper": "КОМУ", "tools": "УТИЛИТЫ", "tools_actions": "Инструменты и действия...", + "tools_actions_hdr": "ИНСТРУМЕНТЫ И ДЕЙСТВИЯ", "total": "Итого", "total_balance_label": "Общий баланс", "transaction_id": "ID ТРАНЗАКЦИИ", @@ -1517,7 +1524,7 @@ "tt_auto_shield": "Автоматически перемещать прозрачный баланс на экранированные адреса для конфиденциальности", "tt_backup": "Создать резервную копию вашего wallet.dat", "tt_block_explorer": "Открыть обозреватель блоков DragonX в браузере", - "tt_blur": "Степень размытия (0%% = выкл., 100%% = максимум)", + "tt_blur": "Степень размытия (0% = выкл., 100% = максимум)", "tt_change_pass": "Сменить пароль шифрования кошелька", "tt_change_pin": "Изменить PIN-код разблокировки", "tt_chat_bubble_accent": "Акцентный цвет для ваших исходящих пузырьков сообщений (или следовать текущей теме)", @@ -1580,7 +1587,7 @@ "tt_low_spec": "Отключить все тяжёлые визуальные эффекты\\nГорячая клавиша: Ctrl+Shift+Down", "tt_merge": "Объединить несколько UTXO в один адрес", "tt_mine_idle": "Автоматически начать майнинг при\\nпростое системы (нет ввода с клавиатуры/мыши)", - "tt_noise": "Интенсивность зернистой текстуры (0%% = выкл., 100%% = максимум)", + "tt_noise": "Интенсивность зернистой текстуры (0% = выкл., 100% = максимум)", "tt_open_app_dir": "Открыть папку ObsidianDragon (настройки, темы, логи) в файловом менеджере", "tt_open_data_dir": "Открыть в файловом менеджере папку с данными кошелька и блокчейна", "tt_open_dir": "Нажмите, чтобы открыть в проводнике", @@ -1619,7 +1626,7 @@ "tt_theme_hotkey": "Горячая клавиша: Ctrl+Влево/Вправо для переключения тем", "tt_tor": "Маршрутизировать подключения демона через сеть Tor для анонимности", "tt_tx_url": "Базовый URL для просмотра транзакций в обозревателе блоков", - "tt_ui_opacity": "Непрозрачность карточек и боковой панели (100%% = полностью непрозрачно, ниже = прозрачнее)", + "tt_ui_opacity": "Непрозрачность карточек и боковой панели (100% = полностью непрозрачно, ниже = прозрачнее)", "tt_validate": "Проверить, действителен ли адрес DragonX", "tt_verbose": "Записывать подробную диагностику подключений,\\nсостояние демона и информацию о владельце порта\\nна вкладке Консоль", "tt_wallets_button": "Показать файлы кошельков и переключаться между ними", @@ -1831,4 +1838,4 @@ "your_addresses": "Ваши адреса", "z_address": "Z-адрес", "z_addresses": "Z-адреса" -} \ No newline at end of file +} diff --git a/res/lang/zh.json b/res/lang/zh.json index 615a6c5..f88ae5e 100644 --- a/res/lang/zh.json +++ b/res/lang/zh.json @@ -74,6 +74,9 @@ "av_title": "Windows Defender 已阻止矿工程序", "available": "可用", "backup_backing_up": "正在备份...", + "backup_col_backup": "备份", + "backup_col_export": "导出", + "backup_col_import": "导入与恢复", "backup_create": "创建备份", "backup_created": "钱包备份已创建", "backup_data": "备份与数据", @@ -423,6 +426,7 @@ "daemon_bundled": "内置", "daemon_install_bundled": "安装内置版本", "daemon_installed": "已安装", + "daemon_maintenance_label": "维护", "daemon_none_bundled": "此版本未内置", "daemon_not_installed": "未安装", "daemon_status_differ": "已安装的程序文件与内置版本不同。", @@ -458,6 +462,7 @@ "daemon_update_verify_note": "在安装前，会根据该版本发布的 SHA-256 和固定的 ed25519 签名对下载内容进行校验。", "daemon_update_verifying": "正在验证…", "daemon_update_version": "版本：", + "daemon_updates_label": "更新", "daemon_version": "守护进程", "dark": "深色", "data_stale_prefix": "更新于", @@ -1226,6 +1231,7 @@ "sb_waiting_daemon_err": "等待 dragonxd — %s", "sb_warming_up": "正在预热...", "sb_witness_cache": "正在重建见证", + "scale_effects": "缩放与效果", "screenshot_open_dir": "打开位置", "screenshot_sweep": "运行截图批处理", "screenshot_sweep_desc": "遍历每个标签页的每一种主题，并将每一个的截图保存到配置目录 screenshots 文件夹下的各标签页子文件夹中（覆盖上一次的遍历）。运行几秒钟。", @@ -1314,12 +1320,12 @@ "settings": "设置", "settings_about_text": "DragonX (DRGX) 屏蔽加密货币钱包，使用 Dear ImGui 构建，提供轻量、便携的体验。", "settings_acrylic_level": "亚克力级别：", - "settings_address_book": "地址簿...", + "settings_address_book": "地址簿…", "settings_auto_detected": "从 DRAGONX.conf 自动检测", "settings_auto_lock": "自动锁定", "settings_auto_shield_desc": "自动将透明资金转移到屏蔽地址", "settings_auto_shield_funds": "自动屏蔽透明资金", - "settings_backup": "备份...", + "settings_backup": "备份…", "settings_block_explorer_urls": "区块浏览器网址", "settings_builtin": "内置", "settings_change_passphrase": "更改密码", @@ -1341,18 +1347,18 @@ "settings_encrypt_first_pin": "请先加密钱包以启用 PIN", "settings_encrypt_wallet": "加密钱包", "settings_explorer_hint": "URL 应包含尾部斜杠。将自动附加 txid/地址。", - "settings_export_all": "全部导出...", - "settings_export_csv": "导出 CSV...", - "settings_export_key": "导出密钥...", + "settings_export_all": "全部导出…", + "settings_export_csv": "导出 CSV…", + "settings_export_key": "导出密钥…", "settings_gradient_bg": "渐变背景", "settings_gradient_desc": "用平滑渐变替换纹理背景", "settings_idle_after": "之后", - "settings_import_key": "导入私钥...", - "settings_import_viewkey": "导入查看密钥...", + "settings_import_key": "导入私钥…", + "settings_import_viewkey": "导入查看密钥…", "settings_language_note": "注意：部分文本需要重启才能更新", "settings_lock_now": "立即锁定", "settings_locked": "已锁定", - "settings_merge_to_address": "合并到地址...", + "settings_merge_to_address": "合并到地址…", "settings_noise_opacity": "噪点不透明度：", "settings_not_connected": "未连接到守护进程", "settings_not_encrypted": "未加密", @@ -1368,7 +1374,7 @@ "settings_reloaded": "已从磁盘重新加载设置", "settings_remove_encryption": "移除加密", "settings_remove_pin": "移除 PIN", - "settings_request_payment": "请求付款...", + "settings_request_payment": "请求付款…", "settings_rescan_desc": "重新扫描区块链以查找丢失的交易", "settings_restart_daemon": "重启守护进程", "settings_rpc_connection": "RPC 连接", @@ -1379,13 +1385,13 @@ "settings_save_shielded_local": "将屏蔽交易历史保存到本地", "settings_saved": "设置已保存", "settings_set_pin": "设置 PIN", - "settings_shield_mining": "屏蔽挖矿...", + "settings_shield_mining": "屏蔽挖矿…", "settings_solid_colors_desc": "使用纯色代替模糊效果（无障碍功能）", "settings_theme_refreshed": "主题列表已刷新", "settings_tor_desc": "通过 Tor 路由所有连接以增强隐私", "settings_unlocked": "已解锁", "settings_use_tor_network": "使用 Tor 进行网络连接", - "settings_validate_address": "验证地址...", + "settings_validate_address": "验证地址…", "settings_visual_effects": "视觉效果", "settings_wallet_file_size": "钱包文件大小：%s", "settings_wallet_info": "钱包信息", @@ -1492,6 +1498,7 @@ "to_upper": "至", "tools": "工具", "tools_actions": "工具与操作...", + "tools_actions_hdr": "工具与操作", "total": "合计", "total_balance_label": "总余额", "transaction_id": "交易 ID", @@ -1515,7 +1522,7 @@ "tt_auto_shield": "自动将透明余额转移到屏蔽地址以增强隐私", "tt_backup": "创建 wallet.dat 的备份", "tt_block_explorer": "在浏览器中打开 DragonX 区块浏览器", - "tt_blur": "模糊程度（0%% = 关闭，100%% = 最大）", + "tt_blur": "模糊程度（0% = 关闭，100% = 最大）", "tt_change_pass": "更改钱包加密密码", "tt_change_pin": "更改您的解锁 PIN", "tt_chat_bubble_accent": "你发出的消息气泡的强调色（或跟随当前主题）", @@ -1578,7 +1585,7 @@ "tt_low_spec": "禁用所有重度视觉效果\\n快捷键：Ctrl+Shift+Down", "tt_merge": "将多个 UTXO 合并到一个地址", "tt_mine_idle": "系统空闲时自动开始挖矿\\n（无键盘/鼠标输入）", - "tt_noise": "颗粒纹理强度（0%% = 关闭，100%% = 最大）", + "tt_noise": "颗粒纹理强度（0% = 关闭，100% = 最大）", "tt_open_app_dir": "在文件管理器中打开 ObsidianDragon 文件夹（设置、主题、日志）", "tt_open_data_dir": "在文件管理器中打开包含您钱包和区块链数据的文件夹", "tt_open_dir": "点击在文件管理器中打开", @@ -1617,7 +1624,7 @@ "tt_theme_hotkey": "快捷键：Ctrl+左/右箭头切换主题", "tt_tor": "通过 Tor 网络路由守护进程连接以实现匿名", "tt_tx_url": "在区块浏览器中查看交易的基础 URL", - "tt_ui_opacity": "卡片和侧边栏不透明度（100%% = 完全不透明，越低越透明）", + "tt_ui_opacity": "卡片和侧边栏不透明度（100% = 完全不透明，越低越透明）", "tt_validate": "检查 DragonX 地址是否有效", "tt_verbose": "将详细连接诊断、守护进程状态\\n和端口所有者信息记录到控制台选项卡", "tt_wallets_button": "列出您的钱包文件并在它们之间切换", @@ -1829,4 +1836,4 @@ "your_addresses": "您的地址", "z_address": "Z 地址", "z_addresses": "Z 地址" -} \ No newline at end of file +} diff --git a/src/app.cpp b/src/app.cpp index 9de781f..79320f8 100644 --- a/src/app.cpp +++ b/src/app.cpp @@ -1795,32 +1795,21 @@ void App::render() sbStatus.unconfirmedTxCount = static_cast(unconfirmedTxids.size()); } - // Sidebar margins from ui.toml schema (DPI-scaled like all sidebar values) - const float sbMarginTop = sbde("margin-top", 0.0f); - const float sbMarginBottom = sbde("margin-bottom", 0.0f); - const float sbMinHeight = sbde("min-height", 360.0f); + // Sidebar minimum height from ui.toml schema (DPI-scaled). + const float sbMinHeight = sbde("min-height", 360.0f); - // Ensure sidebar is tall enough to fit all buttons — shrink margins if needed - float sidebarH = contentH - sbMarginTop - sbMarginBottom; - float effectiveMarginTop = sbMarginTop; - if (sidebarH < sbMinHeight) { - float available = contentH - sbMinHeight; - if (available > 0.0f) { - float ratio = available / (sbMarginTop + sbMarginBottom); - effectiveMarginTop = sbMarginTop * ratio; - } else { - effectiveMarginTop = 0.0f; - } - sidebarH = std::max(contentH - effectiveMarginTop, sbMinHeight); - } - - // Sidebar navigation - // Save cursor Y before applying sidebar margin so the content area - // (placed via SameLine) starts at the original row position, not the - // margin-shifted one. + // Save cursor Y before the sidebar so the content area (restored below) starts at the original row. float preSidebarCursorY = ImGui::GetCursorPosY(); - if (effectiveMarginTop > 0.0f) - ImGui::SetCursorPosY(preSidebarCursorY + effectiveMarginTop); + + // Size the sidebar to span from its own top down to the status-bar top, so the nav panel centers + // within the TRUE visible area (equal top/bottom gaps). Do NOT derive it from contentH (inset by the + // content-area's edge-fade margins) and do NOT apply the legacy sidebar margin-top/-bottom (they are + // asymmetric, -12 / +40, and pushed the panel upward). Window-local reference (matches how the status + // bar is positioned — GetWindowPos/GetWindowSize, not GetMainViewport) so it is correct on every platform. + float sbWindowBottom = ImGui::GetWindowPos().y + ImGui::GetWindowSize().y; + float sbStatusTopY = sbWindowBottom - statusBarH - mainPadBot; + float sbChildTopY = ImGui::GetCursorScreenPos().y; + float sidebarH = std::max(sbMinHeight, sbStatusTopY - sbChildTopY); bool prevCollapsed = sidebar_collapsed_; { PERF_SCOPE("Render.Sidebar"); diff --git a/src/app.h b/src/app.h index 323f1d1..93f0730 100644 --- a/src/app.h +++ b/src/app.h @@ -408,6 +408,9 @@ public: // each under every skin. Output: /screenshots-full//.png + an index. void startFullUiSweep(); std::string screenshotFullDir() const; + // Debug option: restrict either sweep to just the currently-active theme instead of cycling all. + bool sweepCurrentThemeOnly() const { return sweep_current_theme_only_; } + void setSweepCurrentThemeOnly(bool v) { sweep_current_theme_only_ = v; } bool isScreenshotSweeping() const { return screenshot_sweep_active_; } bool wantsScreenshotThisFrame() const { return sweep_capture_this_frame_; } const std::string& screenshotSweepPath() const { return sweep_current_path_; } @@ -1114,6 +1117,7 @@ private: // Debug screenshot sweep state. bool screenshot_sweep_active_ = false; + bool sweep_current_theme_only_ = false; // Debug Options: sweep only the active theme bool sweep_capture_this_frame_ = false; int sweep_skin_idx_ = 0; int sweep_settle_frames_ = 0; // frames to let a new skin/surface settle before capture diff --git a/src/app_sweep.cpp b/src/app_sweep.cpp index 000865e..963b278 100644 --- a/src/app_sweep.cpp +++ b/src/app_sweep.cpp @@ -704,6 +704,10 @@ void App::startSweepImpl(bool full) if (sk.valid) sweep_skins_.push_back(sk.id); if (sweep_skins_.empty()) return; + // Debug Options "Current theme only": sweep just the active skin instead of cycling every theme. + if (sweep_current_theme_only_) + sweep_skins_.assign(1, ui::schema::SkinManager::instance().activeSkinId()); + sweep_full_ = full; if (full) { capture_mode_ = true; installDemoWalletData(); } buildSweepCatalog(); diff --git a/src/ui/layout.h b/src/ui/layout.h index 397e65e..54fe686 100644 --- a/src/ui/layout.h +++ b/src/ui/layout.h @@ -173,11 +173,11 @@ inline float kSidePanelMinWidth() { return schema::UI().drawElement("panels", inline float kSidePanelMaxWidth() { return schema::UI().drawElement("panels", "side-panel").getFloat("max-width", 450.0f) * dpiScale(); } inline float kSidePanelWidthRatio() { return schema::UI().drawElement("panels", "side-panel").getFloat("width-ratio", 0.4f); } -// Overall content-column cap: the max width a tab's content should occupy before it is centered in wider -// windows. Prevents cards/forms/tables (which all derive their size from the content child's width) from -// stretching edge-to-edge at wide/ultrawide widths. <= 0 disables (fill full width). Tunable via ui.toml -// [layout] content-max-width; default is generous so data-dense screens stay comfortable. -inline float kContentMaxWidth() { return schema::UI().drawElement("layout", "content-max-width").sizeOr(1600.0f) * dpiScale(); } +// Overall content-column cap: the max width a tab's content occupies before it is centered in wider +// windows. <= 0 disables the cap so tab content fills ALL available horizontal width (the default — +// requested so large windows don't leave a big empty gutter on the right). Set a positive +// ui.toml [layout] content-max-width to re-enable a centered readable column. +inline float kContentMaxWidth() { return schema::UI().drawElement("layout", "content-max-width").sizeOr(0.0f) * dpiScale(); } // Shared compose-card envelope for the Send + Receive tabs (and any tab wanting the same box): fill the // available column up to the content-max-width cap, then center the leftover as margin. Both tabs MUST @@ -186,7 +186,8 @@ inline float kContentMaxWidth() { return schema::UI().drawElement("layout", "con // Receive on any window wider than ~860dp. Returns {width, offsetX} in the same units as availW. struct CardBox { float width; float offsetX; }; inline CardBox mainComposeCardBox(float availW) { - float w = std::min(availW, kContentMaxWidth()); + float cap = kContentMaxWidth(); + float w = (cap > 0.0f) ? std::min(availW, cap) : availW; // cap <= 0 -> fill full width return CardBox{ w, std::max(0.0f, (availW - w) * 0.5f) }; } diff --git a/src/ui/material/settings_controls.h b/src/ui/material/settings_controls.h index 8d11a92..ee79e86 100644 --- a/src/ui/material/settings_controls.h +++ b/src/ui/material/settings_controls.h @@ -107,7 +107,7 @@ inline float ActionButtonWidth(const char* label, const char* icon, float minWid ImFont* lf = Type().button(); ImFont* icf = Type().iconSmall(); const float dp = Layout::dpiScale(); - const float padX = 12.0f * dp, gap = 6.0f * dp; + const float padX = 9.0f * dp, gap = 6.0f * dp; // mockup .btn padding: 9px horizontal const float labelW = lf->CalcTextSizeA(lf->LegacySize, FLT_MAX, 0, label).x; const float iconW = (icon && icon[0] && icf) ? icf->CalcTextSizeA(icf->LegacySize, FLT_MAX, 0, icon).x : 0.0f; const float w = padX * 2.0f + iconW + (iconW > 0.0f ? gap : 0.0f) + labelW; @@ -133,19 +133,21 @@ inline bool ActionButton(const char* id, const char* label, const char* icon, Ac if (hov) ImGui::SetMouseCursor(ImGuiMouseCursor_Hand); ImDrawList* dl = ImGui::GetWindowDrawList(); const ImVec2 pMax(pos.x + w, pos.y + h); - const float round = ImGui::GetStyle().FrameRounding; + const float round = 7.0f * dp; // mockup .btn radius: 7px (softer than the global 4px frame) const float a = ImGui::GetStyle().Alpha; // BeginDisabled() lowers this ImU32 bg = 0, border = 0, fg = OnSurface(); bool glass = false; switch (tier) { case ActionTier::Primary: - bg = WithAlpha(Primary(), act ? 255 : (hov ? 245 : 220)); - fg = IM_COL32(255, 255, 255, 240); + // Mockup .btn.acc: a dark accent-tinted chip with accent TEXT — not a bright filled button. + bg = WithAlpha(Primary(), hov ? 52 : 38); + border = WithAlpha(Primary(), hov ? 150 : 110); + fg = Primary(); break; case ActionTier::Secondary: - bg = WithAlpha(OnSurface(), hov ? 26 : 16); - border = WithAlpha(OnSurface(), 40); + bg = WithAlpha(OnSurface(), hov ? 30 : 20); + border = WithAlpha(OnSurface(), 48); glass = true; fg = OnSurface(); break; diff --git a/src/ui/pages/settings_page.cpp b/src/ui/pages/settings_page.cpp index 8eecbee..952af1d 100644 --- a/src/ui/pages/settings_page.cpp +++ b/src/ui/pages/settings_page.cpp @@ -164,6 +164,7 @@ struct SettingsPageState { bool effects_expanded = false; bool tools_expanded = false; bool rpc_expanded = false; // Node & Security: reveal the RPC connection fields + int current_tab = 0; // active settings category tab (see SettingsTab enum) bool confirm_clear_ztx = false; bool confirm_delete_blockchain = false; bool confirm_rescan = false; @@ -516,6 +517,7 @@ static void renderConsoleColorToggles(App* app) { app->settings()->save(); } if (ImGui::IsItemHovered()) material::Tooltip("%s", TR("console_toggle_text_color")); + ImGui::SameLine(0, Layout::spacingLg()); // Console behavior (not a GPU effect): focus the command input when the tab opens. Bound straight to // settings — the App reads it at the page transition; no ConsoleTab static needed. bool autoFocus = app->settings()->getConsoleAutoFocus(); @@ -531,6 +533,79 @@ static void renderConsoleColorToggles(App* app) { // Settings Page Renderer // ============================================================================ +// A full-card-width, left-aligned, solid button (icon + label) drawn at an explicit (x,y). +// Used by the side-by-side "column card" tabs (Backup, Wallet) where content is positioned +// manually because ImGui's Indent (which GlassCardScope uses) is window-relative. +static bool renderCardButton(ImDrawList* dl, float x, float y, float w, float h, + const char* id, const char* label, const char* icon) { + using namespace material; + ImGui::SetCursorScreenPos(ImVec2(x, y)); + ImFont* lf = Type().button(); + ImFont* icf = Type().iconSmall(); + const float dpp = Layout::dpiScale(); + const float padX = 12.0f * dpp, ig = 6.0f * dpp; + const float bh = h; + const bool pressed = ImGui::InvisibleButton(id, ImVec2(w, bh)); + const bool hov = ImGui::IsItemHovered(); + if (hov) ImGui::SetMouseCursor(ImGuiMouseCursor_Hand); + const ImVec2 pmin(x, y), pmax(x + w, y + bh); + const float round = 7.0f * dpp; // match ActionButton chips (mockup .btn radius: 7px) + dl->AddRectFilled(pmin, pmax, WithAlpha(OnSurface(), hov ? 30 : 20), round); + dl->AddRect(pmin, pmax, WithAlpha(OnSurface(), 48), round, 0, 1.0f); + const ImU32 fg = ImGui::GetColorU32(OnSurface()); + dl->PushClipRect(pmin, pmax, true); + float tx = x + padX; + if (icon && icon[0] && icf) { + dl->AddText(icf, icf->LegacySize, ImVec2(tx, y + (bh - icf->LegacySize) * 0.5f), fg, icon); + tx += icf->CalcTextSizeA(icf->LegacySize, FLT_MAX, 0, icon).x + ig; + } + dl->AddText(lf, lf->LegacySize, ImVec2(tx, y + (bh - lf->LegacySize) * 0.5f), fg, label); + dl->PopClipRect(); + return pressed; +} + +// ---- Category tabs (top-level settings navigation) ------------------------- +enum SettingsTab { TAB_APPEARANCE = 0, TAB_WALLET, TAB_BACKUP, TAB_NODE, TAB_EXPLORER, TAB_CHAT, TAB_ABOUT, TAB_COUNT }; + +// Pinned horizontal category tab bar, drawn above the settings scroll region. Each category is a +// pill; the active one gets an accent fill. Advances the ImGui cursor past the bar + a divider so +// the scrollable content begins below it. +static void renderSettingsTabBar(float availWidth) { + using namespace material; + struct T { int id; const char* label; const char* idstr; }; + static const T tabs[] = { + {TAB_APPEARANCE, "Appearance", "##stabA"}, {TAB_WALLET, "Wallet", "##stabW"}, + {TAB_BACKUP, "Backup & Data", "##stabB"}, {TAB_NODE, "Node & Security", "##stabN"}, + {TAB_EXPLORER, "Explorer", "##stabE"}, {TAB_CHAT, "Chat", "##stabC"}, + {TAB_ABOUT, "About", "##stabT"}, + }; + ImDrawList* dl = ImGui::GetWindowDrawList(); + ImFont* f = Type().body2(); + const float dp = Layout::dpiScale(); + const float padX = 13.0f * dp, padY = 7.0f * dp, gap = 6.0f * dp, rnd = 8.0f * dp; + const float h = f->LegacySize + padY * 2.0f; + const ImVec2 origin = ImGui::GetCursorScreenPos(); + float x = origin.x, y = origin.y; + for (const T& t : tabs) { + ImVec2 ts = f->CalcTextSizeA(f->LegacySize, FLT_MAX, 0, t.label); + float w = ts.x + padX * 2.0f; + if (x > origin.x && x + w > origin.x + availWidth) { x = origin.x; y += h + gap; } // wrap + ImGui::SetCursorScreenPos(ImVec2(x, y)); + if (ImGui::InvisibleButton(t.idstr, ImVec2(w, h))) s_settingsState.current_tab = t.id; + const bool hovered = ImGui::IsItemHovered(); + const bool active = (s_settingsState.current_tab == t.id); + if (active) dl->AddRectFilled(ImVec2(x, y), ImVec2(x + w, y + h), WithAlpha(Primary(), 34), rnd); + else if (hovered) dl->AddRectFilled(ImVec2(x, y), ImVec2(x + w, y + h), IM_COL32(255, 255, 255, 12), rnd); + dl->AddText(f, f->LegacySize, ImVec2(x + (w - ts.x) * 0.5f, y + (h - ts.y) * 0.5f), + ImGui::GetColorU32((active || hovered) ? OnSurface() : OnSurfaceMedium()), t.label); + x += w + gap; + } + const float bottom = y + h; + dl->AddLine(ImVec2(origin.x, bottom + 5.0f * dp), ImVec2(origin.x + availWidth, bottom + 5.0f * dp), + ImGui::GetColorU32(Divider()), 1.0f); + ImGui::SetCursorScreenPos(ImVec2(origin.x, bottom + 12.0f * dp)); +} + void RenderSettingsPage(App* app) { // Load settings state on first render if (!s_settingsState.initialized && app->settings()) { @@ -571,6 +646,9 @@ void RenderSettingsPage(App* app) { ImVec2 contentAvail = ImGui::GetContentRegionAvail(); float scrollbarMargin = ImGui::GetStyle().ScrollbarSize + Layout::spacingSm(); float availWidth = contentAvail.x - scrollbarMargin; + + // Settings fills the full content width (the global content-max-width cap is disabled). + float settingsLeftOffset = 0.0f; float hs = Layout::hScale(availWidth); float vs = Layout::vScale(contentAvail.y); float pad = Layout::cardInnerPadding(); @@ -596,10 +674,14 @@ void RenderSettingsPage(App* app) { } // Input field width — fill remaining space in card float inputW = std::max(S.drawElement("components.settings-page", "input-min-width").size, availWidth - labelW - pad * 2); + (void)inputW; // used by some sections; may be unused depending on active tab + + // Category tab bar — pinned above the scrollable content area (not part of the scroll). + renderSettingsTabBar(availWidth); // Scrollable content area — NoBackground matches other tabs - - ImGui::BeginChild("##SettingsPageScroll", ImVec2(0, 0), false, + if (settingsLeftOffset > 0.0f) ImGui::SetCursorPosX(ImGui::GetCursorPosX() + settingsLeftOffset); + ImGui::BeginChild("##SettingsPageScroll", ImVec2(settingsLeftOffset > 0.0f ? availWidth + scrollbarMargin : 0.0f, 0), false, ImGuiWindowFlags_NoBackground | ImGuiWindowFlags_NoScrollWithMouse); ApplySmoothScroll(); @@ -647,24 +729,17 @@ void RenderSettingsPage(App* app) { GlassPanelSpec glassSpec; glassSpec.rounding = glassRound; + glassSpec.fillAlpha = 26; // lift the settings cards off the background (closer to the mockup's flat cards) + glassSpec.borderAlpha = 50; // crisper, more defined card border (mockup uses a visible 1px line) ImFont* capFont = Type().caption(); ImFont* body2 = Type().body2(); ImFont* sub1 = Type().subtitle1(); // ==================================================================== - // THEME & LANGUAGE — card (draw-first approach; avoids ChannelsSplit - // which breaks BeginCombo popup rendering in some ImGui versions) + // APPEARANCE — two stacked cards: THEME & LANGUAGE (2x2 dropdown grid) + // then SCALE & EFFECTS (font scale + effect toggles + Advanced sliders). // ==================================================================== - { - Type().textColored(TypeStyle::Overline, OnSurfaceMedium(), TR("theme_language")); - ImGui::Dummy(ImVec2(0, Layout::spacingXs())); - - material::GlassCardScope card(dl, availWidth, pad, bottomPad, glassSpec); - - float contentW = availWidth - pad * 2; - float comboGap = S.drawElement("components.settings-page", "combo-row-gap").size; - float compactBP = S.drawElement("components.settings-page", "compact-breakpoint").size; - bool wideLayout = availWidth >= compactBP * dp; // scale the breakpoint so the 3-combo row drops to the stacked layout at high font scale (else the combos clip) + if (s_settingsState.current_tab == TAB_APPEARANCE) { float refreshBtnW = S.drawElement("components.settings-page", "refresh-btn-width").size; // --- Skin data --- @@ -679,6 +754,7 @@ void RenderSettingsPage(App* app) { break; } } + (void)active_is_custom; // --- Language data --- auto& i18n = util::I18n::instance(); @@ -696,7 +772,7 @@ void RenderSettingsPage(App* app) { if (l.id == s_settingsState.balance_layout) { balPreview = l.name; break; } } - // --- Theme combo popup (shared between wide and narrow paths) --- + // --- Theme combo popup (shared) --- auto renderThemeComboPopup = [&]() { ImGui::TextDisabled("%s", TR("settings_builtin")); ImGui::Separator(); @@ -750,112 +826,120 @@ void RenderSettingsPage(App* app) { } }; - if (wideLayout) { - // ============================================================ - // Wide: 3 combos on one row + compact 3-column effects grid - // ============================================================ + // ============================================================ + // Card 1 — THEME & LANGUAGE (2x2 grid of labeled dropdowns) + // ============================================================ + { + material::GlassCardScope card(dl, availWidth, pad, bottomPad, glassSpec); + Type().textColored(TypeStyle::Overline, OnSurfaceMedium(), TR("theme_language")); + ImGui::Dummy(ImVec2(0, Layout::spacingMd())); + float contentW = availWidth - pad * 2; + float cellGap = Layout::spacingLg(); + bool twoCol = contentW >= 460.0f * dp; // drop to a single column when too narrow (high font scale) + int cols = twoCol ? 2 : 1; + float colW = std::max(160.0f, twoCol ? (contentW - cellGap) * 0.5f : contentW); + float baseX = ImGui::GetCursorScreenPos().x; - // --- Combo row: Theme | Layout | Language [Refresh] --- - { - ImGui::PushFont(body2); - float lblGap = Layout::spacingXs(); - float lblThemeW = ImGui::CalcTextSize(TR("theme")).x + lblGap; - float lblLayoutW = ImGui::CalcTextSize(TR("balance_layout")).x + lblGap; - float lblLangW = ImGui::CalcTextSize(TR("language")).x + lblGap; - // Budget matches the RAW draws below (SameLine(0, comboGap) and ImVec2(refreshBtnW, 0)) — - // don't dpi-scale these terms or the budget over-reserves and the combos shrink needlessly. - float totalFixed = lblThemeW + lblLayoutW + lblLangW - + comboGap * 2 + Layout::spacingSm() + refreshBtnW; - float comboW = std::min(std::max(80.0f, (contentW - totalFixed) / 3.0f), 300.0f * dp); + const char* cellLabels[4] = { TR("theme"), TR("balance_layout"), TR("language"), TR("clock_format") }; + ImGui::PushFont(body2); + float lblW = 0.0f; // label column — mockup puts the label BESIDE the control (.row), not above + for (int i = 0; i < 4; ++i) lblW = std::max(lblW, ImGui::CalcTextSize(cellLabels[i]).x); + lblW += Layout::spacingMd(); + float rowTop = ImGui::GetCursorScreenPos().y; + float rowBottom = rowTop; + for (int i = 0; i < 4; ++i) { + int col = i % cols; + if (col == 0 && i > 0) rowTop = rowBottom; // start a new grid row + float cx = baseX + col * (colW + cellGap); + + // Field label on the left, control filling the rest of the cell (mockup .row layout). + ImGui::SetCursorScreenPos(ImVec2(cx, rowTop)); ImGui::AlignTextToFramePadding(); - ImGui::TextUnformatted(TR("theme")); - ImGui::SameLine(0, lblGap); - ImGui::SetNextItemWidth(comboW); - if (ImGui::BeginCombo("##Theme", active_preview.c_str())) { - renderThemeComboPopup(); - ImGui::EndCombo(); - } - if (ImGui::IsItemHovered()) - material::Tooltip("%s", TR("tt_theme_hotkey")); + ImGui::PushStyleColor(ImGuiCol_Text, ImGui::GetColorU32(OnSurfaceMedium())); + ImGui::TextUnformatted(cellLabels[i]); + ImGui::PopStyleColor(); + ImGui::SetCursorScreenPos(ImVec2(cx + lblW, rowTop)); + ImGui::SetNextItemWidth(colW - lblW); - ImGui::SameLine(0, comboGap); - ImGui::AlignTextToFramePadding(); - ImGui::TextUnformatted(TR("balance_layout")); - ImGui::SameLine(0, lblGap); - ImGui::SetNextItemWidth(comboW); - if (ImGui::BeginCombo("##BalanceLayout", balPreview.c_str())) { - for (const auto& l : layouts) { - if (!l.enabled) continue; - bool selected = (l.id == s_settingsState.balance_layout); - if (ImGui::Selectable(l.name.c_str(), selected)) { - s_settingsState.balance_layout = l.id; - if (app->settings()) { - app->settings()->setBalanceLayout(s_settingsState.balance_layout); - app->settings()->save(); + switch (i) { + case 0: // Theme + if (ImGui::BeginCombo("##Theme", active_preview.c_str())) { renderThemeComboPopup(); ImGui::EndCombo(); } + if (ImGui::IsItemHovered()) material::Tooltip("%s", TR("tt_theme_hotkey")); + break; + case 1: // Balance layout + if (ImGui::BeginCombo("##BalanceLayout", balPreview.c_str())) { + for (const auto& l : layouts) { + if (!l.enabled) continue; + bool selected = (l.id == s_settingsState.balance_layout); + if (ImGui::Selectable(l.name.c_str(), selected)) { + s_settingsState.balance_layout = l.id; + if (app->settings()) { app->settings()->setBalanceLayout(l.id); app->settings()->save(); } + } + if (selected) ImGui::SetItemDefaultFocus(); } + ImGui::EndCombo(); } - if (selected) ImGui::SetItemDefaultFocus(); - } - ImGui::EndCombo(); - } - if (ImGui::IsItemHovered()) - material::Tooltip("%s", TR("tt_layout_hotkey")); - - ImGui::SameLine(0, comboGap); - ImGui::AlignTextToFramePadding(); - ImGui::TextUnformatted(TR("language")); - ImGui::SameLine(0, lblGap); - ImGui::SetNextItemWidth(comboW); - if (ImGui::Combo("##Language", &s_settingsState.language_index, lang_names.data(), - static_cast(lang_names.size()))) { - auto it = languages.begin(); - std::advance(it, s_settingsState.language_index); - i18n.loadLanguage(it->first); - if (app->settings()) { - app->settings()->setLanguage(it->first); - app->settings()->save(); + if (ImGui::IsItemHovered()) material::Tooltip("%s", TR("tt_layout_hotkey")); + break; + case 2: // Language + if (ImGui::Combo("##Language", &s_settingsState.language_index, lang_names.data(), + static_cast(lang_names.size()))) { + auto it = languages.begin(); + std::advance(it, s_settingsState.language_index); + i18n.loadLanguage(it->first); + if (app->settings()) { app->settings()->setLanguage(it->first); app->settings()->save(); } + } + if (ImGui::IsItemHovered()) material::Tooltip("%s", TR("tt_language")); + break; + case 3: { // Clock format + int cf = app->settings() ? app->settings()->getTimeFormat() : 0; + const char* cfItems[] = { TR("chat_ts_24h"), TR("chat_ts_12h") }; + if (ImGui::Combo("##ClockFormat", &cf, cfItems, 2) && app->settings()) { + app->settings()->setTimeFormat(cf); + app->settings()->save(); + } + if (ImGui::IsItemHovered()) material::Tooltip("%s", TR("tt_clock_format")); + break; } } - if (ImGui::IsItemHovered()) material::Tooltip("%s", TR("tt_language")); - ImGui::SameLine(0, Layout::spacingSm()); - if (TactileButton(TR("refresh"), ImVec2(refreshBtnW, 0), S.resolveFont("button"))) { - schema::SkinManager::instance().refresh(); - Notifications::instance().info(TR("settings_theme_refreshed")); + float cellBottom = ImGui::GetCursorScreenPos().y; + rowBottom = (col == 0) ? cellBottom : std::max(rowBottom, cellBottom); + if (col == cols - 1 || i == 3) { + ImGui::SetCursorScreenPos(ImVec2(baseX, rowBottom + 11.0f * dp)); + rowBottom = ImGui::GetCursorScreenPos().y; } - if (ImGui::IsItemHovered()) { - material::Tooltip(TR("tt_scan_themes"), - schema::SkinManager::getUserSkinsDirectory().c_str()); - } - ImGui::PopFont(); } + ImGui::PopFont(); - ImGui::Dummy(ImVec2(0, Layout::spacingSm())); + // Rescan the theme folder — minor action, tucked below the grid. + ImGui::SetCursorScreenPos(ImVec2(baseX, rowBottom)); + if (TactileButton(TR("refresh"), ImVec2(refreshBtnW, 0), S.resolveFont("button"))) { + schema::SkinManager::instance().refresh(); + Notifications::instance().info(TR("settings_theme_refreshed")); + } + if (ImGui::IsItemHovered()) + material::Tooltip(TR("tt_scan_themes"), schema::SkinManager::getUserSkinsDirectory().c_str()); + } - // --- Clock format (app-wide 24h / 12h — the Chat tab can override it in chat settings) --- - { - ImGui::PushFont(body2); - ImGui::AlignTextToFramePadding(); - ImGui::TextUnformatted(TR("clock_format")); - ImGui::SameLine(0, Layout::spacingMd()); - int cf = app->settings() ? app->settings()->getTimeFormat() : 0; - const char* cfItems[] = { TR("chat_ts_24h"), TR("chat_ts_12h") }; - ImGui::SetNextItemWidth(160.0f * Layout::dpiScale()); - if (ImGui::Combo("##ClockFormat", &cf, cfItems, 2) && app->settings()) { - app->settings()->setTimeFormat(cf); - app->settings()->save(); - } - if (ImGui::IsItemHovered()) material::Tooltip("%s", TR("tt_clock_format")); - ImGui::PopFont(); - } - - ImGui::Dummy(ImVec2(0, Layout::spacingSm())); - - // --- Font Scale slider (always visible) --- + ImGui::Dummy(ImVec2(0, gap)); + + // ============================================================ + // Card 2 — SCALE & EFFECTS (font scale + effect toggles + Advanced sliders) + // ============================================================ + { + material::GlassCardScope card(dl, availWidth, pad, bottomPad, glassSpec); + Type().textColored(TypeStyle::Overline, OnSurfaceMedium(), TR("scale_effects")); + ImGui::Dummy(ImVec2(0, Layout::spacingMd())); + float contentW = availWidth - pad * 2; + + // --- Font Scale slider --- { ImGui::PushFont(body2); + ImGui::PushStyleColor(ImGuiCol_Text, ImGui::GetColorU32(OnSurfaceMedium())); ImGui::TextUnformatted(TR("font_scale")); + ImGui::PopStyleColor(); float fontSliderW = std::min(std::max(S.drawElement("components.settings-page", "effects-input-min-width").size, contentW), 360.0f * dp); ImGui::SetNextItemWidth(fontSliderW); s_settingsState.font_scale = Layout::userFontScale(); @@ -878,17 +962,11 @@ void RenderSettingsPage(App* app) { ImGui::PopFont(); } - ImGui::Dummy(ImVec2(0, Layout::spacingSm())); + ImGui::Dummy(ImVec2(0, Layout::spacingMd())); - // --- Collapsible: Advanced Effects... --- - material::CollapsibleHeader(dl, "##EffectsToggle", TR("advanced_effects"), - s_settingsState.effects_expanded, contentW, - body2, OnSurfaceMedium()); - - if (s_settingsState.effects_expanded) { + // --- Effect toggles (always visible, horizontal wrapping flow) --- + { ImGui::PushFont(body2); - - // Effects checkboxes — wrap to new rows instead of overflowing on narrow windows. const float efFh = ImGui::GetFrameHeight(); const float efInner = ImGui::GetStyle().ItemInnerSpacing.x; float efX = 0.0f; bool efFirst = true; @@ -898,6 +976,7 @@ void RenderSettingsPage(App* app) { else if (efX + Layout::spacingLg() + w <= contentW) { ImGui::SameLine(0, Layout::spacingLg()); efX += Layout::spacingLg() + w; } else { efX = w; } }; + efFlow(TR("low_spec_mode")); if (ImGui::Checkbox(TrId("low_spec_mode", "low_spec").c_str(), &s_settingsState.low_spec_mode)) { effects::setLowSpecMode(s_settingsState.low_spec_mode); @@ -950,7 +1029,25 @@ void RenderSettingsPage(App* app) { if (ImGui::IsItemHovered()) material::Tooltip("%s", TR("tt_animate_avatars")); } + ImGui::EndDisabled(); // low-spec + ImGui::PopFont(); + } + + ImGui::Dummy(ImVec2(0, Layout::spacingMd())); + + // --- Collapsible: Advanced Effects... (console colors + 2x2 opacity/blur sliders) --- + material::CollapsibleHeader(dl, "##EffectsToggle", TR("advanced_effects"), + s_settingsState.effects_expanded, contentW, + body2, OnSurfaceMedium()); + + if (s_settingsState.effects_expanded) { + ImGui::PushFont(body2); + + ImGui::BeginDisabled(s_settingsState.low_spec_mode); + // Console output color toggles (own row — no GPU cost, enabled even in low-spec). + // renderConsoleColorToggles() temporarily End/BeginDisabled()s so its own checkboxes + // stay enabled — it MUST be called while exactly one BeginDisabled is active. renderConsoleColorToggles(app); // Row 1: Acrylic preset slider + Noise slider (side by side, labels above) @@ -1032,494 +1129,304 @@ void RenderSettingsPage(App* app) { ImGui::SetCursorScreenPos(ImVec2(baseX, afterRow2Y)); - ImGui::EndDisabled(); // low-spec - ImGui::PopFont(); - } // s_settingsState.effects_expanded - } else { - // ============================================================ - // Narrow: stacked combos + 2-column effects (original layout) - // ============================================================ - - // --- Theme row --- - { - ImGui::PushFont(body2); - ImGui::AlignTextToFramePadding(); - ImGui::TextUnformatted(TR("theme")); - ImGui::SameLine(labelW); - - // Reserve the real gaps (default ItemSpacing, not spacingSm) plus the - // custom-skin "*" marker so the Refresh button never spills past the edge. - float themeComboW = std::max(S.drawElement("components.settings-page", "theme-combo-min-width").size, - availWidth - pad * 2 - labelW - refreshBtnW - ImGui::GetStyle().ItemSpacing.x - - (active_is_custom ? (ImGui::GetStyle().ItemSpacing.x + ImGui::CalcTextSize("*").x) : 0.0f)); - ImGui::SetNextItemWidth(themeComboW); - if (ImGui::BeginCombo("##Theme", active_preview.c_str())) { - renderThemeComboPopup(); - ImGui::EndCombo(); - } - if (ImGui::IsItemHovered()) - material::Tooltip("%s", TR("tt_theme_hotkey")); - if (active_is_custom) { - ImGui::SameLine(); - ImGui::TextColored(ImVec4(0.4f, 0.8f, 1.0f, 1.0f), "*"); - if (ImGui::IsItemHovered()) material::Tooltip("%s", TR("tt_custom_theme")); - } - ImGui::SameLine(); - if (TactileButton(TR("refresh"), ImVec2(refreshBtnW, 0), S.resolveFont("button"))) { - schema::SkinManager::instance().refresh(); - Notifications::instance().info(TR("settings_theme_refreshed")); - } - if (ImGui::IsItemHovered()) { - material::Tooltip(TR("tt_scan_themes"), - schema::SkinManager::getUserSkinsDirectory().c_str()); - } - ImGui::PopFont(); - } - - ImGui::Dummy(ImVec2(0, Layout::spacingXs())); - - // --- Balance Layout row --- - { - ImGui::PushFont(body2); - ImGui::AlignTextToFramePadding(); - ImGui::TextUnformatted(TR("balance_layout")); - ImGui::SameLine(labelW); - ImGui::SetNextItemWidth(std::max(180.0f, inputW)); - if (ImGui::BeginCombo("##BalanceLayout", balPreview.c_str())) { - for (const auto& l : layouts) { - if (!l.enabled) continue; - bool selected = (l.id == s_settingsState.balance_layout); - if (ImGui::Selectable(l.name.c_str(), selected)) { - s_settingsState.balance_layout = l.id; - if (app->settings()) { - app->settings()->setBalanceLayout(s_settingsState.balance_layout); - app->settings()->save(); - } - } - if (selected) ImGui::SetItemDefaultFocus(); - } - ImGui::EndCombo(); - } - if (ImGui::IsItemHovered()) - material::Tooltip("%s", TR("tt_layout_hotkey")); - ImGui::PopFont(); - } - - ImGui::Dummy(ImVec2(0, Layout::spacingXs())); - - // --- Language row --- - { - ImGui::PushFont(body2); - ImGui::AlignTextToFramePadding(); - ImGui::TextUnformatted(TR("language")); - ImGui::SameLine(labelW); - ImGui::SetNextItemWidth(inputW); - if (ImGui::Combo("##Language", &s_settingsState.language_index, lang_names.data(), - static_cast(lang_names.size()))) { - auto it = languages.begin(); - std::advance(it, s_settingsState.language_index); - i18n.loadLanguage(it->first); - if (app->settings()) { - app->settings()->setLanguage(it->first); - app->settings()->save(); - } - } - if (ImGui::IsItemHovered()) material::Tooltip("%s", TR("tt_language")); - ImGui::PopFont(); - } - - ImGui::Dummy(ImVec2(0, Layout::spacingSm())); - - // --- Clock format (app-wide 24h / 12h — the Chat tab can override it in chat settings) --- - { - ImGui::PushFont(body2); - ImGui::AlignTextToFramePadding(); - ImGui::TextUnformatted(TR("clock_format")); - ImGui::SameLine(0, Layout::spacingMd()); - int cf = app->settings() ? app->settings()->getTimeFormat() : 0; - const char* cfItems[] = { TR("chat_ts_24h"), TR("chat_ts_12h") }; - ImGui::SetNextItemWidth(160.0f * Layout::dpiScale()); - if (ImGui::Combo("##ClockFormat", &cf, cfItems, 2) && app->settings()) { - app->settings()->setTimeFormat(cf); - app->settings()->save(); - } - if (ImGui::IsItemHovered()) material::Tooltip("%s", TR("tt_clock_format")); - ImGui::PopFont(); - } - - ImGui::Dummy(ImVec2(0, Layout::spacingSm())); - - // --- Font Scale slider (always visible) --- - { - ImGui::PushFont(body2); - ImGui::TextUnformatted(TR("font_scale")); - float fontSliderW = std::min(std::max(S.drawElement("components.settings-page", "effects-input-min-width").size, - availWidth - pad * 2), 360.0f * dp); - ImGui::SetNextItemWidth(fontSliderW); - s_settingsState.font_scale = Layout::userFontScale(); - float prev_font_scale = s_settingsState.font_scale; - { - char fs_fmt[16]; - snprintf(fs_fmt, sizeof(fs_fmt), "%.2fx", s_settingsState.font_scale); - ImGui::SliderFloat("##FontScale", &s_settingsState.font_scale, 1.0f, 1.5f, fs_fmt, - ImGuiSliderFlags_AlwaysClamp); - } - s_settingsState.font_scale = std::max(1.0f, std::min(1.5f, - std::round(s_settingsState.font_scale * 20.0f) / 20.0f)); - if (s_settingsState.font_scale != prev_font_scale) - Layout::setUserFontScaleVisual(s_settingsState.font_scale); - if (ImGui::IsItemDeactivatedAfterEdit()) { - Layout::setUserFontScale(s_settingsState.font_scale); - saveSettingsPageState(app->settings()); - } - if (ImGui::IsItemHovered()) material::Tooltip("%s", TR("tt_font_scale")); - ImGui::PopFont(); - } - - ImGui::Dummy(ImVec2(0, Layout::spacingSm())); - - // --- Collapsible: Advanced Effects... --- - { - float narrowContentW = availWidth - pad * 2; - material::CollapsibleHeader(dl, "##EffectsToggleN", TR("advanced_effects"), - s_settingsState.effects_expanded, narrowContentW, - body2, OnSurfaceMedium()); - } - - if (s_settingsState.effects_expanded) { - ImGui::PushFont(body2); - - if (ImGui::Checkbox(TrId("low_spec_mode", "low_spec").c_str(), &s_settingsState.low_spec_mode)) { - effects::setLowSpecMode(s_settingsState.low_spec_mode); - if (s_settingsState.low_spec_mode) { - enterLowSpec(true); - } else if (s_settingsState.low_spec_snapshot.valid) { - exitLowSpec(true); - } - saveSettingsPageState(app->settings()); - } - if (ImGui::IsItemHovered()) material::Tooltip("%s", TR("tt_low_spec")); - - if (ImGui::Checkbox(TrId("settings_gradient_bg", "gradient_bg").c_str(), &s_settingsState.gradient_background)) { - schema::SkinManager::instance().setGradientMode(s_settingsState.gradient_background); - saveSettingsPageState(app->settings()); - } - if (ImGui::IsItemHovered()) material::Tooltip("%s", TR("tt_simple_bg_alt")); - - if (ImGui::Checkbox(TrId("reduce_motion", "reduce_motion").c_str(), &s_settingsState.reduce_motion)) { - saveSettingsPageState(app->settings()); - } - if (ImGui::IsItemHovered()) material::Tooltip("%s", TR("tt_reduce_motion")); - - ImGui::BeginDisabled(s_settingsState.low_spec_mode); - - if (ImGui::Checkbox(TrId("console_scanline", "scanline").c_str(), &s_settingsState.scanline_enabled)) { - ConsoleTab::s_scanline_enabled = s_settingsState.scanline_enabled; - app->settings()->setScanlineEnabled(s_settingsState.scanline_enabled); - app->settings()->save(); - } - if (ImGui::IsItemHovered()) material::Tooltip("%s", TR("tt_scanline")); - - ImGui::SameLine(0, Layout::spacingLg()); - if (ImGui::Checkbox(TrId("theme_effects", "theme_fx").c_str(), &s_settingsState.theme_effects_enabled)) { - effects::ThemeEffects::instance().setEnabled(s_settingsState.theme_effects_enabled); - saveSettingsPageState(app->settings()); - } - if (ImGui::IsItemHovered()) material::Tooltip("%s", TR("tt_theme_effects")); - - ImGui::SameLine(0, Layout::spacingLg()); - { - bool anim = app->settings()->getAnimateAvatars(); - if (ImGui::Checkbox(TrId("animate_avatars", "animate_avatars").c_str(), &anim)) { - app->settings()->setAnimateAvatars(anim); - app->settings()->save(); - } - if (ImGui::IsItemHovered()) material::Tooltip("%s", TR("tt_animate_avatars")); - } - - // Console output color toggles (own row — no GPU cost, enabled even in low-spec). - renderConsoleColorToggles(app); - - float ctrlW = std::max(S.drawElement("components.settings-page", "effects-input-min-width").size, - availWidth - pad * 2.0f); - ImGui::TextUnformatted(TR("acrylic")); - ImGui::SetNextItemWidth(ctrlW); - { - char blur_fmt[16]; - if (s_settingsState.blur_amount < 0.01f) - snprintf(blur_fmt, sizeof(blur_fmt), "%s", TR("slider_off")); - else - snprintf(blur_fmt, sizeof(blur_fmt), "%.0f%%%%", s_settingsState.blur_amount / kAcrylicMaxBlur * 100.0f); - if (ImGui::SliderFloat("##AcrylicBlur", &s_settingsState.blur_amount, 0.0f, kAcrylicMaxBlur, blur_fmt, - ImGuiSliderFlags_AlwaysClamp)) { - if (s_settingsState.blur_amount > 0.0f && s_settingsState.blur_amount < kAcrylicMaxBlur * 0.04f) s_settingsState.blur_amount = 0.0f; - s_settingsState.acrylic_enabled = (s_settingsState.blur_amount > 0.001f); - effects::ImGuiAcrylic::ApplyBlurAmount(s_settingsState.blur_amount); - } - } - if (ImGui::IsItemDeactivatedAfterEdit()) saveSettingsPageState(app->settings()); - if (ImGui::IsItemHovered()) material::Tooltip("%s", TR("tt_blur")); - - ImGui::TextUnformatted(TR("noise")); - ImGui::SetNextItemWidth(ctrlW); - { - char noise_fmt[16]; - if (s_settingsState.noise_opacity < 0.01f) - snprintf(noise_fmt, sizeof(noise_fmt), "%s", TR("slider_off")); - else - snprintf(noise_fmt, sizeof(noise_fmt), "%.0f%%%%", s_settingsState.noise_opacity * 100.0f); - if (ImGui::SliderFloat("##NoiseOpacity", &s_settingsState.noise_opacity, 0.0f, 1.0f, noise_fmt, - ImGuiSliderFlags_AlwaysClamp)) { - effects::ImGuiAcrylic::SetNoiseOpacity(s_settingsState.noise_opacity); - } - } - if (ImGui::IsItemDeactivatedAfterEdit()) saveSettingsPageState(app->settings()); - if (ImGui::IsItemHovered()) material::Tooltip("%s", TR("tt_noise")); - - ImGui::TextUnformatted(TR("ui_opacity")); - ImGui::SetNextItemWidth(ctrlW); - { - char uiop_fmt[16]; - snprintf(uiop_fmt, sizeof(uiop_fmt), "%.0f%%%%", s_settingsState.ui_opacity * 100.0f); - if (ImGui::SliderFloat("##UIOpacity", &s_settingsState.ui_opacity, 0.3f, 1.0f, uiop_fmt, - ImGuiSliderFlags_AlwaysClamp)) { - effects::ImGuiAcrylic::SetUIOpacity(s_settingsState.ui_opacity); - } - } - if (ImGui::IsItemDeactivatedAfterEdit()) saveSettingsPageState(app->settings()); - if (ImGui::IsItemHovered()) material::Tooltip("%s", TR("tt_ui_opacity")); - - ImGui::TextUnformatted(TR("window_opacity")); - ImGui::SetNextItemWidth(ctrlW); - { - char winop_fmt[16]; - snprintf(winop_fmt, sizeof(winop_fmt), "%.0f%%%%", s_settingsState.window_opacity * 100.0f); - if (ImGui::SliderFloat("##WindowOpacity", &s_settingsState.window_opacity, 0.3f, 1.0f, winop_fmt, - ImGuiSliderFlags_AlwaysClamp)) { - } - } - if (ImGui::IsItemDeactivatedAfterEdit()) saveSettingsPageState(app->settings()); - if (ImGui::IsItemHovered()) material::Tooltip("%s", TR("tt_window_opacity")); - ImGui::EndDisabled(); // low-spec ImGui::PopFont(); } // s_settingsState.effects_expanded } } - ImGui::Dummy(ImVec2(0, gap)); - // ==================================================================== // WALLET — card (privacy/daemon toggles + collapsible tools) // ==================================================================== - { - Type().textColored(TypeStyle::Overline, OnSurfaceMedium(), TR("wallet")); - ImGui::Dummy(ImVec2(0, Layout::spacingXs())); + if (s_settingsState.current_tab == TAB_WALLET) { + const bool showDaemonOptions = app->supportsFullNodeLifecycleActions(); - material::GlassCardScope card(dl, availWidth, pad, bottomPad, glassSpec); + // Two side-by-side glass cards: OPTIONS (toggles) | DIAGNOSTICS (log + tools). + const float ccGap = Layout::cardGap(); + const float ccW = (availWidth - ccGap) * 0.5f; + const float cw = ccW - pad * 2; + const float ccTop = ImGui::GetCursorScreenPos().y; + const float ccBaseX = ImGui::GetCursorScreenPos().x; + float ccBottom = ccTop; - float contentW = availWidth - pad * 2; + // One foreground channel for both cards; panels painted afterwards at equal (tallest) height. + float cardBot[2] = { ccTop, ccTop }; + dl->ChannelsSplit(2); + dl->ChannelsSetCurrent(1); + auto cardHeader = [&](int col, const char* header) -> float { + const float cx = ccBaseX + col * (ccW + ccGap); + ImGui::SetCursorScreenPos(ImVec2(cx + pad, ccTop + pad)); + Type().textColored(TypeStyle::Overline, OnSurfaceMedium(), header); + return ImGui::GetCursorScreenPos().y + Layout::spacingMd(); + }; + auto cardClose = [&](int col, float lastBottom) { + cardBot[col] = lastBottom + pad; + ccBottom = std::max(ccBottom, cardBot[col]); + }; - // Privacy, Network & Daemon checkboxes — wrap to new rows instead of shrinking the text. + ImGui::PushFont(body2); + const float fh = ImGui::GetFrameHeight(); // checkbox row height + const float bh = ImGui::GetFrameHeight() + 12.0f * dp; // taller, airier buttons (match mockup) + const float gp = Layout::spacingSm(); // roomier gap + + // ---- Card 0: OPTIONS (checkboxes in a 2-column grid — mockup .chks.two) ---- { - const bool showDaemonOptions = app->supportsFullNodeLifecycleActions(); - const float cbSpacing = Layout::spacingLg(); - const float fh = ImGui::GetFrameHeight(); - const float inner = ImGui::GetStyle().ItemInnerSpacing.x; - float cbX = 0.0f; bool cbFirst = true; - // Position the next checkbox: SameLine if it fits on the current row, else wrap. - auto cbFlow = [&](const char* label) { - const float w = fh + inner + ImGui::CalcTextSize(label).x; - if (cbFirst) { cbFirst = false; cbX = w; } - else if (cbX + cbSpacing + w <= contentW) { ImGui::SameLine(0, cbSpacing); cbX += cbSpacing + w; } - else { cbX = w; } + const float cx = ccBaseX + pad; + const float col2W = (cw - Layout::spacingLg()) * 0.5f; + float rowY = cardHeader(0, TR("wallet_options_hdr")); + int c = 0; float last = rowY; + auto CB = [&](const std::string& id, bool* val) -> bool { + ImGui::SetCursorScreenPos(ImVec2(cx + c * (col2W + Layout::spacingLg()), rowY)); + const bool changed = ImGui::Checkbox(id.c_str(), val); + last = rowY + fh; + if (c == 1) { rowY += fh + gp; c = 0; } else { c = 1; } + return changed; }; - cbFlow(TR("save_z_transactions")); - ImGui::Checkbox(TrId("save_z_transactions", "save_ztx").c_str(), &s_settingsState.save_ztxs); + CB(TrId("save_z_transactions", "save_ztx"), &s_settingsState.save_ztxs); if (ImGui::IsItemHovered()) material::Tooltip("%s", TR("tt_save_ztx")); - cbFlow(TR("auto_shield")); - ImGui::Checkbox(TrId("auto_shield", "auto_shld").c_str(), &s_settingsState.auto_shield); + CB(TrId("auto_shield", "auto_shld"), &s_settingsState.auto_shield); if (ImGui::IsItemHovered()) material::Tooltip("%s", TR("tt_auto_shield")); - cbFlow(TR("use_tor")); - ImGui::Checkbox(TrId("use_tor", "tor").c_str(), &s_settingsState.use_tor); + CB(TrId("use_tor", "tor"), &s_settingsState.use_tor); if (ImGui::IsItemHovered()) material::Tooltip("%s", TR("tt_tor")); if (showDaemonOptions) { - cbFlow(TR("keep_daemon")); - if (ImGui::Checkbox(TrId("keep_daemon", "keep_dmn").c_str(), &s_settingsState.keep_daemon_running)) + if (CB(TrId("keep_daemon", "keep_dmn"), &s_settingsState.keep_daemon_running)) saveSettingsPageState(app->settings()); if (ImGui::IsItemHovered()) material::Tooltip("%s", TR("tt_keep_daemon")); - cbFlow(TR("stop_external")); - if (ImGui::Checkbox(TrId("stop_external", "stop_ext").c_str(), &s_settingsState.stop_external_daemon)) + if (CB(TrId("stop_external", "stop_ext"), &s_settingsState.stop_external_daemon)) saveSettingsPageState(app->settings()); if (ImGui::IsItemHovered()) material::Tooltip("%s", TR("tt_stop_external")); } - cbFlow(TR("verbose_logging")); - if (ImGui::Checkbox(TrId("verbose_logging", "verbose").c_str(), &s_settingsState.verbose_logging)) { + if (CB(TrId("verbose_logging", "verbose"), &s_settingsState.verbose_logging)) { dragonx::util::Logger::instance().setVerbose(s_settingsState.verbose_logging); saveSettingsPageState(app->settings()); } if (ImGui::IsItemHovered()) material::Tooltip("%s", TR("tt_verbose")); + cardClose(0, last); } - // 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. + // ---- Card 1: DIAGNOSTICS + Tools & Actions (2-column button grids) ---- { - const float diagBtnW = (contentW - Layout::spacingMd()) * 0.5f; - if (TactileButton(TR("settings_open_log_folder"), ImVec2(diagBtnW, 0), S.resolveFont("button"))) + const float cx = ccBaseX + (ccW + ccGap) + pad; + const float col2W = (cw - Layout::spacingLg()) * 0.5f; + float rowY = cardHeader(1, TR("wallet_diagnostics_hdr")); + int c = 0; float last = rowY; + auto BTN = [&](const char* id, const char* label, const char* icon) -> bool { + const float bx = cx + c * (col2W + Layout::spacingLg()); + const bool p = renderCardButton(dl, bx, rowY, col2W, bh, id, label, icon); + last = rowY + bh; + if (c == 1) { rowY += bh + gp; c = 0; } else { c = 1; } + return p; + }; + auto rowBreak = [&]() { if (c == 1) { rowY += bh + gp; c = 0; } }; + + if (BTN("##wlog", TR("settings_open_log_folder"), ICON_MD_FOLDER)) 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"))) { + if (BTN("##wdiag", TR("settings_copy_diagnostics"), ICON_MD_CONTENT_COPY)) { 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")); - } + rowBreak(); - ImGui::Dummy(ImVec2(0, Layout::spacingSm())); + rowY += Layout::spacingSm(); + ImGui::SetCursorScreenPos(ImVec2(cx, rowY)); + Type().textColored(TypeStyle::Overline, OnSurfaceMedium(), TR("tools_actions_hdr")); + rowY = ImGui::GetCursorScreenPos().y + Layout::spacingMd(); + c = 0; - // --- Collapsible: Tools & Actions... --- - material::CollapsibleHeader(dl, "##ToolsToggle", TR("tools_actions"), - s_settingsState.tools_expanded, contentW, - body2, OnSurfaceMedium()); - - if (s_settingsState.tools_expanded) { - float btnSpacing = Layout::spacingMd(); - int btnsPerRow = (contentW >= 600.0f) ? 3 : 2; - float bw = (contentW - btnSpacing * (btnsPerRow - 1)) / btnsPerRow; - float minBtnW = S.drawElement("components.settings-page", "wallet-btn-min-width").sizeOr(100.0f); - bw = std::max(minBtnW, bw); - // Grow the column so the longest translated label (e.g. German) isn't clipped inside - // ImGui::Button. Measure every label with the actual button font (LegacySize is already - // DPI-scaled — don't scale it again) and add the button's own FramePadding on both sides; - // if that exceeds bw, drop to fewer columns rather than overflow the card width. - { - ImFont* toolsFont = S.resolveFont("button"); - if (!toolsFont) toolsFont = Type().button(); - const char* toolLabels[] = { - TR("settings_address_book"), TR("settings_validate_address"), - TR("settings_request_payment"), TR("settings_shield_mining"), - TR("settings_merge_to_address"), TR("settings_clear_ztx"), - }; - float widestLabel = 0.0f; - for (const char* lbl : toolLabels) - widestLabel = std::max(widestLabel, - toolsFont->CalcTextSizeA(toolsFont->LegacySize, FLT_MAX, 0, lbl).x); - const float needW = widestLabel + ImGui::GetStyle().FramePadding.x * 2.0f - + 8.0f * Layout::dpiScale(); - // Shed columns until the widest label fits (or we're down to a single column). - while (btnsPerRow > 1 && - ((contentW - btnSpacing * (btnsPerRow - 1)) / btnsPerRow) < needW) - --btnsPerRow; - bw = std::max({minBtnW, (contentW - btnSpacing * (btnsPerRow - 1)) / btnsPerRow, needW}); - } - - if (TactileButton(TR("settings_address_book"), ImVec2(bw, 0), S.resolveFont("button"))) - app->setCurrentPage(ui::NavPage::Contacts); // now a top-level tab + if (BTN("##waddr", TR("settings_address_book"), ICON_MD_CONTACTS)) + app->setCurrentPage(ui::NavPage::Contacts); if (ImGui::IsItemHovered()) material::Tooltip("%s", TR("tt_address_book")); - ImGui::SameLine(0, btnSpacing); - if (TactileButton(TR("settings_validate_address"), ImVec2(bw, 0), S.resolveFont("button"))) + if (BTN("##wval", TR("settings_validate_address"), ICON_MD_CHECK_CIRCLE)) ValidateAddressDialog::show(); if (ImGui::IsItemHovered()) material::Tooltip("%s", TR("tt_validate")); - if (btnsPerRow >= 3) { ImGui::SameLine(0, btnSpacing); } else { ImGui::Dummy(ImVec2(0, Layout::spacingXs())); } - if (TactileButton(TR("settings_request_payment"), ImVec2(bw, 0), S.resolveFont("button"))) + if (BTN("##wreq", TR("settings_request_payment"), ICON_MD_QR_CODE)) RequestPaymentDialog::show(); if (ImGui::IsItemHovered()) material::Tooltip("%s", TR("tt_request_payment")); - if (btnsPerRow >= 3) { ImGui::Dummy(ImVec2(0, Layout::spacingXs())); } else { ImGui::SameLine(0, btnSpacing); } - if (TactileButton(TR("settings_shield_mining"), ImVec2(bw, 0), S.resolveFont("button"))) + if (BTN("##wshield", TR("settings_shield_mining"), ICON_MD_SHIELD)) ShieldDialog::show(ShieldDialog::Mode::ShieldCoinbase); if (ImGui::IsItemHovered()) material::Tooltip("%s", TR("tt_shield_mining")); - if (btnsPerRow >= 3) { ImGui::SameLine(0, btnSpacing); } else { ImGui::Dummy(ImVec2(0, Layout::spacingXs())); } - if (TactileButton(TR("settings_merge_to_address"), ImVec2(bw, 0), S.resolveFont("button"))) + if (BTN("##wmerge", TR("settings_merge_to_address"), ICON_MD_CALL_MERGE)) ShieldDialog::show(ShieldDialog::Mode::MergeToAddress); if (ImGui::IsItemHovered()) material::Tooltip("%s", TR("tt_merge")); - ImGui::SameLine(0, btnSpacing); - if (TactileButton(TR("settings_clear_ztx"), ImVec2(bw, 0), S.resolveFont("button"))) { + if (BTN("##wclear", TR("settings_clear_ztx"), ICON_MD_DELETE_SWEEP)) s_settingsState.confirm_clear_ztx = true; - } if (ImGui::IsItemHovered()) material::Tooltip("%s", TR("tt_clear_ztx")); + rowBreak(); + cardClose(1, last); } - // --- Backup & Data --- - ImGui::Dummy(ImVec2(0, Layout::spacingMd())); - Type().textColored(TypeStyle::Overline, OnSurfaceMedium(), TR("backup_data")); - ImGui::Dummy(ImVec2(0, Layout::spacingXs())); + // Paint both cards at the same (tallest) height, then merge the channels. { - using AT = material::ActionTier; - const bool fullNode = app->supportsFullNodeLifecycleActions(); - // Tier-ordered, icon-labelled buttons that WRAP to new rows (no more font-scale-to-fit). - // Emphasized actions (accent) cluster on top, then common actions, then low-emphasis exports. - auto btn = [&](material::ButtonFlow& fl, const char* id, const char* label, const char* icon, - AT tier, const char* tip) -> bool { - fl.next(material::ActionButtonWidth(label, icon)); - const bool p = material::ActionButton(id, label, icon, tier); - if (ImGui::IsItemHovered() && tip && tip[0]) material::Tooltip("%s", tip); - return p; - }; - - // Emphasized (Primary): import key + (full-node) seed / wallets / bootstrap. - material::ButtonFlow fPrim(contentW); - if (btn(fPrim, "##imp_key", TR("settings_import_key"), ICON_MD_KEY, AT::Primary, TR("tt_import_key"))) - app->showImportKeyDialog(); - if (fullNode) { - if (btn(fPrim, "##seed", TR("seed_backup_button"), ICON_MD_VPN_KEY, AT::Primary, TR("tt_seed_backup"))) - app->showSeedBackupDialog(); - if (btn(fPrim, "##wallets", TR("wallets_button"), ICON_MD_ACCOUNT_BALANCE_WALLET, AT::Primary, TR("tt_wallets_button"))) - ui::WalletsDialog::show(app); - if (btn(fPrim, "##bootstrap", TR("download_bootstrap"), ICON_MD_CLOUD_DOWNLOAD, AT::Primary, TR("tt_download_bootstrap"))) - BootstrapDownloadDialog::show(app); + const float eq = std::max(cardBot[0], cardBot[1]); + dl->ChannelsSetCurrent(0); + for (int col = 0; col < 2; ++col) { + const float cx = ccBaseX + col * (ccW + ccGap); + material::DrawGlassPanel(dl, ImVec2(cx, ccTop), ImVec2(cx + ccW, eq), glassSpec); } + dl->ChannelsMerge(); + } - // Common (Secondary): viewing-key import, backup, (full-node) migrate + setup wizard. - ImGui::Dummy(ImVec2(0, Layout::spacingXs())); - material::ButtonFlow fSec(contentW); - if (btn(fSec, "##imp_vk", TR("settings_import_viewkey"), ICON_MD_VISIBILITY, AT::Secondary, TR("tt_import_viewkey"))) - app->showImportViewingKeyDialog(); - if (btn(fSec, "##backup", TR("settings_backup"), ICON_MD_BACKUP, AT::Secondary, TR("tt_backup"))) - app->showBackupDialog(); + ImGui::PopFont(); + // Reserve the full multi-card footprint with a Dummy so the scroll region grows to include + // the manually-positioned cards (a bare SetCursorScreenPos past content warns in ImGui). + ImGui::SetCursorScreenPos(ImVec2(ccBaseX, ccTop)); + ImGui::Dummy(ImVec2(availWidth, (ccBottom - ccTop) + Layout::spacingSm())); + } + + // ==================================================================== + // BACKUP & DATA — card (own category tab; split out of Wallet) + // ==================================================================== + if (s_settingsState.current_tab == TAB_BACKUP) { + const bool fullNode = app->supportsFullNodeLifecycleActions(); + + // Three side-by-side glass cards, each with its header inside (mockup-style grouping). + // Content is positioned manually (SetCursorScreenPos) because ImGui's Indent — which + // GlassCardScope relies on — is window-relative and would pull offset columns back to x0. + const float ccGap = Layout::cardGap(); + const int ccN = 3; + const float ccW = (availWidth - ccGap * (ccN - 1)) / (float)ccN; + const float cw = ccW - pad * 2; + const float ccTop = ImGui::GetCursorScreenPos().y; + const float ccBaseX = ImGui::GetCursorScreenPos().x; + float ccBottom = ccTop; + + ImGui::PushFont(body2); + const float bh = ImGui::GetFrameHeight() + 12.0f * dp; // taller, airier buttons (match mockup) + const float bgp = Layout::spacingSm(); // roomier gap between buttons + + // A full-card-width, left-aligned, solid button drawn at an explicit (x,y). + auto cardBtn = [&](float x, float y, float w, const char* id, const char* label, const char* icon) -> bool { + return renderCardButton(dl, x, y, w, bh, id, label, icon); + }; + // All cards render onto one foreground channel; the glass panels are painted afterwards at a + // single equal height (the tallest card) so side-by-side cards match — mockup grid-stretch look. + float cardBot[3] = { ccTop, ccTop, ccTop }; + dl->ChannelsSplit(2); + dl->ChannelsSetCurrent(1); + auto cardHeader = [&](int col, const char* header) -> float { + const float cx = ccBaseX + col * (ccW + ccGap); + float cy = ccTop + pad; + ImGui::SetCursorScreenPos(ImVec2(cx + pad, cy)); + Type().textColored(TypeStyle::Overline, OnSurfaceMedium(), header); + return ImGui::GetCursorScreenPos().y + Layout::spacingMd(); + }; + auto cardClose = [&](int col, float lastBottom) { + cardBot[col] = lastBottom + pad; + ccBottom = std::max(ccBottom, cardBot[col]); + }; + + // ---- Card 0: Import & Restore ---- + { + const float cx = ccBaseX + pad; + float cy = cardHeader(0, TR("backup_col_import")); + float last = cy; + if (cardBtn(cx, cy, cw, "##imp_key", TR("settings_import_key"), ICON_MD_KEY)) app->showImportKeyDialog(); + if (ImGui::IsItemHovered()) material::Tooltip("%s", TR("tt_import_key")); + last = cy + bh; cy += bh + bgp; + if (cardBtn(cx, cy, cw, "##imp_vk", TR("settings_import_viewkey"), ICON_MD_VISIBILITY)) app->showImportViewingKeyDialog(); + if (ImGui::IsItemHovered()) material::Tooltip("%s", TR("tt_import_viewkey")); + last = cy + bh; if (fullNode) { + cy += bh + bgp; + if (cardBtn(cx, cy, cw, "##wallets", TR("wallets_button"), ICON_MD_ACCOUNT_BALANCE_WALLET)) ui::WalletsDialog::show(app); + if (ImGui::IsItemHovered()) material::Tooltip("%s", TR("tt_wallets_button")); + last = cy + bh; cy += bh + bgp; + if (cardBtn(cx, cy, cw, "##bootstrap", TR("download_bootstrap"), ICON_MD_CLOUD_DOWNLOAD)) BootstrapDownloadDialog::show(app); + if (ImGui::IsItemHovered()) material::Tooltip("%s", TR("tt_download_bootstrap")); + last = cy + bh; + } + cardClose(0, last); + } + + // ---- Card 1: Backup ---- + { + const float cx = ccBaseX + (ccW + ccGap) + pad; + float cy = cardHeader(1, TR("backup_col_backup")); + float last = cy; + if (fullNode) { + if (cardBtn(cx, cy, cw, "##seed", TR("seed_backup_button"), ICON_MD_VPN_KEY)) app->showSeedBackupDialog(); + if (ImGui::IsItemHovered()) material::Tooltip("%s", TR("tt_seed_backup")); + last = cy + bh; cy += bh + bgp; + } + if (cardBtn(cx, cy, cw, "##backup", TR("settings_backup"), ICON_MD_BACKUP)) app->showBackupDialog(); + if (ImGui::IsItemHovered()) material::Tooltip("%s", TR("tt_backup")); + last = cy + bh; + if (fullNode) { + cy += bh + bgp; const bool migrateGlow = app->isPreSeedWallet(); - if (btn(fSec, "##migrate", TR("seed_migrate_button"), ICON_MD_SWAP_HORIZ, AT::Secondary, TR("tt_seed_migrate"))) - app->showSeedMigrationDialog(); - if (migrateGlow) { // pulsing accent halo nudging a legacy wallet to migrate + if (cardBtn(cx, cy, cw, "##migrate", TR("seed_migrate_button"), ICON_MD_SWAP_HORIZ)) app->showSeedMigrationDialog(); + if (ImGui::IsItemHovered()) material::Tooltip("%s", TR("tt_seed_migrate")); + if (migrateGlow) { const ImVec2 gmn = ImGui::GetItemRectMin(), gmx = ImGui::GetItemRectMax(); const float gdp = Layout::dpiScale(); const float pulse = 0.5f + 0.5f * std::sin((float)ImGui::GetTime() * 3.2f); - ImDrawList* gdl = ImGui::GetWindowDrawList(); for (int g = 3; g >= 1; --g) { const float e = (float)g * 2.2f * gdp; const int a = (int)((70.0f + pulse * 95.0f) / (float)g); - gdl->AddRect(ImVec2(gmn.x - e, gmn.y - e), ImVec2(gmx.x + e, gmx.y + e), - material::WithAlpha(material::Primary(), a), 6.0f * gdp + e, 0, 1.6f * gdp); + dl->AddRect(ImVec2(gmn.x - e, gmn.y - e), ImVec2(gmx.x + e, gmx.y + e), + material::WithAlpha(material::Primary(), a), 6.0f * gdp + e, 0, 1.6f * gdp); } } - if (btn(fSec, "##wizard", TR("setup_wizard"), ICON_MD_AUTO_FIX_HIGH, AT::Secondary, TR("tt_wizard"))) - app->restartWizard(); + last = cy + bh; cy += bh + bgp; + if (cardBtn(cx, cy, cw, "##wizard", TR("setup_wizard"), ICON_MD_AUTO_FIX_HIGH)) app->restartWizard(); + if (ImGui::IsItemHovered()) material::Tooltip("%s", TR("tt_wizard")); + last = cy + bh; } - - // Low-emphasis (Tertiary): exports. - ImGui::Dummy(ImVec2(0, Layout::spacingXs())); - material::ButtonFlow fTer(contentW); - if (btn(fTer, "##exp_key", TR("settings_export_key"), ICON_MD_LOGOUT, AT::Tertiary, TR("tt_export_key"))) - app->showExportKeyDialog(); - if (btn(fTer, "##exp_all", TR("settings_export_all"), ICON_MD_ARCHIVE, AT::Tertiary, TR("tt_export_all"))) - ExportAllKeysDialog::show(); - if (btn(fTer, "##exp_csv", TR("settings_export_csv"), ICON_MD_DESCRIPTION, AT::Tertiary, TR("tt_export_csv"))) - ExportTransactionsDialog::show(); + cardClose(1, last); } + + // ---- Card 2: Export ---- + { + const float cx = ccBaseX + (ccW + ccGap) * 2.0f + pad; + float cy = cardHeader(2, TR("backup_col_export")); + float last = cy; + if (cardBtn(cx, cy, cw, "##exp_key", TR("settings_export_key"), ICON_MD_LOGOUT)) app->showExportKeyDialog(); + if (ImGui::IsItemHovered()) material::Tooltip("%s", TR("tt_export_key")); + last = cy + bh; cy += bh + bgp; + if (cardBtn(cx, cy, cw, "##exp_all", TR("settings_export_all"), ICON_MD_ARCHIVE)) ExportAllKeysDialog::show(); + if (ImGui::IsItemHovered()) material::Tooltip("%s", TR("tt_export_all")); + last = cy + bh; cy += bh + bgp; + if (cardBtn(cx, cy, cw, "##exp_csv", TR("settings_export_csv"), ICON_MD_DESCRIPTION)) ExportTransactionsDialog::show(); + if (ImGui::IsItemHovered()) material::Tooltip("%s", TR("tt_export_csv")); + last = cy + bh; + cardClose(2, last); + } + + // Paint all three cards at the same (tallest) height, then merge the channels. + { + const float eq = std::max({cardBot[0], cardBot[1], cardBot[2]}); + dl->ChannelsSetCurrent(0); + for (int col = 0; col < 3; ++col) { + const float cx = ccBaseX + col * (ccW + ccGap); + material::DrawGlassPanel(dl, ImVec2(cx, ccTop), ImVec2(cx + ccW, eq), glassSpec); + } + dl->ChannelsMerge(); + } + + ImGui::PopFont(); + // Reserve the full multi-card footprint with a Dummy so the scroll region grows to include + // the manually-positioned cards (a bare SetCursorScreenPos past content warns in ImGui). + ImGui::SetCursorScreenPos(ImVec2(ccBaseX, ccTop)); + ImGui::Dummy(ImVec2(availWidth, (ccBottom - ccTop) + Layout::spacingSm())); } - ImGui::Dummy(ImVec2(0, gap)); - - // ==================================================================== // NODE & SECURITY — card // ==================================================================== - { - Type().textColored(TypeStyle::Overline, OnSurfaceMedium(), TR("node_security")); - ImGui::Dummy(ImVec2(0, Layout::spacingXs())); - - material::GlassCardScope card(dl, availWidth, pad, bottomPad, glassSpec); + if (s_settingsState.current_tab == TAB_NODE) { + // Two side-by-side glass cards (NODE/SECURITY | DAEMON BINARY), drawn manually because + // GlassCardScope's Indent is window-relative and can't offset the right card. All the + // column *content* below is unchanged; only the card wrapper differs. + const float ndTop = ImGui::GetCursorScreenPos().y; + const float ndBaseX = ImGui::GetCursorScreenPos().x; + bool ndTwoCol = false; + float ndColW = 0.0f, ndColGap = 0.0f, ndLeftBottom = 0.0f, ndRightBottom = 0.0f, ndSingleBottom = ndTop; + dl->ChannelsSplit(2); + dl->ChannelsSetCurrent(1); + ImGui::SetCursorScreenPos(ImVec2(ndBaseX, ndTop + pad)); + ImGui::Indent(pad); float contentW = availWidth - pad * 2; float minBtnW = S.drawElement("components.settings-page", "wallet-btn-min-width").sizeOr(130.0f); @@ -1617,25 +1524,20 @@ void RenderSettingsPage(App* app) { for (int i = 0; i < 6; i++) { if (timeoutValues[i] == timeout) { selTimeout = i; break; } } - // In a narrow (two-column) card the encrypt controls + auto-lock + PIN don't fit on - // one row, so wrap the auto-lock/PIN group onto its own row at the section's left edge. - const bool secWrap = includeRpcEncrypt && secNarrow; - if (includeRpcEncrypt && !secWrap) { - ImGui::SameLine(0, Layout::spacingLg()); - } else { - if (includeRpcEncrypt) ImGui::Dummy(ImVec2(0, Layout::spacingXs())); - ImGui::SetCursorScreenPos(ImVec2(secX, ImGui::GetCursorScreenPos().y)); - } + // Auto-lock gets its own full-width row (label left, dropdown filling — mockup). + (void)secNarrow; + if (includeRpcEncrypt) ImGui::Dummy(ImVec2(0, Layout::spacingSm())); + ImGui::SetCursorScreenPos(ImVec2(secX, ImGui::GetCursorScreenPos().y)); ImGui::AlignTextToFramePadding(); Type().textColored(TypeStyle::Caption, OnSurfaceMedium(), TR("settings_auto_lock")); - ImGui::SameLine(0, Layout::spacingXs()); - ImGui::PushItemWidth(comboW); + const float alLblW = ImGui::CalcTextSize(TR("settings_auto_lock")).x; + ImGui::SameLine(0, Layout::spacingMd()); + ImGui::SetNextItemWidth(std::max(comboW, secColW - alLblW - Layout::spacingMd())); if (ImGui::Combo("##autolock", &selTimeout, timeoutLabels, 6)) { app->settings()->setAutoLockTimeout(timeoutValues[selTimeout]); app->settings()->save(); } if (ImGui::IsItemHovered()) material::Tooltip("%s", TR("tt_auto_lock")); - ImGui::PopItemWidth(); // PIN unlock controls, trailing the auto-lock combo on the same row. bool isEncryptedPIN = app->state().isEncrypted(); @@ -1643,7 +1545,8 @@ void RenderSettingsPage(App* app) { bool hasPIN = app->hasPinVault(); float pinBtnW = std::min(rowBtnW({TR("settings_set_pin"), TR("settings_change_pin"), TR("settings_remove_pin")}), (secColW - Layout::spacingSm()) * 0.5f); - ImGui::SameLine(0, Layout::spacingMd()); + ImGui::Dummy(ImVec2(0, Layout::spacingXs())); + ImGui::SetCursorScreenPos(ImVec2(secX, ImGui::GetCursorScreenPos().y)); if (!hasPIN) { if (TactileButton(TR("settings_set_pin"), ImVec2(pinBtnW, 0), S.resolveFont("button"))) app->showPinSetupDialog(); @@ -1666,7 +1569,8 @@ void RenderSettingsPage(App* app) { ImGui::TextColored(ImVec4(0.3f,1.0f,0.5f,1.0f), "%s", TR("settings_pin_active")); } } else { - ImGui::SameLine(0, Layout::spacingMd()); + ImGui::Dummy(ImVec2(0, Layout::spacingSm())); + ImGui::SetCursorScreenPos(ImVec2(secX, ImGui::GetCursorScreenPos().y)); ImGui::AlignTextToFramePadding(); ImGui::TextColored(ImVec4(1,1,1,0.3f), "%s", TR("settings_encrypt_first_pin")); } @@ -2069,6 +1973,7 @@ void RenderSettingsPage(App* app) { // Advance to the true bottom of the single column. ImGui::SetCursorScreenPos(ImVec2(sectionOrigin.x, ImGui::GetCursorScreenPos().y)); + ndSingleBottom = ImGui::GetCursorScreenPos().y; // lite = single card } else { // ========================= FULL NODE ========================= @@ -2080,9 +1985,14 @@ void RenderSettingsPage(App* app) { // Two-column layout when wide enough: Node / RPC / Security on the left, Daemon binary on // the right (fills the empty right side + shortens the card). One column when narrow. const bool nsHasDaemon = app->supportsFullNodeLifecycleActions(); - const float nsColGap = Layout::spacingXl(); const bool nsTwoCol = nsHasDaemon && contentW > 760.0f * Layout::dpiScale(); - const float nsColW = nsTwoCol ? (contentW - nsColGap) * 0.5f : contentW; + // The two columns become two SEPARATE glass panels: left [x0, x0+cardW], + // right [x0+cardW+cardGap, x0+availWidth]. For the panels to keep a clean cardGap + // between them, the content column must be cardW-2*pad and the right-column indent + // (nsColW+nsColGap) must equal cardW+cardGap — so nsColGap = cardGap + 2*pad. + const float nsColGap = Layout::cardGap() + 2.0f * pad; + const float nsColW = nsTwoCol ? ((availWidth - Layout::cardGap()) * 0.5f - 2.0f * pad) : contentW; + ndTwoCol = nsTwoCol; ndColW = nsColW; ndColGap = nsColGap; // hoist geometry for the two-panel draw const ImVec2 nsColTop = ImGui::GetCursorScreenPos(); // Window-local anchor for the right column. We shift it with Indent() (not a one-shot // SetCursorScreenPos): ImGui resets the cursor X to the window's left indent on every @@ -2095,7 +2005,7 @@ void RenderSettingsPage(App* app) { // -------------------- NODE / DATA -------------------- Type().textColored(TypeStyle::Overline, OnSurfaceMedium(), TR("node")); - ImGui::Dummy(ImVec2(0, Layout::spacingXs())); + ImGui::Dummy(ImVec2(0, Layout::spacingSm())); { const std::string dirPath = util::Platform::getDragonXDataDir(); const std::string walletPath = dirPath + "wallet.dat"; @@ -2108,24 +2018,21 @@ void RenderSettingsPage(App* app) { + Layout::spacingLg(); const ImU32 metaCol = OnSurfaceMedium(); - // Row 1: Data directory — a clickable link (opens the folder) + a copy button. + // Row 1: Data directory — label left; clickable path + copy button RIGHT-aligned + // (mockup .kv space-between ledger look). The path middle-ellipsizes to fit. ImGui::AlignTextToFramePadding(); ImGui::PushStyleColor(ImGuiCol_Text, metaCol); ImGui::TextUnformatted(TR("settings_data_dir")); ImGui::PopStyleColor(); - ImGui::SameLine(0, 0); - ImGui::SetCursorPosX(leftX + labelW); - ImGui::AlignTextToFramePadding(); - // 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 float copyW = ImGui::GetFrameHeight(); + const float pathAvailW = contentW - labelW - copyW - Layout::spacingSm() * 2.0f; const std::string dirShown = material::TruncateToWidth(dirPath, pathFont, pathFont->LegacySize, pathAvailW); + const float pathW = ImGui::CalcTextSize(dirShown.c_str()).x; + ImGui::SameLine(0, 0); + ImGui::SetCursorPosX(leftX + contentW - copyW - Layout::spacingSm() - pathW); + ImGui::AlignTextToFramePadding(); ImGui::TextColored(ImGui::ColorConvertU32ToFloat4(Primary()), "%s", dirShown.c_str()); if (ImGui::IsItemHovered()) { const ImVec2 tmn = ImGui::GetItemRectMin(), tmx = ImGui::GetItemRectMax(); @@ -2144,16 +2051,20 @@ void RenderSettingsPage(App* app) { ImGui::SetClipboardText(dirPath.c_str()); } - // Row 2: Wallet size. + // Row 2: Wallet size — label left, value RIGHT-aligned. ImGui::AlignTextToFramePadding(); ImGui::PushStyleColor(ImGuiCol_Text, metaCol); ImGui::TextUnformatted(TR("settings_wallet_size_label")); ImGui::PopStyleColor(); - ImGui::SameLine(0, 0); - ImGui::SetCursorPosX(leftX + labelW); - ImGui::AlignTextToFramePadding(); - if (wallet_size > 0) ImGui::TextUnformatted(size_str.c_str()); - else ImGui::TextDisabled("%s", TR("settings_not_found")); + { + const char* wv = (wallet_size > 0) ? size_str.c_str() : TR("settings_not_found"); + const float wvW = ImGui::CalcTextSize(wv).x; + ImGui::SameLine(0, 0); + ImGui::SetCursorPosX(leftX + contentW - wvW); + ImGui::AlignTextToFramePadding(); + if (wallet_size > 0) ImGui::TextUnformatted(wv); + else ImGui::TextDisabled("%s", wv); + } // Row 3: folder buttons (their own row so the path gets the full width). ImGui::Dummy(ImVec2(0, Layout::spacingXs())); @@ -2198,55 +2109,41 @@ void RenderSettingsPage(App* app) { const char* portLbl = TR("rpc_port"); const char* userLbl = TR("rpc_user"); const char* passLbl = TR("rpc_pass"); - float labelsW = ImGui::CalcTextSize(hostLbl).x + ImGui::CalcTextSize(portLbl).x + - ImGui::CalcTextSize(userLbl).x + ImGui::CalcTextSize(passLbl).x; + // Two rows, two column-aligned cells each: Host | Port, then Username | Password. + // Each input fills to its column's right edge so the two columns line up vertically. + const float colGap = spMd; + const float colW = std::floor((contentW - colGap) * 0.5f); + const float startX = ImGui::GetCursorPosX(); + const float leftColRight = startX + colW; + const float rightColRight = startX + contentW; - const bool fourAcross = contentW >= 700.0f; - auto field = [&](const char* label, const char* id, char* buf, size_t bufSz, - float inputW, bool password) { + // Read-only: the RPC credentials are auto-detected from the daemon's DRAGONX.conf, + // so these fields DISPLAY the live connection (editing them here did nothing). + auto cell = [&](const char* label, const char* id, char* buf, size_t bufSz, + float cellX, float cellRight, bool password) { + ImGui::SetCursorPosX(cellX); ImGui::AlignTextToFramePadding(); ImGui::TextUnformatted(label); ImGui::SameLine(0, Layout::spacingXs()); - ImGui::SetNextItemWidth(inputW); - // Read-only: the RPC credentials are auto-detected from the daemon's DRAGONX.conf, - // so these fields DISPLAY the live connection (editing them here did nothing). + ImGui::SetNextItemWidth(std::max(60.0f, cellRight - ImGui::GetCursorPosX())); ImGui::InputText(id, buf, bufSz, ImGuiInputTextFlags_ReadOnly | (password ? ImGuiInputTextFlags_Password : 0)); }; - if (fourAcross) { - // fieldW = (contentW - labels - per-field label gaps - 3 inter-field gaps) / 4 - float inputTotal = contentW - labelsW - Layout::spacingXs() * 4 - spMd * 3; - float inputW = std::min(std::max(60.0f, std::floor(inputTotal / 4.0f)), 220.0f * dp); - field(hostLbl, "##RPCHost", s_settingsState.rpc_host, sizeof(s_settingsState.rpc_host), inputW, false); - if (ImGui::IsItemHovered()) material::Tooltip("%s", TR("tt_rpc_host")); - ImGui::SameLine(0, spMd); - field(portLbl, "##RPCPort", s_settingsState.rpc_port, sizeof(s_settingsState.rpc_port), inputW, false); - if (ImGui::IsItemHovered()) material::Tooltip("%s", TR("tt_rpc_port")); - ImGui::SameLine(0, spMd); - field(userLbl, "##RPCUser", s_settingsState.rpc_user, sizeof(s_settingsState.rpc_user), inputW, false); - if (ImGui::IsItemHovered()) material::Tooltip("%s", TR("tt_rpc_user")); - ImGui::SameLine(0, spMd); - field(passLbl, "##RPCPassword", s_settingsState.rpc_password, sizeof(s_settingsState.rpc_password), inputW, true); - if (ImGui::IsItemHovered()) material::Tooltip("%s", TR("tt_rpc_pass")); - } else { - // 2x2: two fields per row. - float halfLabelsW = ImGui::CalcTextSize(hostLbl).x + ImGui::CalcTextSize(userLbl).x; - float inputW = std::max(60.0f, std::floor( - (contentW - halfLabelsW - Layout::spacingXs() * 2 - spMd) / 2.0f)); - field(hostLbl, "##RPCHost", s_settingsState.rpc_host, sizeof(s_settingsState.rpc_host), inputW, false); - if (ImGui::IsItemHovered()) material::Tooltip("%s", TR("tt_rpc_host")); - ImGui::SameLine(0, spMd); - field(userLbl, "##RPCUser", s_settingsState.rpc_user, sizeof(s_settingsState.rpc_user), inputW, false); - if (ImGui::IsItemHovered()) material::Tooltip("%s", TR("tt_rpc_user")); + // Row 1: Host | Port + cell(hostLbl, "##RPCHost", s_settingsState.rpc_host, sizeof(s_settingsState.rpc_host), startX, leftColRight, false); + if (ImGui::IsItemHovered()) material::Tooltip("%s", TR("tt_rpc_host")); + ImGui::SameLine(); + cell(portLbl, "##RPCPort", s_settingsState.rpc_port, sizeof(s_settingsState.rpc_port), leftColRight + colGap, rightColRight, false); + if (ImGui::IsItemHovered()) material::Tooltip("%s", TR("tt_rpc_port")); - field(portLbl, "##RPCPort", s_settingsState.rpc_port, sizeof(s_settingsState.rpc_port), inputW, false); - if (ImGui::IsItemHovered()) material::Tooltip("%s", TR("tt_rpc_port")); - ImGui::SameLine(0, spMd); - field(passLbl, "##RPCPassword", s_settingsState.rpc_password, sizeof(s_settingsState.rpc_password), inputW, true); - if (ImGui::IsItemHovered()) material::Tooltip("%s", TR("tt_rpc_pass")); - } + // Row 2: Username | Password + cell(userLbl, "##RPCUser", s_settingsState.rpc_user, sizeof(s_settingsState.rpc_user), startX, leftColRight, false); + if (ImGui::IsItemHovered()) material::Tooltip("%s", TR("tt_rpc_user")); + ImGui::SameLine(); + cell(passLbl, "##RPCPassword", s_settingsState.rpc_password, sizeof(s_settingsState.rpc_password), leftColRight + colGap, rightColRight, true); + if (ImGui::IsItemHovered()) material::Tooltip("%s", TR("tt_rpc_pass")); Type().textColored(TypeStyle::Caption, OnSurfaceDisabled(), TR("settings_auto_detected")); if (s_settingsState.rpc_plaintext_remote) { @@ -2265,6 +2162,7 @@ void RenderSettingsPage(App* app) { renderSecuritySection(sectionOrigin.x, contentW, /*includeRpcEncrypt=*/true); } // ---- end left column ---- const float nsLeftBottom = ImGui::GetCursorScreenPos().y; + ndLeftBottom = nsLeftBottom; if (nsTwoCol) { // Reset to the top, then indent so every line in the right column starts at the // column X (the indent persists across line-advances; the explicit SetCursorPosX @@ -2300,11 +2198,33 @@ void RenderSettingsPage(App* app) { return std::string(buf); }; - ImGui::Dummy(ImVec2(0, Layout::spacingLg())); - Type().textColored(TypeStyle::Overline, OnSurfaceMedium(), TR("daemon_binary")); - ImGui::Dummy(ImVec2(0, Layout::spacingXs())); + ImGui::Dummy(ImVec2(0, Layout::spacingSm())); + // Heading row: "DAEMON BINARY" on the left, a compact colored status right-aligned + // on the same line (moved up out of the status box, and shortened). + { + const ImVec2 hp = ImGui::GetCursorScreenPos(); + Type().textColored(TypeStyle::Overline, OnSurfaceMedium(), TR("daemon_binary")); + if (bun.available) { + const bool sameSize = inst.exists && inst.size == bun.size; + const char* stTxt = !inst.exists ? TR("daemon_status_none") + : sameSize ? TR("daemon_status_ok") + : TR("daemon_status_diff"); + const ImU32 stCol = (inst.exists && sameSize) ? Success() : Warning(); + ImFont* ov = Type().overline(); + const float stW = ov->CalcTextSizeA(ov->LegacySize, FLT_MAX, 0, stTxt).x; + dl->AddText(ov, ov->LegacySize, ImVec2(hp.x + contentW - stW, hp.y), stCol, stTxt); + } + } + ImGui::Dummy(ImVec2(0, Layout::spacingSm())); - // Version info (Installed / Bundled) as key/value rows, then a status chip. + const float ddp = Layout::dpiScale(); + + // --- Status, grouped in a filled box (mockup .statusbox) --- + const float boxPad = Layout::spacingMd(); // roomier inner padding (mockup ~9-11px) + const float boxLeftX = ImGui::GetCursorScreenPos().x; + ImGui::Dummy(ImVec2(0, boxPad)); + ImGui::BeginGroup(); + ImGui::Indent(boxPad); const float dLeftX = ImGui::GetCursorPosX(); const float dLabelW = std::max(ImGui::CalcTextSize(TR("daemon_installed")).x, ImGui::CalcTextSize(TR("daemon_bundled")).x) + Layout::spacingLg(); @@ -2314,7 +2234,10 @@ void RenderSettingsPage(App* app) { ImGui::TextUnformatted(label); ImGui::PopStyleColor(); ImGui::SameLine(0, 0); - ImGui::SetCursorPosX(dLeftX + dLabelW); + // Right-align the value to the box edge (mockup .kv). If it's too long to fit + // (e.g. the installed version+size+date), fall back to left-packing after the label. + const float dvW = ImGui::CalcTextSize(value.c_str()).x; + ImGui::SetCursorPosX(std::max(dLeftX + dLabelW, dLeftX + (contentW - 2.0f * boxPad) - dvW)); ImGui::AlignTextToFramePadding(); if (dim) ImGui::TextDisabled("%s", value.c_str()); else ImGui::TextUnformatted(value.c_str()); @@ -2338,30 +2261,25 @@ void RenderSettingsPage(App* app) { } else { dkv(TR("daemon_bundled"), TR("daemon_none_bundled"), true); } - if (bun.available) { - const bool sameSize = inst.exists && inst.size == bun.size; - const char* chipTxt = !inst.exists ? TR("daemon_status_missing") - : sameSize ? TR("daemon_status_match") - : TR("daemon_status_differ"); - const ImU32 chipCol = sameSize ? Success() : Warning(); - ImGui::Dummy(ImVec2(0, Layout::spacingXs())); - const float dp = Layout::dpiScale(); - const ImVec2 cp = ImGui::GetCursorScreenPos(); - const float chpad = 8.0f * dp, chh = ImGui::GetFrameHeight(); - const ImVec2 cts = ImGui::CalcTextSize(chipTxt); - const float chw = cts.x + chpad * 2.0f; - dl->AddRectFilled(cp, ImVec2(cp.x + chw, cp.y + chh), material::WithAlpha(chipCol, 38), chh * 0.4f); - dl->AddRect(cp, ImVec2(cp.x + chw, cp.y + chh), material::WithAlpha(chipCol, 120), chh * 0.4f, 0, 1.0f); - dl->AddText(ImVec2(cp.x + chpad, cp.y + (chh - cts.y) * 0.5f), chipCol, chipTxt); - ImGui::Dummy(ImVec2(chw, chh)); + ImGui::Unindent(boxPad); + ImGui::EndGroup(); + { + const ImVec2 gmn = ImGui::GetItemRectMin(), gmx = ImGui::GetItemRectMax(); + const ImVec2 bmn(boxLeftX, gmn.y - boxPad), bmx(boxLeftX + contentW, gmx.y + boxPad); + // Subtle lifted fill (mockup .statusbox #26262a on the #121317 card) + near-invisible border. + dl->AddRectFilled(bmn, bmx, material::WithAlpha(material::OnSurface(), 8), 8.0f * ddp); + dl->AddRect(bmn, bmx, material::WithAlpha(material::OnSurface(), 20), 8.0f * ddp, 0, 1.0f); } + ImGui::Dummy(ImVec2(0, boxPad)); // Refresh the cached daemon info once an in-app install has completed. if (ui::DaemonUpdateDialog::consumeInstalled()) s_settingsState.daemon_info_loaded = false; - // Update actions: Check for updates (primary) | Refresh | Install bundled. - ImGui::Dummy(ImVec2(0, Layout::spacingXs())); + // --- UPDATES --- + ImGui::Dummy(ImVec2(0, Layout::spacingSm())); + Type().textColored(TypeStyle::Overline, OnSurfaceMedium(), TR("daemon_updates_label")); + ImGui::Dummy(ImVec2(0, Layout::spacingSm())); { using AT = material::ActionTier; material::ButtonFlow uf(contentW); @@ -2381,7 +2299,9 @@ void RenderSettingsPage(App* app) { ImGui::EndDisabled(); } - // Maintenance actions: Test / Rescan / Repair | Delete blockchain (destructive). + // --- MAINTENANCE --- + ImGui::Dummy(ImVec2(0, Layout::spacingSm())); + Type().textColored(TypeStyle::Overline, OnSurfaceMedium(), TR("daemon_maintenance_label")); ImGui::Dummy(ImVec2(0, Layout::spacingSm())); { using AT = material::ActionTier; @@ -2418,7 +2338,23 @@ void RenderSettingsPage(App* app) { if (material::ActionButton("##drepair", TR("repair_wallet"), ICON_MD_HEALING, AT::Secondary)) s_settingsState.confirm_repair_wallet = true; if (ImGui::IsItemHovered(ImGuiHoveredFlags_AllowWhenDisabled)) material::Tooltip("%s", TR("tt_repair_wallet")); - mf.next(material::ActionButtonWidth(TR("delete_blockchain"), ICON_MD_DELETE)); + ImGui::EndDisabled(); + } + + // --- Danger zone: Delete Blockchain, fenced off below a divider --- + ImGui::Dummy(ImVec2(0, Layout::spacingMd())); // mockup .danger margin-top: 8px + { + const ImVec2 dvp = ImGui::GetCursorScreenPos(); + // Neutral hairline (mockup .danger border-top #26262b) — not an alarming red rule. + dl->AddLine(dvp, ImVec2(dvp.x + contentW, dvp.y), + material::WithAlpha(material::OnSurface(), 22), 1.0f); + } + ImGui::Dummy(ImVec2(0, Layout::spacingMd())); // mockup .danger padding-top: 11px + { + using AT = material::ActionTier; + material::ButtonFlow df(contentW); + ImGui::BeginDisabled(!app->isUsingEmbeddedDaemon()); + df.next(material::ActionButtonWidth(TR("delete_blockchain"), ICON_MD_DELETE)); if (material::ActionButton("##ddelete", TR("delete_blockchain"), ICON_MD_DELETE, AT::Destructive)) s_settingsState.confirm_delete_blockchain = true; if (ImGui::IsItemHovered(ImGuiHoveredFlags_AllowWhenDisabled)) material::Tooltip("%s", TR("tt_delete_blockchain")); @@ -2427,239 +2363,265 @@ void RenderSettingsPage(App* app) { } } // ---- end right column ---- const float nsRightBottom = ImGui::GetCursorScreenPos().y; + ndRightBottom = nsRightBottom; ndSingleBottom = nsRightBottom; if (nsTwoCol) ImGui::Unindent(nsColW + nsColGap); // restore indent before the rest of the page ImGui::SetCursorScreenPos(ImVec2(nsColTop.x, nsTwoCol ? std::max(nsLeftBottom, nsRightBottom) : nsRightBottom)); ImGui::PopFont(); } + + // ---- Draw the glass card(s) behind the content, then merge the channels ---- + ImGui::Unindent(pad); + dl->ChannelsSetCurrent(0); + if (ndTwoCol) { + const float ndEq = std::max(ndLeftBottom, ndRightBottom); // equal-height cards (mockup grid stretch) + material::DrawGlassPanel(dl, ImVec2(ndBaseX, ndTop), + ImVec2(ndBaseX + 2.0f * pad + ndColW, ndEq + bottomPad), glassSpec); + material::DrawGlassPanel(dl, ImVec2(ndBaseX + ndColW + ndColGap, ndTop), + ImVec2(ndBaseX + availWidth, ndEq + bottomPad), glassSpec); + } else { + material::DrawGlassPanel(dl, ImVec2(ndBaseX, ndTop), + ImVec2(ndBaseX + availWidth, ndSingleBottom + bottomPad), glassSpec); + } + dl->ChannelsMerge(); + const float ndBot = ndTwoCol ? std::max(ndLeftBottom, ndRightBottom) : ndSingleBottom; + ImGui::SetCursorScreenPos(ImVec2(ndBaseX, ndBot + bottomPad)); } } - ImGui::Dummy(ImVec2(0, gap)); - // ==================================================================== // EXPLORER & OPTIONS — full-width card // ==================================================================== - { - Type().textColored(TypeStyle::Overline, OnSurfaceMedium(), TR("explorer_section")); - ImGui::Dummy(ImVec2(0, Layout::spacingXs())); + if (s_settingsState.current_tab == TAB_EXPLORER) { + // Card 1 — URLS + { + material::GlassCardScope card(dl, availWidth, pad, bottomPad, glassSpec); + float contentW = availWidth - pad * 2; + Type().textColored(TypeStyle::Overline, OnSurfaceMedium(), TR("explorer_urls_hdr")); + ImGui::Dummy(ImVec2(0, Layout::spacingMd())); + ImGui::PushFont(body2); - material::GlassCardScope card(dl, availWidth, pad, bottomPad, glassSpec); + // Transaction URL and Address URL — stacked rows, label left, input filling the card (mockup .row). + const float urlLblW = std::max(ImGui::CalcTextSize(TR("transaction_url")).x, + ImGui::CalcTextSize(TR("address_url")).x) + Layout::spacingMd(); + const float urlRowX = ImGui::GetCursorPosX(); + const float urlInputW = contentW - urlLblW; - float contentW = availWidth - pad * 2; - ImGui::PushFont(body2); + ImGui::AlignTextToFramePadding(); + ImGui::TextUnformatted(TR("transaction_url")); + ImGui::SameLine(urlRowX + urlLblW); + ImGui::SetNextItemWidth(urlInputW); + ImGui::InputText("##TxExplorer", s_settingsState.tx_explorer, sizeof(s_settingsState.tx_explorer)); + if (ImGui::IsItemHovered()) material::Tooltip("%s", TR("tt_tx_url")); - // Row 1: Transaction URL | Address URL (side-by-side) - float halfW = (contentW - Layout::spacingLg()) * 0.5f; - float lblTxW = ImGui::CalcTextSize("Transaction URL").x + Layout::spacingXs(); - float lblAddrW = ImGui::CalcTextSize("Address URL").x + Layout::spacingXs(); - float inputTxW = std::min(std::max(80.0f, halfW - lblTxW), 460.0f * dp); - float inputAddrW = std::min(std::max(80.0f, halfW - lblAddrW), 460.0f * dp); + ImGui::Dummy(ImVec2(0, Layout::spacingSm())); - // Row start X (indent-inclusive) — the Address column is placed relative - // to it, not to a fixed `pad`, so it lands correctly in the right column. - const float expRowX = ImGui::GetCursorPosX(); - ImGui::AlignTextToFramePadding(); - ImGui::TextUnformatted(TR("transaction_url")); - ImGui::SameLine(0, Layout::spacingXs()); - ImGui::SetNextItemWidth(inputTxW); - ImGui::InputText("##TxExplorer", s_settingsState.tx_explorer, sizeof(s_settingsState.tx_explorer)); - if (ImGui::IsItemHovered()) material::Tooltip("%s", TR("tt_tx_url")); - ImGui::SameLine(expRowX + halfW + Layout::spacingLg()); - ImGui::AlignTextToFramePadding(); - ImGui::TextUnformatted(TR("address_url")); - ImGui::SameLine(0, Layout::spacingXs()); - ImGui::SetNextItemWidth(inputAddrW); - ImGui::InputText("##AddrExplorer", s_settingsState.addr_explorer, sizeof(s_settingsState.addr_explorer)); - if (ImGui::IsItemHovered()) material::Tooltip("%s", TR("tt_addr_url")); + ImGui::AlignTextToFramePadding(); + ImGui::TextUnformatted(TR("address_url")); + ImGui::SameLine(urlRowX + urlLblW); + ImGui::SetNextItemWidth(urlInputW); + ImGui::InputText("##AddrExplorer", s_settingsState.addr_explorer, sizeof(s_settingsState.addr_explorer)); + if (ImGui::IsItemHovered()) material::Tooltip("%s", TR("tt_addr_url")); - ImGui::PopFont(); - ImGui::Dummy(ImVec2(0, Layout::spacingXs())); - - // Row 2: Checkboxes + Block Explorer button. Keep the two checkboxes - // side-by-side, but wrap the Block Explorer button onto its own row when - // it won't fit the (narrow, two-column) card — measured, so it's locale-safe. - const float expRowRight = ImGui::GetCursorScreenPos().x + contentW; - ImGui::Checkbox(TrId("custom_fees", "custom_fees").c_str(), &s_settingsState.allow_custom_fees); - if (ImGui::IsItemHovered()) material::Tooltip("%s", TR("tt_custom_fees")); - ImGui::SameLine(0, Layout::spacingLg()); - ImGui::Checkbox(TrId("fetch_prices", "fetch_prices").c_str(), &s_settingsState.fetch_prices); - if (ImGui::IsItemHovered()) material::Tooltip("%s", TR("tt_fetch_prices")); - const float expBtnW = ImGui::CalcTextSize(TR("block_explorer")).x - + ImGui::GetStyle().FramePadding.x * 2.0f + Layout::spacingLg(); - if (ImGui::GetItemRectMax().x + expBtnW <= expRowRight) - ImGui::SameLine(0, Layout::spacingLg()); - else - ImGui::Dummy(ImVec2(0, Layout::spacingXs())); - if (TactileButton(TR("block_explorer"), ImVec2(0, 0), S.resolveFont("button"))) { - util::Platform::openUrl("https://explorer.dragonx.is"); + ImGui::PopFont(); } - if (ImGui::IsItemHovered()) material::Tooltip("%s", TR("tt_block_explorer")); - } - ImGui::Dummy(ImVec2(0, gap)); + ImGui::Dummy(ImVec2(0, gap)); + + // Card 2 — OPTIONS + { + material::GlassCardScope card(dl, availWidth, pad, bottomPad, glassSpec); + float contentW = availWidth - pad * 2; + Type().textColored(TypeStyle::Overline, OnSurfaceMedium(), TR("wallet_options_hdr")); + ImGui::Dummy(ImVec2(0, Layout::spacingMd())); + ImGui::PushFont(body2); + + // Checkboxes + Block Explorer button (button wraps to its own row when it won't fit). + const float expRowRight = ImGui::GetCursorScreenPos().x + contentW; + ImGui::Checkbox(TrId("custom_fees", "custom_fees").c_str(), &s_settingsState.allow_custom_fees); + if (ImGui::IsItemHovered()) material::Tooltip("%s", TR("tt_custom_fees")); + ImGui::SameLine(0, Layout::spacingLg()); + ImGui::Checkbox(TrId("fetch_prices", "fetch_prices").c_str(), &s_settingsState.fetch_prices); + if (ImGui::IsItemHovered()) material::Tooltip("%s", TR("tt_fetch_prices")); + const float expBtnW = ImGui::CalcTextSize(TR("block_explorer")).x + + ImGui::GetStyle().FramePadding.x * 2.0f + Layout::spacingLg(); + if (ImGui::GetItemRectMax().x + expBtnW <= expRowRight) + ImGui::SameLine(0, Layout::spacingLg()); + else + ImGui::Dummy(ImVec2(0, Layout::spacingSm())); + if (TactileButton(TR("block_explorer"), ImVec2(0, 0), S.resolveFont("button"))) { + util::Platform::openUrl("https://explorer.dragonx.is"); + } + if (ImGui::IsItemHovered()) material::Tooltip("%s", TR("tt_block_explorer")); + + ImGui::PopFont(); + } + } // ==================================================================== // CHAT & CONTACTS — card (same controls as the Chat tab's settings notch) // ==================================================================== - { - Type().textColored(TypeStyle::Overline, OnSurfaceMedium(), TR("chat_settings_section")); - ImGui::Dummy(ImVec2(0, Layout::spacingXs())); - - material::GlassCardScope card(dl, availWidth, pad, bottomPad, glassSpec); + if (s_settingsState.current_tab == TAB_CHAT) { + // The shared control paints its own two cards (Appearance | Messaging) when drawCards=true. ImGui::PushFont(body2); - RenderChatSettingsControls(app, availWidth - pad * 2.0f); // card inner width (GlassCard doesn't narrow it) + RenderChatSettingsControls(app, availWidth, /*drawCards=*/true); ImGui::PopFont(); } - ImGui::Dummy(ImVec2(0, gap)); - // ==================================================================== // ABOUT — card // ==================================================================== - { - Type().textColored(TypeStyle::Overline, OnSurfaceMedium(), TR("about")); - ImGui::Dummy(ImVec2(0, Layout::spacingXs())); + if (s_settingsState.current_tab == TAB_ABOUT) { + material::GlassCardScope card(dl, availWidth, pad, bottomPad, glassSpec); + const float contentW = availWidth - pad * 2; + const float adp = Layout::dpiScale(); + const float baseX = ImGui::GetCursorScreenPos().x; - ImVec2 cardMin = ImGui::GetCursorScreenPos(); - dl->ChannelsSplit(2); - dl->ChannelsSetCurrent(1); - ImGui::SetCursorScreenPos(ImVec2(cardMin.x, cardMin.y + pad)); - ImGui::Indent(pad); - - // Logo on the left side of the about card. Deferred: reserve horizontal space - // now, but draw the image after the card's final height is known so it scales to - // the full card height (no empty space below it). + // --- Header: small logo + title / tagline / tech line --- + const ImVec2 logoTop = ImGui::GetCursorScreenPos(); + const float logoSz = 60.0f * adp; ImTextureID logoTex = app->getLogoTexture(); - float logoAreaW = 0; - ImVec2 logoPos = ImGui::GetCursorScreenPos(); - float logoAspect = (app->getLogoHeight() > 0) + const float logoAspect = (app->getLogoHeight() > 0) ? (float)app->getLogoWidth() / (float)app->getLogoHeight() : 1.0f; - float logoReserveH = schema::UI().drawElement("components.settings-page", "about-logo-size").sizeOr(150.0f) * dp; - if (logoTex != 0) { - logoAreaW = logoReserveH * logoAspect + Layout::spacingLg(); - ImGui::Indent(logoAreaW); - } + float logoAreaW = 0.0f; + if (logoTex != 0) { logoAreaW = logoSz + Layout::spacingLg(); ImGui::Indent(logoAreaW); } - float contentW = availWidth - pad * 2 - logoAreaW; - - // App name + version on same line ImGui::PushFont(sub1); ImGui::TextUnformatted(DRAGONX_APP_NAME); ImGui::PopFont(); - ImGui::SameLine(0, Layout::spacingLg()); + ImGui::SameLine(0, Layout::spacingSm()); ImGui::PushFont(body2); snprintf(buf, sizeof(buf), "v%s", DRAGONX_VERSION); - ImGui::TextUnformatted(buf); - ImGui::SameLine(0, Layout::spacingLg()); - snprintf(buf, sizeof(buf), "ImGui %s", IMGUI_VERSION); - ImGui::TextColored(ImVec4(1,1,1,0.4f), "%s", buf); + ImGui::TextColored(ImVec4(1, 1, 1, 0.5f), "%s", buf); ImGui::PopFont(); - // Daemon version - { - const auto& st = app->state(); - if (st.daemon_version > 0) { - int dmaj = st.daemon_version / 1000000; - int dmin = (st.daemon_version / 10000) % 100; - int dpat = (st.daemon_version / 100) % 100; - ImGui::PushFont(body2); - snprintf(buf, sizeof(buf), "%s: %d.%d.%d", TR("daemon_version"), dmaj, dmin, dpat); - ImGui::TextColored(ImVec4(1,1,1,0.5f), "%s", buf); - ImGui::PopFont(); - } - } - - ImGui::Dummy(ImVec2(0, Layout::spacingSm())); - ImGui::PushFont(body2); - ImGui::PushTextWrapPos(cardMin.x + availWidth - pad - logoAreaW); + ImGui::PushStyleColor(ImGuiCol_Text, ImGui::GetColorU32(OnSurfaceMedium())); + ImGui::PushTextWrapPos(ImGui::GetCursorPosX() + (contentW - logoAreaW)); ImGui::TextUnformatted(TR("settings_about_text")); ImGui::PopTextWrapPos(); + ImGui::PopStyleColor(); ImGui::PopFont(); - ImGui::Dummy(ImVec2(0, Layout::spacingSm())); - ImGui::PushFont(capFont); - ImGui::TextColored(ImVec4(1,1,1,0.5f), "%s", TR("settings_copyright")); + snprintf(buf, sizeof(buf), "SDL3 \xC2\xB7 Dear ImGui %s \xC2\xB7 GPL-3.0", IMGUI_VERSION); + ImGui::TextColored(ImVec4(1, 1, 1, 0.4f), "%s", buf); ImGui::PopFont(); + if (logoTex != 0) ImGui::Unindent(logoAreaW); + + // Make the header at least as tall as the logo, then draw the logo centered in it. + float headerH = ImGui::GetCursorScreenPos().y - logoTop.y; + if (headerH < logoSz) { ImGui::Dummy(ImVec2(0, logoSz - headerH)); headerH = logoSz; } + if (logoTex != 0) { + float lw = logoSz, lh = logoSz; + if (logoAspect >= 1.0f) lh = logoSz / logoAspect; else lw = logoSz * logoAspect; + const float lx = logoTop.x + (logoSz - lw) * 0.5f; + const float ly = logoTop.y + (headerH - lh) * 0.5f; + dl->AddImage(logoTex, ImVec2(lx, ly), ImVec2(lx + lw, ly + lh)); + } + + // --- Divider --- + ImGui::Dummy(ImVec2(0, Layout::spacingMd())); + { + const ImVec2 dv = ImGui::GetCursorScreenPos(); + dl->AddLine(dv, ImVec2(dv.x + contentW, dv.y), ImGui::GetColorU32(material::Divider()), 1.0f); + } ImGui::Dummy(ImVec2(0, Layout::spacingMd())); - // Top of the (full-width) buttons row — the deferred logo is clamped to end above - // this Y so the tall left-column logo never overlaps the buttons. - float aboutButtonsTopY = ImGui::GetCursorScreenPos().y; + // --- Two columns: Credits (bullets) | License (paragraph + links) --- + const float colGap = Layout::spacingLg(); + const float colW = (contentW - colGap) * 0.5f; + const float colTop = ImGui::GetCursorScreenPos().y; + const float rx = baseX + colW + colGap; - // Buttons — consistent equal-width row (full card width) - if (logoAreaW > 0) { - ImGui::Unindent(logoAreaW); - } + // Left column — Credits + ImGui::SetCursorScreenPos(ImVec2(baseX, colTop)); + Type().textColored(TypeStyle::Overline, OnSurfaceMedium(), TR("about_credits")); + ImGui::Dummy(ImVec2(0, Layout::spacingSm())); { - float fullContentW = availWidth - pad * 2; - // 2x2 grid in the narrow (two-column) card so labels don't clip; - // one 1x4 row at full width. - const bool aboutGrid = fullContentW < 720.0f * Layout::dpiScale(); - float aboutBtnW = aboutGrid ? (fullContentW - Layout::spacingMd()) / 2.0f - : (fullContentW - Layout::spacingMd() * 3) / 4.0f; + ImGui::PushFont(body2); + static const char* kCredits[] = { + "The Hush Developers", + "ObsidianDragon Community", + "Dear ImGui \xE2\x80\x94 Omar Cornut", + "SDL3 \xE2\x80\x94 Sam Lantinga", + "HushChat \xC2\xB7 librustzcash \xC2\xB7 libsodium", + }; + for (size_t i = 0; i < std::size(kCredits); ++i) { + const char* c = kCredits[i]; + const ImVec2 p = ImGui::GetCursorScreenPos(); + const float r = 2.5f * adp; + dl->AddCircleFilled(ImVec2(p.x + r, p.y + ImGui::GetTextLineHeight() * 0.5f), r, + material::WithAlpha(material::Primary(), 210)); + ImGui::SetCursorScreenPos(ImVec2(p.x + r * 2.0f + 8.0f * adp, p.y)); + ImGui::TextUnformatted(c); + if (i < std::size(kCredits) - 1) ImGui::Dummy(ImVec2(0, Layout::spacingSm())); + } + ImGui::PopFont(); + } + const float leftBottom = ImGui::GetCursorScreenPos().y; - if (TactileButton(TrId("website", "about_website").c_str(), ImVec2(aboutBtnW, 0), S.resolveFont("button"))) { + // Right column — License + links + ImGui::SetCursorScreenPos(ImVec2(rx, colTop)); + Type().textColored(TypeStyle::Overline, OnSurfaceMedium(), TR("about_license")); + { + ImGui::SetCursorScreenPos(ImVec2(rx, ImGui::GetCursorScreenPos().y + Layout::spacingSm())); + ImGui::PushFont(capFont); + ImGui::PushStyleColor(ImGuiCol_Text, ImVec4(1, 1, 1, 0.6f)); + ImGui::PushTextWrapPos(ImGui::GetCursorPosX() + colW); + ImGui::TextUnformatted(TR("about_license_text")); + ImGui::PopTextWrapPos(); + ImGui::PopStyleColor(); + ImGui::PopFont(); + } + ImGui::Dummy(ImVec2(0, Layout::spacingLg())); + { + using AT = material::ActionTier; + ImGui::SetCursorScreenPos(ImVec2(rx, ImGui::GetCursorScreenPos().y)); + material::ButtonFlow lf(colW); + lf.next(material::ActionButtonWidth(TR("website"), ICON_MD_PUBLIC)); + if (material::ActionButton("##aboutweb", TR("website"), ICON_MD_PUBLIC, AT::Secondary)) util::Platform::openUrl("https://dragonx.is"); - } if (ImGui::IsItemHovered()) material::Tooltip("%s", TR("tt_website")); - ImGui::SameLine(0, Layout::spacingMd()); - if (TactileButton(TrId("report_bug", "about_bug").c_str(), ImVec2(aboutBtnW, 0), S.resolveFont("button"))) { + lf.next(material::ActionButtonWidth(TR("about_source"), ICON_MD_CODE)); + if (material::ActionButton("##aboutsrc", TR("about_source"), ICON_MD_CODE, AT::Secondary)) + util::Platform::openUrl("https://git.dragonx.is/dragonx/ObsidianDragon"); + lf.next(material::ActionButtonWidth(TR("report_bug"), ICON_MD_BUG_REPORT)); + if (material::ActionButton("##aboutbug", TR("report_bug"), ICON_MD_BUG_REPORT, AT::Secondary)) util::Platform::openUrl("https://git.dragonx.is/dragonx/ObsidianDragon/issues"); - } if (ImGui::IsItemHovered()) material::Tooltip("%s", TR("tt_report_bug")); - if (aboutGrid) ImGui::Dummy(ImVec2(0, Layout::spacingXs())); else ImGui::SameLine(0, Layout::spacingMd()); - if (TactileButton(TrId("save_settings", "about_save").c_str(), ImVec2(aboutBtnW, 0), S.resolveFont("button"))) { + } + const float rightBottom = ImGui::GetCursorScreenPos().y; + + // Reconcile the two columns, then a card-wide settings-actions row. + ImGui::SetCursorScreenPos(ImVec2(baseX, std::max(leftBottom, rightBottom))); + ImGui::Dummy(ImVec2(0, Layout::spacingMd())); + { + using AT = material::ActionTier; + material::ButtonFlow af(contentW); + af.next(material::ActionButtonWidth(TR("save_settings"), ICON_MD_SAVE)); + if (material::ActionButton("##aboutsave", TR("save_settings"), ICON_MD_SAVE, AT::Secondary)) { saveSettingsPageState(app->settings()); Notifications::instance().success(TR("settings_saved")); } if (ImGui::IsItemHovered()) material::Tooltip("%s", TR("tt_save_settings")); - ImGui::SameLine(0, Layout::spacingMd()); - if (TactileButton(TrId("reset_to_defaults", "about_reset").c_str(), ImVec2(aboutBtnW, 0), S.resolveFont("button"))) { - if (app->settings()) { - loadSettingsPageState(app->settings()); - Notifications::instance().info(TR("settings_reloaded")); - } + af.next(material::ActionButtonWidth(TR("reset_to_defaults"), ICON_MD_RESTORE)); + if (material::ActionButton("##aboutreset", TR("reset_to_defaults"), ICON_MD_RESTORE, AT::Tertiary)) { + if (app->settings()) { loadSettingsPageState(app->settings()); Notifications::instance().info(TR("settings_reloaded")); } } if (ImGui::IsItemHovered()) material::Tooltip("%s", TR("tt_reset_settings")); } - - ImGui::Dummy(ImVec2(0, bottomPad)); - ImGui::Unindent(pad); - - ImVec2 cardMax(cardMin.x + availWidth, ImGui::GetCursorScreenPos().y); - - // Draw the logo now that the card height is known — aspect-preserved, capped to the - // reserved width, and clamped to end just above the buttons row so it never overlaps - // the text or the buttons. Still on the content channel (1), above the glass. - if (logoTex != 0) { - float reserveW = logoReserveH * logoAspect; - // Height available above the buttons row (the fix for the logo/buttons overlap). - float logoBottomLimit = aboutButtonsTopY - Layout::spacingSm(); - float logoH = std::max(16.0f, logoBottomLimit - logoPos.y); - float logoW = logoH * logoAspect; - if (logoW > reserveW) { logoW = reserveW; logoH = (logoAspect > 0.0f) ? logoW / logoAspect : logoH; } - dl->AddImage(logoTex, logoPos, ImVec2(logoPos.x + logoW, logoPos.y + logoH)); - } - - dl->ChannelsSetCurrent(0); - DrawGlassPanel(dl, cardMin, cardMax, glassSpec); - dl->ChannelsMerge(); - - ImGui::SetCursorScreenPos(ImVec2(cardMin.x, cardMax.y)); - ImGui::Dummy(ImVec2(availWidth, 0)); } - ImGui::Dummy(ImVec2(0, gap)); + if (s_settingsState.current_tab == TAB_NODE) + ImGui::Dummy(ImVec2(0, gap)); // ==================================================================== // DEBUG OPTIONS — collapsible card (full-node only: holds the screenshot sweep + the dragonxd - // daemon debug= categories written to DRAGONX.conf; lite has no daemon) + // daemon debug= categories written to DRAGONX.conf; lite has no daemon). Shown on the Node tab. // ==================================================================== - if (app->supportsFullNodeLifecycleActions()) { + if (app->supportsFullNodeLifecycleActions() && s_settingsState.current_tab == TAB_NODE) { // Clickable header row ImVec2 headerPos = ImGui::GetCursorScreenPos(); const char* arrow = s_settingsState.debug_expanded ? ICON_MD_EXPAND_LESS : ICON_MD_EXPAND_MORE; @@ -2721,6 +2683,14 @@ void RenderSettingsPage(App* app) { app->seedChatDemoData(); if (ImGui::IsItemHovered()) material::Tooltip("%s", TR("tt_seed_demo_chat")); } + // Restrict either sweep to just the active theme instead of cycling every skin. + ImGui::SameLine(); + { + bool only = app->sweepCurrentThemeOnly(); + if (ImGui::Checkbox(TR("sweep_current_theme_only"), &only)) + app->setSweepCurrentThemeOnly(only); + if (ImGui::IsItemHovered()) material::Tooltip("%s", TR("tt_sweep_current_theme_only")); + } ImGui::Dummy(ImVec2(0, Layout::spacingSm())); ImGui::Separator(); ImGui::Dummy(ImVec2(0, Layout::spacingSm())); diff --git a/src/ui/sidebar.h b/src/ui/sidebar.h index b6d53fa..8badf4d 100644 --- a/src/ui/sidebar.h +++ b/src/ui/sidebar.h @@ -538,11 +538,6 @@ inline bool RenderSidebar(NavPage& current, float sidebarWidth, float contentHei float exitRelY = curY + bottomPadding; float panelH = exitRelY + stripH; - // Vertical centering — offset so panel is centered in the child window - float centerOffset = std::max(glassMarginY, (contentHeight - panelH) * 0.5f); - if (centerOffset + panelH > contentHeight) - centerOffset = std::max(0.0f, contentHeight - panelH); - // =================================================================== // PASS 2: Render using computed positions // =================================================================== @@ -552,6 +547,13 @@ inline bool RenderSidebar(NavPage& current, float sidebarWidth, float contentHei ImDrawList* dl = ImGui::GetWindowDrawList(); ImVec2 wp = ImGui::GetWindowPos(); + // Vertical centering — center the panel within the child. app.cpp sizes the child (contentHeight) + // to the visible area (child top -> status-bar top) using window-local geometry, so this yields + // equal top/bottom gaps at any height on every platform, no viewport dependency. + float centerOffset = std::max(glassMarginY, (contentHeight - panelH) * 0.5f); + if (centerOffset + panelH > contentHeight) + centerOffset = std::max(0.0f, contentHeight - panelH); + float panelLeft = wp.x + glassMarginL; float panelRight = wp.x + sidebarWidth - glassMarginR; float panelTopY = wp.y + centerOffset; diff --git a/src/ui/windows/chat_tab.cpp b/src/ui/windows/chat_tab.cpp index 6dbbb16..6427233 100644 --- a/src/ui/windows/chat_tab.cpp +++ b/src/ui/windows/chat_tab.cpp @@ -1885,20 +1885,37 @@ void ResetChatTab() s_show_chat_settings = false; } -void RenderChatSettingsControls(App* app, float contentWidth) +void RenderChatSettingsControls(App* app, float contentWidth, bool drawCards) { auto* st = app ? app->settings() : nullptr; if (!st) return; const float dp = Layout::dpiScale(); const float ctrlW = 250.0f * dp; // control column width (fits a 3-segment control comfortably) - const float rowGap = 5.0f * dp; + const float rowGap = 10.0f * dp; + + // Optionally paint two glass cards (Appearance | Messaging) around our own two columns so the + // Settings tab matches the mockup's card-per-group layout. The chat modal passes drawCards=false + // and keeps its plain single-surface layout — the controls themselves are identical either way. + ImDrawList* cardDL = ImGui::GetWindowDrawList(); + const float cardPad = drawCards ? Layout::cardInnerPadding() : 0.0f; + material::GlassPanelSpec cardSpec; cardSpec.rounding = Layout::glassRounding(); + float cardTopScr = 0.0f, cardBaseXScr = 0.0f, cardLeftBotScr = 0.0f; + if (drawCards) { + cardTopScr = ImGui::GetCursorScreenPos().y; + cardBaseXScr = ImGui::GetCursorScreenPos().x; + cardDL->ChannelsSplit(2); + cardDL->ChannelsSetCurrent(1); + ImGui::SetCursorScreenPos(ImVec2(cardBaseXScr, cardTopScr + cardPad)); + ImGui::Indent(cardPad); + } // Right-align controls to the row's true right edge. The Settings tab renders us inside a GlassCard // whose content region isn't narrowed to the card padding, so it passes an explicit contentWidth; // the chat modal's dialog content region is correct, so it passes 0 (auto). // leftX/rowW define the current column the rows lay out in; retargeted below // to split Appearance | Messaging into two columns when the card is wide. float leftX = ImGui::GetCursorPosX(); - float rowW = (contentWidth > 0.0f) ? contentWidth : ImGui::GetContentRegionAvail().x; + float rowW = drawCards ? (contentWidth - 2.0f * cardPad) + : ((contentWidth > 0.0f) ? contentWidth : ImGui::GetContentRegionAvail().x); // Label left, control right-aligned within [leftX, leftX+rowW]. Leaves the cursor at the control origin. auto beginRow = [&](const char* label) { @@ -1966,7 +1983,7 @@ void RenderChatSettingsControls(App* app, float contentWidth) // Two internal columns when the card is wide enough: Appearance on the left, // Messaging on the right — fills the width and roughly halves the height. // (Mirrors the Node & Security card.) Narrow (the chat modal) stays single-column. - const float chatColGap = 24.0f * dp; + const float chatColGap = drawCards ? (Layout::cardGap() + 2.0f * cardPad) : (24.0f * dp); const bool chatTwoCol = rowW > 760.0f * dp; const float chatColW = chatTwoCol ? (rowW - chatColGap) * 0.5f : rowW; const float chatBaseLeftX = leftX; @@ -2023,6 +2040,7 @@ void RenderChatSettingsControls(App* app, float contentWidth) // line-start holds the column; retarget leftX so controls right-align in it). if (chatTwoCol) { chatLeftBottomY = ImGui::GetCursorPosY(); + cardLeftBotScr = ImGui::GetCursorScreenPos().y; // left column bottom (screen), for its card panel ImGui::SetCursorPosY(chatTopY); ImGui::Indent(chatColW + chatColGap); leftX = chatBaseLeftX + chatColW + chatColGap; @@ -2056,12 +2074,41 @@ void RenderChatSettingsControls(App* app, float contentWidth) } // Close the two-column band: un-indent and drop below the taller column. + const float cardRightBotScr = ImGui::GetCursorScreenPos().y; // right (or only) column bottom, screen if (chatTwoCol) { ImGui::Unindent(chatColW + chatColGap); const float chatRightBottomY = ImGui::GetCursorPosY(); ImGui::SetCursorPosX(chatBaseLeftX); ImGui::SetCursorPosY(std::max(chatLeftBottomY, chatRightBottomY)); } + + // Paint the glass card(s) behind the content, then merge the channels. + if (drawCards) { + ImGui::Unindent(cardPad); + cardDL->ChannelsSetCurrent(0); + const float cardW = (contentWidth - Layout::cardGap()) * 0.5f; + if (chatTwoCol) { + const float eqBot = std::max(cardLeftBotScr, cardRightBotScr); // equal-height cards (mockup grid stretch) + material::DrawGlassPanel(cardDL, ImVec2(cardBaseXScr, cardTopScr), + ImVec2(cardBaseXScr + cardW, eqBot + cardPad), cardSpec); + material::DrawGlassPanel(cardDL, ImVec2(cardBaseXScr + cardW + Layout::cardGap(), cardTopScr), + ImVec2(cardBaseXScr + contentWidth, eqBot + cardPad), cardSpec); + } else { + material::DrawGlassPanel(cardDL, ImVec2(cardBaseXScr, cardTopScr), + ImVec2(cardBaseXScr + contentWidth, cardRightBotScr + cardPad), cardSpec); + } + cardDL->ChannelsMerge(); + const float botScr = chatTwoCol ? std::max(cardLeftBotScr, cardRightBotScr) : cardRightBotScr; + // Reserve the card footprint with a Dummy so the parent scroll region grows to include it + // (a bare SetCursorScreenPos past content warns in ImGui). + ImGui::SetCursorScreenPos(ImVec2(cardBaseXScr, cardTopScr)); + ImGui::Dummy(ImVec2(contentWidth, (botScr - cardTopScr) + cardPad)); + + // Live conversation preview below the two cards (Settings tab only — the chat modal renders + // its own preview column beside these controls, so it passes drawCards=false and skips this). + ImGui::Dummy(ImVec2(0.0f, Layout::spacingMd())); + RenderChatSettingsPreview(app, contentWidth); + } } } // namespace ui diff --git a/src/ui/windows/chat_tab.h b/src/ui/windows/chat_tab.h index 0e673ee..71fe390 100644 --- a/src/ui/windows/chat_tab.h +++ b/src/ui/windows/chat_tab.h @@ -34,7 +34,7 @@ void RenderChatTab(App* app); * width from the Settings tab (whose GlassCard doesn't narrow the content region). 0 = auto * (use the current content region, correct inside the chat modal's dialog). */ -void RenderChatSettingsControls(App* app, float contentWidth = 0.0f); +void RenderChatSettingsControls(App* app, float contentWidth = 0.0f, bool drawCards = false); /** * @brief Securely wipe the Chat tab's UI-local state (composer / new-conversation diff --git a/src/util/i18n.cpp b/src/util/i18n.cpp index 779269e..9a7d9ff 100644 --- a/src/util/i18n.cpp +++ b/src/util/i18n.cpp @@ -460,15 +460,23 @@ void I18n::loadBuiltinEnglish() // Settings sections strings_["appearance"] = "APPEARANCE"; strings_["theme_language"] = "THEME & LANGUAGE"; + strings_["scale_effects"] = "SCALE & EFFECTS"; strings_["advanced_effects"] = "Advanced Effects..."; strings_["tools_actions"] = "Tools & Actions..."; + strings_["tools_actions_hdr"] = "TOOLS & ACTIONS"; + strings_["wallet_options_hdr"] = "OPTIONS"; + strings_["wallet_diagnostics_hdr"] = "DIAGNOSTICS"; strings_["wallet"] = "WALLET"; strings_["node_security"] = "NODE & SECURITY"; strings_["node"] = "NODE"; strings_["security"] = "SECURITY"; strings_["explorer_section"] = "EXPLORER"; + strings_["explorer_urls_hdr"] = "URLS"; strings_["about"] = "About"; strings_["backup_data"] = "BACKUP & DATA"; + strings_["backup_col_import"] = "IMPORT & RESTORE"; + strings_["backup_col_backup"] = "BACKUP"; + strings_["backup_col_export"] = "EXPORT"; strings_["balance_layout"] = "Balance Layout"; strings_["low_spec_mode"] = "Low-spec mode"; strings_["simple_background"] = "Simple background"; @@ -496,9 +504,11 @@ void I18n::loadBuiltinEnglish() strings_["screenshot_sweep"] = "Run screenshot sweep"; strings_["screenshot_sweep_full"] = "Full UI sweep"; strings_["screenshot_open_dir"] = "Open location"; + strings_["sweep_current_theme_only"] = "Current theme only"; + strings_["tt_sweep_current_theme_only"] = "Sweep only the active theme instead of cycling every theme"; strings_["screenshot_sweep_desc"] = "Cycles every theme across every tab and saves a screenshot of each into per-tab subfolders under the config directory's screenshots folder (overwriting the previous sweep). Runs for a few seconds."; strings_["mine_when_idle"] = "Mine when idle"; - strings_["setup_wizard"] = "Run Setup Wizard..."; + strings_["setup_wizard"] = "Run Setup Wizard…"; // RPC / Explorer settings strings_["rpc_connection"] = "RPC Connection..."; @@ -512,21 +522,21 @@ void I18n::loadBuiltinEnglish() strings_["fetch_prices"] = "Fetch price data from CoinGecko"; strings_["block_explorer"] = "Block Explorer"; strings_["test_connection"] = "Test Connection"; - strings_["rescan"] = "Rescan Blockchain"; + strings_["rescan"] = "Rescan"; // Settings: buttons - strings_["settings_address_book"] = "Address Book..."; - strings_["settings_validate_address"] = "Validate Address..."; - strings_["settings_request_payment"] = "Request Payment..."; - strings_["settings_shield_mining"] = "Shield Mining..."; - strings_["settings_merge_to_address"] = "Merge to Address..."; + strings_["settings_address_book"] = "Address Book…"; + strings_["settings_validate_address"] = "Validate Address…"; + strings_["settings_request_payment"] = "Request Payment…"; + strings_["settings_shield_mining"] = "Shield Mining…"; + strings_["settings_merge_to_address"] = "Merge to Address…"; strings_["settings_clear_ztx"] = "Clear Z-Tx History"; - strings_["settings_import_key"] = "Import Private Key..."; - strings_["settings_import_viewkey"] = "Import Viewing Key..."; - strings_["settings_export_key"] = "Export Key..."; - strings_["settings_export_all"] = "Export All..."; - strings_["settings_backup"] = "Backup..."; - strings_["settings_export_csv"] = "Export CSV..."; + strings_["settings_import_key"] = "Import Private Key…"; + strings_["settings_import_viewkey"] = "Import Viewing Key…"; + strings_["settings_export_key"] = "Export Key…"; + strings_["settings_export_all"] = "Export All…"; + strings_["settings_backup"] = "Backup…"; + strings_["settings_export_csv"] = "Export CSV…"; strings_["settings_encrypt_wallet"] = "Encrypt Wallet"; strings_["settings_change_passphrase"] = "Change Passphrase"; strings_["settings_lock_now"] = "Lock Now"; @@ -655,8 +665,8 @@ void I18n::loadBuiltinEnglish() strings_["wiz_pin_confirm"] = "Confirm PIN:"; strings_["wiz_pin_invalid"] = "PIN must be 4-8 digits"; strings_["wiz_pin_mismatch"] = "PINs do not match"; - strings_["settings_data_dir"] = "Data Dir:"; - strings_["settings_wallet_size_label"] = "Wallet Size:"; + strings_["settings_data_dir"] = "Data Dir"; + strings_["settings_wallet_size_label"] = "Wallet Size"; strings_["settings_debug_changed"] = "Debug categories changed \xe2\x80\x94 restart daemon to apply"; strings_["settings_auto_detected"] = "Auto-detected from DRAGONX.conf"; strings_["settings_visual_effects"] = "Visual Effects"; @@ -670,7 +680,7 @@ void I18n::loadBuiltinEnglish() strings_["settings_wallet_info"] = "Wallet Info"; strings_["settings_block_explorer_urls"] = "Block Explorer URLs"; strings_["settings_configure_explorer"] = "Configure external block explorer links"; - strings_["settings_auto_lock"] = "AUTO-LOCK"; + strings_["settings_auto_lock"] = "Auto-lock"; strings_["timeout_off"] = "Off"; strings_["timeout_1min"] = "1 min"; strings_["timeout_5min"] = "5 min"; @@ -700,9 +710,9 @@ void I18n::loadBuiltinEnglish() strings_["tt_scanline"] = "CRT scanline effect in console"; strings_["tt_theme_effects"] = "Shimmer, glow, hue-cycling per theme"; strings_["tt_animate_avatars"] = "Play animated (GIF / WebP) contact avatars; off shows the first frame only"; - strings_["tt_blur"] = "Blur amount (0%% = off, 100%% = maximum)"; - strings_["tt_noise"] = "Grain texture intensity (0%% = off, 100%% = maximum)"; - strings_["tt_ui_opacity"] = "Card and sidebar opacity (100%% = fully opaque, lower = more see-through)"; + strings_["tt_blur"] = "Blur amount (0% = off, 100% = maximum)"; + strings_["tt_noise"] = "Grain texture intensity (0% = off, 100% = maximum)"; + strings_["tt_ui_opacity"] = "Card and sidebar opacity (100% = fully opaque, lower = more see-through)"; strings_["tt_window_opacity"] = "Background opacity (lower = desktop visible through window)"; strings_["tt_font_scale"] = "Scale all text and UI (1.0x = default, up to 1.5x). Hotkey: Alt + Scroll Wheel"; strings_["tt_custom_theme"] = "Custom theme active"; @@ -805,12 +815,14 @@ void I18n::loadBuiltinEnglish() strings_["rescan_detecting"] = "Checking which blocks your node has on disk…"; strings_["rescan_bootstrapped_msg"] = "Your node was bootstrapped, so blocks below the snapshot aren't on disk and a rescan from genesis would fail. Rescan from a height your snapshot includes to reconcile your wallet's spent balance. Your wallet.dat and chain data are not deleted."; strings_["rescan_from_height"] = "Rescan from block height:"; - strings_["repair_wallet"] = "Repair Wallet"; + strings_["repair_wallet"] = "Repair"; strings_["tt_repair_wallet"] = "Wipe and rebuild the wallet's transaction records from the blockchain (fixes notes that fail to send after a rescan)"; strings_["confirm_repair_wallet_title"] = "Repair Wallet"; strings_["confirm_repair_wallet_msg"] = "This restarts the daemon with -zapwallettxes=2: it deletes all of the wallet's transaction and note records, then rebuilds them from the blockchain. Use this when transactions fail to build (\"Invalid sapling spend proof\" / \"shielded requirements not met\") even after a full rescan. It takes a long time and the wallet stays offline until it finishes."; strings_["confirm_repair_wallet_safe"] = "Your keys, addresses and balance are preserved — only the cached transaction records are rebuilt."; strings_["daemon_binary"] = "Daemon binary"; + strings_["daemon_updates_label"] = "UPDATES"; + strings_["daemon_maintenance_label"] = "MAINTENANCE"; strings_["daemon_installed"] = "Installed"; strings_["daemon_bundled"] = "Bundled"; strings_["daemon_not_installed"] = "not installed"; @@ -818,6 +830,10 @@ void I18n::loadBuiltinEnglish() strings_["daemon_status_match"] = "Installed binary matches the bundled version."; strings_["daemon_status_differ"] = "Installed binary differs from the bundled version."; strings_["daemon_status_missing"] = "No daemon installed — install the bundled version."; + // Compact status shown right-aligned on the DAEMON BINARY heading row. + strings_["daemon_status_ok"] = "Up to date"; + strings_["daemon_status_diff"] = "Version differs"; + strings_["daemon_status_none"] = "Not installed"; strings_["daemon_install_bundled"] = "Install bundled"; strings_["tt_daemon_install_bundled"] = "Stop the node, overwrite the installed dragonxd with the version bundled in this wallet build, then restart"; strings_["confirm_reinstall_daemon_title"] = "Install Bundled Daemon"; @@ -1500,6 +1516,7 @@ void I18n::loadBuiltinEnglish() strings_["about_chain"] = "Chain:"; strings_["about_connections"] = "Connections:"; strings_["about_credits"] = "Credits"; + strings_["about_source"] = "Source"; strings_["about_daemon"] = "Daemon:"; strings_["about_debug"] = "Debug"; strings_["about_edition"] = "ImGui Edition"; From 558cfcbe56a095f0967fa9adff1601bca3736c04 Mon Sep 17 00:00:00 2001 From: DanS Date: Thu, 20 Aug 2026 17:06:04 -0500 Subject: [PATCH 62/89] fix(ui): restore ObsidianDragon logo in header and About tab MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit ensureLogoTexture() rasterized the embedded DragonX SVG into logo_tex_ and returned early (added in 1752500 "themed DragonX logo"), so the app/product branding — the top-left header (app.cpp AddImage) and the About tab (getLogoTexture) — showed the DragonX coin mark instead of the ObsidianDragon logo. Drop that step so logo_tex_ resolves via the intended path: active-skin override → ui.toml header-icon → bundled ObsidianDragon dark/light PNG (disk, then embedded RESOURCE_LOGO). The DragonX SVG stays for coin_logo_tex_ (balance card) and drgx_emoji_tex_ (chat emoji), which are the currency mark and correct. Co-Authored-By: Claude Opus 4.8 (1M context) --- src/app.cpp | 13 ++++--------- 1 file changed, 4 insertions(+), 9 deletions(-) diff --git a/src/app.cpp b/src/app.cpp index 79320f8..b66088b 100644 --- a/src/app.cpp +++ b/src/app.cpp @@ -1502,16 +1502,11 @@ void App::ensureLogoTexture() } } - // 0) DragonX mark — rasterize the embedded SVG recolored to the theme (body = accent, detail = white) - // at ~2x the 128px viewBox for crisp downscaling. This is the branding on every skin; the per-skin - // PNG path below is only a fallback if rasterization ever fails. - if (util::LoadTextureFromSvg(embedded::kLogoDragonXSvg, 256, logoAccent, - detailCol, &logo_tex_, &logo_w_, &logo_h_)) { - DEBUG_LOGF("Rendered DragonX SVG logo (%dx%d, accent %08X)\n", logo_w_, logo_h_, logoAccent); - return; - } + // The header / top-left / About branding is the ObsidianDragon PRODUCT logo — NOT the DragonX coin + // mark (that is coin_logo_tex_ / drgx_emoji_tex_ above). Resolve it below: active-skin override, else + // the ui.toml header-icon, else the bundled ObsidianDragon dark/light PNG (disk, then embedded). - // 1) Fallback — theme-override logo from the active skin + // 1) theme-override logo from the active skin const auto* activeSkin = ui::schema::SkinManager::instance().findById( ui::schema::SkinManager::instance().activeSkinId()); std::string logoPath; From a7514becbc3c3c6e46d00e1fef03de5f3f691800 Mon Sep 17 00:00:00 2001 From: DanS Date: Thu, 20 Aug 2026 17:17:03 -0500 Subject: [PATCH 63/89] feat(ui): credit The DragonX Developers in the About tab Add "The DragonX Developers" to the About-tab credits (after The Hush Developers), acknowledging the DragonX chain/daemon this wallet drives. Co-Authored-By: Claude Opus 4.8 (1M context) --- src/ui/pages/settings_page.cpp | 1 + 1 file changed, 1 insertion(+) diff --git a/src/ui/pages/settings_page.cpp b/src/ui/pages/settings_page.cpp index 952af1d..1e89001 100644 --- a/src/ui/pages/settings_page.cpp +++ b/src/ui/pages/settings_page.cpp @@ -2543,6 +2543,7 @@ void RenderSettingsPage(App* app) { ImGui::PushFont(body2); static const char* kCredits[] = { "The Hush Developers", + "The DragonX Developers", "ObsidianDragon Community", "Dear ImGui \xE2\x80\x94 Omar Cornut", "SDL3 \xE2\x80\x94 Sam Lantinga", From 6d26ccd0ede7da0e8b75f1e167319114f0a16c2b Mon Sep 17 00:00:00 2001 From: DanS Date: Thu, 20 Aug 2026 17:41:25 -0500 Subject: [PATCH 64/89] feat(ui): large-wallet nudge in Node & Security MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit The BDB wallet.dat bloats with shielded-note witness data and never shrinks in place, so a mining/shielded wallet can grow past 500 MB. Below the Wallet Size row, show a one-line amber hint once wallet.dat crosses 500 MB with a "Consolidate notes…" shortcut that opens the Merge to Address (z_mergetoaddress) dialog. Full-node only (lite has no wallet.dat here); threshold is a single named constant. i18n keys fall back to English for non-English locales. Co-Authored-By: Claude Opus 4.8 (1M context) --- src/ui/pages/settings_page.cpp | 19 +++++++++++++++++++ src/util/i18n.cpp | 3 +++ 2 files changed, 22 insertions(+) diff --git a/src/ui/pages/settings_page.cpp b/src/ui/pages/settings_page.cpp index 1e89001..c9cd3c5 100644 --- a/src/ui/pages/settings_page.cpp +++ b/src/ui/pages/settings_page.cpp @@ -2066,6 +2066,25 @@ void RenderSettingsPage(App* app) { else ImGui::TextDisabled("%s", wv); } + // Large-wallet nudge: the BDB wallet.dat bloats with shielded-note witness data and + // never shrinks in place. Past a threshold, hint the user toward consolidating notes + // (Merge to Address) to curb further growth. Full-node only (lite has no wallet.dat here). + static constexpr uint64_t kWalletBloatWarnBytes = 500ull * 1024 * 1024; // 500 MB + if (app->supportsFullNodeLifecycleActions() && wallet_size > kWalletBloatWarnBytes) { + ImGui::Dummy(ImVec2(0, Layout::spacingSm())); + ImGui::PushStyleColor(ImGuiCol_Text, Warning()); + ImGui::PushTextWrapPos(leftX + contentW); + ImGui::TextWrapped("%s", TR("wallet_size_warn")); + ImGui::PopTextWrapPos(); + ImGui::PopStyleColor(); + if (ImGui::IsItemHovered()) material::Tooltip("%s", TR("tt_wallet_size_warn")); + ImGui::Dummy(ImVec2(0, Layout::spacingXs())); + if (material::ActionButton("##walletconsolidate", TR("wallet_size_consolidate"), + ICON_MD_CALL_MERGE, material::ActionTier::Secondary)) + ShieldDialog::show(ShieldDialog::Mode::MergeToAddress); + if (ImGui::IsItemHovered()) material::Tooltip("%s", TR("tt_merge")); + } + // Row 3: folder buttons (their own row so the path gets the full width). ImGui::Dummy(ImVec2(0, Layout::spacingXs())); material::ButtonFlow ff(contentW); diff --git a/src/util/i18n.cpp b/src/util/i18n.cpp index 9a7d9ff..0c684fa 100644 --- a/src/util/i18n.cpp +++ b/src/util/i18n.cpp @@ -667,6 +667,9 @@ void I18n::loadBuiltinEnglish() strings_["wiz_pin_mismatch"] = "PINs do not match"; strings_["settings_data_dir"] = "Data Dir"; strings_["settings_wallet_size_label"] = "Wallet Size"; + strings_["wallet_size_warn"] = "This wallet file is large. Consolidating your notes can curb further growth."; + strings_["tt_wallet_size_warn"] = "Shielded wallets grow with each note's witness data — merging many notes into one address reduces it. Back up first."; + strings_["wallet_size_consolidate"] = "Consolidate notes\xE2\x80\xA6"; strings_["settings_debug_changed"] = "Debug categories changed \xe2\x80\x94 restart daemon to apply"; strings_["settings_auto_detected"] = "Auto-detected from DRAGONX.conf"; strings_["settings_visual_effects"] = "Visual Effects"; From 5daf2d83b678ba745b17bb92eb226bef03857ca5 Mon Sep 17 00:00:00 2001 From: DanS Date: Thu, 20 Aug 2026 18:09:36 -0500 Subject: [PATCH 65/89] feat(ui): large-wallet nudge as a one-time toast + clickable alert MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Extend the wallet-bloat warning beyond the Settings banner: when wallet.dat first crosses 500 MB (full-node, synced), fire a one-time warning toast plus a clickable "Consolidate notes…" entry in the bell/alerts panel that opens Merge to Address. The persisted large_wallet_warned flag keeps it once-only and re-arms if the file later shrinks back under the threshold. - AlertRecord gains an optional onClick + actionHint; Notifications::action() pushes a toast and a clickable history entry. renderAlertHistoryPanel() now renders the accent action link (under the message) and measures true content height so wrapped messages + the link aren't clipped. - App::maybeWarnLargeWallet() (mirrors maybeRemindSeedBackup) runs once per launch from update(); reuses the existing wallet_size_warn/consolidate strings. Co-Authored-By: Claude Opus 4.8 (1M context) --- src/app.cpp | 33 +++++++++++++++++++++++++++++---- src/app.h | 2 ++ src/app_network.cpp | 31 +++++++++++++++++++++++++++++++ src/config/settings.cpp | 2 ++ src/config/settings.h | 5 +++++ src/ui/notifications.h | 16 ++++++++++++++-- 6 files changed, 83 insertions(+), 6 deletions(-) diff --git a/src/app.cpp b/src/app.cpp index b66088b..ee4d877 100644 --- a/src/app.cpp +++ b/src/app.cpp @@ -878,6 +878,9 @@ void App::update() // (a prior/unwitnessed salvage likely moved the coins into a wallet..bak). maybeWarnEmptyWalletWithFundedSiblings(); + // One-time nudge if wallet.dat has bloated past the threshold (toast + clickable alert → consolidate). + maybeWarnLargeWallet(); + // Classify the wallet's mnemonic status (once per connect) so the Migrate-to-seed button can // glow for a legacy, pre-seed-phrase wallet. probeWalletSeedStatus(); @@ -2421,10 +2424,19 @@ void App::renderAlertHistoryPanel() return; } - // Scrollable list, newest first. Height adapts to the entry count but caps so a busy session - // scrolls inside the panel instead of blowing past the popup's max height. - const float perEntry = txtF->LegacySize * 2.0f + 14.0f * dp; // message line + time line + spacing - const float listH = std::min(300.0f * dp, static_cast(hist.size()) * perEntry); + // Scrollable list, newest first. Measure the TRUE content height so wrapped (multi-line) messages + // and optional action links aren't clipped by an under-estimate; cap so a busy session scrolls + // inside the panel instead of blowing past the popup's max height. + const float msgWrapW = std::max(40.0f * dp, innerW - 2.0f * padX - icoF->LegacySize - 6.0f * dp); + float contentH = 0.0f; + for (const auto& a : hist) { + const float msgH = txtF->CalcTextSizeA(txtF->LegacySize, FLT_MAX, msgWrapW, a.message.c_str()).y; + contentH += std::max(msgH, static_cast(icoF->LegacySize)); // icon + wrapped message + contentH += txtF->LegacySize; // relative-age line + if (a.onClick && !a.actionHint.empty()) contentH += txtF->LegacySize; // action-link line + contentH += 8.0f * dp; // inter-entry spacing + } + const float listH = std::min(300.0f * dp, contentH); ImGui::BeginChild("##AlertRows", ImVec2(0, listH), false); int idx = 0; for (auto it = hist.rbegin(); it != hist.rend(); ++it, ++idx) { @@ -2452,6 +2464,19 @@ void App::renderAlertHistoryPanel() ImGui::TextWrapped("%s", a.message.c_str()); ImGui::PopTextWrapPos(); ImGui::PopStyleColor(); + // Optional clickable action (accent link), directly under the message so it stays prominent. + if (a.onClick && !a.actionHint.empty()) { + ImGui::SetCursorPosX(padX + icoF->LegacySize + 6.0f * dp); + ImGui::PushStyleColor(ImGuiCol_Text, m::Primary()); + ImGui::TextUnformatted(a.actionHint.c_str()); + ImGui::PopStyleColor(); + if (ImGui::IsItemHovered()) { + const ImVec2 lmn = ImGui::GetItemRectMin(), lmx = ImGui::GetItemRectMax(); + ImGui::GetWindowDrawList()->AddLine(ImVec2(lmn.x, lmx.y), ImVec2(lmx.x, lmx.y), m::Primary()); + ImGui::SetMouseCursor(ImGuiMouseCursor_Hand); + } + if (ImGui::IsItemClicked()) { a.onClick(); ImGui::CloseCurrentPopup(); } + } // Relative age, dim, indented under the message. ImGui::SetCursorPosX(padX + icoF->LegacySize + 6.0f * dp); ImGui::PushStyleColor(ImGuiCol_Text, m::OnSurfaceDisabled()); diff --git a/src/app.h b/src/app.h index 93f0730..dc1f0fa 100644 --- a/src/app.h +++ b/src/app.h @@ -817,6 +817,7 @@ private: // install) to back up their seed phrase. Cheap early-outs keep it idle until it can act. void maybeRemindSeedBackup(); void maybeWarnEmptyWalletWithFundedSiblings(); // full-node: empty active wallet + a funded sibling → warn once + void maybeWarnLargeWallet(); // full-node: wallet.dat past bloat threshold → one-time toast + clickable alert void scanFundedSiblingsAsync(); // off-UI-thread probe of sibling wallet files static void scrubAndRemoveExport(const std::string& path); // zero + delete a plaintext key export (H-02) void sweepStaleDecryptExports(); // startup net: purge stale obsidiandecryptexport* files (H-02) @@ -1007,6 +1008,7 @@ private: bool seed_backup_loading_ = false; bool seed_backup_no_mnemonic_ = false; bool seed_backup_reminder_in_flight_ = false; // guards the one-time backup nudge probe + bool large_wallet_checked_ = false; // gate: stat wallet.dat for the bloat nudge once per launch // Cached mnemonic status of the current wallet, driving the Migrate-to-seed button glow. Probed // once per connect (probeWalletSeedStatus, via exportSeedPhrase); NoMnemonic = a legacy wallet a diff --git a/src/app_network.cpp b/src/app_network.cpp index 64b0eca..718f064 100644 --- a/src/app_network.cpp +++ b/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/shield_dialog.h" // ui::ShieldDialog — Merge to Address shortcut from the bloat nudge #include "ui/windows/mining_pool_panel.h" // ui::resolveMiningUserAddress #include // sodium_memzero for wiping the fetched mnemonic #include @@ -4232,6 +4233,36 @@ void App::maybeRemindSeedBackup() }); } +// One-time nudge (full-node) when the BDB wallet.dat has bloated past the threshold. Berkeley DB never +// shrinks in place and shielded-note witness data accumulates, so a mining/shielded wallet can grow +// unbounded. Fires ONCE (persisted flag) a warning toast + a clickable "Consolidate notes…" entry in the +// bell/alert panel that opens Merge to Address; re-arms if the file later drops back under the threshold. +void App::maybeWarnLargeWallet() +{ + if (capture_mode_ || lite_wallet_) return; // no live nags during a UI sweep; lite has no wallet.dat + if (!supportsFullNodeLifecycleActions() || !settings_) return; + if (!state_.connected || !state_.encryption_state_known) return; + if (state_.warming_up || state_.daemon_initializing || !state_.sync.isSynced()) return; + if (large_wallet_checked_) return; // stat wallet.dat at most once per launch + large_wallet_checked_ = true; + + static constexpr uint64_t kWalletBloatWarnBytes = 500ull * 1024 * 1024; // 500 MB (matches the Settings banner) + const std::string walletPath = util::Platform::getDragonXDataDir() + "/wallet.dat"; + const uint64_t sz = util::Platform::getFileSize(walletPath); + if (sz <= kWalletBloatWarnBytes) { + // Re-arm the one-time warning if the file shrank back under the threshold (e.g. after a fresh seed wallet). + if (settings_->getLargeWalletWarned()) { settings_->setLargeWalletWarned(false); settings_->save(); } + return; + } + if (settings_->getLargeWalletWarned()) return; // already warned once for this bloat episode + settings_->setLargeWalletWarned(true); + settings_->save(); + ui::Notifications::instance().action( + TR("wallet_size_warn"), ui::NotificationType::Warning, + []() { ui::ShieldDialog::show(ui::ShieldDialog::Mode::MergeToAddress); }, + TR("wallet_size_consolidate"), 12.0f); +} + // Complementary on-disk safety net (full-node) for a wallet salvage we did NOT witness this launch — it // happened on a prior run, or under an external daemon whose startup output we never captured, so // detectWalletAutoRecovery() never fired. If the active wallet loads EMPTY while a sibling wallet file in diff --git a/src/config/settings.cpp b/src/config/settings.cpp index 7374515..fd58bc2 100644 --- a/src/config/settings.cpp +++ b/src/config/settings.cpp @@ -232,6 +232,7 @@ bool Settings::load(const std::string& path) } loadScalar(j, "wizard_completed", wizard_completed_); loadScalar(j, "seed_backup_reminded", seed_backup_reminded_); + loadScalar(j, "large_wallet_warned", large_wallet_warned_); if (j.contains("empty_wallet_warning_acked") && j["empty_wallet_warning_acked"].is_array()) { empty_wallet_warning_acked_.clear(); for (const auto& w : j["empty_wallet_warning_acked"]) @@ -506,6 +507,7 @@ bool Settings::save(const std::string& path) } j["wizard_completed"] = wizard_completed_; j["seed_backup_reminded"] = seed_backup_reminded_; + j["large_wallet_warned"] = large_wallet_warned_; j["empty_wallet_warning_acked"] = json::array(); for (const auto& w : empty_wallet_warning_acked_) j["empty_wallet_warning_acked"].push_back(w); diff --git a/src/config/settings.h b/src/config/settings.h index 2fb7129..5d12aff 100644 --- a/src/config/settings.h +++ b/src/config/settings.h @@ -330,6 +330,10 @@ public: bool getSeedBackupReminded() const { return seed_backup_reminded_; } void setSeedBackupReminded(bool v) { seed_backup_reminded_ = v; } + // One-time nudge when wallet.dat grows past the bloat threshold (re-armed if it shrinks back). + bool getLargeWalletWarned() const { return large_wallet_warned_; } + void setLargeWalletWarned(bool v) { large_wallet_warned_ = v; } + // Wallet filenames for which the one-time "this wallet is empty but a sibling holds funds" // warning has been dismissed. Keyed per active wallet file so switching to a different empty // wallet can warn again (see App::maybeWarnEmptyWalletWithFundedSiblings). @@ -597,6 +601,7 @@ private: std::map address_meta_; bool wizard_completed_ = false; bool seed_backup_reminded_ = false; + bool large_wallet_warned_ = false; std::set empty_wallet_warning_acked_; // wallet files whose empty-wallet warning was dismissed bool encryption_pending_ = false; long long daemon_update_prompted_size_ = 0; // bundled daemon size last offered via the update prompt diff --git a/src/ui/notifications.h b/src/ui/notifications.h index fb628f1..25e764e 100644 --- a/src/ui/notifications.h +++ b/src/ui/notifications.h @@ -31,6 +31,8 @@ struct AlertRecord { std::string message; NotificationType type; std::int64_t epoch; // std::time(nullptr) at push — wall-clock, for relative-age display + std::function onClick; // optional: makes this bell-panel entry actionable + std::string actionHint; // optional: accent link label rendered for the action }; struct Notification { @@ -92,15 +94,25 @@ public: if (duration < 0.0f) duration = schemaDuration("duration-error", 4.0f); push(message, NotificationType::Error, duration); } + + // An actionable alert: a normal toast PLUS a clickable entry in the bell/alert-history panel. + // onClick fires when the user clicks the accent `actionHint` link in that panel. + void action(const std::string& message, NotificationType type, std::function onClick, + const std::string& actionHint, float duration = -1.0f) { + if (duration < 0.0f) duration = schemaDuration("duration-warning", 3.5f); + push(message, type, duration, std::move(onClick), actionHint); + } - void push(const std::string& message, NotificationType type, float duration = 5.0f) { + void push(const std::string& message, NotificationType type, float duration = 5.0f, + std::function onClick = nullptr, const std::string& actionHint = "") { 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::time(nullptr))}); + history_.push_back(AlertRecord{message, type, static_cast(std::time(nullptr)), + std::move(onClick), actionHint}); ++total_pushed_; while (history_.size() > kMaxHistory) { history_.pop_front(); From 08cfeb0e0886215c42b96f554055b9bc0d1c7c6d Mon Sep 17 00:00:00 2001 From: DanS Date: Thu, 20 Aug 2026 22:33:59 -0500 Subject: [PATCH 66/89] feat(ui): rework the consolidate/merge modal MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Make Merge to Address actually serve wallet-bloat consolidation and be far less opaque. New ShieldDialog::showConsolidate() preset (used by the large-wallet Settings banner + alert action) frames it as "Consolidate funds" and targets shielded notes — the bloat the nudge warns about. - Source selector: consolidate shielded notes (ANY_SAPLING), transparent (ANY_TADDR), or both (*) — previously hardcoded to ANY_TADDR, which never reduced the shielded-witness bloat. Batch limit now applies to the right side. - Scope: on open, count spendable UTXOs + notes (listunspent / z_listunspent) and show "N transparent + M shielded · ~X DRGX"; warn "repeat to finish" when the set exceeds one batch. - Destination auto-selects the best spendable z-address (button enabled by default); empty wallets get an inline "Create shielded address" (z_getnewaddress). - Advanced disclosure hides Fee + "Max inputs per batch" (renamed from the "UTXO Limit" jargon) with sane defaults. - Inline confirm step before the fund-moving call (amount + input count + dest). - Live progress: self-polls z_getoperationstatus to show Consolidating… → Done/Failed, replacing the raw opid + manual "Check status" button. All three merge entry points now use the typed showMerge()/showConsolidate() (no stale-static leaks from direct show(MergeToAddress)). Shield-coinbase mode keeps working. New i18n keys fall back to English. Co-Authored-By: Claude Opus 4.8 (1M context) --- src/app_network.cpp | 2 +- src/ui/pages/settings_page.cpp | 4 +- src/ui/windows/shield_dialog.cpp | 678 +++++++++++++++++++------------ src/ui/windows/shield_dialog.h | 8 +- src/util/i18n.cpp | 23 ++ 5 files changed, 447 insertions(+), 268 deletions(-) diff --git a/src/app_network.cpp b/src/app_network.cpp index 718f064..17015f8 100644 --- a/src/app_network.cpp +++ b/src/app_network.cpp @@ -4259,7 +4259,7 @@ void App::maybeWarnLargeWallet() settings_->save(); ui::Notifications::instance().action( TR("wallet_size_warn"), ui::NotificationType::Warning, - []() { ui::ShieldDialog::show(ui::ShieldDialog::Mode::MergeToAddress); }, + []() { ui::ShieldDialog::showConsolidate(); }, TR("wallet_size_consolidate"), 12.0f); } diff --git a/src/ui/pages/settings_page.cpp b/src/ui/pages/settings_page.cpp index c9cd3c5..bee107d 100644 --- a/src/ui/pages/settings_page.cpp +++ b/src/ui/pages/settings_page.cpp @@ -1248,7 +1248,7 @@ void RenderSettingsPage(App* app) { ShieldDialog::show(ShieldDialog::Mode::ShieldCoinbase); if (ImGui::IsItemHovered()) material::Tooltip("%s", TR("tt_shield_mining")); if (BTN("##wmerge", TR("settings_merge_to_address"), ICON_MD_CALL_MERGE)) - ShieldDialog::show(ShieldDialog::Mode::MergeToAddress); + ShieldDialog::showMerge(); if (ImGui::IsItemHovered()) material::Tooltip("%s", TR("tt_merge")); if (BTN("##wclear", TR("settings_clear_ztx"), ICON_MD_DELETE_SWEEP)) s_settingsState.confirm_clear_ztx = true; @@ -2081,7 +2081,7 @@ void RenderSettingsPage(App* app) { ImGui::Dummy(ImVec2(0, Layout::spacingXs())); if (material::ActionButton("##walletconsolidate", TR("wallet_size_consolidate"), ICON_MD_CALL_MERGE, material::ActionTier::Secondary)) - ShieldDialog::show(ShieldDialog::Mode::MergeToAddress); + ShieldDialog::showConsolidate(); if (ImGui::IsItemHovered()) material::Tooltip("%s", TR("tt_merge")); } diff --git a/src/ui/windows/shield_dialog.cpp b/src/ui/windows/shield_dialog.cpp index ae9b979..f7961fc 100644 --- a/src/ui/windows/shield_dialog.cpp +++ b/src/ui/windows/shield_dialog.cpp @@ -5,6 +5,7 @@ #include "shield_dialog.h" #include "../../app.h" #include "../../config/version.h" +#include "../../data/wallet_state.h" #include "../../rpc/rpc_client.h" #include "../../rpc/rpc_worker.h" #include "../../util/i18n.h" @@ -15,39 +16,98 @@ #include #include +#include namespace dragonx { namespace ui { -// Static state -static bool s_open = false; +// ── Static dialog state ───────────────────────────────────────────────────────────────────────── +static bool s_open = false; static ShieldDialog::Mode s_mode = ShieldDialog::Mode::ShieldCoinbase; -static char s_from_address[512] = "*"; -static char s_to_address[512] = ""; +static bool s_consolidate = false; // opened from the wallet-bloat nudge (shielded preset + framing) +static int s_src = 2; // merge source: 0 = transparent, 1 = shielded, 2 = both +static char s_from_address[512] = "*"; +static char s_to_address[512] = ""; +static int s_selected_zaddr_idx = -1; static double s_fee = DRAGONX_DEFAULT_FEE; -static int s_utxo_limit = 50; // overridden by schema at runtime -static bool s_operation_pending = false; +static int s_utxo_limit = 50; // overridden by schema at runtime +static bool s_advanced = false; // Advanced (fee + batch size) disclosure +static bool s_confirm = false; // inline "confirm before moving funds" phase +static bool s_operation_pending = false; +static bool s_op_terminal = false; // async op reached success/failed — freeze inputs static std::string s_operation_id; static std::string s_status_message; -static int s_selected_zaddr_idx = -1; +static double s_last_poll = 0.0; // live-progress self-poll timer (ImGui::GetTime seconds) +// Scope of what can be consolidated (fetched once on open, merge mode only). +static bool s_scope_loading = false; +static bool s_scope_loaded = false; +static int s_t_count = 0, s_z_count = 0; +static double s_t_amount = 0.0, s_z_amount = 0.0; +static bool s_creating_addr = false; // z_getnewaddress in flight (empty state) + +static void resetTransient() +{ + s_operation_pending = false; + s_op_terminal = false; + s_confirm = false; + s_status_message.clear(); + s_operation_id.clear(); + s_creating_addr = false; +} + +// Count + sum spendable transparent UTXOs and shielded notes so the user can see the scope of a +// consolidation (and how many batches it may take). Read-only; runs off the UI thread. +static void loadScope(App* app) +{ + if (!app || !app->worker()) return; + s_scope_loading = true; s_scope_loaded = false; + app->worker()->post([app, rpc = app->rpc()]() -> rpc::RPCWorker::MainCb { + int tC = 0, zC = 0; double tA = 0.0, zA = 0.0; std::string error; + try { + rpc::RPCClient::TraceScope trace("Shield dialog / Scope count"); + nlohmann::json us = rpc->call("listunspent", nlohmann::json::array({0})); + if (us.is_array()) for (const auto& u : us) { + if (u.value("confirmations", 0) >= 1 && u.value("spendable", true)) { ++tC; tA += u.value("amount", 0.0); } + } + nlohmann::json zs = rpc->call("z_listunspent", nlohmann::json::array({0})); + if (zs.is_array()) for (const auto& z : zs) { + if (z.value("confirmations", 0) >= 1) { ++zC; zA += z.value("amount", 0.0); } + } + } catch (const std::exception& e) { error = e.what(); } + return [tC, zC, tA, zA, error]() { + s_scope_loading = false; s_scope_loaded = error.empty(); + s_t_count = tC; s_z_count = zC; s_t_amount = tA; s_z_amount = zA; + // Clamp the source to what actually has inputs (unless the user is mid-op). + const bool tOk = tC > 0, zOk = zC > 0; + if (!s_operation_pending) { + if (s_consolidate && zOk) s_src = 1; // bloat nudge → shielded + else if (s_src == 0 && !tOk) s_src = zOk ? 1 : 2; + else if (s_src == 1 && !zOk) s_src = tOk ? 0 : 2; + else if (!tOk && zOk) s_src = 1; + else if (tOk && !zOk) s_src = 0; + } + }; + }); +} void ShieldDialog::show(Mode mode) { s_mode = mode; s_open = true; - s_operation_pending = false; - s_status_message.clear(); - s_operation_id.clear(); - - if (mode == Mode::ShieldCoinbase) { - strncpy(s_from_address, "*", sizeof(s_from_address)); - } else { - s_from_address[0] = '\0'; - } + s_consolidate = false; // reset preset flags so stale statics don't leak across opens + s_src = 2; + resetTransient(); + s_from_address[0] = '\0'; + if (mode == Mode::ShieldCoinbase) strncpy(s_from_address, "*", sizeof(s_from_address)); s_to_address[0] = '\0'; + s_selected_zaddr_idx = -1; s_fee = DRAGONX_DEFAULT_FEE; s_utxo_limit = (int)schema::UI().drawElement("business", "utxo-limit").size; - s_selected_zaddr_idx = -1; + if (s_utxo_limit < 1) s_utxo_limit = 50; + s_advanced = false; + s_scope_loaded = false; s_scope_loading = false; + s_t_count = s_z_count = 0; s_t_amount = s_z_amount = 0.0; + s_last_poll = 0.0; } void ShieldDialog::showShieldCoinbase(const std::string& fromAddress) @@ -59,14 +119,146 @@ void ShieldDialog::showShieldCoinbase(const std::string& fromAddress) void ShieldDialog::showMerge() { show(Mode::MergeToAddress); + s_consolidate = false; + s_src = 2; // generic merge: both sources +} + +void ShieldDialog::showConsolidate() +{ + show(Mode::MergeToAddress); + s_consolidate = true; + s_src = 1; // wallet-bloat consolidation targets shielded notes (witness bloat) } void ShieldDialog::hide() { s_open = false; - s_operation_pending = false; - s_status_message.clear(); - s_operation_id.clear(); + resetTransient(); +} + +// Relevant count/amount for the currently-selected merge source. +static int srcCount() { return s_src == 0 ? s_t_count : s_src == 1 ? s_z_count : (s_t_count + s_z_count); } +static double srcAmount() { return s_src == 0 ? s_t_amount : s_src == 1 ? s_z_amount : (s_t_amount + s_z_amount); } + +static std::string fmtAmt(double v) { char b[48]; std::snprintf(b, sizeof(b), "%.4f", v); return b; } + +static std::string shortAddr(const std::string& a) +{ + if (a.size() <= 20) return a; + return a.substr(0, 10) + "…" + a.substr(a.size() - 8); +} + +// Auto-pick the best spendable z-address as the default destination (fewest hops for the user). +static void autoSelectDestination(const WalletState& state) +{ + if (s_to_address[0] != '\0' || state.z_addresses.empty()) return; + int idx = bestSpendableAddressIndex(state.z_addresses); + if (idx < 0) idx = 0; + s_selected_zaddr_idx = idx; + strncpy(s_to_address, state.z_addresses[idx].address.c_str(), sizeof(s_to_address) - 1); +} + +// Fire the actual shield/merge op. Registers the opid with the shared poller (for balance refresh) +// AND kicks the modal's own live-progress poll. +static void submitOperation(App* app) +{ + s_operation_pending = true; + s_op_terminal = false; + s_status_message = TR("shield_submitting"); + s_last_poll = ImGui::GetTime(); + + if (s_mode == ShieldDialog::Mode::ShieldCoinbase) { + std::string from(s_from_address), to(s_to_address); + double fee = s_fee; int limit = s_utxo_limit; + if (!app->worker()) return; + app->worker()->post([app, rpc = app->rpc(), from, to, fee, limit]() -> rpc::RPCWorker::MainCb { + nlohmann::json result; std::string error; + try { + rpc::RPCClient::TraceScope trace("Shield dialog / Shield coinbase"); + result = rpc->call("z_shieldcoinbase", {from, to, fee, limit}); + } catch (const std::exception& e) { error = e.what(); } + return [app, result, error]() { + if (error.empty()) { + s_operation_id = result.value("opid", ""); + s_status_message = TR("merge_progress"); + Notifications::instance().success(TR("shield_started")); + app->trackOperation(s_operation_id); + } else { + s_operation_pending = false; s_op_terminal = true; + s_status_message = std::string(TR("shield_error_prefix")) + error; + Notifications::instance().error(std::string(TR("shield_send_failed")) + error); + } + }; + }); + return; + } + + // Merge / consolidate. Source → z_mergetoaddress fromaddress selector (this is the fix: shielded + // notes, not just transparent UTXOs — the wallet-bloat the nudge warns about is shielded witnesses). + std::vector fromAddrs; + if (s_src == 0) fromAddrs = { "ANY_TADDR" }; + else if (s_src == 1) fromAddrs = { "ANY_SAPLING" }; + else fromAddrs = { "*" }; + std::string to(s_to_address); + double fee = s_fee; int limit = s_utxo_limit; + if (!app->worker()) return; + app->worker()->post([app, rpc = app->rpc(), fromAddrs, to, fee, limit]() -> rpc::RPCWorker::MainCb { + nlohmann::json addrs = nlohmann::json::array(); + for (const auto& a : fromAddrs) addrs.push_back(a); + nlohmann::json result; std::string error; + try { + rpc::RPCClient::TraceScope trace("Shield dialog / Consolidate"); + // fromaddrs, toaddr, fee, transparent_limit, shielded_limit — cap both to the batch size. + result = rpc->call("z_mergetoaddress", {addrs, to, fee, limit, limit}); + } catch (const std::exception& e) { error = e.what(); } + return [app, result, error]() { + if (error.empty()) { + s_operation_id = result.value("opid", ""); + s_status_message = TR("merge_progress"); + Notifications::instance().success(TR("merge_started")); + app->trackOperation(s_operation_id); + } else { + s_operation_pending = false; s_op_terminal = true; + s_status_message = std::string(TR("shield_error_prefix")) + error; + Notifications::instance().error(std::string(TR("merge_send_failed")) + error); + } + }; + }); +} + +// Live-progress self-poll: while an op is in flight, poll z_getoperationstatus every ~2s so the modal +// shows "Consolidating… → Done/Failed" without a manual button. (The shared poller also tracks it for +// balance refresh; this drives only the inline display.) +static void pollOperation(App* app) +{ + if (s_operation_id.empty() || s_op_terminal || !app->worker()) return; + const double now = ImGui::GetTime(); + if (now - s_last_poll < 2.0) return; + s_last_poll = now; + std::string opid = s_operation_id; + app->worker()->post([rpc = app->rpc(), opid]() -> rpc::RPCWorker::MainCb { + nlohmann::json result; std::string error; + try { + rpc::RPCClient::TraceScope trace("Shield dialog / Op status"); + result = rpc->call("z_getoperationstatus", {nlohmann::json::array({opid})}); + } catch (const std::exception& e) { error = e.what(); } + return [result, error]() { + if (!error.empty() || !result.is_array() || result.empty()) return; // transient — retry next tick + const auto& op = result[0]; + const std::string status = op.value("status", ""); + if (status == "success") { + s_operation_pending = false; s_op_terminal = true; + s_status_message = TR("shield_completed"); + Notifications::instance().success(TR("shield_merge_done")); + } else if (status == "failed") { + std::string msg = op.value("error", nlohmann::json{}).value("message", std::string(TR("shield_unknown_error"))); + s_operation_pending = false; s_op_terminal = true; + s_status_message = std::string(TR("shield_op_failed")) + msg; + Notifications::instance().error(std::string(TR("shield_op_failed")) + msg); + } + // queued / executing → leave the "Consolidating…" message and keep polling. + }; + }); } void ShieldDialog::render(App* app) @@ -74,263 +266,221 @@ void ShieldDialog::render(App* app) if (!s_open) return; auto& S = schema::UI(); - auto win = S.window("dialogs.shield"); - auto addrLbl = S.label("dialogs.shield", "address-label"); - auto addrFrontLbl = S.label("dialogs.shield", "address-front-label"); - auto addrBackLbl = S.label("dialogs.shield", "address-back-label"); - auto feeInput = S.input("dialogs.shield", "fee-input"); - auto utxoInput = S.input("dialogs.shield", "utxo-limit-input"); - auto shieldBtn = S.button("dialogs.shield", "shield-button"); - auto cancelBtn = S.button("dialogs.shield", "cancel-button"); + auto win = S.window("dialogs.shield"); + auto addrLbl = S.label("dialogs.shield", "address-label"); + auto addrFront = S.label("dialogs.shield", "address-front-label"); + auto addrBack = S.label("dialogs.shield", "address-back-label"); + auto feeInput = S.input("dialogs.shield", "fee-input"); + auto utxoInput = S.input("dialogs.shield", "utxo-limit-input"); + auto shieldBtn = S.button("dialogs.shield", "shield-button"); + auto cancelBtn = S.button("dialogs.shield", "cancel-button"); + const float dp = Layout::dpiScale(); + const bool isMerge = (s_mode == Mode::MergeToAddress); - const char* title = (s_mode == Mode::ShieldCoinbase) - ? TR("shield_title") - : TR("merge_title"); + const char* title = s_consolidate ? TR("consolidate_title") + : isMerge ? TR("merge_title") + : TR("shield_title"); material::OverlayDialogSpec ov; ov.title = title; ov.p_open = &s_open; ov.style = material::OverlayStyle::BlurFloat; ov.cardWidth = win.width; ov.idSuffix = "shielddialog"; - if (material::BeginOverlayDialog(ov)) { - const auto& state = app->getWalletState(); + if (!material::BeginOverlayDialog(ov)) return; - // Description - if (s_mode == Mode::ShieldCoinbase) { - ImGui::TextWrapped("%s", TR("shield_description")); - } else { - ImGui::TextWrapped("%s", TR("merge_description")); + const auto& state = app->getWalletState(); + autoSelectDestination(state); + pollOperation(app); + if (isMerge && !s_scope_loaded && !s_scope_loading && s_operation_id.empty()) loadScope(app); + + // ── Description ────────────────────────────────────────────────────────────────────────────── + ImGui::TextWrapped("%s", s_consolidate ? TR("consolidate_desc") + : isMerge ? TR("merge_description") + : TR("shield_description")); + ImGui::Spacing(); + + const bool opInFlight = !s_operation_id.empty(); // submitted — inputs frozen, showing progress + + // ── Merge: scope + source selector ────────────────────────────────────────────────────────── + if (isMerge && !opInFlight) { + if (s_scope_loading) { + material::Type().textColored(material::TypeStyle::Caption, material::OnSurfaceMedium(), + TR("merge_scope_loading")); + } else if (s_scope_loaded) { + char buf[160]; + std::snprintf(buf, sizeof(buf), TR("merge_scope_fmt"), + s_t_count, s_z_count, fmtAmt(s_t_amount + s_z_amount).c_str()); + material::Type().textColored(material::TypeStyle::Caption, material::OnSurfaceMedium(), buf); } - ImGui::Spacing(); - // From address (for shield coinbase) - if (s_mode == Mode::ShieldCoinbase) { - material::LabeledInput(TR("shield_from_address"), "##FromAddr", s_from_address, sizeof(s_from_address)); - ImGui::TextDisabled("%s", TR("shield_wildcard_hint")); + // Source selector — only offer the types that actually have inputs. + const bool tOk = s_t_count > 0, zOk = s_z_count > 0; + if (tOk && zOk) { + ImGui::AlignTextToFramePadding(); + ImGui::TextUnformatted(TR("merge_source")); + ImGui::SameLine(0, Layout::spacingLg()); + ImGui::RadioButton(TR("merge_src_shielded"), &s_src, 1); ImGui::SameLine(); + ImGui::RadioButton(TR("merge_src_transparent"), &s_src, 0); ImGui::SameLine(); + ImGui::RadioButton(TR("merge_src_both"), &s_src, 2); ImGui::Spacing(); } - - // To address (z-address dropdown) - ImGui::Text("%s", TR("shield_to_address")); - - // Get z-addresses for dropdown - std::string to_display = s_to_address[0] ? s_to_address : TR("shield_select_z"); - if (to_display.length() > static_cast(addrLbl.truncate)) { - to_display = to_display.substr(0, addrFrontLbl.truncate) + "..." + to_display.substr(to_display.length() - addrBackLbl.truncate); - } - - ImGui::SetNextItemWidth(-1); - if (ImGui::BeginCombo("##ToAddr", to_display.c_str())) { - for (size_t i = 0; i < state.z_addresses.size(); i++) { - const auto& addr = state.z_addresses[i]; - std::string label = addr.address; - if (label.length() > static_cast(addrLbl.truncate)) { - label = label.substr(0, addrFrontLbl.truncate) + "..." + label.substr(label.length() - addrBackLbl.truncate); - } - - bool selected = (s_selected_zaddr_idx == static_cast(i)); - if (ImGui::Selectable(label.c_str(), selected)) { - s_selected_zaddr_idx = static_cast(i); - strncpy(s_to_address, addr.address.c_str(), sizeof(s_to_address) - 1); - } - if (selected) { - ImGui::SetItemDefaultFocus(); - } - } - ImGui::EndCombo(); - } - if (state.z_addresses.empty()) { - material::Type().textColored(material::TypeStyle::Caption, material::Warning(), - TR("shield_no_zaddr_hint")); - } - - ImGui::Spacing(); - - // Fee + UTXO limit share one row (two columns) to tighten vertical rhythm. - float pairColX = ImGui::GetContentRegionAvail().x * 0.5f; - - // Fee (left column) - ImGui::Text("%s", TR("fee_label")); - ImGui::SetNextItemWidth(feeInput.width * Layout::dpiScale()); - ImGui::InputDouble("##Fee", &s_fee, 0.0001, 0.001, "%.8f"); - if (s_fee < 0.0) s_fee = 0.0; // no negative fee - if (s_fee > 1.0) s_fee = 1.0; // guard a fat-fingered huge fee (mirrors utxo clamp) - ImGui::SameLine(); - ImGui::TextDisabled("DRGX"); - - // UTXO limit (right column) — hint drops under the input (rather than beside it) since - // "Max UTXOs per operation" is too long to share the narrower half-width column with "DRGX". - ImGui::SameLine(pairColX); - ImGui::BeginGroup(); - ImGui::Text("%s", TR("shield_utxo_limit")); - ImGui::SetNextItemWidth(utxoInput.width * Layout::dpiScale()); - ImGui::InputInt("##Limit", &s_utxo_limit); - if (s_utxo_limit < 1) s_utxo_limit = 1; - if (s_utxo_limit > 100) s_utxo_limit = 100; - material::Type().textColored(material::TypeStyle::Caption, material::OnSurfaceMedium(), - TR("shield_max_utxos")); - ImGui::EndGroup(); - - ImGui::Spacing(); - - // Status message - if (!s_status_message.empty()) { - if (s_operation_pending) { - ImGui::TextColored(ImVec4(1.0f, 0.8f, 0.0f, 1.0f), "%s", s_status_message.c_str()); - } else { - ImGui::TextWrapped("%s", s_status_message.c_str()); - } - ImGui::Spacing(); - } - - // Buttons — guard on connection/sync like the Send tab (a disconnected or mid-sync submit just - // fails at the daemon with a raw error). - bool sh_connected = app->isConnected(); - bool sh_syncing = state.sync.syncing; - bool can_submit = !s_operation_pending && s_to_address[0] != '\0' && sh_connected && !sh_syncing; - - // Center the primary + Cancel action row via the shared footer helper. We can't use - // DialogActionFooter here because the primary button carries a disabled-hover tooltip that must - // fire on ITS item (the helper draws primary+Close internally, leaving no hook between them), so - // we keep the two TactileButtons + the interleaved tooltip and only standardize the placement. - const char* btn_label = (s_mode == Mode::ShieldCoinbase) ? TR("shield_funds") : TR("merge_funds"); - float footerBtnW = shieldBtn.width + cancelBtn.width + ImGui::GetStyle().ItemSpacing.x; - material::BeginOverlayDialogFooter(footerBtnW, /*drawSeparator=*/false); - - if (!can_submit) ImGui::BeginDisabled(); - - if (material::TactileButton(btn_label, ImVec2(shieldBtn.width, 0), S.resolveFont(shieldBtn.font))) { - s_operation_pending = true; - s_status_message = TR("shield_submitting"); - - if (s_mode == Mode::ShieldCoinbase) { - std::string from(s_from_address), to(s_to_address); - double fee = s_fee; - int limit = s_utxo_limit; - if (app->worker()) { - app->worker()->post([app, rpc = app->rpc(), from, to, fee, limit]() -> rpc::RPCWorker::MainCb { - nlohmann::json result; - std::string error; - try { - rpc::RPCClient::TraceScope trace("Send tab / Shield coinbase"); - result = rpc->call("z_shieldcoinbase", {from, to, fee, limit}); - } catch (const std::exception& e) { - error = e.what(); - } - return [app, result, error]() { - s_operation_pending = false; - if (error.empty()) { - s_operation_id = result.value("opid", ""); - s_status_message = std::string(TR("shield_op_submitted")) + s_operation_id; - Notifications::instance().success(TR("shield_started")); - // Register with the shared poller so an async failure is - // surfaced (and balances refresh) even after this dialog closes. - app->trackOperation(s_operation_id); - } else { - s_status_message = std::string(TR("shield_error_prefix")) + error; - Notifications::instance().error(std::string(TR("shield_send_failed")) + error); - } - }; - }); - } - } else { - std::vector fromAddrs; - fromAddrs.push_back("ANY_TADDR"); - std::string to(s_to_address); - double fee = s_fee; - int limit = s_utxo_limit; - if (app->worker()) { - app->worker()->post([app, rpc = app->rpc(), fromAddrs, to, fee, limit]() -> rpc::RPCWorker::MainCb { - nlohmann::json addrs = nlohmann::json::array(); - for (const auto& addr : fromAddrs) addrs.push_back(addr); - nlohmann::json result; - std::string error; - try { - rpc::RPCClient::TraceScope trace("Send tab / Merge funds"); - result = rpc->call("z_mergetoaddress", {addrs, to, fee, 0, limit}); - } catch (const std::exception& e) { - error = e.what(); - } - return [app, result, error]() { - s_operation_pending = false; - if (error.empty()) { - s_operation_id = result.value("opid", ""); - s_status_message = std::string(TR("shield_op_submitted")) + s_operation_id; - Notifications::instance().success(TR("merge_started")); - // Register with the shared poller so an async failure is - // surfaced (and balances refresh) even after this dialog closes. - app->trackOperation(s_operation_id); - } else { - s_status_message = std::string(TR("shield_error_prefix")) + error; - Notifications::instance().error(std::string(TR("merge_send_failed")) + error); - } - }; - }); - } - } - } - - if (!can_submit) ImGui::EndDisabled(); - if (!can_submit && ImGui::IsItemHovered(ImGuiHoveredFlags_AllowWhenDisabled)) { - if (!sh_connected) material::Tooltip("%s", TR("send_tooltip_not_connected")); - else if (sh_syncing) material::Tooltip("%s", TR("send_tooltip_syncing")); - else if (s_to_address[0]=='\0') material::Tooltip("%s", TR("shield_select_z")); - } - - ImGui::SameLine(); - - if (material::TactileButton(TR("cancel"), ImVec2(cancelBtn.width, 0), S.resolveFont(cancelBtn.font))) { - s_open = false; - } - - // Show operation status if we have an opid - if (!s_operation_id.empty()) { - ImGui::Spacing(); - ImGui::Separator(); - ImGui::Spacing(); - - ImGui::Text(TR("shield_operation_id"), s_operation_id.c_str()); - - if (material::TactileButton(TR("shield_check_status"), ImVec2(0,0), S.resolveFont(shieldBtn.font))) { - std::string opid = s_operation_id; - if (app->worker()) { - app->worker()->post([rpc = app->rpc(), opid]() -> rpc::RPCWorker::MainCb { - nlohmann::json result; - std::string error; - try { - rpc::RPCClient::TraceScope trace("Send tab / Shield operation status"); - nlohmann::json ids = nlohmann::json::array(); - ids.push_back(opid); - result = rpc->call("z_getoperationstatus", {ids}); - } catch (const std::exception& e) { - error = e.what(); - } - return [result, error]() { - if (error.empty() && result.is_array() && !result.empty()) { - auto& op = result[0]; - std::string status = op.value("status", "unknown"); - if (status == "success") { - s_status_message = TR("shield_completed"); - Notifications::instance().success(TR("shield_merge_done")); - } else if (status == "failed") { - std::string errMsg = op.value("error", nlohmann::json{}).value("message", TR("shield_unknown_error")); - s_status_message = std::string(TR("shield_op_failed")) + errMsg; - Notifications::instance().error(std::string(TR("shield_op_failed")) + errMsg); - } else if (status == "executing") { - s_status_message = TR("shield_in_progress"); - } else { - s_status_message = std::string(TR("shield_status_label")) + status; - } - } else if (!error.empty()) { - s_status_message = std::string(TR("shield_status_check_error")) + error; - } - }; - }); - } - } - } - material::EndOverlayDialog(); } + + // ── Shield coinbase: from address ─────────────────────────────────────────────────────────── + if (!isMerge && !opInFlight) { + material::LabeledInput(TR("shield_from_address"), "##FromAddr", s_from_address, sizeof(s_from_address)); + ImGui::TextDisabled("%s", TR("shield_wildcard_hint")); + ImGui::Spacing(); + } + + // ── Destination (z-address) ───────────────────────────────────────────────────────────────── + if (!opInFlight) { + ImGui::TextUnformatted(TR("shield_to_address")); + if (state.z_addresses.empty()) { + material::Type().textColored(material::TypeStyle::Caption, material::Warning(), TR("shield_no_zaddr_hint")); + ImGui::Spacing(); + if (s_creating_addr) { + ImGui::TextDisabled("%s", TR("merge_creating")); + } else if (material::TactileButton(TR("merge_create_zaddr"), ImVec2(0, 0), S.resolveFont(shieldBtn.font))) { + s_creating_addr = true; + if (app->worker()) app->worker()->post([app, rpc = app->rpc()]() -> rpc::RPCWorker::MainCb { + std::string addr, error; + try { + rpc::RPCClient::TraceScope trace("Shield dialog / New z-address"); + addr = rpc->call("z_getnewaddress", nlohmann::json::array()).get(); + } catch (const std::exception& e) { error = e.what(); } + return [app, addr, error]() { + s_creating_addr = false; + if (error.empty() && !addr.empty()) { + strncpy(s_to_address, addr.c_str(), sizeof(s_to_address) - 1); + Notifications::instance().success(TR("merge_addr_created")); + } else { + Notifications::instance().error(std::string(TR("shield_error_prefix")) + error); + } + }; + }); + } + } else { + std::string to_display = s_to_address[0] ? s_to_address : TR("shield_select_z"); + if (to_display.length() > static_cast(addrLbl.truncate)) + to_display = to_display.substr(0, addrFront.truncate) + "..." + to_display.substr(to_display.length() - addrBack.truncate); + ImGui::SetNextItemWidth(-1); + if (ImGui::BeginCombo("##ToAddr", to_display.c_str())) { + for (size_t i = 0; i < state.z_addresses.size(); i++) { + std::string label = state.z_addresses[i].address; + if (label.length() > static_cast(addrLbl.truncate)) + label = label.substr(0, addrFront.truncate) + "..." + label.substr(label.length() - addrBack.truncate); + bool selected = (s_selected_zaddr_idx == static_cast(i)); + if (ImGui::Selectable(label.c_str(), selected)) { + s_selected_zaddr_idx = static_cast(i); + strncpy(s_to_address, state.z_addresses[i].address.c_str(), sizeof(s_to_address) - 1); + } + if (selected) ImGui::SetItemDefaultFocus(); + } + ImGui::EndCombo(); + } + } + ImGui::Spacing(); + + // ── Advanced (fee + batch size) ───────────────────────────────────────────────────────── + ImDrawList* dl = ImGui::GetWindowDrawList(); + material::CollapsibleHeader(dl, "##AdvToggle", TR("merge_advanced"), s_advanced, + ImGui::GetContentRegionAvail().x, material::Type().caption(), + material::OnSurfaceMedium()); + if (s_advanced) { + ImGui::Spacing(); + ImGui::TextUnformatted(TR("fee_label")); + ImGui::SetNextItemWidth(feeInput.width * dp); + ImGui::InputDouble("##Fee", &s_fee, 0.0001, 0.001, "%.8f"); + if (s_fee < 0.0) s_fee = 0.0; + if (s_fee > 1.0) s_fee = 1.0; + ImGui::SameLine(); ImGui::TextDisabled("DRGX"); + material::Type().textColored(material::TypeStyle::Caption, material::OnSurfaceMedium(), TR("merge_fee_hint")); + + ImGui::Spacing(); + ImGui::TextUnformatted(TR("merge_max_inputs")); + ImGui::SetNextItemWidth(utxoInput.width * dp); + ImGui::InputInt("##Limit", &s_utxo_limit); + if (s_utxo_limit < 1) s_utxo_limit = 1; + if (s_utxo_limit > 100) s_utxo_limit = 100; + } + + // Batch hint: one run only merges up to the limit; large sets need repeats. + if (isMerge && s_scope_loaded && srcCount() > s_utxo_limit) { + char hb[160]; + std::snprintf(hb, sizeof(hb), TR("merge_batch_fmt"), s_utxo_limit); + ImGui::Spacing(); + material::Type().textColored(material::TypeStyle::Caption, material::Warning(), hb); + } + ImGui::Spacing(); + } + + // ── Live progress / status ────────────────────────────────────────────────────────────────── + if (!s_status_message.empty()) { + if (s_operation_pending && !s_op_terminal) + ImGui::TextColored(ImVec4(1.0f, 0.8f, 0.0f, 1.0f), "%s", s_status_message.c_str()); + else + ImGui::TextWrapped("%s", s_status_message.c_str()); + ImGui::Spacing(); + } + + // ── Footer ────────────────────────────────────────────────────────────────────────────────── + const bool connected = app->isConnected(); + const bool syncing = state.sync.syncing; + const bool haveDest = s_to_address[0] != '\0'; + + if (opInFlight) { + // After submit: just a Close button (progress shows above; op continues in the background). + material::BeginOverlayDialogFooter(cancelBtn.width, /*drawSeparator=*/false); + if (material::TactileButton(s_op_terminal ? TR("done") : TR("close"), + ImVec2(cancelBtn.width, 0), S.resolveFont(cancelBtn.font))) + s_open = false; + material::EndOverlayDialog(); + return; + } + + const char* primaryLabel = s_confirm ? TR("merge_confirm_btn") + : s_consolidate ? TR("consolidate_funds_btn") + : isMerge ? TR("merge_funds") + : TR("shield_funds"); + const char* secondaryLabel = s_confirm ? TR("merge_back") : TR("cancel"); + + // Confirm summary (inline, before the fund-moving call). Merge/consolidate shows amount + input + // count; shield-coinbase just gets the button relabel (its inputs aren't enumerated here). + if (s_confirm && isMerge) { + char cb[200]; + std::snprintf(cb, sizeof(cb), TR("merge_confirm_fmt"), + fmtAmt(srcAmount()).c_str(), srcCount(), shortAddr(s_to_address).c_str()); + ImGui::TextWrapped("%s", cb); + ImGui::Spacing(); + } + + bool can_submit = haveDest && connected && !syncing; + if (isMerge && s_scope_loaded && srcCount() == 0) can_submit = false; + + float footerBtnW = shieldBtn.width + cancelBtn.width + ImGui::GetStyle().ItemSpacing.x; + material::BeginOverlayDialogFooter(footerBtnW, /*drawSeparator=*/false); + + if (!can_submit) ImGui::BeginDisabled(); + if (material::TactileButton(primaryLabel, ImVec2(shieldBtn.width, 0), S.resolveFont(shieldBtn.font))) { + if (s_confirm) { submitOperation(app); } + else { s_confirm = true; } // first click → show the confirm summary + } + if (!can_submit) ImGui::EndDisabled(); + if (!can_submit && ImGui::IsItemHovered(ImGuiHoveredFlags_AllowWhenDisabled)) { + if (!connected) material::Tooltip("%s", TR("send_tooltip_not_connected")); + else if (syncing) material::Tooltip("%s", TR("send_tooltip_syncing")); + else if (!haveDest) material::Tooltip("%s", TR("shield_select_z")); + else if (isMerge && srcCount() == 0) material::Tooltip("%s", TR("merge_no_spendable")); + } + + ImGui::SameLine(); + if (material::TactileButton(secondaryLabel, ImVec2(cancelBtn.width, 0), S.resolveFont(cancelBtn.font))) { + if (s_confirm) s_confirm = false; // Back → return to the form + else s_open = false; // Cancel → close + } + + material::EndOverlayDialog(); } } // namespace ui diff --git a/src/ui/windows/shield_dialog.h b/src/ui/windows/shield_dialog.h index 296c32c..e37cd86 100644 --- a/src/ui/windows/shield_dialog.h +++ b/src/ui/windows/shield_dialog.h @@ -33,10 +33,16 @@ public: static void showShieldCoinbase(const std::string& fromAddress = "*"); /** - * @brief Show merge to address dialog + * @brief Show merge to address dialog (generic — both transparent + shielded sources) */ static void showMerge(); + /** + * @brief Show the consolidate-funds flow preset for wallet-bloat reduction (shielded notes). + * Used by the large-wallet nudges (Settings banner + alert action). + */ + static void showConsolidate(); + /** * @brief Render the dialog (call each frame) */ diff --git a/src/util/i18n.cpp b/src/util/i18n.cpp index 0c684fa..3230589 100644 --- a/src/util/i18n.cpp +++ b/src/util/i18n.cpp @@ -2241,6 +2241,29 @@ void I18n::loadBuiltinEnglish() strings_["merge_funds"] = "Merge Funds"; strings_["merge_started"] = "Merge operation started"; strings_["merge_title"] = "Merge to Address"; + // Consolidate-funds flow (rich merge modal + wallet-bloat preset). + strings_["consolidate_title"] = "Consolidate funds"; + strings_["consolidate_desc"] = "Combine many small inputs into a single shielded note. Fewer notes means a smaller wallet file and better privacy."; + strings_["consolidate_funds_btn"] = "Consolidate"; + strings_["merge_scope_loading"] = "Checking your inputs\xE2\x80\xA6"; + strings_["merge_scope_fmt"] = "%d transparent + %d shielded inputs \xC2\xB7 ~%s DRGX spendable"; + strings_["merge_source"] = "Consolidate"; + strings_["merge_src_transparent"] = "Transparent"; + strings_["merge_src_shielded"] = "Shielded"; + strings_["merge_src_both"] = "Both"; + strings_["merge_batch_fmt"] = "Merges up to %d inputs per run \xE2\x80\x94 repeat to finish the rest."; + strings_["merge_advanced"] = "Advanced"; + strings_["merge_max_inputs"] = "Max inputs per batch"; + strings_["merge_fee_hint"] = "Network fee for this transaction."; + strings_["merge_create_zaddr"] = "Create shielded address"; + strings_["merge_creating"] = "Creating address\xE2\x80\xA6"; + strings_["merge_addr_created"] = "Shielded address created."; + strings_["merge_confirm_fmt"] = "Consolidate ~%s DRGX from %d input(s) into %s?"; + strings_["merge_confirm_btn"] = "Confirm"; + strings_["merge_back"] = "Back"; + strings_["merge_progress"] = "Consolidating\xE2\x80\xA6 this can take a few minutes. You can close this window."; + strings_["merge_no_spendable"] = "No spendable inputs to consolidate yet."; + strings_["done"] = "Done"; // --- Transaction Details Dialog --- strings_["tx_confirmations"] = "%d confirmations"; From 870793433be713553139746b04bf3ea6d815517d Mon Sep 17 00:00:00 2001 From: DanS Date: Sun, 30 Aug 2026 22:45:51 -0500 Subject: [PATCH 67/89] fix(sync): stop large-wallet balance polling from starving block connection MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit On a fully-shielded (ac_private=1) chain, z_gettotalbalance is O(mapWallet) and holds the daemon's cs_main for its whole duration — ~20s on a ~5k-tx wallet. The Overview refresh polled it every ~2s (twice: minconf 0 and 1), so cs_main was held almost continuously, starving the single block-connection thread: the node connected blocks only in the gaps between polls and could fall further behind the tip than it caught up (observed live: gap growing 58→100 blocks while the GUI was open, one core pegged on GetFilteredNotes, 22 idle, ~17 B/s download). Two hardening changes on top of the existing "skip balance while syncing" guard: - Hysteresis: keep the low-impact sync profile (and balance suppression) for a short settle window after catching up, so a large-wallet scan can't immediately re-starve connection and bounce the node back into syncing. Armed only on the syncing→caught-up edge, so a wallet synced from the start is never throttled at connect (effectivelySyncing()). - Adaptive balance cadence: time each z_gettotalbalance scan and require the next poll to wait at least (cost / 10%), so balance scanning never occupies more than ~10% of wall-clock. Cheap wallets are unaffected (the tab's Core timer stays the cadence); a ~20s scan backs off to ~200s. Wallet mutations (send/shield) force the next poll through so the user's own action updates the balance immediately (balanceRefreshDue()). getblockchaininfo keeps its normal cadence throughout, so sync progress stays live. Build + test_phase4 green. Co-Authored-By: Claude Opus 4.8 (1M context) --- src/app.cpp | 4 +- src/app.h | 10 +++++ src/app_network.cpp | 56 +++++++++++++++++++++--- src/services/network_refresh_service.cpp | 12 ++++- src/services/network_refresh_service.h | 1 + 5 files changed, 76 insertions(+), 7 deletions(-) diff --git a/src/app.cpp b/src/app.cpp index ee4d877..9828be1 100644 --- a/src/app.cpp +++ b/src/app.cpp @@ -919,7 +919,9 @@ void App::update() // Re-apply the refresh cadence when sync starts/finishes: while syncing we throttle polling to // a low-impact profile so RPC contention doesn't slow block download (see applyRefreshPolicy). - if (state_.sync.syncing != refresh_policy_syncing_) { + // effectivelySyncing() includes the post-sync settle window, so this also reverts to the normal + // per-tab cadence once that window elapses. + if (effectivelySyncing() != refresh_policy_syncing_) { applyRefreshPolicy(current_page_); } diff --git a/src/app.h b/src/app.h index dc1f0fa..93cc22a 100644 --- a/src/app.h +++ b/src/app.h @@ -1102,6 +1102,14 @@ private: bool daemon_start_error_shown_ = false; int daemon_last_seen_crashes_ = 0; // surface each new embedded-daemon crash reason once bool refresh_policy_syncing_ = false; // whether the sync-throttle refresh profile is active + // Sync-settle hysteresis + adaptive balance-poll throttle. Balance polling (z_gettotalbalance) is + // O(mapWallet) and holds the daemon's cs_main, which starves block connection on a large shielded + // wallet — so we keep the low-impact profile briefly after catching up, and back the balance poll + // off in proportion to its own measured cost. See effectivelySyncing() / balanceRefreshDue(). + bool was_core_syncing_ = false; // previous Core-refresh sync state, to detect the caught-up edge + std::time_t sync_settle_until_ = 0; // hold the sync-throttle until this wall-clock time (0 = not settling) + double last_balance_scan_ms_ = 0.0; // measured cost of the last z_gettotalbalance scan + bool force_balance_refresh_ = false; // a wallet mutation forces the next balance poll through the throttle // Auto-clear for secrets copied to the clipboard. Only a hash of the copied secret is kept. std::uint64_t clipboard_secret_hash_ = 0; double clipboard_clear_deadline_ = 0.0; @@ -1439,6 +1447,8 @@ private: void refreshPrice(); void refreshWalletEncryptionState(); void applyRefreshPolicy(ui::NavPage page); + bool effectivelySyncing() const; // syncing, or within the post-sync settle window (hysteresis) + bool balanceRefreshDue() const; // adaptive: enough time elapsed given the last balance-scan cost? bool currentPageNeedsWalletDataRefresh() const; bool shouldRunWalletTransactionRefresh() const; bool shouldRefreshTransactions() const; diff --git a/src/app_network.cpp b/src/app_network.cpp index 17015f8..b05ca64 100644 --- a/src/app_network.cpp +++ b/src/app_network.cpp @@ -837,13 +837,39 @@ void App::applyRefreshPolicy(ui::NavPage page) // While the daemon is syncing, override the per-tab cadence with the low-impact sync profile so // the wallet stops contending for the daemon's cs_main lock (frequent getpeerinfo / per-block // transaction scans / balance polls slow block connection). This makes every tab sync as fast - // as the Console tab does today. Reverts to the per-tab profile once sync finishes. - refresh_policy_syncing_ = state_.sync.syncing; + // as the Console tab does today. effectivelySyncing() keeps this profile on briefly after catching + // up (hysteresis) so a large-wallet scan can't immediately re-starve connection and bounce the + // node back into "syncing". Reverts to the per-tab profile once the settle window passes. + refresh_policy_syncing_ = effectivelySyncing(); network_refresh_.setIntervals(refresh_policy_syncing_ ? services::RefreshScheduler::kSyncProfile : getIntervalsForPage(page)); } +// True while the node is behind, and for a short settle window after it first catches up. The settle +// window is armed only on the syncing→caught-up edge (see the Core refresh callback), so a wallet that +// was synced from the start is never throttled at connect — only a node that just finished catching up. +bool App::effectivelySyncing() const +{ + if (state_.sync.syncing) return true; + if (sync_settle_until_ == 0) return false; // no pending settle → genuinely caught up + return std::time(nullptr) < sync_settle_until_; +} + +// Adaptive throttle: the next balance poll must wait at least (lastScanCost / kBalanceDutyCycle) since +// the last one, so balance scanning can never occupy more than ~kBalanceDutyCycle of wall-clock. A +// cheap wallet (sub-cadence cost) is unaffected — the tab's Core timer stays the real cadence; a ~20s +// scan on a large wallet backs off to roughly every ~200s instead of every 2s, freeing cs_main for +// block connection. A wallet mutation bypasses this via force_balance_refresh_. +bool App::balanceRefreshDue() const +{ + constexpr double kBalanceDutyCycle = 0.10; + if (state_.last_balance_update == 0) return true; // never fetched + if (last_balance_scan_ms_ <= 0.0) return true; // no cost measured yet + const double minInterval = (last_balance_scan_ms_ / 1000.0) / kBalanceDutyCycle; + return std::difftime(std::time(nullptr), state_.last_balance_update) >= minInterval; +} + bool App::currentPageNeedsWalletDataRefresh() const { using NP = ui::NavPage; @@ -1666,9 +1692,15 @@ void App::refreshCoreData() ? fast_rpc_.get() : rpc_.get(); if (!w || !rpc) return; ui::NavPage tracePage = current_page_; - // Skip the balance call while syncing (it's incomplete anyway and takes the wallet lock + - // cs_main). Captured on the main thread to avoid reading state_ off the worker thread. - const bool includeBalance = !state_.sync.syncing; + // Decide whether to include the balance call (z_gettotalbalance — O(mapWallet), holds cs_main). + // Suppress it (a) while syncing or within the post-sync settle window, so it can't starve block + // connection, and (b) unless enough time has elapsed given the LAST scan's measured cost, so a + // large shielded wallet backs off automatically instead of re-scanning every couple of seconds. + // A wallet mutation (send/shield) forces the next poll through so the user's own action updates the + // balance immediately. Captured on the main thread to avoid reading state_ off the worker thread. + const bool includeBalance = !effectivelySyncing() && + (force_balance_refresh_ || balanceRefreshDue()); + if (includeBalance) force_balance_refresh_ = false; auto enqueued = network_refresh_.enqueue(services::NetworkRefreshService::Job::Core, *w, [this, rpc, tracePage, includeBalance]() -> rpc::RPCWorker::MainCb { AppRefreshRpcGateway refreshRpc(*rpc, traceSource(tracePage, "Core refresh")); @@ -1678,6 +1710,19 @@ void App::refreshCoreData() NetworkRefreshService::applyCoreRefreshResult(state_, result, std::time(nullptr)); applyPendingSendBalanceDeltas(true); + // Feed the adaptive balance throttle + sync-settle hysteresis. Record the last scan's + // cost (0 when balance was skipped), and arm the settle window only on the + // syncing→caught-up edge so a wallet synced from the start is never throttled at connect. + if (result.balanceScanMs > 0.0) last_balance_scan_ms_ = result.balanceScanMs; + const bool nowSyncing = state_.sync.syncing; + if (nowSyncing) { + sync_settle_until_ = 0; + } else if (was_core_syncing_) { + constexpr double kSyncSettleSeconds = 8.0; + sync_settle_until_ = std::time(nullptr) + static_cast(kSyncSettleSeconds); + } + was_core_syncing_ = nowSyncing; + // Mid-session connection-loss detection. During normal operation, both core // RPCs failing together means the daemon connection is dead (a busy daemon // fails them individually, not both at once). Warmup is excluded — both fail @@ -5300,6 +5345,7 @@ void App::submitZSendMany(const std::string& from, const std::string& to, double // Force transaction list refresh so the sent tx appears immediately transactions_dirty_ = true; last_tx_block_height_ = -1; + force_balance_refresh_ = true; // the user's own send must update the balance now, past the throttle network_refresh_.markWalletMutationRefresh(); // z_sendmany only returned an opid: the transaction is built/signed/ // broadcast asynchronously by the daemon. Defer the user-facing diff --git a/src/services/network_refresh_service.cpp b/src/services/network_refresh_service.cpp index 39755e5..33d331f 100644 --- a/src/services/network_refresh_service.cpp +++ b/src/services/network_refresh_service.cpp @@ -3,6 +3,7 @@ #include #include +#include #include #include #include @@ -294,8 +295,13 @@ NetworkRefreshService::CoreRefreshResult NetworkRefreshService::collectCoreRefre json blockInfo; bool balanceOk = false; bool blockOk = false; + double balanceScanMs = 0.0; if (includeBalance) { + // z_gettotalbalance is O(mapWallet) and holds the daemon's cs_main for its whole duration — + // seconds on a large shielded wallet. Time it so the caller can throttle how often it polls + // (balanceRefreshDue()), keeping balance scans from starving block connection. + const auto balanceStart = std::chrono::steady_clock::now(); 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; @@ -305,6 +311,8 @@ NetworkRefreshService::CoreRefreshResult NetworkRefreshService::collectCoreRefre try { // SPENDABLE total: minconf=1 (confirmed). If absent, spendable degrades to display in apply. spendableBalance = rpc.call("z_gettotalbalance", json::array({1})); } catch (...) {} + balanceScanMs = std::chrono::duration( + std::chrono::steady_clock::now() - balanceStart).count(); } try { @@ -314,7 +322,9 @@ NetworkRefreshService::CoreRefreshResult NetworkRefreshService::collectCoreRefre DEBUG_LOGF("BlockchainInfo error: %s\n", e.what()); } - return parseCoreRefreshResult(totalBalance, spendableBalance, balanceOk, blockInfo, blockOk); + auto result = parseCoreRefreshResult(totalBalance, spendableBalance, balanceOk, blockInfo, blockOk); + result.balanceScanMs = balanceScanMs; + return result; } NetworkRefreshService::MiningRefreshResult NetworkRefreshService::parseMiningRefreshResult( diff --git a/src/services/network_refresh_service.h b/src/services/network_refresh_service.h index 26f2215..514a345 100644 --- a/src/services/network_refresh_service.h +++ b/src/services/network_refresh_service.h @@ -111,6 +111,7 @@ public: std::optional verificationProgress; std::optional longestChain; std::optional notarized; + double balanceScanMs = 0.0; // wall-clock spent in z_gettotalbalance this refresh (0 if balance skipped) }; struct MiningRefreshResult { From 29274c2f489d7876492e029666eb6b94f9d35f20 Mon Sep 17 00:00:00 2001 From: DanS Date: Sun, 30 Aug 2026 23:09:17 -0500 Subject: [PATCH 68/89] fix(ui): trim verbose startup notice; show daemon output on shutdown for external daemons MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit - Loading "taking longer than expected" notice: shorten the body + hint so the startup screen reads less wordy (same info, ~half the text). - Shutdown screen: when the wallet attached to an EXTERNAL daemon (no captured stdout — debug_log_path_ is only set when we spawn it), the "dragonxd output" panel was always empty, leaving just a spinner. Fall back to tailing the daemon's debug.log so the user can watch the node flush the block index and exit. Adds App::tailDaemonDebugLog() (best-effort, reads only the file tail). Co-Authored-By: Claude Opus 4.8 (1M context) --- src/app.cpp | 37 +++++++++++++++++++++++++++++++++++++ src/app.h | 7 +++++++ src/util/i18n.cpp | 4 ++-- 3 files changed, 46 insertions(+), 2 deletions(-) diff --git a/src/app.cpp b/src/app.cpp index 9828be1..304d60b 100644 --- a/src/app.cpp +++ b/src/app.cpp @@ -5742,6 +5742,39 @@ void App::beginShutdown() }); } +std::vector App::tailDaemonDebugLog(int maxLines) const +{ + std::vector out; + if (maxLines <= 0) return out; + const std::string path = util::Platform::getDataDir() + "debug.log"; + std::error_code ec; + const auto sz = std::filesystem::file_size(path, ec); + if (ec || sz == 0) return out; + std::ifstream f(path, std::ios::binary); + if (!f) return out; + + // Read only the last ~16 KB — plenty for a handful of lines, cheap even for a multi-GB log. + const std::uintmax_t kTailBytes = 16 * 1024; + const std::uintmax_t start = sz > kTailBytes ? sz - kTailBytes : 0; + f.seekg(static_cast(start), std::ios::beg); + std::string chunk(static_cast(sz - start), '\0'); + f.read(&chunk[0], static_cast(chunk.size())); + chunk.resize(static_cast(f.gcount())); + + std::vector lines; + std::string cur; + for (char c : chunk) { + if (c == '\n') { if (!cur.empty()) lines.push_back(cur); cur.clear(); } + else if (c != '\r') cur.push_back(c); + } + if (!cur.empty()) lines.push_back(cur); + // When we seeked into the middle of the file the first line is a fragment — drop it. + if (start > 0 && !lines.empty()) lines.erase(lines.begin()); + if (static_cast(lines.size()) > maxLines) + lines.erase(lines.begin(), lines.end() - static_cast(maxLines)); + return lines; +} + void App::renderShutdownScreen() { using namespace ui::material; @@ -5974,6 +6007,10 @@ void App::renderShutdownScreen() // ------------------------------------------------------------------- if (daemon_controller_) { auto lines = daemon_controller_->recentLines(8); + // External daemon (attached, not spawned) has no captured stdout — tail its debug.log directly + // so the user can still watch the node flush the block index and exit. + if (lines.empty()) + lines = tailDaemonDebugLog(8); if (!lines.empty()) { float panelW = vp_size.x * shutElem("panel-width-fraction", 0.70f); float panelX = cx - panelW * 0.5f; diff --git a/src/app.h b/src/app.h index 93cc22a..ba1f41c 100644 --- a/src/app.h +++ b/src/app.h @@ -175,6 +175,13 @@ public: */ void renderShutdownScreen(); + /** + * @brief Tail the last N lines of the daemon's debug.log (best-effort, reads only the file tail). + * Fallback for the shutdown screen when we have no captured stdout — e.g. an external daemon we + * attached to rather than spawned — so the user can still see the node flushing/exiting. + */ + std::vector tailDaemonDebugLog(int maxLines) const; + /** * @brief Render loading overlay in content area while daemon is starting/syncing * @param contentH Height of the content area child window diff --git a/src/util/i18n.cpp b/src/util/i18n.cpp index 3230589..d1c9351 100644 --- a/src/util/i18n.cpp +++ b/src/util/i18n.cpp @@ -1456,8 +1456,8 @@ void I18n::loadBuiltinEnglish() 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_["loading_stall_body"] = "Initializing for %.0fs — normal after an update or first launch. Connects automatically when ready."; + strings_["loading_stall_hint"] = "Stuck? Settings → Restart Daemon, or check the Console."; 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_["rpc_plaintext_remote_warning"] = "Remote RPC is using plaintext HTTP. Add rpctls=1 to DRAGONX.conf if your daemon supports TLS."; strings_["settings_open_log_folder"] = "Open log folder"; From 7e8b99a82bbe8428079d037f7c50a7e8c30e77a9 Mon Sep 17 00:00:00 2001 From: DanS Date: Sun, 30 Aug 2026 23:32:03 -0500 Subject: [PATCH 69/89] feat(shutdown): confirm before stopping the daemon mid witness-cache rebuild MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Stopping dragonxd while it's rebuilding the Sapling witness cache discards the in-progress work — BuildWitnessCache aborts on shutdown without persisting — so the next launch redoes a multi-minute rebuild (the "Activating best chain…" hang). This bites especially with stop_external_daemon enabled, where wallet exit sends the node a stop. beginShutdown() now defers when it would StopDaemon while a rebuild is active and shows a confirm modal: "Keep node running & quit" (DisconnectOnly — leaves it up to finish), "Stop anyway & quit", or "Cancel". Rebuild detection reads the debug.log tail markers (Cleared witness data / Setting Initial Sapling Witness / Reading blocks for witness rebuild, vs. the "rebuilt … in …ms" / abort lines). The gate lives entirely in beginShutdown()/render() — no SDL event-loop changes. Co-Authored-By: Claude Opus 4.8 (1M context) --- src/app.cpp | 107 +++++++++++++++++++++++++++++++++++++++++++++++++++- src/app.h | 13 +++++++ 2 files changed, 119 insertions(+), 1 deletion(-) diff --git a/src/app.cpp b/src/app.cpp index 304d60b..4d25ca5 100644 --- a/src/app.cpp +++ b/src/app.cpp @@ -2224,6 +2224,7 @@ void App::render() renderDecryptWalletDialog(); renderPinDialogs(); renderSwitchStopDaemonDialog(); + renderDaemonStopConfirm(); renderBlockDbReindexDialog(); renderWalletRecoveredDialog(); renderEmptyWalletWarningDialog(); @@ -5652,6 +5653,16 @@ void App::beginShutdown() { // Only start shutdown once if (shutting_down_) return; + + // Guard: don't silently discard an in-progress witness-cache rebuild. If we're about to stop the + // daemon while it's rebuilding (stopping now forces a multi-minute rebuild on the next launch), + // defer shutdown and let render() show the confirm modal. The user's choice re-enters beginShutdown() + // with shutdown_confirmed_ set (and, for "keep node running", shutdown_keep_daemon_override_). + if (!shutdown_confirmed_ && shouldConfirmDaemonStop()) { + pending_shutdown_confirm_ = true; + return; // NOT shutting down yet — the normal UI + modal keep rendering + } + shutting_down_ = true; quit_requested_ = true; shutdown_timer_ = 0.0f; @@ -5712,7 +5723,7 @@ void App::beginShutdown() } auto shutdownDecision = daemon_controller_->shutdownDecision( - settings_ && settings_->getKeepDaemonRunning(), + (settings_ && settings_->getKeepDaemonRunning()) || shutdown_keep_daemon_override_, settings_ && settings_->getStopExternalDaemon()); if (shutdownDecision.action == daemon::DaemonController::ShutdownAction::DisconnectOnly) { DEBUG_LOGF("beginShutdown: %s, skipping daemon stop\n", shutdownDecision.logReason); @@ -5775,6 +5786,100 @@ std::vector App::tailDaemonDebugLog(int maxLines) const return lines; } +bool App::daemonWitnessRebuildActive() const +{ + // Scan the debug.log tail for the daemon's witness-rebuild markers (wallet.cpp): "Cleared witness + // data from" (start), "Setting Initial Sapling Witness" / "Reading blocks for witness rebuild" + // (progress), vs. "rebuilt N note witness cache(s)" / "aborting…" (finished). Active iff the most + // recent relevant line is a start/progress line, not a completion. + const auto lines = tailDaemonDebugLog(80); + int state = 0; // 0 none, 1 active, 2 finished/aborted + for (const auto& l : lines) { + if (l.find("note witness cache(s) to height") != std::string::npos || + l.find("aborting witness rebuild") != std::string::npos || + l.find("aborted during witness rebuild") != std::string::npos) { + state = 2; + } else if (l.find("Reading blocks for witness rebuild") != std::string::npos || + l.find("Setting Initial Sapling Witness") != std::string::npos || + l.find("Cleared witness data from") != std::string::npos) { + state = 1; + } + } + return state == 1; +} + +bool App::shouldConfirmDaemonStop() const +{ + if (!daemon_controller_) return false; + // Only relevant when this shutdown would actually STOP the daemon (embedded, or external with + // stop-on-exit) — a DisconnectOnly shutdown leaves it running and loses nothing. + const auto decision = daemon_controller_->shutdownDecision( + settings_ && settings_->getKeepDaemonRunning(), + settings_ && settings_->getStopExternalDaemon()); + if (decision.action != daemon::DaemonController::ShutdownAction::StopDaemon) return false; + return daemonWitnessRebuildActive(); +} + +void App::renderDaemonStopConfirm() +{ + using namespace ui::material; + if (pending_shutdown_confirm_) { + ImGui::OpenPopup("##DaemonStopConfirm"); + pending_shutdown_confirm_ = false; + daemon_stop_confirm_open_ = true; + } + if (!daemon_stop_confirm_open_) return; + + ImVec2 center = ImGui::GetMainViewport()->GetCenter(); + ImGui::SetNextWindowPos(center, ImGuiCond_Appearing, ImVec2(0.5f, 0.5f)); + bool proceed = false; + if (ImGui::BeginPopupModal("##DaemonStopConfirm", nullptr, + ImGuiWindowFlags_AlwaysAutoResize | ImGuiWindowFlags_NoTitleBar)) { + if (Type().subtitle1()) ImGui::PushFont(Type().subtitle1()); + ImGui::TextUnformatted("Node is rebuilding its witness cache"); + if (Type().subtitle1()) ImGui::PopFont(); + ImGui::Spacing(); + ImGui::PushTextWrapPos(ImGui::GetFontSize() * 26.0f); + ImGui::TextUnformatted( + "Stopping the node now discards the in-progress rebuild and restarts it (several minutes) " + "the next time you open the wallet. You can keep the node running instead."); + ImGui::PopTextWrapPos(); + ImGui::Spacing(); + ImGui::Spacing(); + + if (TactileButton("Keep node running & quit", ImVec2(0, 0))) { + shutdown_keep_daemon_override_ = true; + shutdown_confirmed_ = true; + daemon_stop_confirm_open_ = false; + proceed = true; + ImGui::CloseCurrentPopup(); + } + ImGui::SameLine(); + ImGui::PushStyleColor(ImGuiCol_Button, ImGui::ColorConvertU32ToFloat4(WithAlpha(Error(), 210))); + ImGui::PushStyleColor(ImGuiCol_ButtonHovered, ImGui::ColorConvertU32ToFloat4(Error())); + ImGui::PushStyleColor(ImGuiCol_ButtonActive, ImGui::ColorConvertU32ToFloat4(WithAlpha(Error(), 160))); + const bool stopAnyway = TactileButton("Stop anyway & quit", ImVec2(0, 0)); + ImGui::PopStyleColor(3); + if (stopAnyway) { + shutdown_confirmed_ = true; + daemon_stop_confirm_open_ = false; + proceed = true; + ImGui::CloseCurrentPopup(); + } + ImGui::SameLine(); + if (TactileButton("Cancel", ImVec2(0, 0))) { + daemon_stop_confirm_open_ = false; // abort the quit; stay open + ImGui::CloseCurrentPopup(); + } + ImGui::EndPopup(); + } else { + daemon_stop_confirm_open_ = false; // dismissed via Esc / click-away = Cancel + } + + // Re-enter shutdown outside the popup scope now that the user has chosen (shutdown_confirmed_ set). + if (proceed) beginShutdown(); +} + void App::renderShutdownScreen() { using namespace ui::material; diff --git a/src/app.h b/src/app.h index ba1f41c..0bcd80d 100644 --- a/src/app.h +++ b/src/app.h @@ -182,6 +182,14 @@ public: */ std::vector tailDaemonDebugLog(int maxLines) const; + // True when the daemon's debug.log shows an in-progress Sapling witness-cache rebuild (best-effort + // heuristic). Stopping the daemon during one discards it and forces a multi-minute redo next launch. + bool daemonWitnessRebuildActive() const; + // Whether beginShutdown() should pause and confirm before stopping the daemon (rebuild in progress). + bool shouldConfirmDaemonStop() const; + // The "node is rebuilding — stop anyway / keep running / cancel" modal, rendered from render(). + void renderDaemonStopConfirm(); + /** * @brief Render loading overlay in content area while daemon is starting/syncing * @param contentH Height of the content area child window @@ -911,6 +919,11 @@ private: bool address_list_dirty_ = false; // P8: dedup rebuildAddressList GuardedStatus shutdown_status_; // thread-safe: written by the shutdown thread, read by the UI (M-05) std::thread shutdown_thread_; + // Confirm-before-stopping-daemon-mid-witness-rebuild guard (see beginShutdown / renderDaemonStopConfirm) + bool pending_shutdown_confirm_ = false; // a quit is deferred, waiting to open the confirm modal + bool daemon_stop_confirm_open_ = false; // the confirm modal is currently showing + bool shutdown_confirmed_ = false; // user chose to proceed — bypass the guard on re-entry + bool shutdown_keep_daemon_override_ = false; // user chose "keep node running" for this shutdown only float shutdown_timer_ = 0.0f; bool force_quit_confirm_ = false; std::chrono::steady_clock::time_point shutdown_start_time_; From a2f84be2d4f81f49b12b28f5a0f8479f5499a05b Mon Sep 17 00:00:00 2001 From: DanS Date: Sun, 30 Aug 2026 23:43:12 -0500 Subject: [PATCH 70/89] fix(win): stop console-window flash on launch (spawn daemon with CREATE_NO_WINDOW) MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit The embedded daemon was launched with CREATE_NEW_CONSOLE + SW_HIDE. CREATE_NEW_CONSOLE allocates a console window that flashes on screen before SW_HIDE hides it — visible as a console-window flash every time the wallet starts dragonxd (i.e. on launch). Switch to CREATE_NO_WINDOW (the console child gets no window at all, matching the xmrig launcher); dragonxd logs to debug.log, not a console, so nothing is lost. Co-Authored-By: Claude Opus 4.8 (1M context) --- src/daemon/embedded_daemon.cpp | 9 ++++++--- 1 file changed, 6 insertions(+), 3 deletions(-) diff --git a/src/daemon/embedded_daemon.cpp b/src/daemon/embedded_daemon.cpp index e4487eb..e922cbd 100644 --- a/src/daemon/embedded_daemon.cpp +++ b/src/daemon/embedded_daemon.cpp @@ -689,7 +689,10 @@ bool EmbeddedDaemon::startProcess(const std::string& binary_path, const std::vec debug_log_path_.c_str(), debug_log_offset_); } - // Launch daemon with CREATE_NEW_CONSOLE (hidden via SW_HIDE). + // Launch daemon windowless. Use CREATE_NO_WINDOW (NOT CREATE_NEW_CONSOLE): CREATE_NEW_CONSOLE + // allocates a console window that briefly flashes on screen before SW_HIDE can hide it, which is + // visible as a console-window flash on wallet launch. CREATE_NO_WINDOW gives the console child no + // window at all (same approach as the xmrig launcher). The daemon logs to debug.log, not a console. // The daemon binary must NOT be in the data directory (%APPDATA%\Hush\DRAGONX) // — it must be in /dragonx/ to avoid conflicts with lock files and data. STARTUPINFOA si; @@ -699,7 +702,7 @@ bool EmbeddedDaemon::startProcess(const std::string& binary_path, const std::vec si.dwFlags = STARTF_USESHOWWINDOW; si.wShowWindow = SW_HIDE; ZeroMemory(&pi, sizeof(pi)); - + char* cmd_line = _strdup(cmd.c_str()); BOOL success = CreateProcessA( NULL, @@ -707,7 +710,7 @@ bool EmbeddedDaemon::startProcess(const std::string& binary_path, const std::vec NULL, NULL, FALSE, - CREATE_NEW_CONSOLE, + CREATE_NO_WINDOW, NULL, work_dir.c_str(), &si, From 0942691eb370400a018ba0b4c6c1b996ab262de6 Mon Sep 17 00:00:00 2001 From: DanS Date: Sun, 30 Aug 2026 23:58:54 -0500 Subject: [PATCH 71/89] fix(win): route shell-outs through a windowless helper (no cmd.exe flash) MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit _popen/_popen-style shell-outs flash a cmd.exe console window on Windows. Add Platform::runHiddenCapture() — CreateProcess + CREATE_NO_WINDOW capturing stdout on Windows, popen on POSIX — and route the remaining shell-outs through it: - GPU-aware idle detection (getGpuUtilization: "where nvidia-smi" / "nvidia-smi --query-gpu") - xmrig discovery + version (findXmrigBinary "where xmrig.exe"; " --version", stderr merged) - wallet-rebuild helper (app_network) — keeps its exit-code check via the new exitCode out-param None of these are on the launch path (that was the daemon spawn, fixed in a2f84be); each would flash a console only when it ran (idle-GPU mining, mining tab, wallet recovery). Co-Authored-By: Claude Opus 4.8 (1M context) --- src/app_network.cpp | 21 +++------ src/daemon/xmrig_manager.cpp | 55 ++++++----------------- src/util/platform.cpp | 87 +++++++++++++++++++++++++++++------- src/util/platform.h | 9 ++++ 4 files changed, 101 insertions(+), 71 deletions(-) diff --git a/src/app_network.cpp b/src/app_network.cpp index b05ca64..8641598 100644 --- a/src/app_network.cpp +++ b/src/app_network.cpp @@ -5043,21 +5043,12 @@ void App::rebuildWalletDatabase() 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 + // 3. Run the helper (src -> tmpOut). Quote both paths; capture its JSON line. Windowless + // (runHiddenCapture) so a wallet rebuild never flashes a cmd.exe console; it runs the + // helper via CreateProcess directly on Windows, so no cmd.exe outer-quote wrap is needed. + const std::string cmd = "\"" + helper + "\" \"" + src + "\" \"" + tmpOut + "\""; + int rc = -1; + const std::string jout = util::Platform::runHiddenCapture(cmd, /*mergeStderr=*/false, &rc); 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. diff --git a/src/daemon/xmrig_manager.cpp b/src/daemon/xmrig_manager.cpp index 4d76c21..776896b 100644 --- a/src/daemon/xmrig_manager.cpp +++ b/src/daemon/xmrig_manager.cpp @@ -23,6 +23,7 @@ #include #include "../util/logger.h" +#include "../util/platform.h" #include "../util/pool_registry.h" #ifdef _WIN32 @@ -145,32 +146,18 @@ std::string XmrigManager::findXmrigBinary() { return path; } - // Fallback: system PATH + // Fallback: system PATH — windowless so it never flashes a console. #ifdef _WIN32 - FILE* f = _popen("where xmrig.exe 2>nul", "r"); + std::string out = util::Platform::runHiddenCapture("where xmrig.exe"); #else - FILE* f = popen("which xmrig 2>/dev/null", "r"); -#endif - if (f) { - char line[512]; - if (fgets(line, sizeof(line), f)) { - std::string s(line); - while (!s.empty() && (s.back() == '\n' || s.back() == '\r')) - s.pop_back(); - if (!s.empty() && fs::exists(s)) { -#ifdef _WIN32 - _pclose(f); -#else - pclose(f); -#endif - return s; - } - } -#ifdef _WIN32 - _pclose(f); -#else - pclose(f); + std::string out = util::Platform::runHiddenCapture("which xmrig"); #endif + { + std::string s = out; + const auto nl = s.find_first_of("\r\n"); // first line only + if (nl != std::string::npos) s.erase(nl); + while (!s.empty() && (s.back() == ' ' || s.back() == '\t')) s.pop_back(); + if (!s.empty() && fs::exists(s)) return s; } return {}; @@ -927,24 +914,10 @@ void XmrigManager::startVersionDetection() const bool binShellSafe = !bin.empty() && bin.find_first_of("\"'`$;&|<>^%\n\r") == std::string::npos; if (binShellSafe) { - const std::string cmd = "\"" + bin + "\" --version 2>&1"; -#ifdef _WIN32 - FILE* fp = _popen(cmd.c_str(), "r"); -#else - FILE* fp = popen(cmd.c_str(), "r"); -#endif - if (fp) { - std::string out; - char buf[256]; - size_t n; - while ((n = fread(buf, 1, sizeof(buf), fp)) > 0) out.append(buf, n); -#ifdef _WIN32 - _pclose(fp); -#else - pclose(fp); -#endif - ver = parseMinerVersion(out); - } + // Windowless capture (mergeStderr: xmrig may print --version to stderr) — never flashes. + const std::string cmd = "\"" + bin + "\" --version"; + const std::string out = util::Platform::runHiddenCapture(cmd, /*mergeStderr=*/true); + if (!out.empty()) ver = parseMinerVersion(out); } std::lock_guard lk(g_installed_ver_mutex); g_installed_ver = ver; diff --git a/src/util/platform.cpp b/src/util/platform.cpp index c0f7d4f..b177f65 100644 --- a/src/util/platform.cpp +++ b/src/util/platform.cpp @@ -867,6 +867,70 @@ int Platform::getSystemIdleSeconds() // GPU utilization detection // ============================================================================ +std::string Platform::runHiddenCapture(const std::string& cmdLine, bool mergeStderr, int* exitCode) +{ + if (exitCode) *exitCode = -1; +#ifdef _WIN32 + SECURITY_ATTRIBUTES sa; + ZeroMemory(&sa, sizeof(sa)); + sa.nLength = sizeof(sa); + sa.bInheritHandle = TRUE; + HANDLE hRead = NULL, hWrite = NULL; + if (!CreatePipe(&hRead, &hWrite, &sa, 0)) return {}; + SetHandleInformation(hRead, HANDLE_FLAG_INHERIT, 0); // parent's read end stays private + + HANDLE hNul = INVALID_HANDLE_VALUE; + if (!mergeStderr) { + hNul = CreateFileA("NUL", GENERIC_WRITE, FILE_SHARE_READ | FILE_SHARE_WRITE, &sa, + OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL); + } + + STARTUPINFOA si; + ZeroMemory(&si, sizeof(si)); + si.cb = sizeof(si); + si.dwFlags = STARTF_USESTDHANDLES | STARTF_USESHOWWINDOW; + si.wShowWindow = SW_HIDE; + si.hStdInput = GetStdHandle(STD_INPUT_HANDLE); + si.hStdOutput = hWrite; + si.hStdError = mergeStderr ? hWrite : hNul; + + PROCESS_INFORMATION pi; + ZeroMemory(&pi, sizeof(pi)); + std::string cl = cmdLine; // CreateProcessA may modify lpCommandLine → needs a mutable buffer + std::string out; + if (CreateProcessA(NULL, cl.empty() ? NULL : &cl[0], NULL, NULL, TRUE, + CREATE_NO_WINDOW, NULL, NULL, &si, &pi)) { + CloseHandle(hWrite); hWrite = NULL; // close our copy so ReadFile hits EOF when the child exits + if (hNul != INVALID_HANDLE_VALUE) { CloseHandle(hNul); hNul = INVALID_HANDLE_VALUE; } + char buf[4096]; + DWORD n = 0; + while (ReadFile(hRead, buf, sizeof(buf), &n, NULL) && n > 0) out.append(buf, n); + WaitForSingleObject(pi.hProcess, INFINITE); + if (exitCode) { + DWORD code = 0; + if (GetExitCodeProcess(pi.hProcess, &code)) *exitCode = static_cast(code); + } + CloseHandle(pi.hProcess); + CloseHandle(pi.hThread); + } + if (hWrite != NULL) CloseHandle(hWrite); + if (hNul != INVALID_HANDLE_VALUE) CloseHandle(hNul); + CloseHandle(hRead); + return out; +#else + const std::string full = cmdLine + (mergeStderr ? " 2>&1" : " 2>/dev/null"); + std::string out; + FILE* f = popen(full.c_str(), "r"); + if (!f) return out; + char buf[512]; + size_t n; + while ((n = fread(buf, 1, sizeof(buf), f)) > 0) out.append(buf, n); + const int st = pclose(f); + if (exitCode) *exitCode = st; // raw status (matches prior pclose-based rc checks) + return out; +#endif +} + int Platform::getGpuUtilization() { #ifdef _WIN32 @@ -877,23 +941,16 @@ int Platform::getGpuUtilization() static bool s_has_nvidia = false; if (!s_tried_nvidia) { s_tried_nvidia = true; - FILE* f = _popen("where nvidia-smi 2>nul", "r"); - if (f) { - char buf[256]; - s_has_nvidia = (fgets(buf, sizeof(buf), f) != nullptr); - _pclose(f); - } + // Windowless (runHiddenCapture) so GPU-aware idle detection never flashes a cmd.exe console. + const std::string w = runHiddenCapture("where nvidia-smi"); + s_has_nvidia = (w.find_first_not_of(" \t\r\n") != std::string::npos); } if (s_has_nvidia) { - FILE* f = _popen("nvidia-smi --query-gpu=utilization.gpu --format=csv,noheader,nounits 2>nul", "r"); - if (f) { - char buf[64]; - int util = -1; - if (fgets(buf, sizeof(buf), f)) { - util = atoi(buf); - if (util < 0 || util > 100) util = -1; - } - _pclose(f); + const std::string o = runHiddenCapture( + "nvidia-smi --query-gpu=utilization.gpu --format=csv,noheader,nounits"); + if (!o.empty()) { + int util = atoi(o.c_str()); + if (util < 0 || util > 100) util = -1; return util; } } diff --git a/src/util/platform.h b/src/util/platform.h index f5fbc79..baad2ce 100644 --- a/src/util/platform.h +++ b/src/util/platform.h @@ -179,6 +179,15 @@ public: * @return GPU busy percent, or -1 if unavailable. */ static int getGpuUtilization(); + + // Run a command line and capture its stdout WITHOUT ever popping a console window: Windows uses + // CreateProcess + CREATE_NO_WINDOW (a plain popen()/_popen() flashes a cmd.exe console), POSIX uses + // popen(). Use this instead of _popen for anything run while the GUI is up. `mergeStderr` folds the + // child's stderr into the result (like "2>&1"); otherwise stderr is discarded. `exitCode`, if given, + // receives the child's exit status (raw pclose() status on POSIX, GetExitCodeProcess on Windows; -1 + // if the process could not be launched). + static std::string runHiddenCapture(const std::string& cmdLine, bool mergeStderr = false, + int* exitCode = nullptr); }; /** From ba1d760bb330dd21d40f21864542e21f8d136c17 Mon Sep 17 00:00:00 2001 From: DanS Date: Mon, 31 Aug 2026 22:33:12 -0500 Subject: [PATCH 72/89] fix(autoshield): defer to the daemon's own coinbase auto-shield on v1.3.0+ MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit v1.3.0 daemons auto-shield coinbase by default (when the HD seed is recoverable — which every ObsidianDragon-created wallet is, via -usemnemonic=1). The wallet also ran its own client-side auto-shield every refresh tick, so both raced for the same coinbase UTXOs and split funds across different z-addresses (the wallet picks the first z_listaddresses entry; the daemon uses a seed-hardened derivation). Probe z_autoshieldstatus once per connection (while synced, so the daemon is past warmup) and skip the wallet's client-side shield when the daemon reports it active. Fail-closed: a pre-1.3.0 daemon has no such RPC, so the probe returns active=false and the wallet keeps shielding — no regression on the currently-bundled v1.0.3. Re-probes on reconnect (handles a live daemon upgrade/swap). Follow-up (not done): drive the Settings "Auto-shield" toggle + disabled_reason from z_autoshieldstatus (O1) — needs runtime verification of the RPC fields on a live v1.3.0 node. Co-Authored-By: Claude Opus 4.8 (1M context) --- src/app.h | 7 +++++++ src/app_network.cpp | 32 +++++++++++++++++++++++++++++--- 2 files changed, 36 insertions(+), 3 deletions(-) diff --git a/src/app.h b/src/app.h index 0bcd80d..fe1fd7c 100644 --- a/src/app.h +++ b/src/app.h @@ -1241,6 +1241,13 @@ private: // Auto-shield guard (prevents concurrent auto-shield operations) std::atomic auto_shield_pending_{false}; + // v1.3.0+ daemons auto-shield coinbase themselves; probe z_autoshieldstatus once per connection and + // defer the wallet's own client-side auto-shield when the daemon is doing it (otherwise both race for + // the same coinbase UTXOs and split funds across different z-addresses). Fail-closed: a pre-1.3.0 + // daemon lacks the RPC → active stays false → the wallet keeps shielding client-side (no regression). + bool daemon_autoshield_probed_ = false; + bool daemon_autoshield_active_ = false; + std::atomic daemon_autoshield_probe_inflight_{false}; // P4: Incremental transaction cache int last_tx_block_height_ = -1; // block height at last full tx fetch diff --git a/src/app_network.cpp b/src/app_network.cpp index 8641598..0c82961 100644 --- a/src/app_network.cpp +++ b/src/app_network.cpp @@ -714,6 +714,11 @@ void App::onDisconnected(const std::string& reason) wallet_seed_status_ = WalletSeedStatus::Unknown; wallet_seed_status_attempts_ = 0; + // Re-probe whether the daemon auto-shields coinbase on the next connect — it may have been + // upgraded/swapped (e.g. v1.0.3 which has no z_autoshieldstatus -> v1.3.0 which auto-shields). + daemon_autoshield_probed_ = false; + daemon_autoshield_active_ = false; + // Clear RPC result caches viewtx_cache_.clear(); confirmed_tx_cache_.clear(); @@ -1741,9 +1746,30 @@ void App::refreshCoreData() } } - // Auto-shield transparent funds if enabled - if (result.balanceOk && settings_ && settings_->getAutoShield() && - state_.spendableTransparentBalance > 0.0001 && !state_.sync.syncing && + // Auto-shield transparent funds if enabled. A v1.3.0+ daemon auto-shields coinbase + // itself; probe z_autoshieldstatus once (while synced, so the daemon is past warmup) and + // defer to it when it's active — otherwise the wallet and the daemon race for the same + // coinbase UTXOs and split funds across different z-addresses. A pre-1.3.0 daemon lacks + // the RPC, so the probe fails closed (active=false) and the wallet keeps shielding. + const bool autoShieldEligible = result.balanceOk && settings_ && settings_->getAutoShield() && + state_.spendableTransparentBalance > 0.0001 && !state_.sync.syncing; + if (autoShieldEligible && !daemon_autoshield_probed_ && worker_ && + !daemon_autoshield_probe_inflight_.exchange(true)) { + worker_->post([this]() -> rpc::RPCWorker::MainCb { + bool active = false; + try { + auto st = rpc_->call("z_autoshieldstatus", json::array()); + if (st.is_object() && st.contains("autoshield")) + active = st["autoshield"].get(); + } catch (...) { active = false; } // pre-1.3.0 daemon: method not found + return [this, active]() { + daemon_autoshield_active_ = active; + daemon_autoshield_probed_ = true; + daemon_autoshield_probe_inflight_ = false; + }; + }); + } + if (autoShieldEligible && daemon_autoshield_probed_ && !daemon_autoshield_active_ && !auto_shield_pending_.exchange(true)) { std::string targetZAddr; for (const auto& addr : state_.addresses) { From ef8ceeaf9a88ff85cdc50ad76c1f35276b5b7fa5 Mon Sep 17 00:00:00 2001 From: DanS Date: Mon, 31 Aug 2026 22:48:46 -0500 Subject: [PATCH 73/89] feat(net): seed via the round-robin DNS record + node1/node5 (backwards-compatible) MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Replace the wallet's stale hardcoded -addnode list (node. + node1-4.dragonx.is — a drifted subset with a bogus bare 'node.') with the daemon's authoritative vSeeds: seed.dragonx.is (a round-robin A record over the live seed set, so it self-updates without a wallet release) plus node1/node5 as static fallbacks. Applied in both seeding sites: the launch args (embedded_daemon.cpp) and the generated DRAGONX.conf (connection.cpp). Kept (not deleted) — pre-1.3.0 daemons had broken peer discovery and rely on these -addnode entries to find peers at all; plain hostname resolution works on every daemon version. Co-Authored-By: Claude Opus 4.8 (1M context) --- src/daemon/embedded_daemon.cpp | 10 ++++++---- src/rpc/connection.cpp | 8 ++++---- 2 files changed, 10 insertions(+), 8 deletions(-) diff --git a/src/daemon/embedded_daemon.cpp b/src/daemon/embedded_daemon.cpp index e922cbd..2fae346 100644 --- a/src/daemon/embedded_daemon.cpp +++ b/src/daemon/embedded_daemon.cpp @@ -205,11 +205,13 @@ std::vector EmbeddedDaemon::getChainParams() "-ac_reward=300000000", "-ac_blocktime=36", "-ac_private=1", - "-addnode=node.dragonx.is", + // Seeds: seed.dragonx.is is a round-robin A record over the live seed set (self-updates without + // a wallet release), with node1/node5 as static fallbacks — mirrors the daemon's own vSeeds. + // Plain -addnode hostname resolution works on EVERY daemon version, and is load-bearing for + // pre-1.3.0 daemons whose built-in peer discovery was broken (they rely on these to find peers). + "-addnode=seed.dragonx.is", "-addnode=node1.dragonx.is", - "-addnode=node2.dragonx.is", - "-addnode=node3.dragonx.is", - "-addnode=node4.dragonx.is", + "-addnode=node5.dragonx.is", "-experimentalfeatures", "-developerencryptwallet", // Create fresh wallets from a BIP39 mnemonic so their 24-word phrase can be diff --git a/src/rpc/connection.cpp b/src/rpc/connection.cpp index a30ef2c..9c8bfc1 100644 --- a/src/rpc/connection.cpp +++ b/src/rpc/connection.cpp @@ -456,11 +456,11 @@ bool Connection::createDefaultConfig(const std::string& path) file << "exportdir=" << dataDir << "\n"; file << "experimentalfeatures=1\n"; file << "developerencryptwallet=1\n"; - file << "addnode=node.dragonx.is\n"; + // Round-robin DNS seed (self-updating) + static fallbacks; mirrors the daemon's vSeeds and keeps + // pre-1.3.0 daemons (broken peer discovery) able to find peers. Works on every daemon version. + file << "addnode=seed.dragonx.is\n"; file << "addnode=node1.dragonx.is\n"; - file << "addnode=node2.dragonx.is\n"; - file << "addnode=node3.dragonx.is\n"; - file << "addnode=node4.dragonx.is\n"; + file << "addnode=node5.dragonx.is\n"; file.close(); From 90e02b1ddd7ac4df70d20acf842b7cd2d5cf38cb Mon Sep 17 00:00:00 2001 From: DanS Date: Mon, 31 Aug 2026 22:48:46 -0500 Subject: [PATCH 74/89] feat(ui): surface daemon DEGRADED mode + v1.3.0 auto-shield status MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Rec3 — v1.3.0+ opens a wallet that lost its hdchain in DEGRADED mode (existing funds spendable, but no new HD-key derivation) instead of aborting. Add a daemon-log classifier (walletOpenedDegraded) + detectWalletDegraded(), warned once per session. Pre-1.3.0 daemons never emit that line, so it's a no-op there. O1 — probe z_autoshieldstatus once per connection (now decoupled from our own toggle/balance) and, in Settings, show whether the node handles auto-shield itself (+ its destination, or the daemon's disabled_reason). The checkbox now governs only the wallet's fallback shielder, which defers to the node. Nothing renders on pre-1.3.0 daemons (no such RPC), so behaviour is unchanged. Co-Authored-By: Claude Opus 4.8 (1M context) --- src/app.h | 13 +++++++ src/app_network.cpp | 52 ++++++++++++++++++++------- src/daemon/daemon_startup_diagnosis.h | 10 ++++++ src/ui/pages/settings_page.cpp | 12 +++++++ src/util/i18n.cpp | 2 ++ 5 files changed, 76 insertions(+), 13 deletions(-) diff --git a/src/app.h b/src/app.h index fe1fd7c..0a34982 100644 --- a/src/app.h +++ b/src/app.h @@ -163,6 +163,13 @@ public: bool supportsEmbeddedDaemon() const { return wallet::supportsEmbeddedDaemon(walletCapabilities()); } bool supportsFullNodeLifecycleActions() const { return wallet::supportsFullNodeLifecycleActions(walletCapabilities()); } + // Daemon (v1.3.0+) coinbase auto-shield status, from z_autoshieldstatus. "Not probed" / all-false on + // pre-1.3.0 daemons (no such RPC) — callers treat that as "the wallet handles auto-shield itself". + bool daemonAutoShieldProbed() const { return daemon_autoshield_probed_; } + bool daemonAutoShieldActive() const { return daemon_autoshield_active_; } + const std::string& daemonAutoShieldAddress() const { return daemon_autoshield_address_; } + const std::string& daemonAutoShieldDisabledReason() const { return daemon_autoshield_disabled_reason_; } + // 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(); @@ -958,6 +965,8 @@ private: // 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 wallet_degraded_ = false; // v1.3.0+ opened the wallet in DEGRADED mode (no new HD keys) + bool wallet_degraded_warned_ = false; // guard: surface the degraded-mode notice once per session bool show_wallet_recovered_dialog_ = false; // auto-shown warning dialog // Complementary on-disk safety net for a salvage we DIDN'T witness this launch (happened on a prior // run, or under an external daemon whose startup output we never captured): if the active wallet loads @@ -1248,6 +1257,9 @@ private: bool daemon_autoshield_probed_ = false; bool daemon_autoshield_active_ = false; std::atomic daemon_autoshield_probe_inflight_{false}; + std::string daemon_autoshield_address_; // z_autoshieldstatus fields (O1); empty on old daemons + std::string daemon_autoshield_disabled_reason_; // daemon's reason auto-shield is off (e.g. seed not recoverable) + bool daemon_autoshield_seed_recoverable_ = false; // P4: Incremental transaction cache int last_tx_block_height_ = -1; // block height at last full tx fetch @@ -1440,6 +1452,7 @@ private: void renderWalletRecoveredDialog(); // warn that the node auto-recovered/salvaged wallet.dat void renderEmptyWalletWarningDialog();// warn that the active wallet is empty while a sibling holds funds void detectWalletAutoRecovery(); // scan daemon output for a salvage; fire the warning once/session + void detectWalletDegraded(); // scan daemon output for a DEGRADED-mode open; warn once/session void restoreOriginalWallet(); // swap the wallet..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) diff --git a/src/app_network.cpp b/src/app_network.cpp index 0c82961..06fda63 100644 --- a/src/app_network.cpp +++ b/src/app_network.cpp @@ -249,6 +249,21 @@ void App::detectWalletAutoRecovery() VERBOSE_LOGF("[recovery] Daemon auto-recovered/salvaged wallet.dat — surfacing the recovery dialog\n"); } +// v1.3.0+ opens a wallet that lost its hdchain in DEGRADED mode (funds spendable) instead of aborting, +// but can't derive NEW HD keys — z_getnewaddress / z_shieldcoinbase / t->z z_sendmany fail with "HD seed +// not found". Only a startup log line signals it, so scan the captured output and warn once. Pre-1.3.0 +// daemons never emit it, so this is a no-op there (backwards compatible). +void App::detectWalletDegraded() +{ + if (wallet_degraded_warned_) return; + if (!isUsingEmbeddedDaemon() || !daemon_controller_ || !daemon_controller_->daemon()) return; + if (!daemon::walletOpenedDegraded(daemon_controller_->daemon()->getOutput())) return; + wallet_degraded_ = true; + wallet_degraded_warned_ = true; + ui::Notifications::instance().warning(TR("wallet_degraded_notify"), 30.0f); + VERBOSE_LOGF("[recovery] Daemon opened wallet in DEGRADED mode — new-key derivation disabled\n"); +} + void App::tryConnect() { // Lite builds have no full node / RPC daemon, so never run the RPC connection state machine @@ -259,6 +274,7 @@ void App::tryConnect() // 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 (!daemon_restarting_) detectWalletDegraded(); if (connection_in_progress_) return; @@ -1746,29 +1762,39 @@ void App::refreshCoreData() } } - // Auto-shield transparent funds if enabled. A v1.3.0+ daemon auto-shields coinbase - // itself; probe z_autoshieldstatus once (while synced, so the daemon is past warmup) and - // defer to it when it's active — otherwise the wallet and the daemon race for the same - // coinbase UTXOs and split funds across different z-addresses. A pre-1.3.0 daemon lacks - // the RPC, so the probe fails closed (active=false) and the wallet keeps shielding. - const bool autoShieldEligible = result.balanceOk && settings_ && settings_->getAutoShield() && - state_.spendableTransparentBalance > 0.0001 && !state_.sync.syncing; - if (autoShieldEligible && !daemon_autoshield_probed_ && worker_ && + // Probe the daemon's auto-shield status once per connection — independent of our own + // toggle/balance — so both the defer-gate below and the Settings UI (O1) can read it. + // Only when synced (daemon past warmup). Fail-closed: a pre-1.3.0 daemon lacks the RPC, + // so the probe leaves active=false and the wallet keeps shielding client-side. + if (result.balanceOk && !state_.sync.syncing && !daemon_autoshield_probed_ && worker_ && !daemon_autoshield_probe_inflight_.exchange(true)) { worker_->post([this]() -> rpc::RPCWorker::MainCb { - bool active = false; + bool active = false, seedRecoverable = false; + std::string addr, reason; try { auto st = rpc_->call("z_autoshieldstatus", json::array()); - if (st.is_object() && st.contains("autoshield")) - active = st["autoshield"].get(); - } catch (...) { active = false; } // pre-1.3.0 daemon: method not found - return [this, active]() { + if (st.is_object()) { + if (st.contains("autoshield")) active = st["autoshield"].get(); + if (st.contains("autoshieldaddress")) addr = st["autoshieldaddress"].get(); + if (st.contains("disabled_reason")) reason = st["disabled_reason"].get(); + if (st.contains("seed_recoverable")) seedRecoverable = st["seed_recoverable"].get(); + } + } catch (...) {} // pre-1.3.0 daemon: no such method — leave defaults (inactive) + return [this, active, addr, reason, seedRecoverable]() { daemon_autoshield_active_ = active; + daemon_autoshield_address_ = addr; + daemon_autoshield_disabled_reason_ = reason; + daemon_autoshield_seed_recoverable_ = seedRecoverable; daemon_autoshield_probed_ = true; daemon_autoshield_probe_inflight_ = false; }; }); } + + // Auto-shield transparent funds — but defer to the daemon's own coinbase auto-shielder + // (v1.3.0+) when it's active, so we don't double-shield and split funds across z-addrs. + const bool autoShieldEligible = result.balanceOk && settings_ && settings_->getAutoShield() && + state_.spendableTransparentBalance > 0.0001 && !state_.sync.syncing; if (autoShieldEligible && daemon_autoshield_probed_ && !daemon_autoshield_active_ && !auto_shield_pending_.exchange(true)) { std::string targetZAddr; diff --git a/src/daemon/daemon_startup_diagnosis.h b/src/daemon/daemon_startup_diagnosis.h index 72ce57e..325e2bb 100644 --- a/src/daemon/daemon_startup_diagnosis.h +++ b/src/daemon/daemon_startup_diagnosis.h @@ -49,6 +49,16 @@ inline bool walletAutoRecovered(const std::string& out) && out.find(".bak") != std::string::npos); // Recover moved wallet.dat aside } +// True when dragonxd (v1.3.0+) opened the wallet in DEGRADED mode: a wallet.dat that lost its hdchain +// record (e.g. an old `-salvagewallet` output) now OPENS — existing keys stay intact and spendable — +// instead of aborting, but the daemon can no longer derive NEW HD keys, so z_getnewaddress / +// z_shieldcoinbase / a t->z z_sendmany fail with "HD seed not found". The only signal is a startup log +// line; pre-1.3.0 daemons never emit it, so this classifier is naturally a no-op against them. +inline bool walletOpenedDegraded(const std::string& out) +{ + return out.find("Wallet opened in DEGRADED mode") != std::string::npos; +} + // If `name` is a daemon salvage backup "wallet..bak", return its timestamp; else -1. inline long long parseWalletSalvageBakTs(const std::string& name) { diff --git a/src/ui/pages/settings_page.cpp b/src/ui/pages/settings_page.cpp index bee107d..b1f36e4 100644 --- a/src/ui/pages/settings_page.cpp +++ b/src/ui/pages/settings_page.cpp @@ -1186,6 +1186,18 @@ void RenderSettingsPage(App* app) { if (ImGui::IsItemHovered()) material::Tooltip("%s", TR("tt_save_ztx")); CB(TrId("auto_shield", "auto_shld"), &s_settingsState.auto_shield); if (ImGui::IsItemHovered()) material::Tooltip("%s", TR("tt_auto_shield")); + // O1: when a v1.3.0+ node auto-shields coinbase itself, show its real state — the checkbox + // above only governs the wallet's own fallback shielder (which defers to the node). Nothing + // renders on pre-1.3.0 daemons (never probed), so their behaviour is unchanged. + if (app && app->daemonAutoShieldProbed()) { + if (app->daemonAutoShieldActive()) { + ImGui::TextColored(ImVec4(0.40f, 0.78f, 0.40f, 1.0f), " %s", TR("autoshield_by_node")); + if (!app->daemonAutoShieldAddress().empty()) + ImGui::TextDisabled(" %s", app->daemonAutoShieldAddress().c_str()); + } else if (!app->daemonAutoShieldDisabledReason().empty()) { + ImGui::TextDisabled(" %s", app->daemonAutoShieldDisabledReason().c_str()); + } + } CB(TrId("use_tor", "tor"), &s_settingsState.use_tor); if (ImGui::IsItemHovered()) material::Tooltip("%s", TR("tt_tor")); if (showDaemonOptions) { diff --git a/src/util/i18n.cpp b/src/util/i18n.cpp index d1c9351..00b7e6f 100644 --- a/src/util/i18n.cpp +++ b/src/util/i18n.cpp @@ -1250,6 +1250,8 @@ void I18n::loadBuiltinEnglish() 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."; + strings_["wallet_degraded_notify"] = "Your wallet opened in reduced-function mode: existing funds are safe and spendable, but creating new addresses and shielding are disabled. Back up your seed phrase and restore it to fully repair the wallet."; + strings_["autoshield_by_node"] = "Auto-shield is handled by your node"; // In-dialog recovery lifecycle (Offer → Working → Done/Failed) + disclosures. strings_["wallet_recovery_working_label"] = "Working"; strings_["wallet_recovery_done"] = "Done"; From aec996a9ce5016e61b8cd1693896f47b4df0be91 Mon Sep 17 00:00:00 2001 From: DanS Date: Mon, 31 Aug 2026 23:19:48 -0500 Subject: [PATCH 75/89] feat(mining): host a RandomX stratum pool from the node (v1.3.0+) Add an opt-in "Host a mining pool (stratum)" toggle so a v1.3.0+ node can run its native RandomX stratum server for other miners to point at. Settings toggle + optional allow-IP/CIDR; passes -stratum (+ -stratumallowip) to the daemon launch args, mirroring the -maxconnections plumbing (EmbeddedDaemon::setStratumHosting <- DaemonController::syncSettings <- Settings). Backwards compatible / safe by default: - UI gated on daemon_version >= 1030000, so it's never offered where it would do nothing. - The launch flag is harmless on older daemons (they ignore unknown args), and the toggle can only be enabled while connected to a v1.3.0+ node anyway. - Blank allow-IP => the daemon serves loopback only (its safe default); entering a subnet opens it to that LAN, with an explicit exposure warning in the UI. - Takes effect on the next daemon start/restart. Co-Authored-By: Claude Opus 4.8 (1M context) --- src/config/settings.cpp | 4 ++++ src/config/settings.h | 7 +++++++ src/daemon/daemon_controller.cpp | 1 + src/daemon/embedded_daemon.cpp | 9 +++++++++ src/daemon/embedded_daemon.h | 3 +++ src/ui/pages/settings_page.cpp | 27 +++++++++++++++++++++++++++ src/util/i18n.cpp | 5 +++++ 7 files changed, 56 insertions(+) diff --git a/src/config/settings.cpp b/src/config/settings.cpp index fd58bc2..e6c05ad 100644 --- a/src/config/settings.cpp +++ b/src/config/settings.cpp @@ -252,6 +252,8 @@ bool Settings::load(const std::string& path) loadScalar(j, "keep_daemon_running", keep_daemon_running_); loadScalar(j, "stop_external_daemon", stop_external_daemon_); loadScalar(j, "max_connections", max_connections_); + loadScalar(j, "stratum_host_enabled", stratum_host_enabled_); + loadScalar(j, "stratum_allowip", stratum_allowip_); if (j.contains("lite_wallet") && j["lite_wallet"].is_object()) { const auto& lite = j["lite_wallet"]; if (lite.contains("server_selection_mode")) { @@ -525,6 +527,8 @@ bool Settings::save(const std::string& path) j["keep_daemon_running"] = keep_daemon_running_; j["stop_external_daemon"] = stop_external_daemon_; j["max_connections"] = max_connections_; + j["stratum_host_enabled"] = stratum_host_enabled_; + j["stratum_allowip"] = stratum_allowip_; { json lite = json::object(); lite["server_selection_mode"] = liteServerSelectionPreferenceModeName(lite_server_selection_mode_); diff --git a/src/config/settings.h b/src/config/settings.h index 5d12aff..4017575 100644 --- a/src/config/settings.h +++ b/src/config/settings.h @@ -400,6 +400,11 @@ public: // Daemon — maximum peer connections (0 = daemon default) int getMaxConnections() const { return max_connections_; } void setMaxConnections(int v) { max_connections_ = std::max(0, v); } + // Host a RandomX stratum pool from the node (v1.3.0+ daemons). Empty allow-IP = loopback only (safe). + bool getStratumHost() const { return stratum_host_enabled_; } + void setStratumHost(bool v) { stratum_host_enabled_ = v; } + const std::string& getStratumAllowIp() const { return stratum_allowip_; } + void setStratumAllowIp(const std::string& v) { stratum_allowip_ = v; } // Lite wallet server selection LiteServerSelectionPreferenceMode getLiteServerSelectionMode() const { return lite_server_selection_mode_; } @@ -617,6 +622,8 @@ private: bool keep_daemon_running_ = false; bool stop_external_daemon_ = false; int max_connections_ = 0; // 0 = daemon default + bool stratum_host_enabled_ = false; // host a RandomX stratum pool from the node (v1.3.0+ daemons) + std::string stratum_allowip_; // -stratumallowip filter (empty = daemon default: loopback only) // Lite wallet server preferences. These are user/server settings only; // wallet secrets, wallet files, and lifecycle state are never stored here. diff --git a/src/daemon/daemon_controller.cpp b/src/daemon/daemon_controller.cpp index d960975..305656d 100644 --- a/src/daemon/daemon_controller.cpp +++ b/src/daemon/daemon_controller.cpp @@ -26,6 +26,7 @@ void DaemonController::syncSettings(const config::Settings* settings) if (!settings) return; daemon_->setDebugCategories(settings->getDebugCategories()); daemon_->setMaxConnections(settings->getMaxConnections()); + daemon_->setStratumHosting(settings->getStratumHost(), settings->getStratumAllowIp()); std::string walletFile = settings->getActiveWalletFile(); // The Wallets dialog opens an out-of-datadir wallet by linking it into the datadir under a diff --git a/src/daemon/embedded_daemon.cpp b/src/daemon/embedded_daemon.cpp index 2fae346..0ca0e1a 100644 --- a/src/daemon/embedded_daemon.cpp +++ b/src/daemon/embedded_daemon.cpp @@ -545,6 +545,15 @@ bool EmbeddedDaemon::start(const std::string& binary_path) args.push_back("-maxconnections=" + std::to_string(max_connections_)); } + // Host a RandomX stratum pool from this node (-stratum). Only v1.3.0+ daemons implement it; older + // ones ignore the unknown flag (no fatal arg check), and the Settings toggle is gated on daemon + // version, so this is only enabled against a daemon that supports it. Without -stratumallowip the + // daemon serves loopback only (safe default); a subnet opens it to that LAN. + if (stratum_enabled_) { + args.push_back("-stratum"); + if (!stratum_allowip_.empty()) args.push_back("-stratumallowip=" + stratum_allowip_); + } + // Active wallet file (multi-wallet). The daemon loads /. Only pass it for a // non-default name so the common case's command line is unchanged; skip during an isolated // start (seed migration manages its own throwaway wallet). diff --git a/src/daemon/embedded_daemon.h b/src/daemon/embedded_daemon.h index 86d9abc..b2b8576 100644 --- a/src/daemon/embedded_daemon.h +++ b/src/daemon/embedded_daemon.h @@ -182,6 +182,7 @@ public: * @brief Set maximum peer connections (0 = use daemon default) */ void setMaxConnections(int v) { max_connections_ = v; } + void setStratumHosting(bool enabled, const std::string& allowIp) { stratum_enabled_ = enabled; stratum_allowip_ = allowIp; } /** * @brief Request a blockchain rescan on the next daemon start @@ -311,6 +312,8 @@ private: std::atomic should_stop_{false}; std::set debug_categories_; int max_connections_ = 0; // 0 = daemon default + bool stratum_enabled_ = false; // -stratum: host a RandomX pool (v1.3.0+; older daemons ignore it) + std::string stratum_allowip_; // -stratumallowip subnet (empty = daemon default: loopback only) std::string wallet_file_; // -wallet= for the active wallet; empty/"wallet.dat" = default std::atomic crash_count_{0}; // consecutive crash counter std::atomic rescan_on_next_start_{false}; // -rescan flag for next start diff --git a/src/ui/pages/settings_page.cpp b/src/ui/pages/settings_page.cpp index b1f36e4..25f2539 100644 --- a/src/ui/pages/settings_page.cpp +++ b/src/ui/pages/settings_page.cpp @@ -116,6 +116,8 @@ struct SettingsPageState { LowSpecSnapshot low_spec_snapshot; bool keep_daemon_running = false; bool stop_external_daemon = false; + bool stratum_host = false; // O2: host a RandomX stratum pool from the node (v1.3.0+) + char stratum_allowip[64] = ""; // -stratumallowip subnet (blank = loopback only) bool lite_lifecycle_expanded = false; int lite_lifecycle_operation = 0; char lite_wallet_path[256] = ""; @@ -420,6 +422,9 @@ static void loadSettingsPageState(config::Settings* settings) { Layout::setUserFontScale(s_settingsState.font_scale); // sync with Layout on load s_settingsState.keep_daemon_running = settings->getKeepDaemonRunning(); s_settingsState.stop_external_daemon = settings->getStopExternalDaemon(); + s_settingsState.stratum_host = settings->getStratumHost(); + std::snprintf(s_settingsState.stratum_allowip, sizeof(s_settingsState.stratum_allowip), "%s", + settings->getStratumAllowIp().c_str()); // Lite-server selection is managed entirely by the Network tab (not the Settings page). s_settingsState.mine_when_idle = settings->getMineWhenIdle(); s_settingsState.mine_idle_delay = settings->getMineIdleDelay(); @@ -483,6 +488,8 @@ static void saveSettingsPageState(config::Settings* settings) { settings->setFontScale(s_settingsState.font_scale); settings->setKeepDaemonRunning(s_settingsState.keep_daemon_running); settings->setStopExternalDaemon(s_settingsState.stop_external_daemon); + settings->setStratumHost(s_settingsState.stratum_host); + settings->setStratumAllowIp(s_settingsState.stratum_allowip); // Lite-server selection is owned by the Network tab; the Settings page no longer writes it. settings->setMineWhenIdle(s_settingsState.mine_when_idle); settings->setMineIdleDelay(s_settingsState.mine_idle_delay); @@ -1207,6 +1214,26 @@ void RenderSettingsPage(App* app) { if (CB(TrId("stop_external", "stop_ext"), &s_settingsState.stop_external_daemon)) saveSettingsPageState(app->settings()); if (ImGui::IsItemHovered()) material::Tooltip("%s", TR("tt_stop_external")); + + // O2: host a RandomX stratum pool from this node. Only offered on daemons that implement + // it (v1.3.0+, version encoded major*1e6+minor*1e4+rev*100+build), so we never show a + // toggle that does nothing. Takes effect on the next daemon start/restart. Blank allow-IP + // = loopback only (safe); a subnet opens it to that LAN. + if (app->state().daemon_version >= 1030000) { + if (CB(TrId("stratum_host", "strat_host"), &s_settingsState.stratum_host)) + saveSettingsPageState(app->settings()); + if (ImGui::IsItemHovered()) material::Tooltip("%s", TR("tt_stratum_host")); + if (s_settingsState.stratum_host) { + ImGui::TextDisabled(" %s", TR("stratum_host_hint")); + ImGui::SetNextItemWidth(220.0f * Layout::dpiScale()); + if (ImGui::InputTextWithHint("##stratumallowip", TR("stratum_allowip_hint"), + s_settingsState.stratum_allowip, sizeof(s_settingsState.stratum_allowip))) + saveSettingsPageState(app->settings()); + if (s_settingsState.stratum_allowip[0] != '\0') + ImGui::TextColored(ImVec4(0.95f, 0.75f, 0.25f, 1.0f), " %s", + TR("stratum_expose_warn")); + } + } } if (CB(TrId("verbose_logging", "verbose"), &s_settingsState.verbose_logging)) { dragonx::util::Logger::instance().setVerbose(s_settingsState.verbose_logging); diff --git a/src/util/i18n.cpp b/src/util/i18n.cpp index 00b7e6f..44c520b 100644 --- a/src/util/i18n.cpp +++ b/src/util/i18n.cpp @@ -730,6 +730,11 @@ void I18n::loadBuiltinEnglish() strings_["tt_tor"] = "Route daemon connections through the Tor network for anonymity"; strings_["tt_keep_daemon"] = "Daemon will still stop when running the setup wizard"; strings_["tt_stop_external"] = "Applies when connecting to a daemon\nyou started outside this wallet"; + strings_["stratum_host"] = "Host a mining pool (stratum)"; + strings_["tt_stratum_host"] = "Run a RandomX stratum pool server on this node so other RandomX miners can point at this computer. Requires a v1.3.0+ node and a daemon restart to apply."; + strings_["stratum_host_hint"] = "Miners connect to this computer on port 22769 (RPC port + 1000) with a RandomX stratum miner. Restart the daemon to apply."; + strings_["stratum_allowip_hint"] = "Allow miners from IP or CIDR (blank = this computer only)"; + strings_["stratum_expose_warn"] = "Opens a mining port to the network you allow — only use on a trusted LAN."; strings_["tt_verbose"] = "Log detailed connection diagnostics,\ndaemon state, and port owner info\nto the Console tab"; strings_["tt_mine_idle"] = "Automatically start mining when the\nsystem is idle (no keyboard/mouse input)"; strings_["tt_idle_delay"] = "How long to wait before starting mining"; From f7df315695ae5d102e9b0196be839703aee8284d Mon Sep 17 00:00:00 2001 From: DanS Date: Tue, 1 Sep 2026 00:15:27 -0500 Subject: [PATCH 76/89] fix(ui): remove the "Taking longer than expected" startup stall notice It added clutter to the loading screen (the yellow title + two lines of explanatory text). The live daemon-output panel below it is the real progress signal. connect_stall_since_ stays maintained in app_network.cpp for connection bookkeeping; it just no longer drives any on-screen text (loading_stall_* i18n strings + util::connectHasStalled are now unused). Co-Authored-By: Claude Opus 4.8 (1M context) --- src/app.cpp | 52 ++++------------------------------------------------ 1 file changed, 4 insertions(+), 48 deletions(-) diff --git a/src/app.cpp b/src/app.cpp index 4d25ca5..6f8053d 100644 --- a/src/app.cpp +++ b/src/app.cpp @@ -6511,54 +6511,10 @@ void App::renderLoadingOverlay(float contentH) } } - // ------------------------------------------------------------------- - // 3d. "Taking longer than expected" notice — the daemon is reachable/launching but - // hasn't become ready within the stall threshold. The connect loop keeps retrying - // underneath (this notice clears itself the instant it connects); it just stops the - // user staring at a silent spinner forever. Guarded off while the daemon is in the - // Error state — that case is owned by the crash block (3c) above. - // ------------------------------------------------------------------- - if (connect_stall_since_ > 0.0 && - !(daemon_controller_ && - daemon_controller_->state() == daemon::EmbeddedDaemon::State::Error) && - util::connectHasStalled(connect_stall_since_, ImGui::GetTime(), - loadElem("stall-timeout-sec", util::kConnectStallDefaultSeconds))) { - curY += gap; - ImFont* bodyFont2 = Type().body2(); - if (!bodyFont2) bodyFont2 = ImGui::GetFont(); - ImFont* capFont = Type().caption(); - if (!capFont) capFont = ImGui::GetFont(); - - // Title - const char* title = TR("loading_stall_title"); - ImVec2 ts = bodyFont2->CalcTextSizeA(bodyFont2->LegacySize, FLT_MAX, 0.0f, title); - dl->AddText(bodyFont2, bodyFont2->LegacySize, - ImVec2(wp.x + cx - ts.x * 0.5f, curY), - IM_COL32(255, 210, 90, 235), title); - curY += ts.y + gap * 0.5f; - - // Body (wrapped) — reassure + show elapsed seconds - char stallBody[256]; - snprintf(stallBody, sizeof(stallBody), TR("loading_stall_body"), - (float)(ImGui::GetTime() - connect_stall_since_)); - float wrapW = ws.x * 0.8f; - if (wrapW > 640.0f * dpi) wrapW = 640.0f * dpi; - ImVec2 bs = capFont->CalcTextSizeA(capFont->LegacySize, FLT_MAX, wrapW, stallBody); - dl->AddText(capFont, capFont->LegacySize, - ImVec2(wp.x + cx - wrapW * 0.5f, curY), - IM_COL32(200, 200, 200, 210), stallBody, nullptr, wrapW); - curY += bs.y + gap * 0.5f; - - // Actionable guidance (full-node only — lite has no daemon to restart) - if (supportsFullNodeLifecycleActions()) { - const char* hint = TR("loading_stall_hint"); - ImVec2 hs = capFont->CalcTextSizeA(capFont->LegacySize, FLT_MAX, 0.0f, hint); - dl->AddText(capFont, capFont->LegacySize, - ImVec2(wp.x + cx - hs.x * 0.5f, curY), - IM_COL32(180, 180, 180, 190), hint); - curY += hs.y + gap; - } - } + // 3d. The "Taking longer than expected" stall notice was intentionally removed — it added + // clutter to the startup screen. The live daemon-output panel below is the real signal that + // the node is making progress. (connect_stall_since_ is still maintained in app_network.cpp + // for connection bookkeeping; it just no longer drives any on-screen text.) // ------------------------------------------------------------------- // 4. Daemon output snippet (last few lines, if embedded) From a3892c0fd3cd485b95046df24f5a1b177ca96d9f Mon Sep 17 00:00:00 2001 From: DanS Date: Tue, 1 Sep 2026 00:49:06 -0500 Subject: [PATCH 77/89] fix(ui): stop spurious "Blockchain rescan complete" toast after restoring from minimize MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit While minimized the main loop skips the frame body (SDL_Delay+continue), so App::update() — which drains the daemon output via outputSince(daemon_output_offset_) — never runs and the offset isn't advanced. On restore the whole accumulated backlog is parsed in one batch: a background witness rebuild's progress lines (parsed as a rescan → state_.sync.rescanning=true) AND its "rebuilt … in Xms" completion (parsed as finished) arrive together and fire "Blockchain rescan complete" for a scan the user never initiated. On WINDOW_RESTORED, discard the daemon-output backlog (advance the offset to the current end, via App::skipDaemonOutputBacklog) before the resumed update parses it — so only new output is parsed. Genuine user-initiated rescans still surface completion via the getrescaninfo monitor. Co-Authored-By: Claude Opus 4.8 (1M context) --- src/app.cpp | 12 ++++++++++++ src/app.h | 4 ++++ src/main.cpp | 33 +++++++++++++++++++++++++++++++++ 3 files changed, 49 insertions(+) diff --git a/src/app.cpp b/src/app.cpp index 6f8053d..bc9af9f 100644 --- a/src/app.cpp +++ b/src/app.cpp @@ -5047,6 +5047,18 @@ void App::refreshNow() invalidateShieldedHistoryScanProgress(true); } +void App::skipDaemonOutputBacklog() +{ + // While minimized, App::update() is paused, so daemon_output_offset_ is never advanced and a large + // backlog of daemon output piles up. Parsing it all at once on restore would replay a background + // witness rebuild's progress + completion in a single batch and fire a spurious "Blockchain rescan + // complete" toast. Advance the offset to the current end so only NEW (post-restore) output is parsed. + // A genuine user-initiated rescan still surfaces completion via the getrescaninfo monitor. + if (daemon_controller_ && daemon_controller_->isRunning()) { + (void)daemon_controller_->outputSince(daemon_output_offset_); // advances daemon_output_offset_ to the end + } +} + void App::handlePaymentURI(const std::string& uri) { auto payment = util::parsePaymentURI(uri); diff --git a/src/app.h b/src/app.h index 0a34982..75460ec 100644 --- a/src/app.h +++ b/src/app.h @@ -393,6 +393,10 @@ public: // Force refresh void refreshNow(); + // Called on window restore: drop the daemon-output backlog that accumulated while minimized (the + // per-frame update loop was paused), so a background witness rebuild that started+finished during + // the minimize isn't parsed in one batch and mistaken for a completed rescan (spurious toast). + void skipDaemonOutputBacklog(); void refreshMiningInfo(); void refreshPeerInfo(); void refreshMarketData(); diff --git a/src/main.cpp b/src/main.cpp index 4e1dbd7..fbbc99b 100644 --- a/src/main.cpp +++ b/src/main.cpp @@ -1263,6 +1263,36 @@ int main(int argc, char* argv[]) SDL_SetWindowMinimumSize(window, (int)(1024 * currentDpiScale), (int)(720 * currentDpiScale)); } + // DEV/TEST hook (dormant unless the env is set): DRAGONX_WIN_GEOM="WxH" forces an exact window + // size, placing it on the largest display that can hold it and bypassing the primary-monitor + // clamp. Lets a headless WSLg sweep render at sizes wider than the 1280 primary (e.g. 2560x1440 + // on the mirrored 4K/1440p outputs). Needs the x11 backend so absolute positioning takes effect. + int wantW = 0, wantH = 0; + if (const char* geom = std::getenv("DRAGONX_WIN_GEOM")) + sscanf(geom, "%dx%d", &wantW, &wantH); + if (wantW > 0 && wantH > 0) { + int count = 0; + SDL_DisplayID* disp = SDL_GetDisplays(&count); + SDL_DisplayID best = 0; SDL_Rect bestUsable{0, 0, 0, 0}; + for (int i = 0; i < count; ++i) { + SDL_Rect u; + if (!SDL_GetDisplayUsableBounds(disp[i], &u)) continue; + bool fits = (u.w >= wantW && u.h >= wantH); + bool bestFits = (bestUsable.w >= wantW && bestUsable.h >= wantH); + // Prefer a display that fits; among those, the smallest; else the largest available. + if ((fits && !bestFits) || + (fits && bestFits && (long)u.w * u.h < (long)bestUsable.w * bestUsable.h) || + (!fits && !bestFits && (long)u.w * u.h > (long)bestUsable.w * bestUsable.h)) { + bestUsable = u; best = disp[i]; + } + } + if (disp) SDL_free(disp); + if (best) { + SDL_SetWindowMinimumSize(window, 320, 240); + SDL_SetWindowPosition(window, bestUsable.x + 10, bestUsable.y + 10); + SDL_SetWindowSize(window, wantW, wantH); + } + } else { // Clamp to the current display's work area — runs on EVERY startup (this clamp used to live // inside the HiDPI branch, so a size saved on a larger/disconnected monitor could open the // window off-screen or bigger than the screen on a same-DPI cold start). @@ -1281,6 +1311,7 @@ int main(int argc, char* argv[]) DEBUG_LOGF("Startup: window fitted %dx%d -> %dx%d (scale %.2f)\n", curW, curH, newW, newH, currentDpiScale); } + } } #endif winlog("STARTUP savedSize=%dx%d currentDpiScale=%.3f", savedWinW, savedWinH, currentDpiScale); @@ -1552,6 +1583,7 @@ int main(int argc, char* argv[]) // Window restored from minimized — trigger immediate data refresh if (waitEvent.type == SDL_EVENT_WINDOW_RESTORED && waitEvent.window.windowID == SDL_GetWindowID(window)) { + app.skipDaemonOutputBacklog(); // drop the minimized-period backlog (avoids a spurious "rescan complete" toast) app.refreshNow(); } // Handle DPI change that arrived while idle (same logic as poll loop) @@ -1681,6 +1713,7 @@ int main(int argc, char* argv[]) // Window restored from minimized — trigger immediate data refresh if (event.type == SDL_EVENT_WINDOW_RESTORED && event.window.windowID == SDL_GetWindowID(window)) { + app.skipDaemonOutputBacklog(); // drop the minimized-period backlog (avoids a spurious "rescan complete" toast) app.refreshNow(); } // Handle DPI/display scale changes (e.g. window dragged to a From 0343d48c13d32e33dddc9551ffce97c2befaed20 Mon Sep 17 00:00:00 2001 From: DanS Date: Tue, 1 Sep 2026 01:09:50 -0500 Subject: [PATCH 78/89] feat(ui): keep the wallet syncing while minimized MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Previously the main loop just did SDL_Delay+continue when minimized, skipping app.update() — so the wallet stopped draining RPC results, ticking the refresh scheduler, and reconnecting until it was restored (and a large daemon-output backlog piled up, which is what produced the spurious "rescan complete" toast on restore). Now app.update() runs while minimized (it only reads GetIO/GetTime/IsAnyItemActive, all valid outside a NewFrame) with a real-clock DeltaTime, skipping only the ImGui frame + GPU present, throttled to ~5 Hz so CPU stays near-idle. Also clamp io.DeltaTime at the top of App::update() so a long minimize (or machine sleep) can't report a huge delta and fire every refresh/animation timer at once on the next update. No backlog now builds, so skipDaemonOutputBacklog becomes a harmless no-op. Co-Authored-By: Claude Opus 4.8 (1M context) --- src/app.cpp | 4 ++++ src/main.cpp | 26 +++++++++++++++++++++----- 2 files changed, 25 insertions(+), 5 deletions(-) diff --git a/src/app.cpp b/src/app.cpp index bc9af9f..50ba895 100644 --- a/src/app.cpp +++ b/src/app.cpp @@ -739,6 +739,10 @@ void App::update() { PERF_SCOPE("Update.Total"); ImGuiIO& io = ImGui::GetIO(); + // Clamp the frame delta: after a long pause (window minimized, or the machine slept) NewFrame reports + // a huge DeltaTime that would fire every refresh/animation timer at once. Every timer reads + // io.DeltaTime, so one clamp here bounds them all (also caps the real-clock delta fed while minimized). + if (io.DeltaTime > 0.25f) io.DeltaTime = 0.25f; // Full UI screenshot sweep: demo state is injected once and must stay frozen. Skip every live // op (refresh/connect/pumps) so a real daemon can't clobber it — on Windows a running node's diff --git a/src/main.cpp b/src/main.cpp index fbbc99b..7143d2d 100644 --- a/src/main.cpp +++ b/src/main.cpp @@ -1500,6 +1500,7 @@ int main(int argc, char* argv[]) // WINDOW_RESIZED events during the transition can't corrupt savedSizeForScale / lastKnownW/H. int dpiSettleFrames = 0; SDL_DisplayID lastLoggedDisplay = 0; // [WINLOG] throttle: log MOVED only when the display changes + Uint64 minimizedLastTickMs = 0; // real-clock tick for the minimized "keep syncing" update { float s = dragonx::ui::material::Typography::instance().getDpiScale(); int w = 0, h = 0; @@ -1734,13 +1735,28 @@ int main(int argc, char* argv[]) // Check if window is minimized if (SDL_GetWindowFlags(window) & SDL_WINDOW_MINIMIZED) { - // Still check shouldQuit while minimized to avoid hang - if (app.shouldQuit()) { - running = false; - } - SDL_Delay(10); + // Keep the wallet syncing while minimized: run the logic update (drains RPC results, ticks the + // refresh scheduler, keeps the daemon connection/reconnect + sync status live) but skip the + // ImGui frame + GPU present since nothing is visible. app.update() only reads + // GetIO()/GetTime()/IsAnyItemActive() — all valid outside a frame — so it's safe without a + // NewFrame; feed it a real-clock DeltaTime (NewFrame, which normally sets it, is skipped) and + // let app.update() clamp it. Throttled to ~5 Hz so CPU stays near-idle (refresh cadences are + // seconds-scale). shouldQuit is still checked so a quit request never hangs behind minimize. + Uint64 nowMs = SDL_GetTicks(); + float minDelta = (minimizedLastTickMs == 0) ? 0.001f + : (float)(nowMs - minimizedLastTickMs) / 1000.0f; + minimizedLastTickMs = nowMs; + ImGui::GetIO().DeltaTime = (minDelta > 0.0f) ? minDelta : 0.001f; + try { + app.update(); + } catch (const std::exception& e) { + DEBUG_LOGF("[Main] minimized app.update() threw: %s\n", e.what()); + } catch (...) {} + if (app.shouldQuit()) running = false; + SDL_Delay(200); continue; } + minimizedLastTickMs = 0; // visible again — reset the minimized clock // --- PerfLog: begin frame --- dragonx::util::PerfLog::instance().beginFrame(); From 398fb274fae13433ae07f02479bf97bbf5d654f1 Mon Sep 17 00:00:00 2001 From: DanS Date: Tue, 1 Sep 2026 01:18:57 -0500 Subject: [PATCH 79/89] fix(ui): only toast "Blockchain rescan complete" for user-initiated rescans MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit The daemon-output parser treats autonomous background witness rebuilds as a rescan (they set state_.sync.rescanning via the foundWitness branch), so one completing fired "Blockchain rescan complete" even though the user never started a rescan — most visibly after a minimize, where a whole rebuild's start+finish arrives in one batch. Add user_initiated_rescan_ (atomic — some triggers run on worker threads), set it at the wallet's real rescan triggers (the Rescan button, a -rescan/salvage/zap/reindex restart, key import, seed migration), and gate the three "rescan complete" toasts on it, clearing it when shown. The rescan/witness progress state machine is untouched — only the toast is gated — so background rebuilds no longer announce a completed rescan while genuine user rescans still do (and can't double-toast). Co-Authored-By: Claude Opus 4.8 (1M context) --- src/app.cpp | 11 +++++++++-- src/app.h | 5 +++++ src/app_network.cpp | 11 ++++++++--- 3 files changed, 22 insertions(+), 5 deletions(-) diff --git a/src/app.cpp b/src/app.cpp index 50ba895..b222982 100644 --- a/src/app.cpp +++ b/src/app.cpp @@ -988,7 +988,10 @@ void App::update() // saw the rescan running. Without the confirmed-active gate, the first // poll (which hits the still-running pre-restart daemon, rescanning=false) // would fire a false "complete" the instant rescan was clicked. - ui::Notifications::instance().success("Blockchain rescan complete"); + if (user_initiated_rescan_) { + ui::Notifications::instance().success("Blockchain rescan complete"); + user_initiated_rescan_ = false; // surfaced once; not for background rebuilds + } resetWitnessRescanProgress(); state_.sync.rescan_progress = 1.0f; } @@ -1091,8 +1094,9 @@ void App::update() // Apply results directly — we are already on the main thread. const std::string& status = scan.lastStatus; if (scan.finished) { - if (state_.sync.rescanning) { + if (state_.sync.rescanning && user_initiated_rescan_) { ui::Notifications::instance().success("Blockchain rescan complete"); + user_initiated_rescan_ = false; // surfaced once; not for background rebuilds } // Witness rebuild finishes with the rescan it's part of. resetWitnessRescanProgress(); @@ -5464,6 +5468,7 @@ void App::rescanBlockchain() // pre-restart daemon and see rescanning=false) can't be misread as instant completion. state_.sync.rescanning = true; rescan_confirmed_active_ = false; + user_initiated_rescan_ = true; // user-triggered rescan → its completion should toast state_.sync.rescan_progress = 0.0f; state_.sync.rescan_status = decision.status; transactions_dirty_ = true; @@ -5515,6 +5520,7 @@ void App::repairWallet() // confirmed-active gating as rescan: the first poll may still reach the pre-restart daemon. state_.sync.rescanning = true; rescan_confirmed_active_ = false; + user_initiated_rescan_ = true; // user-triggered repair (implies rescan) → completion should toast state_.sync.rescan_progress = 0.0f; state_.sync.rescan_status = decision.status; transactions_dirty_ = true; @@ -6930,6 +6936,7 @@ void App::reindexBlockDatabase() } if (!daemon_controller_) return; daemon_controller_->setReindexOnNextStart(true); + user_initiated_rescan_ = true; // reindex implies a rescan → its completion should toast daemon_controller_->resetCrashCount(); // the abort no longer counts against the restart budget show_block_db_reindex_confirm_ = false; block_db_reindex_available_ = false; // un-gate → the connect loop restarts the node with -reindex diff --git a/src/app.h b/src/app.h index 75460ec..9509600 100644 --- a/src/app.h +++ b/src/app.h @@ -1302,6 +1302,11 @@ private: // the per-second mining/rescan-status pollers are suppressed (the daemon holds cs_main for // the whole scan and would block them); completion is signalled by the rescan RPC callback. bool runtime_rescan_active_ = false; + // True only for a rescan the WALLET/USER initiated (the Rescan button, a -rescan/salvage/zap/reindex + // restart, key import, seed migration) — not an autonomous background witness rebuild the daemon does + // on its own. Gates the "Blockchain rescan complete" toast so background rebuilds don't fire it; + // cleared when the toast is shown. + std::atomic user_initiated_rescan_{false}; // atomic: some rescan triggers run on worker threads // Set when a bootstrap completes; consumed once the daemon is connected to auto-run a rescan // that reconciles the preserved wallet.dat against the freshly-imported chain. bool post_bootstrap_rescan_pending_ = false; diff --git a/src/app_network.cpp b/src/app_network.cpp index 06fda63..57a1c23 100644 --- a/src/app_network.cpp +++ b/src/app_network.cpp @@ -1365,6 +1365,7 @@ void App::switchToWallet(const std::string& walletFile, bool stopDaemonConfirmed if (daemon_controller_) daemon_controller_->clearExternalDaemonDetected(); if (salvage && daemon_controller_) daemon_controller_->setSalvageOnNextStart(true); // repair a corrupt wallet else if (needRescan && daemon_controller_) daemon_controller_->setRescanOnNextStart(true); // (salvage implies rescan) + if (salvage || needRescan) user_initiated_rescan_ = true; // wallet-triggered repair/rescan → completion should toast // Start ONCE. Do NOT retry-spawn: a second start while the first is still shutting down leaves // two dragonxd holding wallet.dat against each other (BDB "Failed to rename … Error"). The // stopDaemonForWalletSwitch() wait already ensured the old node's process is gone, so a valid @@ -1680,7 +1681,10 @@ void App::refreshCoreData() transactions_dirty_ = true; last_tx_block_height_ = -1; invalidateShieldedHistoryScanProgress(true); - ui::Notifications::instance().success("Blockchain rescan complete"); + if (user_initiated_rescan_) { + ui::Notifications::instance().success("Blockchain rescan complete"); + user_initiated_rescan_ = false; // surfaced once; not for background rebuilds + } } NetworkRefreshService::applyConnectionInfoResult(state_, result.info); @@ -4831,7 +4835,7 @@ void App::beginAdoptSeedWallet() // 3. Rescan on next start (only if the swap happened) and bring the daemon back up — // unless we're quitting, in which case don't resurrect it. - if (swapDone && daemon_controller_) daemon_controller_->setRescanOnNextStart(true); + if (swapDone && daemon_controller_) { daemon_controller_->setRescanOnNextStart(true); user_initiated_rescan_ = true; } if (!shutting_down_) { // We stopped the daemon ourselves (port_free) — clear the adopted-external latch so the // relaunched process is treated as owned (stop/isRunning/exit behave normally afterward). @@ -5130,7 +5134,7 @@ void App::rebuildWalletDatabase() 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 (daemon_controller_) { daemon_controller_->setRescanOnNextStart(true); user_initiated_rescan_ = true; } } } } @@ -5558,6 +5562,7 @@ void App::runtimeRescan(int startHeight) runtime_rescan_active_ = true; state_.sync.rescanning = true; rescan_confirmed_active_ = true; + user_initiated_rescan_ = true; // user clicked Rescan → completion should toast state_.sync.rescan_progress = 0.0f; state_.sync.rescan_status = "Rescanning from block " + std::to_string(startHeight) + "..."; transactions_dirty_ = true; From 56d93b6128596d73637c85a0767295f89828fa1c Mon Sep 17 00:00:00 2001 From: DanS Date: Tue, 1 Sep 2026 02:21:49 -0500 Subject: [PATCH 80/89] fix(shutdown): don't warn "node is rebuilding" for routine witness activity / on v1.3.0 MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit The shutdown guard fired its "Node is rebuilding its witness cache" prompt almost always on an active wallet: the daemon does a per-tx VerifyAndSetInitialWitness as each newly received wallet tx lands during normal sync, and those markers (sparse — minutes apart — with no matching "rebuilt N note witness cache(s) … in Xms") kept the heuristic latched "active". - daemonWitnessRebuildActive() now requires the last progress marker to be part of the CURRENT log activity (within ~15s of the newest log line, via a same-log timestamp delta), so routine minutes-old per-tx witness sets no longer count as an ongoing rebuild. - shouldConfirmDaemonStop() suppresses the prompt entirely on v1.3.0+ daemons (version >= 1030000): they checkpoint witness-rescan progress, so stopping mid-rebuild resumes on the next start rather than redoing it — the warning's "restarts it (several minutes)" premise no longer holds. Co-Authored-By: Claude Opus 4.8 (1M context) --- src/app.cpp | 41 +++++++++++++++++++++++++++++++++-------- 1 file changed, 33 insertions(+), 8 deletions(-) diff --git a/src/app.cpp b/src/app.cpp index b222982..0843d9c 100644 --- a/src/app.cpp +++ b/src/app.cpp @@ -5808,26 +5808,47 @@ std::vector App::tailDaemonDebugLog(int maxLines) const return lines; } +// Parse a "YYYY-MM-DD HH:MM:SS ..." debug.log line prefix to time_t. Interpreted as local time, but it +// is only ever used for DELTAS between two lines of the SAME log, so the timezone cancels. Returns 0 if +// the line has no such timestamp prefix. +static std::time_t parseDaemonLogTimestamp(const std::string& line) +{ + int y = 0, mo = 0, d = 0, h = 0, mi = 0, s = 0; + if (std::sscanf(line.c_str(), "%d-%d-%d %d:%d:%d", &y, &mo, &d, &h, &mi, &s) != 6) return 0; + std::tm tm{}; + tm.tm_year = y - 1900; tm.tm_mon = mo - 1; tm.tm_mday = d; + tm.tm_hour = h; tm.tm_min = mi; tm.tm_sec = s; tm.tm_isdst = -1; + return std::mktime(&tm); +} + bool App::daemonWitnessRebuildActive() const { // Scan the debug.log tail for the daemon's witness-rebuild markers (wallet.cpp): "Cleared witness - // data from" (start), "Setting Initial Sapling Witness" / "Reading blocks for witness rebuild" - // (progress), vs. "rebuilt N note witness cache(s)" / "aborting…" (finished). Active iff the most - // recent relevant line is a start/progress line, not a completion. - const auto lines = tailDaemonDebugLog(80); - int state = 0; // 0 none, 1 active, 2 finished/aborted + // data from" (start), "Reading blocks for witness rebuild" / "Setting Initial Sapling Witness" + // (progress), vs. "rebuilt N note witness cache(s)" / "aborting…" (finished). + // + // A genuine ongoing rebuild logs progress CONTINUOUSLY. The routine per-tx witness set the daemon + // does as each new wallet tx lands during normal sync is SPARSE (minutes apart) and must NOT trip + // this — that was firing the "node is rebuilding" prompt on wallets that just receive frequently. + // So require the last progress marker to be (a) later than any completion AND (b) part of the CURRENT + // activity — within a few seconds of the newest log line (same-log timestamp delta → timezone-free). + const auto lines = tailDaemonDebugLog(120); + std::time_t newest = 0, lastProgress = 0, lastDone = 0; for (const auto& l : lines) { + const std::time_t ts = parseDaemonLogTimestamp(l); + if (ts > newest) newest = ts; if (l.find("note witness cache(s) to height") != std::string::npos || l.find("aborting witness rebuild") != std::string::npos || l.find("aborted during witness rebuild") != std::string::npos) { - state = 2; + if (ts > lastDone) lastDone = ts; } else if (l.find("Reading blocks for witness rebuild") != std::string::npos || l.find("Setting Initial Sapling Witness") != std::string::npos || l.find("Cleared witness data from") != std::string::npos) { - state = 1; + if (ts > lastProgress) lastProgress = ts; } } - return state == 1; + if (lastProgress == 0 || lastDone >= lastProgress || newest == 0) return false; + return (newest - lastProgress) <= 15; // progress is part of the current activity → ongoing rebuild } bool App::shouldConfirmDaemonStop() const @@ -5839,6 +5860,10 @@ bool App::shouldConfirmDaemonStop() const settings_ && settings_->getKeepDaemonRunning(), settings_ && settings_->getStopExternalDaemon()); if (decision.action != daemon::DaemonController::ShutdownAction::StopDaemon) return false; + // v1.3.0+ checkpoints witness-rescan progress, so stopping mid-rebuild resumes on the next start + // instead of redoing it from scratch — the warning's premise no longer holds, so don't prompt. + // (daemon_version encodes major*1e6 + minor*1e4 + rev*100 + build; v1.3.0 == 1030000.) + if (state_.daemon_version >= 1030000) return false; return daemonWitnessRebuildActive(); } From 4492aa342580a5591c610c50bbd49dbcdbecc11c Mon Sep 17 00:00:00 2001 From: DanS Date: Tue, 1 Sep 2026 19:36:30 -0500 Subject: [PATCH 81/89] fix(sync): prioritize getblockchaininfo and pause chat scans while behind MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit The node kept falling behind the network near the tip because sync DETECTION was starved: getblockchaininfo was queued behind the O(mapWallet) wallet RPCs (z_gettotalbalance / z_listunspent), so longestchain went stale, the wallet decided it was "synced", and it resumed hammering cs_main — a feedback loop. - Issue getblockchaininfo FIRST each cycle and skip the balance/address/ tx refresh entirely while behind, so sync state (and kSyncProfile) updates before any heavy wallet scan runs. - Gate the two chat note scans (refreshChatNoteBudgetNode / fastScanChatMemos) on effectivelySyncing() and the active page, so chat memo scanning no longer competes with block connection during sync. - Windows debug.log tailer: reset the read offset when dragonxd truncates the log on startup (it was stranding at Block:0 with no witness/rescan progress). - Tests cover the getblockchaininfo-first ordering and behind-skip. Co-Authored-By: Claude Opus 4.8 (1M context) --- src/app_network.cpp | 134 +++++++++++++++++++++-- src/daemon/embedded_daemon.cpp | 12 +- src/services/network_refresh_service.cpp | 61 +++++++++-- src/services/network_refresh_service.h | 17 +++ tests/test_phase4.cpp | 36 ++++-- 5 files changed, 231 insertions(+), 29 deletions(-) diff --git a/src/app_network.cpp b/src/app_network.cpp index 57a1c23..cc2f979 100644 --- a/src/app_network.cpp +++ b/src/app_network.cpp @@ -882,13 +882,32 @@ bool App::effectivelySyncing() const // cheap wallet (sub-cadence cost) is unaffected — the tab's Core timer stays the real cadence; a ~20s // scan on a large wallet backs off to roughly every ~200s instead of every 2s, freeing cs_main for // block connection. A wallet mutation bypasses this via force_balance_refresh_. +bool App::scanRefreshDue(std::int64_t lastUpdate, double lastScanMs) const +{ + constexpr double kScanDutyCycle = 0.10; + if (lastUpdate == 0) return true; // never fetched + if (lastScanMs <= 0.0) return true; // no cost measured yet + const double minInterval = (lastScanMs / 1000.0) / kScanDutyCycle; + return std::difftime(std::time(nullptr), static_cast(lastUpdate)) >= minInterval; +} + bool App::balanceRefreshDue() const { - constexpr double kBalanceDutyCycle = 0.10; - if (state_.last_balance_update == 0) return true; // never fetched - if (last_balance_scan_ms_ <= 0.0) return true; // no cost measured yet - const double minInterval = (last_balance_scan_ms_ / 1000.0) / kBalanceDutyCycle; - return std::difftime(std::time(nullptr), state_.last_balance_update) >= minInterval; + return scanRefreshDue(state_.last_balance_update, last_balance_scan_ms_); +} + +// The address scan (z_listunspent) and history scan (z_listreceivedbyaddress) are just as O(mapWallet) +// and cs_main-bound as the balance scan, so they get the same adaptive back-off. This is what keeps a +// large synced wallet from re-scanning them every tab cadence — the near-tip starvation the balance-only +// throttle missed (only the periodic poll is gated; explicit refreshes call the refresh directly). +bool App::addressRefreshDue() const +{ + return scanRefreshDue(state_.last_address_update, last_address_scan_ms_); +} + +bool App::txRefreshDue() const +{ + return scanRefreshDue(state_.last_tx_update, last_tx_scan_ms_); } bool App::currentPageNeedsWalletDataRefresh() const @@ -1739,11 +1758,19 @@ void App::refreshCoreData() // cost (0 when balance was skipped), and arm the settle window only on the // syncing→caught-up edge so a wallet synced from the start is never throttled at connect. if (result.balanceScanMs > 0.0) last_balance_scan_ms_ = result.balanceScanMs; + // Sticky-behind hysteresis: hold the low-impact profile for kSyncSettleSeconds after the + // LAST time we read "behind" — not only on the caught-up edge. While actually syncing we + // re-arm every Core tick, so the profile stays engaged continuously; once we truly reach + // the tip (within the 2-block tolerance in applyCoreRefreshResult) we stop re-arming and it + // lapses after the window. This is what breaks the near-tip feedback loop: a single stale or + // optimistic "caught up" reading can no longer immediately unleash the heavy O(mapWallet) + // scans and re-starve the tail (which dropped us behind again → oscillation). With the + // scans suppressed, kSyncProfile keeps sync detection itself cheap, so we keep getting fresh + // "behind" readings and stay latched until genuinely caught up. Window must exceed the + // worst-case Core-refresh interval so it can't lapse between two behind readings mid-catchup. const bool nowSyncing = state_.sync.syncing; - if (nowSyncing) { - sync_settle_until_ = 0; - } else if (was_core_syncing_) { - constexpr double kSyncSettleSeconds = 8.0; + constexpr double kSyncSettleSeconds = 30.0; + if (nowSyncing || was_core_syncing_) { sync_settle_until_ = std::time(nullptr) + static_cast(kSyncSettleSeconds); } was_core_syncing_ = nowSyncing; @@ -1872,7 +1899,13 @@ void App::refreshAddressData() return [this, previousAddressCount, previousWalletIdentity, result = std::move(result)]() mutable { const bool addrListOk = result.addressListOk; // capture before the move + const double scanMs = result.scanMs; // feed the adaptive throttle (addressRefreshDue) + if (scanMs > 0.0) last_address_scan_ms_ = scanMs; + // #3: this scan already listed the wallet's unspent notes — feed the chat send-budget from it + // (dedups the dedicated chat z_listunspent). Grab it before `result` is moved below. + auto unspentNotes = std::move(result.unspentNotes); NetworkRefreshService::applyAddressRefreshResult(state_, std::move(result)); + updateChatNoteBudgetFromUnspent(unspentNotes); // Mark the address list as loaded ONLY if enumeration actually succeeded — a swallowed // z_listaddresses/getaddressesbyaccount failure returns a falsely-short list, and stamping it // would let the empty-wallet warning trust a spurious 0 count (see maybeWarnEmptyWallet…). @@ -1931,6 +1964,13 @@ void App::refreshTransactionData() transactionSnapshot.maxShieldedReceiveScans = shieldedReceiveScanBudget(current_page_); transactionSnapshot.shieldedScanTipTolerance = shieldedScanTipTolerance(transactionSnapshot.shieldedAddresses.size()); + // When fully synced, widen the re-scan tolerance so the O(mapWallet) per-address history scan runs + // every several blocks instead of ~every 2 — the heaviest residual synced-state cs_main cost. The + // balance poll still surfaces incoming funds on its own cadence; only the detailed history list lags a + // few minutes. (During catch-up the tx refresh is suppressed by kSyncProfile, so this is synced-only.) + if (!effectivelySyncing()) + transactionSnapshot.shieldedScanTipTolerance = + std::max(transactionSnapshot.shieldedScanTipTolerance, 8); ui::NavPage tracePage = current_page_; auto enqueued = network_refresh_.enqueue(services::NetworkRefreshService::Job::Transactions, *worker_, [this, currentBlocks, @@ -1941,6 +1981,7 @@ void App::refreshTransactionData() return [this, result = std::move(result)]() mutable { bool shieldedScanComplete = result.shieldedScanComplete; + if (result.scanMs > 0.0) last_tx_scan_ms_ = result.scanMs; // feed the adaptive throttle (txRefreshDue) std::size_t nextShieldedScanStartIndex = result.nextShieldedScanStartIndex; auto shieldedScanHeights = std::move(result.shieldedScanHeights); NetworkRefreshService::TransactionCacheUpdate cacheUpdate{ @@ -2006,6 +2047,9 @@ void App::refreshRecentTransactionData() transactionSnapshot.maxShieldedReceiveScans = 1; transactionSnapshot.shieldedScanTipTolerance = shieldedScanTipTolerance(transactionSnapshot.shieldedAddresses.size()); + if (!effectivelySyncing()) // synced: widen the re-scan tolerance (see refreshTransactionData) + transactionSnapshot.shieldedScanTipTolerance = + std::max(transactionSnapshot.shieldedScanTipTolerance, 8); ui::NavPage tracePage = current_page_; auto enqueued = network_refresh_.enqueue(services::NetworkRefreshService::Job::Transactions, *worker_, [this, currentBlocks, @@ -3535,9 +3579,25 @@ void App::refreshChatNoteBudget(const wallet::LiteWalletAppRefreshModel& model) void App::refreshChatNoteBudgetNode() { if (lite_wallet_ || !chat::hushChatFeatureEnabledAtBuild() || !chat_service_.hasIdentity()) return; if (!state_.connected || !rpc_ || !worker_ || state_.isLocked()) return; + // Never contend the daemon's cs_main while the node is catching up. z_listunspent is O(mapWallet) + // and holds cs_main for its whole duration — seconds on a large wallet — so an ungated per-few-second + // chat scan here starves block connection and keeps the node from ever pinning to the tip. Chat + // send-readiness can wait until we're synced; this budget is only advisory (the send path re-checks). + if (effectivelySyncing()) return; + // Only pre-warm the send-budget while the user is actually in chat. Off the Chat tab this heavy + // z_listunspent is unnecessary — and on a wallet-data tab, refreshAddressData's own z_listunspent + // already feeds the budget for free (updateChatNoteBudgetFromUnspent), so this dedicated scan is a + // fallback for the Chat tab (where the address refresh doesn't run). + if (current_page_ != ui::NavPage::Chat) return; if (chat_note_scan_in_flight_) return; // one scan at a time const double now = ImGui::GetTime(); - if (now - chat_note_scan_last_ < 4.0) return; // rate limit; self-throttles via the in-flight flag too + // Adaptive back-off keyed on the last scan's own cost: on a large wallet where the scan takes many + // seconds, this stretches the interval so the scan can't occupy more than ~10% of wall-clock (same + // duty-cycle discipline as the balance/address/tx polls). A cheap wallet stays at the 4s floor. + double minInterval = 4.0; + if (chat_note_scan_ms_ > 0.0) + minInterval = std::max(4.0, (chat_note_scan_ms_ / 1000.0) / 0.10); + if (now - chat_note_scan_last_ < minInterval) return; chat_note_scan_last_ = now; chat_note_scan_in_flight_ = true; @@ -3548,6 +3608,7 @@ void App::refreshChatNoteBudgetNode() { int verified = 0, pipeline = 0; std::uint64_t verifiedZat = 0; bool ok = false; + const auto scanStart = std::chrono::steady_clock::now(); try { rpc::RPCClient::TraceScope trace("HushChat / note-buffer scan"); nlohmann::json notes = rpc_->call("z_listunspent", nlohmann::json::array({0})); // 0 = include maturing @@ -3567,9 +3628,12 @@ void App::refreshChatNoteBudgetNode() { } } } catch (const std::exception&) {} - return [this, scanGen, ok, verified, pipeline, verifiedZat]() { + const double scanMs = std::chrono::duration( + std::chrono::steady_clock::now() - scanStart).count(); + return [this, scanGen, ok, verified, pipeline, verifiedZat, scanMs]() { if (scanGen != chat_session_generation_) return; // wallet switched — drop (reset cleared the flag) chat_note_scan_in_flight_ = false; + if (scanMs > 0.0) chat_note_scan_ms_ = scanMs; // feed the adaptive back-off if (!ok) return; // z_listunspent unavailable — leave caches as-is chat_note_model_seen_ = true; chat_verified_note_budget_ = verified; @@ -3584,6 +3648,36 @@ void App::refreshChatNoteBudgetNode() { }); } +// #3: derive the chat send-budget from an already-collected z_listunspent (refreshAddressData's scan), +// so we don't issue a duplicate z_listunspent. Runs on the main thread; the notes are pre-parsed to the +// fields we need (amount / locked / TRUE confirmations), so there's no RPC and no worker hop. Mirrors the +// apply in refreshChatNoteBudgetNode and stamps chat_note_scan_last_ so the dedicated scan backs off. +void App::updateChatNoteBudgetFromUnspent( + const std::vector& unspentNotes) { + if (lite_wallet_ || !chat::hushChatFeatureEnabledAtBuild() || !chat_service_.hasIdentity()) return; + const int confsNeeded = chatConfsRequired(); + const std::uint64_t minVal = chatDrgxToZat(kChatMinFeeDrgx); + int verified = 0, pipeline = 0; + std::uint64_t verifiedZat = 0; + for (const auto& nz : unspentNotes) { + if (nz.locked) continue; // tied up by an in-flight send + const std::uint64_t amtZat = chatDrgxToZat(nz.amount); + if (amtZat < minVal) continue; // skip dust below a fee + ++pipeline; // unspent self-note (verified or maturing) + if (nz.confirmations >= confsNeeded) { ++verified; verifiedZat += amtZat; } + } + chat_note_model_seen_ = true; + chat_verified_note_budget_ = verified; + chat_pipeline_note_count_ = pipeline; + chat_verified_shielded_zat_ = verifiedZat; + chat_note_scan_last_ = ImGui::GetTime(); // counts as a fresh scan → dedicated scan backs off + if (chat_split_outstanding_ && + (chat_pipeline_note_count_ >= kChatRefillTrigger || + ImGui::GetTime() - chat_split_submitted_at_ > kChatSplitWatchdogSecs)) { + chat_split_outstanding_ = false; + } +} + void App::enqueueChatSend(LiteOpKind kind, const chat::OutgoingChatMemos& memos, const std::string& echoLocalId) { QueuedChatOp op; op.kind = kind; @@ -3825,15 +3919,28 @@ void App::fastScanChatMemos() if (!chat::hushChatFeatureEnabledAtBuild() || !chat_service_.hasIdentity()) return; if (!state_.connected || !rpc_ || !worker_) return; if (chat_fast_scan_in_flight_) return; // don't stack RPCs if a previous scan is still running + // z_listreceivedbyaddress is O(mapWallet) (the daemon iterates every wtx even when filtered to one + // address) — seconds on a large wallet — so this 0-conf poll must NOT run while the node is catching + // up, and even when synced it backs off to ~10% wall-clock keyed on its own cost. The block-tip + // harvest still ingests every message on confirmation; this only trades away mempool-speed delivery. + if (effectivelySyncing()) return; + // Mempool-speed 0-conf delivery is only worth its heavy cost while the user is watching chat. Off the + // Chat tab, incoming messages still arrive via the confirmed block-tip harvest (+ toast) within ~1 block. + if (current_page_ != ui::NavPage::Chat) return; + const double nowT = ImGui::GetTime(); + if (chat_fast_scan_ms_ > 0.0 && + nowT - chat_fast_scan_last_ < (chat_fast_scan_ms_ / 1000.0) / 0.10) return; const std::string addr = chatReplyZaddr(); if (addr.empty()) return; + chat_fast_scan_last_ = nowT; chat_fast_scan_in_flight_ = true; const int scanGen = chat_session_generation_; // guard: drop the result if the wallet switches/locks worker_->post([this, addr, scanGen]() -> rpc::RPCWorker::MainCb { std::vector metadata; int rawMemoCount = 0; // received notes carrying a memo at the reply addr (0-conf visibility signal) std::string scanError; + const auto scanStart = std::chrono::steady_clock::now(); try { rpc::RPCClient::TraceScope trace("HushChat / 0-conf fast scan"); nlohmann::json received = rpc_->call("z_listreceivedbyaddress", {addr, 0}); // 0 = include mempool @@ -3864,12 +3971,15 @@ void App::fastScanChatMemos() } } catch (const std::exception& e) { scanError = e.what(); } const int parsedCount = static_cast(metadata.size()); - return [this, scanGen, metadata = std::move(metadata), rawMemoCount, parsedCount, scanError]() mutable { + const double scanMs = std::chrono::duration( + std::chrono::steady_clock::now() - scanStart).count(); + return [this, scanGen, metadata = std::move(metadata), rawMemoCount, parsedCount, scanError, scanMs]() mutable { // The wallet was switched/locked between post and now — this metadata belongs to the previous // session. resetChatSession already reset the in-flight flag, so just drop; clearing it here // would clobber a new session's own in-flight scan (mirrors the broadcast/identity guards). if (scanGen != chat_session_generation_) return; chat_fast_scan_in_flight_ = false; + if (scanMs > 0.0) chat_fast_scan_ms_ = scanMs; // feed the adaptive back-off // Diagnostic (console App/chat channel): log when the memo-note count at the reply address // CHANGES, so a stable mempool doesn't spam every 2.5s. Reveals whether inbound 0-conf messages // are reaching us at all, and how many parse as chat vs are unrelated memos. diff --git a/src/daemon/embedded_daemon.cpp b/src/daemon/embedded_daemon.cpp index 0ca0e1a..c05c4f6 100644 --- a/src/daemon/embedded_daemon.cpp +++ b/src/daemon/embedded_daemon.cpp @@ -816,11 +816,21 @@ void EmbeddedDaemon::drainOutput() } size_t currentSize = static_cast(fileSize.QuadPart); + // Truncation / rotation detection. dragonxd shrinks debug.log on startup (ShrinkDebugFile keeps + // only the tail once it has grown large), so the file can become SMALLER than where we left off. + // Our offset was set to the PRE-shrink size at spawn, so without this reset it stays stranded ahead + // of the freshly-truncated file and we read NOTHING for the whole session — no block height (status + // bar shows "Block: 0") and, worse, no witness-rebuild progress, since the "Setting Initial Sapling + // Witness …" lines the warmup progress bar parses only exist in debug.log on Windows. On a shrink, + // restart from the new beginning; the parser is monotonic and converges as it reaches current output. + if (currentSize < debug_log_offset_) { + debug_log_offset_ = 0; + } if (currentSize <= debug_log_offset_) { CloseHandle(hFile); return; // No new data } - + // Seek to where we left off LARGE_INTEGER seekPos; seekPos.QuadPart = static_cast(debug_log_offset_); diff --git a/src/services/network_refresh_service.cpp b/src/services/network_refresh_service.cpp index 33d331f..0763966 100644 --- a/src/services/network_refresh_service.cpp +++ b/src/services/network_refresh_service.cpp @@ -297,7 +297,31 @@ NetworkRefreshService::CoreRefreshResult NetworkRefreshService::collectCoreRefre bool blockOk = false; double balanceScanMs = 0.0; - if (includeBalance) { + // getblockchaininfo FIRST — it's cheap, and the sync state it returns gates everything else + // (the balance/address/tx throttles and kSyncProfile). Running it BEFORE the O(mapWallet) balance + // scan keeps sync detection from being delayed behind (or, under contention, starved by) that + // scan — the failure mode where the wallet kept reading "synced" while actually falling behind, + // so kSyncProfile never engaged. See effectivelySyncing()'s sticky-behind latch. + try { + blockInfo = rpc.call("getblockchaininfo", json::array()); + blockOk = true; + } catch (const std::exception& e) { + DEBUG_LOGF("BlockchainInfo error: %s\n", e.what()); + } + + // If getblockchaininfo shows we're behind (same 2-block tolerance as applyCoreRefreshResult), skip + // the balance scan this cycle regardless of includeBalance: the balance is incomplete mid-sync + // anyway, and skipping it lets the sync-state update — and hence kSyncProfile — take effect at the + // end of THIS (now-cheap) task instead of being delayed ~20s behind the scan. This is what lets the + // sticky-behind latch engage promptly the first time the node falls behind. + bool behind = false; + if (blockOk && blockInfo.is_object()) { + const long long b = blockInfo.value("blocks", 0LL); + const long long lc = blockInfo.value("longestchain", 0LL); + if (lc > 0 && b < lc - 2) behind = true; + } + + if (includeBalance && !behind) { // z_gettotalbalance is O(mapWallet) and holds the daemon's cs_main for its whole duration — // seconds on a large shielded wallet. Time it so the caller can throttle how often it polls // (balanceRefreshDue()), keeping balance scans from starving block connection. @@ -315,13 +339,6 @@ NetworkRefreshService::CoreRefreshResult NetworkRefreshService::collectCoreRefre std::chrono::steady_clock::now() - balanceStart).count(); } - try { - blockInfo = rpc.call("getblockchaininfo", json::array()); - blockOk = true; - } catch (const std::exception& e) { - DEBUG_LOGF("BlockchainInfo error: %s\n", e.what()); - } - auto result = parseCoreRefreshResult(totalBalance, spendableBalance, balanceOk, blockInfo, blockOk); result.balanceScanMs = balanceScanMs; return result; @@ -603,6 +620,10 @@ NetworkRefreshService::AddressRefreshResult NetworkRefreshService::collectAddres const AddressRefreshSnapshot& snapshot) { AddressRefreshResult result; + // Time the whole scan — z_listunspent (and per-address z_getbalance fallback) hold the daemon's + // cs_main for the duration, seconds on a large shielded wallet. The measured cost feeds the + // caller's adaptive throttle so the address poll can't starve block connection. + const auto scanStart = std::chrono::steady_clock::now(); try { json zList = rpc.call("z_listaddresses", json::array()); @@ -644,6 +665,22 @@ NetworkRefreshService::AddressRefreshResult NetworkRefreshService::collectAddres try { json unspent = rpc.call("z_listunspent", json::array({0, 9999999, false})); // minconf=0 → include 0-conf change applyShieldedBalancesFromUnspent(result.shieldedAddresses, unspent); + // Retain a minimal view so a downstream consumer (chat note-budget) can reuse this scan instead + // of issuing its own z_listunspent. rawconfirmations is the TRUE depth; `confirmations` is + // dPoW-clamped to 1 and understates it. + if (unspent.is_array()) { + result.unspentNotes.reserve(unspent.size()); + for (const auto& nz : unspent) { + if (!nz.is_object()) continue; + UnspentNoteLite lite; + lite.amount = nz.value("amount", 0.0); + lite.locked = nz.value("locked", false); + lite.confirmations = (nz.contains("rawconfirmations") && nz["rawconfirmations"].is_number_integer()) + ? nz["rawconfirmations"].get() + : nz.value("confirmations", 0); + result.unspentNotes.push_back(lite); + } + } } catch (const std::exception& e) { DEBUG_LOGF("z_listunspent unavailable (%s), falling back to z_getbalance\n", e.what()); for (auto& info : result.shieldedAddresses) { @@ -673,6 +710,8 @@ NetworkRefreshService::AddressRefreshResult NetworkRefreshService::collectAddres DEBUG_LOGF("listunspent error: %s\n", e.what()); } + result.scanMs = std::chrono::duration( + std::chrono::steady_clock::now() - scanStart).count(); return result; } @@ -864,6 +903,10 @@ NetworkRefreshService::TransactionRefreshResult NetworkRefreshService::collectTr result.blockHeight = currentBlockHeight; result.shieldedAddressCount = snapshot.shieldedAddresses.size(); result.shieldedScanHeights = snapshot.shieldedScanHeights; + // Time the whole scan — the per-address z_listreceivedbyaddress pass is O(mapWallet) and holds the + // daemon's cs_main. The measured cost feeds the caller's adaptive throttle (txRefreshDue()) so the + // routine full history rescan can't starve block connection on a large wallet. + const auto scanStart = std::chrono::steady_clock::now(); std::set knownTxids; HushChatMemoOutputMap hushChatReceivedOutputs; @@ -1044,6 +1087,8 @@ NetworkRefreshService::TransactionRefreshResult NetworkRefreshService::collectTr } sortTransactionsNewestFirst(result.transactions); + result.scanMs = std::chrono::duration( + std::chrono::steady_clock::now() - scanStart).count(); return result; } diff --git a/src/services/network_refresh_service.h b/src/services/network_refresh_service.h index 514a345..426463e 100644 --- a/src/services/network_refresh_service.h +++ b/src/services/network_refresh_service.h @@ -147,6 +147,14 @@ public: std::string errorMessage; }; + // Minimal per-note view of a z_listunspent entry — just what a downstream consumer needs to derive + // spendable-note budgets without re-scanning. Kept UI/feature-agnostic (no chat specifics here). + struct UnspentNoteLite { + double amount = 0.0; // note value, DRGX + bool locked = false; // tied up by an in-flight send + int confirmations = 0; // TRUE depth (rawconfirmations when present, else confirmations) + }; + struct AddressRefreshResult { std::vector shieldedAddresses; std::vector transparentAddresses; @@ -154,6 +162,12 @@ public: // lists may be falsely short. Consumers that treat an empty list as authoritative (e.g. the // empty-wallet warning) must not trust a 0 count unless this is true. bool addressListOk = true; + // Wall-clock spent in the address scan (dominated by z_listunspent — O(mapWallet), holds the + // daemon's cs_main). Lets the caller throttle how often it polls (addressRefreshDue()). + double scanMs = 0.0; + // The wallet's unspent notes from this same z_listunspent scan, so a consumer (e.g. the chat + // note-budget) can be fed for free instead of running its own duplicate z_listunspent. + std::vector unspentNotes; }; struct AddressRefreshSnapshot { @@ -205,6 +219,9 @@ public: std::size_t shieldedAddressCount = 0; std::unordered_map shieldedScanHeights; bool shieldedScanComplete = true; + // Wall-clock spent in the history scan (z_listreceivedbyaddress — O(mapWallet), holds cs_main). + // Lets the caller throttle the routine full rescan by its measured cost (txRefreshDue()). + double scanMs = 0.0; }; struct OperationStatusPollResult { diff --git a/tests/test_phase4.cpp b/tests/test_phase4.cpp index 1d33034..9c5f775 100644 --- a/tests/test_phase4.cpp +++ b/tests/test_phase4.cpp @@ -1417,31 +1417,51 @@ void testNetworkRefreshRpcCollectors() }); coreRpc.addResponse("getblockchaininfo", json{ {"blocks", 150}, - {"headers", 155}, + {"headers", 150}, {"bestblockhash", "core-best-150"}, - {"verificationprogress", 0.80}, - {"longestchain", 160}, + {"verificationprogress", 1.0}, + {"longestchain", 150}, // caught up → balance scan runs {"notarized", 145} }); auto core = Refresh::collectCoreRefreshResult(coreRpc); + // getblockchaininfo is issued FIRST — sync detection gates (and must not be delayed behind) the + // O(mapWallet) balance scan. When caught up, the balance scan follows: display (minconf=0) + + // spendable (minconf=1). EXPECT_TRUE(coreRpc.methodNames() == std::vector({ - "z_gettotalbalance", "z_gettotalbalance", "getblockchaininfo" // display (minconf=0) + spendable (minconf=1) + "getblockchaininfo", "z_gettotalbalance", "z_gettotalbalance" })); - EXPECT_EQ(coreRpc.calls[0].params, json::array({0})); - EXPECT_EQ(coreRpc.calls[1].params, json::array({1})); + EXPECT_EQ(coreRpc.calls[1].params, json::array({0})); + EXPECT_EQ(coreRpc.calls[2].params, json::array({1})); EXPECT_TRUE(core.balanceOk); EXPECT_TRUE(core.blockchainOk); EXPECT_NEAR(*core.totalBalance, 4.25, 0.00000001); EXPECT_EQ(*core.blocks, 150); EXPECT_EQ(*core.bestBlockHash, std::string("core-best-150")); - EXPECT_EQ(*core.longestChain, 160); + EXPECT_EQ(*core.longestChain, 150); + + // When getblockchaininfo shows the node is behind (blocks < longestchain - 2), the balance scan is + // skipped this cycle regardless of includeBalance — so sync-state (and hence kSyncProfile) updates + // promptly instead of after the multi-second scan. Only getblockchaininfo is issued. + MockRefreshRpc coreBehindRpc; + coreBehindRpc.addResponse("z_gettotalbalance", json{{"total", "4.25000000"}}); + coreBehindRpc.addResponse("getblockchaininfo", json{ + {"blocks", 150}, {"headers", 160}, {"longestchain", 160} + }); + auto coreBehind = Refresh::collectCoreRefreshResult(coreBehindRpc); + EXPECT_TRUE(coreBehindRpc.methodNames() == std::vector({"getblockchaininfo"})); + EXPECT_FALSE(coreBehind.balanceOk); + EXPECT_TRUE(coreBehind.blockchainOk); + EXPECT_EQ(*coreBehind.blocks, 150); + EXPECT_EQ(*coreBehind.longestChain, 160); MockRefreshRpc coreFallbackRpc; coreFallbackRpc.addFailure("z_gettotalbalance", "wallet warming up"); coreFallbackRpc.addResponse("getblockchaininfo", json{{"blocks", 8}, {"headers", 9}}); auto partialCore = Refresh::collectCoreRefreshResult(coreFallbackRpc); + // No longestchain in the response → not classified as "behind" → balance is still attempted (here it + // fails). getblockchaininfo is still issued first. EXPECT_TRUE(coreFallbackRpc.methodNames() == std::vector({ - "z_gettotalbalance", "z_gettotalbalance", "getblockchaininfo" + "getblockchaininfo", "z_gettotalbalance", "z_gettotalbalance" })); EXPECT_FALSE(partialCore.balanceOk); EXPECT_TRUE(partialCore.blockchainOk); From ed675f90d8813e758c77558ced181dc28b9d59fc Mon Sep 17 00:00:00 2001 From: DanS Date: Tue, 1 Sep 2026 19:36:50 -0500 Subject: [PATCH 82/89] feat(i18n): add English source + 8-language translations for 193 UI strings Adds the i18n source for 193 previously-hardcoded UI strings (the security / PIN / lock flow, first-run seed-backup wizard, witness-rebuild shutdown dialog, and balance / mining / explorer labels) so they can be localized. The TR() call-site wrapping rides in the accompanying UI commit. - 193 keys added to loadBuiltinEnglish() (the English source of truth), including one pre-existing missing key (copied_to_clipboard). - Additive res/lang/{de,es,fr,ja,ko,pt,ru,zh}.json (+193 each); every translation's printf format-signature was validated against English (0 mismatches) so the runtime validator accepts them. - Rebuilt res/fonts/NotoSansCJK-Subset.ttf to cover ~30 new Han/Hangul glyphs introduced by the zh/ja/ko translations (tofu-free). Co-Authored-By: Claude Opus 4.8 (1M context) --- res/fonts/NotoSansCJK-Subset.ttf | Bin 675232 -> 683312 bytes res/lang/de.json | 193 ++++++++++++++++ res/lang/es.json | 193 ++++++++++++++++ res/lang/fr.json | 193 ++++++++++++++++ res/lang/ja.json | 193 ++++++++++++++++ res/lang/ko.json | 193 ++++++++++++++++ res/lang/pt.json | 193 ++++++++++++++++ res/lang/ru.json | 193 ++++++++++++++++ res/lang/zh.json | 193 ++++++++++++++++ src/util/i18n.cpp | 381 +++++++++++++++++++++++++++++++ 10 files changed, 1925 insertions(+) diff --git a/res/fonts/NotoSansCJK-Subset.ttf b/res/fonts/NotoSansCJK-Subset.ttf index e2694514c82bc0f11ce283022ed0ec1ed8bed44a..f751d672ab944f10d3655de73ffd8b44ee057bb5 100644 GIT binary patch delta 36191 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 delta 29203 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

YTk2cpTj6h& z*OY7cgKuZZ9=izJ9b&_-UC->ZZB)O8?6b)4(?AmN}$PK$X8yjMKN|Ikj)!W`vzT*?}**9b2liBaMn>f3Lv(A>{vGzaazQNx& zAA|tLDSKs(3R9(38C70Yv*&`;Q&Fn1YO0#6Rw_odRh?8<)l>CR{nY?9NDWaV)qCng zHAziXv(-Gc$ac>J)H=06ZBkp+H|l$}(^0$BUUfhnR!7tc^_x1cE~*>qHfTr#=^z7S zhNmDaWQSak2l7DyC$ce5CL@{66!-UXbI8K24bNr^nhNF03%>D zya(gK50hXj%z#<22$sSMSPg4o1AGFT!1)Zez!&fpY=a%}E$oEdun!Kx5%>j8!ddtO z{)C%|m!bKHvC@EhETyKx^L z!k_Ud{)%VtJpPUs@e*Fan|K@V5)zZ9)RdNvPmqVlSgk#bT&s!DZ< zkhi6_)Rjo7FAb%!G?nJkQd&!lw380fNt`ayO?pWm=_ig1lo>Kx=E)*iC;yU9WwU%C zU(0s+Ru0HvIVLCMl$?>va$Ro8T@6~aPp8%Cbte6keqLwM+4M^~kIt_P>!SKqT|$@A zmGoP>s*cpHbQ>M3JLoRDhwi2O=>9rE57tBVSVxc7emz-F*DG~E&xDSWO>KtKn40F& znj}Gzbvb2)L$-JCbyZeXP}Nl}uYs?LYNlGK)?O2z+r!sO#Vbc8cwKy>)L8YAnyjYT zW2y7iVzol8RqNG8^{M(weXD*@KdRlz+2_^u9aX=o)9QlyQ{7Z|AQhyAC%pQ;ry-lI z?{mxh@{nekGtBRD{Y<)hqI=3sKO(mie`U7-$Rap&RssI2Z^c;T;$Y6JR1t zhG|~a-(pw>D`5?+gN1J`{58Ag%fZJ&cQ{v1h;G(U|P(K zPbIbiX2+bE8}niTEQBxPD_9asV_7VRZ(t?c6Id6cumLu~Rv3eAu@iQ|?ih#hn1F+D zC=SDsUX$QB9FHI2WSow((3yjaaTNyaLCwwh1%Bl<4E~6Fa6cZ#BX|r?;#s_af8d{Z z8L#3kyh9;GB$SHMP&!Ia8ND9Dytaoh%(f7gPi!HqP7&0|Ya(n-ZK*wVre0nr;Q$&& zqv##mNBBNXpvg4Tp*b|47Sa-0MeArIeM(#C3;K$-(GL2KcG4a?NI%n2`jt-8dHRzs z(`|dnuIAL7fiv+lUZr79&cpe*5EtVxF3DxMJioz}xe8a~8eEGbxjr}IrreTSa}0Oj zZXD13c?b{ZclbkgCi7ID!LxZDf6NPcF)!uiyo%TGT3*i^`Ct4Q@8tu0h>!9we3~!t zHLpEUTkxcjC*(U*h9i?0Awz|FUXv-aYdgYFeSMNAX zkJA&hGf_{`GxRFG);Gg9$Ap^-rmCr78kr_Z2c3fK8>u$`|Lim6OnFn$+|1buc1}+6n!z2niV`!YkU>=V5Rh&Lb@x-?w;tTsr>j z@$m$o{BIfQJPsuPK}I^S>++8U$|O!&M!JN2fRB(xrE&LLs*xOI9+|LmZ)VaU=Of=qPDB=)FH>_zRT*Wx~^`iyO16-!84E(idxEr*<@D_ z8bb%@0{vkS47EA#LzrT7++0`!%V8A+U_ESw@8Ku70@vU+8q9#t<4afpD`Rzxz}nad zo7xj^+F^U!&ep@!!NGP49AmLF1sCE9T#akd*@R!>*SG_}$6fdn9>C*x0#D&-Jcl<3 z$VZvzMan^iOcWKT5;j`B|;j84%Rxz);H09ddfE#l&Zp*RUkvnsD?#+GK;ekAq zNAM_qm*3-Y`~gqkk9Zo-;T62eR<|7EQ+$Tc@$Y<*FY|T2#dm}xm86$U@{~L)FGx-) zCSg+2OG0g>z4VaY(pM5>u*{OVvQU;7r-SwN?Xq7E$r1TQPReOHCs*aB+|f#tPGxt7 zPw0&LN&T#TQRmRPbv|9lp3q)Qhv~AqoNlMP>E3#P9;Aosk@_7y##;9py-v@9PVSyl zvL{6trPA25G1J+m;t18y29{W_HayO;c_qR2hL2T#FR8dWWocqg*=AG9L3LDJQditQ zacjh`4L@xIi5o*o*zi#o8ri_n8T#3{F(fH!%z@;f@uh7Q-vgK7s!b9;Om9;}PAqS; zLN%{fydgSnSZIr}UQ~#;F=3dk8h69N0$iS$3xfXl9R^duF}Hghf3vCJIw_k1GSUl_ z-RmJQW)ncLgSNMqP@w#yS2E!G=K)vaBu3LLeuQPAGEa{4*h5+{G)C?xt;HW zvwd1`sxQW+xU8M!Yq0B7L7QsB?d$~K$4dV;!FdneO z_zv0kSVOqmqMkg0m(k&N@a}3yZg=1wrbp<}`dvG8uMW=I-pO6z&b=`^1k|>WW1fYS z^h_k#LV^b3+Q%$wAFg@0)^S9gvaWI0Zi#}P5%h~D)-Qr?@h*(Bj`5M_829_dUc1`4 z0@ppqaDtXm7^_;#sF`FLU9l(jPBe@uc0^r>OFg@|-z^ThUSSt;u16H0!c>$>T2}}< z!U*dGlRPh2ZTBdy3mm7j_c_2z?#{%qM(}Fto?OAMOI#;#eV}=w4|GZNfdM?o^8vqA z|2{sPLibnrhSfY<&1XoV`QlddrR==t?mt}B_e|3KY~#xP^Av)2T*aT4Ybg|;CQMn#;lGN>r``!+~mA0Gt7vPck4(Ro2s28jk*f`t3HGB zET2N4@kv?PmFAZJQ=Hl3lC&9A=A57|llkti7jAN?nSs9HrV{(Q;Hi+V_SV3^_YJc$ zFy>7Y#r_Lb?U|XQs+qnjkg0|VSN_Nd`!zH$Kf<8$KVQpa4s5S!nt{J?ZBr}|Tib*w z73!Z{$1L>aw!h1}`772n-8j_V&E?-%*Tnks*E7X9pS_mRyJ`}c+|a~hAZt@oL Daemon neu starten, um es erneut zu versuchen", + "appx_waiting_for_daemon_to_encrypt_wallet": "Warten, bis der Daemon das Wallet verschlüsselt...", + "appx_wallet_created_and_backed_up": "Wallet erstellt und gesichert.", + "appx_wallet_open_failed_prefix": "Öffnen des Wallets fehlgeschlagen: ", "auto_shield": "Mining automatisch abschirmen", "av_intro": "Mining-Software wird oft als potenziell unerwünscht eingestuft. Führen Sie diese Schritte aus, um das Pool-Mining zu aktivieren:", "av_open_security": "Windows-Sicherheit öffnen", @@ -100,6 +174,17 @@ "balance_shielded_fmt": "Abgeschirmt: %.8f", "balance_syncing_pct": "Synchronisiere %.1f%%", "balance_transparent_fmt": "Transparent: %.8f", + "baltab_market": "Markt", + "baltab_market_price_4dp": "Markt: $%.4f", + "baltab_market_price_8dp": "Markt: $%.8f", + "baltab_pct_change_24h": "%s%.1f%% 24h", + "baltab_pct_of_total_zaddr": "%.0f%% des Gesamtbetrags · %d Z-addr", + "baltab_shielded": "Geschützt", + "baltab_shielded_amount": "Geschützt %.8f", + "baltab_t_addresses_count": "%d T-Adressen", + "baltab_total_balance": "Gesamtguthaben", + "baltab_transparent": "Transparent", + "baltab_transparent_amount": "Transparent %.8f", "ban": "Sperren", "banned_peers": "Gesperrte Peers", "block": "Block", @@ -414,6 +499,7 @@ "contacts_shape_square": "Quadrat", "contacts_shape_tab": "Reiter", "copied": "Kopiert!", + "copied_to_clipboard": "In die Zwischenablage kopiert", "copy": "Kopieren", "copy_address": "Vollständige Adresse kopieren", "copy_error": "Fehler kopieren", @@ -593,6 +679,63 @@ "general": "Allgemein", "generating": "Wird generiert", "go_to_receive": "Zum Empfangen", + "grpa_current_block_paren": "(Aktuell: %d)", + "grpa_days_ago": "vor %lld Tagen", + "grpa_dbg_addrman": "Verfolgung und Verwaltung von Peer-Adressen", + "grpa_dbg_alert": "Meldungen des Alarmsystems", + "grpa_dbg_bench": "Benchmark-Zeiten für Operationen", + "grpa_dbg_coindb": "Lese-/Schreiboperationen der Coin-Datenbank", + "grpa_dbg_db": "Berkeley-DB-Operationen", + "grpa_dbg_estimatefee": "Algorithmus zur Gebührenschätzung", + "grpa_dbg_http": "Aktivität des HTTP-RPC-Servers", + "grpa_dbg_libevent": "Libevent-Netzwerkbibliothek", + "grpa_dbg_lock": "Debugging von Lock-Konflikten", + "grpa_dbg_mempool": "Aktivität des Transaktions-Mempools", + "grpa_dbg_net": "Netzwerkverbindungen und -nachrichten", + "grpa_dbg_paymentdisclosure": "Zahlungsoffenlegungsprotokoll", + "grpa_dbg_pow": "Proof-of-Work-Mining-Aktivität", + "grpa_dbg_proxy": "SOCKS5-Proxy-Verbindungen", + "grpa_dbg_prune": "Block-Pruning-Operationen", + "grpa_dbg_rand": "Zufallszahlengenerierung", + "grpa_dbg_reindex": "Fortschritt der Blockchain-Neuindizierung", + "grpa_dbg_rpc": "Verarbeitung von RPC-Befehlen", + "grpa_dbg_selectcoins": "Coin-Auswahl für Transaktionen", + "grpa_dbg_tor": "Tor-Integration und Circuit-Informationen", + "grpa_dbg_zmq": "ZeroMQ-Benachrichtigungssystem", + "grpa_dbg_zrpc": "Geschützte (z-addr) RPC-Operationen", + "grpa_enter_private_key_to_import": "Geben Sie einen privaten Schlüssel zum Importieren ein.", + "grpa_error_prefix": "Fehler: ", + "grpa_hr_ago": "vor %lld Std", + "grpa_invalid_response_from_daemon": "Ungültige Antwort vom Daemon", + "grpa_invalid_suffix": " (ungültig)", + "grpa_min_ago": "vor %lld Min", + "grpa_sec_ago": "vor %lld Sek", + "grpa_seed_demo_chat": "Seed-Demo-Chat", + "grpa_showing_first_100_of": "... die ersten 100 von %d werden angezeigt", + "grpa_tab_about": "Über", + "grpa_tab_appearance": "Darstellung", + "grpa_tab_backup_data": "Backup & Daten", + "grpa_tab_chat": "Chat", + "grpa_tab_explorer": "Explorer", + "grpa_tab_node_security": "Node & Sicherheit", + "grpa_tab_wallet": "Wallet", + "grpa_unexpected_getblockhash_result": "unerwartetes getblockhash-Ergebnis", + "grpb_copy": "Kopieren", + "grpb_max": "Max", + "grpb_new_badge_suffix": " [NEU]", + "grpb_preview_msg_payment_through": "Ist die Zahlung durchgegangen? 🙂", + "grpb_preview_msg_sending_rest": "Sende jetzt den Rest 👍", + "grpb_preview_msg_yep_confirmed": "Ja — gerade bestätigt ✅", + "grpb_selected_suffix": "\n(ausgewählt)", + "grpb_tooltip_address_balance": "%s\nGuthaben: %.8f %s%s", + "grpb_undo_clear": "Löschen rückgängig", + "grpc_benchmark_inconclusive": "Benchmark nicht aussagekräftig: es wurden keine Hashrate-Werte aufgezeichnet. Prüfen Sie die Pool-Verbindung und versuchen Sie es erneut.", + "grpc_benchmark_takes_secs": "Der Benchmark dauert ~%ds und unterbricht das Mining. Erneut klicken zum Starten.", + "grpc_bootstrap_failed": "Bootstrap fehlgeschlagen", + "grpc_bootstrap_not_initialized": "Bootstrap nicht initialisiert", + "grpc_hashrate_fee": "%s %s%% Gebühr", + "grpc_key_not_available": "Schlüssel für diese Adresse nicht verfügbar", + "grpc_na": "N/V", "height": "Höhe", "help": "Hilfe", "hidden_tag": " (versteckt)", @@ -1240,6 +1383,45 @@ "screenshot_sweep_full": "Vollständiger UI-Durchlauf", "search_icons": "Symbole suchen...", "search_placeholder": "Suchen...", + "sec_changing_passphrase": "Passphrase wird geändert...", + "sec_changing_pin": "PIN wird geändert...", + "sec_couldnt_lock_wallet": "Wallet konnte nicht gesperrt werden — es ist weiterhin entsperrt. Prüfen Sie die Daemon-Verbindung.", + "sec_encrypted_backup_suffix": "\nVerschlüsseltes Backup: wallet.dat.encrypted.bak", + "sec_encrypting_wallet": "Wallet wird verschlüsselt...", + "sec_encryption_did_not_complete": "Die Wallet-Verschlüsselung wurde nicht abgeschlossen — Ihr Wallet ist NICHT verschlüsselt. Öffnen Sie die Einstellungen, um die Verschlüsselung abzuschließen.", + "sec_encryption_failed_prefix": "Verschlüsselung fehlgeschlagen: ", + "sec_failed_prefix": "Fehlgeschlagen: ", + "sec_failed_to_create_vault": "Tresor konnte nicht erstellt werden", + "sec_importing_keys_rescanning": "Schlüssel werden importiert & Blockchain neu gescannt — Wallet ist währenddessen nutzbar", + "sec_incorrect_current_pin": "Aktuelle PIN falsch", + "sec_incorrect_passphrase_decrypt": "Falsche Passphrase", + "sec_incorrect_passphrase_pin_setup": "Falsche Passphrase", + "sec_incorrect_pin_remove": "Falsche PIN", + "sec_internal_error_change_pin": "Interner Fehler", + "sec_internal_error_remove_pin": "Interner Fehler", + "sec_mode_passphrase": " Passphrase", + "sec_not_connected_to_daemon": "Nicht mit Daemon verbunden", + "sec_not_connected_to_daemon_pin": "Nicht mit Daemon verbunden", + "sec_passphrase_changed_successfully": "Passphrase erfolgreich geändert", + "sec_pin_changed_successfully": "PIN erfolgreich geändert", + "sec_pin_removed": "PIN entfernt", + "sec_pin_set_successfully": "PIN erfolgreich festgelegt", + "sec_restart_daemon_for_encryption": "Bitte starten Sie Ihren Daemon neu, damit die Verschlüsselung wirksam wird.", + "sec_too_many_attempts_wait": "Zu viele Versuche. Warten Sie %.0f Sekunden...", + "sec_total_elapsed_fmt": "Gesamtdauer: %dm %02ds", + "sec_unlock_button": "Entsperren", + "sec_unlock_failed_prefix": "Entsperren fehlgeschlagen: ", + "sec_unlocking_fmt": "Entsperren%s", + "sec_use_passphrase_instead": "Stattdessen Passphrase verwenden", + "sec_use_pin_instead": "Stattdessen PIN verwenden", + "sec_verifying_passphrase": "Passphrase wird überprüft...", + "sec_verifying_pin": "PIN wird überprüft...", + "sec_wallet_decrypted_all_keys_imported": "Wallet erfolgreich entschlüsselt! Alle Schlüssel importiert.", + "sec_wallet_encrypted_and_pin_set": "Wallet verschlüsselt & PIN festgelegt", + "sec_wallet_encrypted_but_pin_vault_failed": "Wallet verschlüsselt, aber PIN-Tresor fehlgeschlagen", + "sec_wallet_encrypted_restarting_daemon": "Wallet verschlüsselt. Daemon wird neu gestartet...", + "sec_wallet_encrypted_successfully": "Wallet erfolgreich verschlüsselt", + "sec_wallet_locked_title": "Wallet gesperrt", "security": "SICHERHEIT", "seed_backup_button": "Wiederherstellungsphrase", "seed_backup_close": "Schließen", @@ -1461,6 +1643,17 @@ "sweep_to": "Gefegt an:", "sweep_toggle": "In meine Wallet fegen (Schlüssel nicht behalten)", "sweep_tx": "Transaktion:", + "swin_connection_failed": "Verbindung fehlgeschlagen: ", + "swin_connection_successful": "Verbindung erfolgreich!\ndragonxd-Version: ", + "swin_invalid_suffix": " (ungültig)", + "swin_no_history_file_found": "Keine Verlaufsdatei gefunden", + "swin_rescan_failed": "Neuscan fehlgeschlagen: ", + "swin_rescan_started_from_block": "Neuscan gestartet ab Block ", + "swin_rescan_to": " bis ", + "swin_rpc_client_not_initialized": "RPC-Client nicht initialisiert", + "swin_settings_saved": "Einstellungen gespeichert", + "swin_theme_list_refreshed": "Design-Liste aktualisiert", + "swin_ztx_history_cleared": "Z-Transaktionsverlauf gelöscht", "switch_corrupt_body": "Diese Wallet scheint beschädigt zu sein – der Knoten konnte sie nicht öffnen. Aus einem Backup wiederherstellen, neu erstellen oder eine Reparatur versuchen.", "switch_corrupt_repair": "Reparatur versuchen (Salvage)", "switch_progress_background": "Im Hintergrund fortsetzen", diff --git a/res/lang/es.json b/res/lang/es.json index 85dbccf..8be75dc 100644 --- a/res/lang/es.json +++ b/res/lang/es.json @@ -60,6 +60,80 @@ "amount_label": "Cantidad:", "animate_avatars": "Animar avatares", "appearance": "APARIENCIA", + "appx_back": "Atrás", + "appx_back_up_seed_phrase_title": "Haz una copia de tu frase semilla", + "appx_birthday_block_height": "Fecha de creación (altura de bloque): %llu — guárdala también.", + "appx_blockchain_data_deleted": "Datos de la cadena de bloques eliminados (%d elementos). El daemon se está reiniciando para volver a sincronizar desde la red.", + "appx_blockchain_maintenance_in_progress": "Ya hay una operación de mantenimiento de la cadena de bloques en curso.", + "appx_blockchain_rescan_complete": "Reescaneo de la cadena de bloques completado", + "appx_bootstrap_complete_reconciling": "Arranque inicial completado; reconciliando tu cartera con los nuevos datos de la cadena.", + "appx_cancel": "Cancelar", + "appx_cleaning_up": "Limpiando...", + "appx_confirm_your_backup": "Confirma tu copia de seguridad", + "appx_copied_clipboard_autoclears": "Copiado; el portapapeles se borra automáticamente en 45 s", + "appx_copy": "Copiar", + "appx_could_not_start_restore": "No se pudo iniciar la restauración", + "appx_create_failed_prefix": "Error al crear: ", + "appx_creating_your_wallet": "Creando tu cartera…", + "appx_daemon_error": "Error del daemon", + "appx_daemon_reinstall_in_progress": "La reinstalación del daemon ya está en curso.", + "appx_disconnecting": "Desconectando...", + "appx_done": "Listo", + "appx_dragonxd_output": "Salida de dragonxd", + "appx_encrypting_wallet": "Cifrando la cartera...", + "appx_fullnode_lifecycle_unavailable_lite": "Las acciones de ciclo de vida del nodo completo no están disponibles en la versión lite", + "appx_installing_bundled_daemon": "Instalando el daemon incluido; el nodo se detendrá, se actualizará y se reiniciará...", + "appx_invalid_payment_uri_prefix": "URI de pago no válida: ", + "appx_ive_written_it_down": "Ya la anoté", + "appx_keep_node_running_and_quit": "Mantener el nodo y salir", + "appx_last_block_n": "Último bloque: %d", + "appx_last_used_wallet_not_found_prefix": "Tu último archivo de cartera usado (", + "appx_last_used_wallet_not_found_suffix": ") no se encontró; se abrió la cartera predeterminada en su lugar. Si lo moviste, restáuralo y vuelve a él desde la lista de carteras.", + "appx_low_spec_mode_disabled": "Modo de bajos recursos desactivado", + "appx_low_spec_mode_enabled": "Modo de bajos recursos activado", + "appx_miner_stopped_prefix": "Minero detenido: ", + "appx_miner_stopped_unexpectedly": "El minero se detuvo inesperadamente.", + "appx_n_min_n_sec": "%d min %d s", + "appx_n_seconds": "%d segundos", + "appx_no_bundled_daemon_to_install": "Esta versión no incluye un daemon para instalar", + "appx_no_embedded_daemon_to_install": "Esta versión no incluye un daemon integrado para instalar", + "appx_node_busy_restarting": "El nodo está ocupado reiniciándose; inténtalo de nuevo en un momento.", + "appx_node_rebuilding_witness_cache": "El nodo está reconstruyendo su caché de testigos", + "appx_not_next_word": " — esa no es la siguiente palabra", + "appx_payment_request_loaded": "Solicitud de pago cargada", + "appx_pool_miner_connected_and_hashing": "Minero de pool conectado y calculando hashes.", + "appx_progress_n_of_n": "Progreso: %d / %d", + "appx_rebuilding_sapling_note_witnesses": "Reconstruyendo testigos de notas Sapling…", + "appx_rebuilding_witness_cache_blocks_left": "Reconstruyendo la caché de testigos %.0f%% — %d bloques restantes", + "appx_rebuilding_witness_cache_pct": "Reconstruyendo la caché de testigos %.0f%%", + "appx_recovery_phrase_word_count": "La frase de recuperación debe tener 24 palabras; tú tienes %d.", + "appx_restarting_daemon_rescan_flag": "Reiniciando el daemon con la opción -rescan...", + "appx_restarting_daemon_zapwallettxes": "Reiniciando el daemon con -zapwallettxes=2 (reparación de cartera)...", + "appx_restoring_your_wallet": "Restaurando tu cartera…", + "appx_seed_backup_warning": "Estas 24 palabras son la ÚNICA forma de restaurar tu cartera. Anótalas en orden, guárdalas sin conexión y nunca las compartas. Si las pierdes, tus fondos se perderán para siempre.", + "appx_seed_not_backed_up_warning": "No has hecho una copia de tu semilla; podrías perder tus fondos. ¿Omitir de todos modos?", + "appx_sending_stop_command_to_daemon": "Enviando el comando de parada al daemon...", + "appx_setting_initial_sapling_witnesses": "Estableciendo testigos Sapling iniciales %.0f%%", + "appx_shutdown_complete": "Apagado completado", + "appx_simple_background_disabled": "Fondo simple desactivado", + "appx_simple_background_enabled": "Fondo simple activado", + "appx_skip": "Omitir", + "appx_skip_anyway": "Omitir de todos modos", + "appx_still_status_prefix": "Aún \"", + "appx_still_status_suffix": "\" — forzar el cierre ahora podría dañar los datos de la cadena.", + "appx_stop_anyway_and_quit": "Detener de todos modos y salir", + "appx_stopping_daemon_deleting_blockchain": "Deteniendo el daemon y eliminando los datos de la cadena de bloques...", + "appx_stopping_node_discards_rebuild": "Detener el nodo ahora descarta la reconstrucción en curso y la reinicia (varios minutos) la próxima vez que abras la cartera. También puedes dejar el nodo en ejecución.", + "appx_stopping_pool_miner": "Deteniendo el minero de pool...", + "appx_syncing_pct_block_n_of_n": "Sincronizando %.1f%% — Bloque %d / %d", + "appx_tap_words_in_order": "Toca las palabras en el orden correcto para confirmar que las guardaste.", + "appx_theme_effects_disabled": "Efectos de tema desactivados", + "appx_theme_effects_enabled": "Efectos de tema activados", + "appx_theme_prefix": "Tema: ", + "appx_use_settings_restart_daemon_hint": "Usa Ajustes > Reiniciar daemon para intentarlo de nuevo", + "appx_waiting_for_daemon_to_encrypt_wallet": "Esperando a que el daemon cifre la cartera...", + "appx_wallet_created_and_backed_up": "Cartera creada y respaldada.", + "appx_wallet_open_failed_prefix": "Error al abrir la cartera: ", "auto_shield": "Auto-proteger minería", "av_intro": "El software de minería suele marcarse como potencialmente no deseado. Sigue estos pasos para habilitar la minería en pool:", "av_open_security": "Abrir Seguridad de Windows", @@ -100,6 +174,17 @@ "balance_shielded_fmt": "Protegido: %.8f", "balance_syncing_pct": "Sincronizando %.1f%%", "balance_transparent_fmt": "Transparente: %.8f", + "baltab_market": "Mercado", + "baltab_market_price_4dp": "Mercado: $%.4f", + "baltab_market_price_8dp": "Mercado: $%.8f", + "baltab_pct_change_24h": "%s%.1f%% 24h", + "baltab_pct_of_total_zaddr": "%.0f%% del total · %d Z-addr", + "baltab_shielded": "Blindado", + "baltab_shielded_amount": "Blindado %.8f", + "baltab_t_addresses_count": "%d T-addresses", + "baltab_total_balance": "Saldo total", + "baltab_transparent": "Transparente", + "baltab_transparent_amount": "Transparente %.8f", "ban": "Bloquear", "banned_peers": "Nodos Bloqueados", "block": "Bloque", @@ -414,6 +499,7 @@ "contacts_shape_square": "Cuadrado", "contacts_shape_tab": "Pestaña", "copied": "¡Copiado!", + "copied_to_clipboard": "Copiado al portapapeles", "copy": "Copiar", "copy_address": "Copiar Dirección Completa", "copy_error": "Copiar Error", @@ -593,6 +679,63 @@ "general": "General", "generating": "Generando", "go_to_receive": "Ir a Recibir", + "grpa_current_block_paren": "(Actual: %d)", + "grpa_days_ago": "hace %lld días", + "grpa_dbg_addrman": "Seguimiento y gestión de direcciones de pares", + "grpa_dbg_alert": "Mensajes del sistema de alertas", + "grpa_dbg_bench": "Tiempos de referencia de las operaciones", + "grpa_dbg_coindb": "Operaciones de lectura/escritura de la base de datos de monedas", + "grpa_dbg_db": "Operaciones de Berkeley DB", + "grpa_dbg_estimatefee": "Algoritmo de estimación de comisiones", + "grpa_dbg_http": "Actividad del servidor RPC HTTP", + "grpa_dbg_libevent": "Biblioteca de red Libevent", + "grpa_dbg_lock": "Depuración de contención de bloqueos", + "grpa_dbg_mempool": "Actividad del pool de memoria de transacciones", + "grpa_dbg_net": "Conexiones y mensajes de red", + "grpa_dbg_paymentdisclosure": "Protocolo de divulgación de pagos", + "grpa_dbg_pow": "Actividad de minería por prueba de trabajo", + "grpa_dbg_proxy": "Conexiones de proxy SOCKS5", + "grpa_dbg_prune": "Operaciones de poda de bloques", + "grpa_dbg_rand": "Generación de números aleatorios", + "grpa_dbg_reindex": "Progreso de reindexación de la cadena de bloques", + "grpa_dbg_rpc": "Procesamiento de comandos RPC", + "grpa_dbg_selectcoins": "Selección de monedas para transacciones", + "grpa_dbg_tor": "Integración de Tor e información de circuitos", + "grpa_dbg_zmq": "Sistema de notificaciones ZeroMQ", + "grpa_dbg_zrpc": "Operaciones RPC blindadas (z-addr)", + "grpa_enter_private_key_to_import": "Introduce una clave privada para importar.", + "grpa_error_prefix": "Error: ", + "grpa_hr_ago": "hace %lld h", + "grpa_invalid_response_from_daemon": "Respuesta no válida del daemon", + "grpa_invalid_suffix": " (no válido)", + "grpa_min_ago": "hace %lld min", + "grpa_sec_ago": "hace %lld s", + "grpa_seed_demo_chat": "Chat de demostración con semilla", + "grpa_showing_first_100_of": "... mostrando los primeros 100 de %d", + "grpa_tab_about": "Acerca de", + "grpa_tab_appearance": "Apariencia", + "grpa_tab_backup_data": "Copia de seguridad y datos", + "grpa_tab_chat": "Chat", + "grpa_tab_explorer": "Explorador", + "grpa_tab_node_security": "Nodo y seguridad", + "grpa_tab_wallet": "Cartera", + "grpa_unexpected_getblockhash_result": "resultado inesperado de getblockhash", + "grpb_copy": "Copiar", + "grpb_max": "Máx.", + "grpb_new_badge_suffix": " [NUEVO]", + "grpb_preview_msg_payment_through": "¿Se realizó el pago? 🙂", + "grpb_preview_msg_sending_rest": "Enviando el resto ahora 👍", + "grpb_preview_msg_yep_confirmed": "Sí — acabo de confirmarlo ✅", + "grpb_selected_suffix": "\n(seleccionado)", + "grpb_tooltip_address_balance": "%s\nSaldo: %.8f %s%s", + "grpb_undo_clear": "Deshacer borrado", + "grpc_benchmark_inconclusive": "Prueba de rendimiento no concluyente: no se registraron muestras de tasa de hash. Comprueba la conexión con el pool e inténtalo de nuevo.", + "grpc_benchmark_takes_secs": "La prueba de rendimiento tarda ~%ds e interrumpe la minería. Haz clic de nuevo para empezar.", + "grpc_bootstrap_failed": "Error en el arranque inicial", + "grpc_bootstrap_not_initialized": "Arranque inicial no inicializado", + "grpc_hashrate_fee": "%s %s%% de comisión", + "grpc_key_not_available": "Clave no disponible para esta dirección", + "grpc_na": "N/D", "height": "Altura", "help": "Ayuda", "hidden_tag": " (oculto)", @@ -1240,6 +1383,45 @@ "screenshot_sweep_full": "Barrido completo de la interfaz", "search_icons": "Buscar iconos...", "search_placeholder": "Buscar...", + "sec_changing_passphrase": "Cambiando la frase de contraseña...", + "sec_changing_pin": "Cambiando el PIN...", + "sec_couldnt_lock_wallet": "No se pudo bloquear la cartera; sigue desbloqueada. Comprueba la conexión con el daemon.", + "sec_encrypted_backup_suffix": "\nCopia de seguridad cifrada: wallet.dat.encrypted.bak", + "sec_encrypting_wallet": "Cifrando la cartera...", + "sec_encryption_did_not_complete": "El cifrado de la cartera no se completó; tu cartera NO está cifrada. Abre Ajustes para terminar de cifrarla.", + "sec_encryption_failed_prefix": "Error de cifrado: ", + "sec_failed_prefix": "Error: ", + "sec_failed_to_create_vault": "No se pudo crear la bóveda", + "sec_importing_keys_rescanning": "Importando claves y volviendo a escanear la cadena de bloques; la cartera se puede usar mientras tanto", + "sec_incorrect_current_pin": "PIN actual incorrecto", + "sec_incorrect_passphrase_decrypt": "Frase de contraseña incorrecta", + "sec_incorrect_passphrase_pin_setup": "Frase de contraseña incorrecta", + "sec_incorrect_pin_remove": "PIN incorrecto", + "sec_internal_error_change_pin": "Error interno", + "sec_internal_error_remove_pin": "Error interno", + "sec_mode_passphrase": " Frase de contraseña", + "sec_not_connected_to_daemon": "Sin conexión con el daemon", + "sec_not_connected_to_daemon_pin": "Sin conexión con el daemon", + "sec_passphrase_changed_successfully": "Frase de contraseña cambiada correctamente", + "sec_pin_changed_successfully": "PIN cambiado correctamente", + "sec_pin_removed": "PIN eliminado", + "sec_pin_set_successfully": "PIN configurado correctamente", + "sec_restart_daemon_for_encryption": "Reinicia el daemon para que el cifrado surta efecto.", + "sec_too_many_attempts_wait": "Demasiados intentos. Espera %.0f segundos...", + "sec_total_elapsed_fmt": "Tiempo total: %dm %02ds", + "sec_unlock_button": "Desbloquear", + "sec_unlock_failed_prefix": "Error al desbloquear: ", + "sec_unlocking_fmt": "Desbloqueando%s", + "sec_use_passphrase_instead": "Usar frase de contraseña en su lugar", + "sec_use_pin_instead": "Usar PIN en su lugar", + "sec_verifying_passphrase": "Verificando la frase de contraseña...", + "sec_verifying_pin": "Verificando el PIN...", + "sec_wallet_decrypted_all_keys_imported": "¡Cartera descifrada correctamente! Todas las claves importadas.", + "sec_wallet_encrypted_and_pin_set": "Cartera cifrada y PIN configurado", + "sec_wallet_encrypted_but_pin_vault_failed": "Cartera cifrada, pero falló la bóveda del PIN", + "sec_wallet_encrypted_restarting_daemon": "Cartera cifrada. Reiniciando el daemon...", + "sec_wallet_encrypted_successfully": "Cartera cifrada correctamente", + "sec_wallet_locked_title": "Cartera bloqueada", "security": "SEGURIDAD", "seed_backup_button": "Frase de recuperación", "seed_backup_close": "Cerrar", @@ -1461,6 +1643,17 @@ "sweep_to": "Barrido a:", "sweep_toggle": "Barrer a mi monedero (no conservar la clave)", "sweep_tx": "Transacción:", + "swin_connection_failed": "Error de conexión: ", + "swin_connection_successful": "¡Conexión correcta!\nVersión de dragonxd: ", + "swin_invalid_suffix": " (no válido)", + "swin_no_history_file_found": "No se encontró ningún archivo de historial", + "swin_rescan_failed": "Error en el reescaneo: ", + "swin_rescan_started_from_block": "Reescaneo iniciado desde el bloque ", + "swin_rescan_to": " hasta ", + "swin_rpc_client_not_initialized": "Cliente RPC no inicializado", + "swin_settings_saved": "Ajustes guardados", + "swin_theme_list_refreshed": "Lista de temas actualizada", + "swin_ztx_history_cleared": "Historial de transacciones Z borrado", "switch_corrupt_body": "Esta cartera parece dañada: el nodo no pudo abrirla. Restáurala desde una copia de seguridad, vuelve a crearla o intenta repararla.", "switch_corrupt_repair": "Intentar reparar (salvage)", "switch_progress_background": "Continuar en segundo plano", diff --git a/res/lang/fr.json b/res/lang/fr.json index d878f78..80e2b96 100644 --- a/res/lang/fr.json +++ b/res/lang/fr.json @@ -60,6 +60,80 @@ "amount_label": "Montant :", "animate_avatars": "Animer les avatars", "appearance": "APPARENCE", + "appx_back": "Retour", + "appx_back_up_seed_phrase_title": "Sauvegardez votre phrase de récupération", + "appx_birthday_block_height": "Naissance (hauteur de bloc) : %llu — sauvegardez-la également.", + "appx_blockchain_data_deleted": "Données de la blockchain supprimées (%d éléments). Le démon redémarre pour se resynchroniser depuis le réseau.", + "appx_blockchain_maintenance_in_progress": "Une opération de maintenance de la blockchain est déjà en cours.", + "appx_blockchain_rescan_complete": "Nouvelle analyse de la blockchain terminée", + "appx_bootstrap_complete_reconciling": "Amorçage terminé — réconciliation de votre portefeuille avec les nouvelles données de la chaîne.", + "appx_cancel": "Annuler", + "appx_cleaning_up": "Nettoyage...", + "appx_confirm_your_backup": "Confirmez votre sauvegarde", + "appx_copied_clipboard_autoclears": "Copié — le presse-papiers s'efface automatiquement dans 45 s", + "appx_copy": "Copier", + "appx_could_not_start_restore": "Impossible de démarrer la restauration", + "appx_create_failed_prefix": "Échec de la création : ", + "appx_creating_your_wallet": "Création de votre portefeuille…", + "appx_daemon_error": "Erreur du démon", + "appx_daemon_reinstall_in_progress": "La réinstallation du démon est déjà en cours.", + "appx_disconnecting": "Déconnexion...", + "appx_done": "Terminé", + "appx_dragonxd_output": "Sortie de dragonxd", + "appx_encrypting_wallet": "Chiffrement du portefeuille...", + "appx_fullnode_lifecycle_unavailable_lite": "Les actions de cycle de vie du nœud complet ne sont pas disponibles dans la version allégée", + "appx_installing_bundled_daemon": "Installation du démon intégré — le nœud va s'arrêter, se mettre à jour, puis redémarrer...", + "appx_invalid_payment_uri_prefix": "URI de paiement invalide : ", + "appx_ive_written_it_down": "Je les ai notés", + "appx_keep_node_running_and_quit": "Laisser le nœud actif et quitter", + "appx_last_block_n": "Dernier bloc : %d", + "appx_last_used_wallet_not_found_prefix": "Votre dernier fichier de portefeuille utilisé (", + "appx_last_used_wallet_not_found_suffix": ") est introuvable — le portefeuille par défaut a été ouvert à la place. Si vous l'avez déplacé, restaurez-le et revenez à celui-ci depuis la liste des portefeuilles.", + "appx_low_spec_mode_disabled": "Mode faibles ressources désactivé", + "appx_low_spec_mode_enabled": "Mode faibles ressources activé", + "appx_miner_stopped_prefix": "Mineur arrêté : ", + "appx_miner_stopped_unexpectedly": "Le mineur s'est arrêté de manière inattendue.", + "appx_n_min_n_sec": "%d min %d s", + "appx_n_seconds": "%d secondes", + "appx_no_bundled_daemon_to_install": "Cette version ne contient aucun démon intégré à installer", + "appx_no_embedded_daemon_to_install": "Cette version ne contient aucun démon embarqué à installer", + "appx_node_busy_restarting": "Le nœud est occupé à redémarrer — réessayez dans un instant.", + "appx_node_rebuilding_witness_cache": "Le nœud reconstruit son cache de témoins", + "appx_not_next_word": " — ce n'est pas le mot suivant", + "appx_payment_request_loaded": "Demande de paiement chargée", + "appx_pool_miner_connected_and_hashing": "Mineur de pool connecté et en cours de hachage.", + "appx_progress_n_of_n": "Progression : %d / %d", + "appx_rebuilding_sapling_note_witnesses": "Reconstruction des témoins de notes Sapling…", + "appx_rebuilding_witness_cache_blocks_left": "Reconstruction du cache de témoins %.0f%% — %d blocs restants", + "appx_rebuilding_witness_cache_pct": "Reconstruction du cache de témoins %.0f%%", + "appx_recovery_phrase_word_count": "La phrase de récupération doit comporter 24 mots — vous en avez %d.", + "appx_restarting_daemon_rescan_flag": "Redémarrage du démon avec l'option -rescan...", + "appx_restarting_daemon_zapwallettxes": "Redémarrage du démon avec -zapwallettxes=2 (réparation du portefeuille)...", + "appx_restoring_your_wallet": "Restauration de votre portefeuille…", + "appx_seed_backup_warning": "Ces 24 mots sont le SEUL moyen de restaurer votre portefeuille. Notez-les dans l'ordre, conservez-les hors ligne et ne les partagez jamais. Si vous les perdez, vos fonds seront perdus à jamais.", + "appx_seed_not_backed_up_warning": "Vous n'avez pas sauvegardé votre phrase de récupération — des fonds pourraient être perdus. Ignorer quand même ?", + "appx_sending_stop_command_to_daemon": "Envoi de la commande d'arrêt au démon...", + "appx_setting_initial_sapling_witnesses": "Définition des témoins Sapling initiaux %.0f%%", + "appx_shutdown_complete": "Arrêt terminé", + "appx_simple_background_disabled": "Arrière-plan simple désactivé", + "appx_simple_background_enabled": "Arrière-plan simple activé", + "appx_skip": "Ignorer", + "appx_skip_anyway": "Ignorer quand même", + "appx_still_status_prefix": "Toujours « ", + "appx_still_status_suffix": " » — forcer la fermeture maintenant peut corrompre les données de la chaîne.", + "appx_stop_anyway_and_quit": "Arrêter quand même et quitter", + "appx_stopping_daemon_deleting_blockchain": "Arrêt du démon et suppression des données de la blockchain...", + "appx_stopping_node_discards_rebuild": "Arrêter le nœud maintenant abandonne la reconstruction en cours et la relance (plusieurs minutes) à la prochaine ouverture du portefeuille. Vous pouvez plutôt laisser le nœud en marche.", + "appx_stopping_pool_miner": "Arrêt du mineur de pool...", + "appx_syncing_pct_block_n_of_n": "Synchronisation %.1f%% — Bloc %d / %d", + "appx_tap_words_in_order": "Touchez les mots dans le bon ordre pour confirmer que vous les avez enregistrés.", + "appx_theme_effects_disabled": "Effets de thème désactivés", + "appx_theme_effects_enabled": "Effets de thème activés", + "appx_theme_prefix": "Thème : ", + "appx_use_settings_restart_daemon_hint": "Utilisez Paramètres > Redémarrer le démon pour réessayer", + "appx_waiting_for_daemon_to_encrypt_wallet": "En attente du chiffrement du portefeuille par le démon...", + "appx_wallet_created_and_backed_up": "Portefeuille créé et sauvegardé.", + "appx_wallet_open_failed_prefix": "Échec de l'ouverture du portefeuille : ", "auto_shield": "Auto-blindage du minage", "av_intro": "Les logiciels de minage sont souvent signalés comme potentiellement indésirables. Suivez ces étapes pour activer le minage en pool :", "av_open_security": "Ouvrir Sécurité Windows", @@ -100,6 +174,17 @@ "balance_shielded_fmt": "Blindé : %.8f", "balance_syncing_pct": "Synchronisation %.1f%%", "balance_transparent_fmt": "Transparent : %.8f", + "baltab_market": "Marché", + "baltab_market_price_4dp": "Marché : %.4f $", + "baltab_market_price_8dp": "Marché : %.8f $", + "baltab_pct_change_24h": "%s%.1f%% 24h", + "baltab_pct_of_total_zaddr": "%.0f%% du total · %d Z-addr", + "baltab_shielded": "Protégé", + "baltab_shielded_amount": "Protégé %.8f", + "baltab_t_addresses_count": "%d T-addresses", + "baltab_total_balance": "Solde total", + "baltab_transparent": "Transparent", + "baltab_transparent_amount": "Transparent %.8f", "ban": "Bannir", "banned_peers": "Pairs bannis", "block": "Bloc", @@ -414,6 +499,7 @@ "contacts_shape_square": "Carré", "contacts_shape_tab": "Onglet", "copied": "Copié !", + "copied_to_clipboard": "Copié dans le presse-papiers", "copy": "Copier", "copy_address": "Copier l'adresse complète", "copy_error": "Copier l'erreur", @@ -593,6 +679,63 @@ "general": "Général", "generating": "Génération", "go_to_receive": "Aller à Recevoir", + "grpa_current_block_paren": "(Actuel : %d)", + "grpa_days_ago": "il y a %lld jours", + "grpa_dbg_addrman": "Suivi et gestion des adresses des pairs", + "grpa_dbg_alert": "Messages du système d'alerte", + "grpa_dbg_bench": "Chronométrage des performances des opérations", + "grpa_dbg_coindb": "Opérations de lecture/écriture de la base de données des pièces", + "grpa_dbg_db": "Opérations Berkeley DB", + "grpa_dbg_estimatefee": "Algorithme d'estimation des frais", + "grpa_dbg_http": "Activité du serveur RPC HTTP", + "grpa_dbg_libevent": "Bibliothèque réseau Libevent", + "grpa_dbg_lock": "Débogage de la contention des verrous", + "grpa_dbg_mempool": "Activité du pool mémoire des transactions", + "grpa_dbg_net": "Connexions et messages réseau", + "grpa_dbg_paymentdisclosure": "Protocole de divulgation de paiement", + "grpa_dbg_pow": "Activité de minage par preuve de travail", + "grpa_dbg_proxy": "Connexions proxy SOCKS5", + "grpa_dbg_prune": "Opérations d'élagage des blocs", + "grpa_dbg_rand": "Génération de nombres aléatoires", + "grpa_dbg_reindex": "Progression de la réindexation de la blockchain", + "grpa_dbg_rpc": "Traitement des commandes RPC", + "grpa_dbg_selectcoins": "Sélection des pièces pour les transactions", + "grpa_dbg_tor": "Intégration de Tor et informations de circuit", + "grpa_dbg_zmq": "Système de notification ZeroMQ", + "grpa_dbg_zrpc": "Opérations RPC protégées (z-addr)", + "grpa_enter_private_key_to_import": "Saisissez une clé privée à importer.", + "grpa_error_prefix": "Erreur : ", + "grpa_hr_ago": "il y a %lld h", + "grpa_invalid_response_from_daemon": "Réponse invalide du démon", + "grpa_invalid_suffix": " (invalide)", + "grpa_min_ago": "il y a %lld min", + "grpa_sec_ago": "il y a %lld s", + "grpa_seed_demo_chat": "Chat de démonstration seed", + "grpa_showing_first_100_of": "... affichage des 100 premiers sur %d", + "grpa_tab_about": "À propos", + "grpa_tab_appearance": "Apparence", + "grpa_tab_backup_data": "Sauvegarde et données", + "grpa_tab_chat": "Chat", + "grpa_tab_explorer": "Explorateur", + "grpa_tab_node_security": "Nœud et sécurité", + "grpa_tab_wallet": "Portefeuille", + "grpa_unexpected_getblockhash_result": "résultat getblockhash inattendu", + "grpb_copy": "Copier", + "grpb_max": "Max", + "grpb_new_badge_suffix": " [NOUVEAU]", + "grpb_preview_msg_payment_through": "Le paiement est-il passé ? 🙂", + "grpb_preview_msg_sending_rest": "J'envoie le reste maintenant 👍", + "grpb_preview_msg_yep_confirmed": "Oui — je viens de confirmer ✅", + "grpb_selected_suffix": "\n(sélectionné)", + "grpb_tooltip_address_balance": "%s\nSolde : %.8f %s%s", + "grpb_undo_clear": "Annuler l'effacement", + "grpc_benchmark_inconclusive": "Benchmark non concluant : aucun échantillon de taux de hachage n'a été enregistré. Vérifiez la connexion au pool et réessayez.", + "grpc_benchmark_takes_secs": "Le benchmark prend environ %d s et interrompt le minage. Cliquez de nouveau pour démarrer.", + "grpc_bootstrap_failed": "Échec de l'amorçage", + "grpc_bootstrap_not_initialized": "Amorçage non initialisé", + "grpc_hashrate_fee": "%s %s%% de frais", + "grpc_key_not_available": "Clé non disponible pour cette adresse", + "grpc_na": "N/D", "height": "Hauteur", "help": "Aide", "hidden_tag": " (masqué)", @@ -1240,6 +1383,45 @@ "screenshot_sweep_full": "Balayage complet de l'interface", "search_icons": "Rechercher des icônes...", "search_placeholder": "Rechercher...", + "sec_changing_passphrase": "Modification de la phrase secrète...", + "sec_changing_pin": "Modification du PIN...", + "sec_couldnt_lock_wallet": "Impossible de verrouiller le portefeuille — il reste déverrouillé. Vérifiez la connexion au démon.", + "sec_encrypted_backup_suffix": "\nSauvegarde chiffrée : wallet.dat.encrypted.bak", + "sec_encrypting_wallet": "Chiffrement du portefeuille...", + "sec_encryption_did_not_complete": "Le chiffrement du portefeuille ne s'est pas terminé — votre portefeuille N'est PAS chiffré. Ouvrez les Paramètres pour terminer le chiffrement.", + "sec_encryption_failed_prefix": "Échec du chiffrement : ", + "sec_failed_prefix": "Échec : ", + "sec_failed_to_create_vault": "Échec de la création du coffre", + "sec_importing_keys_rescanning": "Importation des clés et nouvelle analyse de la blockchain — le portefeuille reste utilisable pendant l'opération", + "sec_incorrect_current_pin": "PIN actuel incorrect", + "sec_incorrect_passphrase_decrypt": "Phrase secrète incorrecte", + "sec_incorrect_passphrase_pin_setup": "Phrase secrète incorrecte", + "sec_incorrect_pin_remove": "PIN incorrect", + "sec_internal_error_change_pin": "Erreur interne", + "sec_internal_error_remove_pin": "Erreur interne", + "sec_mode_passphrase": " Phrase secrète", + "sec_not_connected_to_daemon": "Non connecté au démon", + "sec_not_connected_to_daemon_pin": "Non connecté au démon", + "sec_passphrase_changed_successfully": "Phrase secrète modifiée avec succès", + "sec_pin_changed_successfully": "PIN modifié avec succès", + "sec_pin_removed": "PIN supprimé", + "sec_pin_set_successfully": "PIN défini avec succès", + "sec_restart_daemon_for_encryption": "Veuillez redémarrer votre démon pour que le chiffrement prenne effet.", + "sec_too_many_attempts_wait": "Trop de tentatives. Patientez %.0f secondes...", + "sec_total_elapsed_fmt": "Temps total écoulé : %dm %02ds", + "sec_unlock_button": "Déverrouiller", + "sec_unlock_failed_prefix": "Échec du déverrouillage : ", + "sec_unlocking_fmt": "Déverrouillage%s", + "sec_use_passphrase_instead": "Utiliser une phrase secrète", + "sec_use_pin_instead": "Utiliser un PIN", + "sec_verifying_passphrase": "Vérification de la phrase secrète...", + "sec_verifying_pin": "Vérification du PIN...", + "sec_wallet_decrypted_all_keys_imported": "Portefeuille déchiffré avec succès ! Toutes les clés ont été importées.", + "sec_wallet_encrypted_and_pin_set": "Portefeuille chiffré et PIN défini", + "sec_wallet_encrypted_but_pin_vault_failed": "Portefeuille chiffré mais échec du coffre PIN", + "sec_wallet_encrypted_restarting_daemon": "Portefeuille chiffré. Redémarrage du démon...", + "sec_wallet_encrypted_successfully": "Portefeuille chiffré avec succès", + "sec_wallet_locked_title": "Portefeuille verrouillé", "security": "SÉCURITÉ", "seed_backup_button": "Phrase de récupération", "seed_backup_close": "Fermer", @@ -1461,6 +1643,17 @@ "sweep_to": "Balayé vers :", "sweep_toggle": "Balayer vers mon portefeuille (ne pas conserver la clé)", "sweep_tx": "Transaction :", + "swin_connection_failed": "Échec de la connexion : ", + "swin_connection_successful": "Connexion réussie !\nVersion de dragonxd : ", + "swin_invalid_suffix": " (invalide)", + "swin_no_history_file_found": "Aucun fichier d'historique trouvé", + "swin_rescan_failed": "Échec de la nouvelle analyse : ", + "swin_rescan_started_from_block": "Nouvelle analyse démarrée à partir du bloc ", + "swin_rescan_to": " à ", + "swin_rpc_client_not_initialized": "Client RPC non initialisé", + "swin_settings_saved": "Paramètres enregistrés", + "swin_theme_list_refreshed": "Liste des thèmes actualisée", + "swin_ztx_history_cleared": "Historique des transactions Z effacé", "switch_corrupt_body": "Ce portefeuille semble corrompu — le nœud n'a pas pu l'ouvrir. Restaurez-le depuis une sauvegarde, recréez-le ou tentez de le réparer.", "switch_corrupt_repair": "Tenter une réparation (salvage)", "switch_progress_background": "Continuer en arrière-plan", diff --git a/res/lang/ja.json b/res/lang/ja.json index dac35d6..ed45308 100644 --- a/res/lang/ja.json +++ b/res/lang/ja.json @@ -60,6 +60,80 @@ "amount_label": "金額：", "animate_avatars": "アバターをアニメーション", "appearance": "外観", + "appx_back": "戻る", + "appx_back_up_seed_phrase_title": "シードフレーズをバックアップ", + "appx_birthday_block_height": "誕生日（ブロック高）: %llu — これもバックアップしてください。", + "appx_blockchain_data_deleted": "ブロックチェーンデータを削除しました（%d件）。ネットワークから再同期するため、デーモンを再起動しています。", + "appx_blockchain_maintenance_in_progress": "ブロックチェーンのメンテナンス操作がすでに進行中です。", + "appx_blockchain_rescan_complete": "ブロックチェーンの再スキャンが完了しました", + "appx_bootstrap_complete_reconciling": "ブートストラップが完了しました。新しいチェーンデータとウォレットを照合しています。", + "appx_cancel": "キャンセル", + "appx_cleaning_up": "クリーンアップしています...", + "appx_confirm_your_backup": "バックアップを確認", + "appx_copied_clipboard_autoclears": "コピーしました — クリップボードは45秒後に自動的にクリアされます", + "appx_copy": "コピー", + "appx_could_not_start_restore": "復元を開始できませんでした", + "appx_create_failed_prefix": "作成に失敗しました: ", + "appx_creating_your_wallet": "ウォレットを作成しています…", + "appx_daemon_error": "デーモンエラー", + "appx_daemon_reinstall_in_progress": "デーモンの再インストールがすでに進行中です。", + "appx_disconnecting": "切断しています...", + "appx_done": "完了", + "appx_dragonxd_output": "dragonxd の出力", + "appx_encrypting_wallet": "ウォレットを暗号化しています...", + "appx_fullnode_lifecycle_unavailable_lite": "フルノードのライフサイクル操作はライトビルドでは利用できません", + "appx_installing_bundled_daemon": "同梱デーモンをインストールしています。ノードが停止、更新、再起動されます...", + "appx_invalid_payment_uri_prefix": "無効な支払いURI: ", + "appx_ive_written_it_down": "書き留めました", + "appx_keep_node_running_and_quit": "ノードを起動したまま終了", + "appx_last_block_n": "最新ブロック: %d", + "appx_last_used_wallet_not_found_prefix": "前回使用したウォレットファイル（", + "appx_last_used_wallet_not_found_suffix": "）が見つかりませんでした。代わりにデフォルトのウォレットを開きました。移動した場合は、元に戻してからウォレット一覧で切り替えてください。", + "appx_low_spec_mode_disabled": "低スペックモードを無効にしました", + "appx_low_spec_mode_enabled": "低スペックモードを有効にしました", + "appx_miner_stopped_prefix": "マイナーが停止しました: ", + "appx_miner_stopped_unexpectedly": "マイナーが予期せず停止しました。", + "appx_n_min_n_sec": "%d分 %d秒", + "appx_n_seconds": "%d秒", + "appx_no_bundled_daemon_to_install": "このビルドにはインストールできる同梱デーモンがありません", + "appx_no_embedded_daemon_to_install": "このビルドにはインストールできる組み込みデーモンがありません", + "appx_node_busy_restarting": "ノードが再起動中でビジー状態です。少し待ってから再試行してください。", + "appx_node_rebuilding_witness_cache": "ノードがウィットネスキャッシュを再構築しています", + "appx_not_next_word": " — 次の単語ではありません", + "appx_payment_request_loaded": "支払いリクエストを読み込みました", + "appx_pool_miner_connected_and_hashing": "プールマイナーが接続し、ハッシュ計算中です。", + "appx_progress_n_of_n": "進捗: %d / %d", + "appx_rebuilding_sapling_note_witnesses": "Saplingノートウィットネスを再構築しています…", + "appx_rebuilding_witness_cache_blocks_left": "ウィットネスキャッシュを再構築中 %.0f%% — 残り%dブロック", + "appx_rebuilding_witness_cache_pct": "ウィットネスキャッシュを再構築中 %.0f%%", + "appx_recovery_phrase_word_count": "リカバリーフレーズは24単語である必要があります。現在は%d単語です。", + "appx_restarting_daemon_rescan_flag": "-rescanフラグ付きでデーモンを再起動しています...", + "appx_restarting_daemon_zapwallettxes": "-zapwallettxes=2（ウォレット修復）付きでデーモンを再起動しています...", + "appx_restoring_your_wallet": "ウォレットを復元しています…", + "appx_seed_backup_warning": "この24個の単語は、ウォレットを復元する唯一の手段です。順番どおりに書き留め、オフラインで保管し、決して他人に教えないでください。紛失すると、資金は永久に失われます。", + "appx_seed_not_backed_up_warning": "シードをバックアップしていません。資金を失う可能性があります。それでもスキップしますか？", + "appx_sending_stop_command_to_daemon": "デーモンに停止コマンドを送信しています...", + "appx_setting_initial_sapling_witnesses": "初期Saplingウィットネスを設定中 %.0f%%", + "appx_shutdown_complete": "シャットダウンが完了しました", + "appx_simple_background_disabled": "シンプル背景を無効にしました", + "appx_simple_background_enabled": "シンプル背景を有効にしました", + "appx_skip": "スキップ", + "appx_skip_anyway": "それでもスキップ", + "appx_still_status_prefix": "まだ「", + "appx_still_status_suffix": "」です — 今強制終了するとチェーンデータが破損する可能性があります。", + "appx_stop_anyway_and_quit": "それでも停止して終了", + "appx_stopping_daemon_deleting_blockchain": "デーモンを停止し、ブロックチェーンデータを削除しています...", + "appx_stopping_node_discards_rebuild": "今ノードを停止すると、進行中の再構築が破棄され、次回ウォレットを開いたときに再度実行されます（数分かかります）。代わりにノードを起動したままにすることもできます。", + "appx_stopping_pool_miner": "プールマイナーを停止しています...", + "appx_syncing_pct_block_n_of_n": "同期中 %.1f%% — ブロック %d / %d", + "appx_tap_words_in_order": "保存したことを確認するため、単語を正しい順番でタップしてください。", + "appx_theme_effects_disabled": "テーマ効果を無効にしました", + "appx_theme_effects_enabled": "テーマ効果を有効にしました", + "appx_theme_prefix": "テーマ: ", + "appx_use_settings_restart_daemon_hint": "設定 > デーモンを再起動 から再試行してください", + "appx_waiting_for_daemon_to_encrypt_wallet": "デーモンによるウォレットの暗号化を待っています...", + "appx_wallet_created_and_backed_up": "ウォレットを作成し、バックアップしました。", + "appx_wallet_open_failed_prefix": "ウォレットを開けませんでした: ", "auto_shield": "マイニング自動シールド", "av_intro": "マイニングソフトウェアは、望ましくない可能性があるものとしてフラグが立てられることがよくあります。プールマイニングを有効にするには、次の手順に従ってください。", "av_open_security": "Windows セキュリティを開く", @@ -100,6 +174,17 @@ "balance_shielded_fmt": "シールド: %.8f", "balance_syncing_pct": "同期中 %.1f%%", "balance_transparent_fmt": "透明: %.8f", + "baltab_market": "市場", + "baltab_market_price_4dp": "市場価格: $%.4f", + "baltab_market_price_8dp": "市場価格: $%.8f", + "baltab_pct_change_24h": "%s%.1f%% 24h", + "baltab_pct_of_total_zaddr": "全体の%.0f%% · %d Z-addr", + "baltab_shielded": "シールド", + "baltab_shielded_amount": "シールド %.8f", + "baltab_t_addresses_count": "%d 個のT-address", + "baltab_total_balance": "合計残高", + "baltab_transparent": "透明", + "baltab_transparent_amount": "透明 %.8f", "ban": "ブロック", "banned_peers": "ブロック済みピア", "block": "ブロック", @@ -414,6 +499,7 @@ "contacts_shape_square": "四角", "contacts_shape_tab": "左タブ", "copied": "コピーしました！", + "copied_to_clipboard": "クリップボードにコピーしました", "copy": "コピー", "copy_address": "完全なアドレスをコピー", "copy_error": "エラーをコピー", @@ -593,6 +679,63 @@ "general": "一般", "generating": "生成中", "go_to_receive": "受信へ移動", + "grpa_current_block_paren": "（現在: %d）", + "grpa_days_ago": "%lld日前", + "grpa_dbg_addrman": "ピアアドレスの追跡と管理", + "grpa_dbg_alert": "アラートシステムのメッセージ", + "grpa_dbg_bench": "操作のベンチマーク計測", + "grpa_dbg_coindb": "コインデータベースの読み書き操作", + "grpa_dbg_db": "Berkeley DB の操作", + "grpa_dbg_estimatefee": "手数料見積もりアルゴリズム", + "grpa_dbg_http": "HTTP RPCサーバーの動作", + "grpa_dbg_libevent": "Libevent ネットワークライブラリ", + "grpa_dbg_lock": "ロック競合のデバッグ", + "grpa_dbg_mempool": "トランザクションメモリプールの動作", + "grpa_dbg_net": "ネットワーク接続とメッセージ", + "grpa_dbg_paymentdisclosure": "支払い開示プロトコル", + "grpa_dbg_pow": "プルーフオブワークのマイニング動作", + "grpa_dbg_proxy": "SOCKS5 プロキシ接続", + "grpa_dbg_prune": "ブロックのプルーニング操作", + "grpa_dbg_rand": "乱数生成", + "grpa_dbg_reindex": "ブロックチェーンの再インデックス進捗", + "grpa_dbg_rpc": "RPCコマンドの処理", + "grpa_dbg_selectcoins": "トランザクション用のコイン選択", + "grpa_dbg_tor": "Tor統合とサーキット情報", + "grpa_dbg_zmq": "ZeroMQ 通知システム", + "grpa_dbg_zrpc": "シールド（z-addr）RPC操作", + "grpa_enter_private_key_to_import": "インポートする秘密鍵を入力してください。", + "grpa_error_prefix": "エラー: ", + "grpa_hr_ago": "%lld時間前", + "grpa_invalid_response_from_daemon": "デーモンからの応答が無効です", + "grpa_invalid_suffix": "（無効）", + "grpa_min_ago": "%lld分前", + "grpa_sec_ago": "%lld秒前", + "grpa_seed_demo_chat": "デモチャットのシード", + "grpa_showing_first_100_of": "... %d件中の最初の100件を表示", + "grpa_tab_about": "情報", + "grpa_tab_appearance": "外観", + "grpa_tab_backup_data": "バックアップとデータ", + "grpa_tab_chat": "チャット", + "grpa_tab_explorer": "エクスプローラー", + "grpa_tab_node_security": "ノードとセキュリティ", + "grpa_tab_wallet": "ウォレット", + "grpa_unexpected_getblockhash_result": "予期しない getblockhash の結果", + "grpb_copy": "コピー", + "grpb_max": "最大", + "grpb_new_badge_suffix": " [新規]", + "grpb_preview_msg_payment_through": "支払いは完了しましたか？ 🙂", + "grpb_preview_msg_sending_rest": "残りを今送金します 👍", + "grpb_preview_msg_yep_confirmed": "はい — たった今確認できました ✅", + "grpb_selected_suffix": "\n（選択済み）", + "grpb_tooltip_address_balance": "%s\n残高: %.8f %s%s", + "grpb_undo_clear": "消去を元に戻す", + "grpc_benchmark_inconclusive": "ベンチマークの結果が不明確です: ハッシュレートのサンプルが記録されませんでした。プール接続を確認して再試行してください。", + "grpc_benchmark_takes_secs": "ベンチマークには約%d秒かかり、マイニングが中断されます。開始するにはもう一度クリックしてください。", + "grpc_bootstrap_failed": "ブートストラップに失敗しました", + "grpc_bootstrap_not_initialized": "ブートストラップが初期化されていません", + "grpc_hashrate_fee": "%s 手数料 %s%%", + "grpc_key_not_available": "このアドレスの鍵は利用できません", + "grpc_na": "該当なし", "height": "高さ", "help": "ヘルプ", "hidden_tag": " (非表示)", @@ -1237,6 +1380,45 @@ "screenshot_sweep_full": "UI全体スイープ", "search_icons": "アイコンを検索...", "search_placeholder": "検索...", + "sec_changing_passphrase": "パスフレーズを変更しています...", + "sec_changing_pin": "PINを変更しています...", + "sec_couldnt_lock_wallet": "ウォレットをロックできませんでした。まだロック解除された状態です。デーモンの接続を確認してください。", + "sec_encrypted_backup_suffix": "\n暗号化バックアップ: wallet.dat.encrypted.bak", + "sec_encrypting_wallet": "ウォレットを暗号化しています...", + "sec_encryption_did_not_complete": "ウォレットの暗号化が完了しませんでした。ウォレットは暗号化されていません。設定を開いて暗号化を完了してください。", + "sec_encryption_failed_prefix": "暗号化に失敗しました: ", + "sec_failed_prefix": "失敗しました: ", + "sec_failed_to_create_vault": "ボールトの作成に失敗しました", + "sec_importing_keys_rescanning": "鍵をインポートし、ブロックチェーンを再スキャンしています。処理中もウォレットは使用できます", + "sec_incorrect_current_pin": "現在のPINが正しくありません", + "sec_incorrect_passphrase_decrypt": "パスフレーズが正しくありません", + "sec_incorrect_passphrase_pin_setup": "パスフレーズが正しくありません", + "sec_incorrect_pin_remove": "PINが正しくありません", + "sec_internal_error_change_pin": "内部エラー", + "sec_internal_error_remove_pin": "内部エラー", + "sec_mode_passphrase": " パスフレーズ", + "sec_not_connected_to_daemon": "デーモンに接続されていません", + "sec_not_connected_to_daemon_pin": "デーモンに接続されていません", + "sec_passphrase_changed_successfully": "パスフレーズを変更しました", + "sec_pin_changed_successfully": "PINを変更しました", + "sec_pin_removed": "PINを削除しました", + "sec_pin_set_successfully": "PINを設定しました", + "sec_restart_daemon_for_encryption": "暗号化を有効にするには、デーモンを再起動してください。", + "sec_too_many_attempts_wait": "試行回数が多すぎます。%.0f秒お待ちください...", + "sec_total_elapsed_fmt": "合計経過時間: %d分 %02d秒", + "sec_unlock_button": "ロック解除", + "sec_unlock_failed_prefix": "ロック解除に失敗しました: ", + "sec_unlocking_fmt": "ロック解除中%s", + "sec_use_passphrase_instead": "代わりにパスフレーズを使用", + "sec_use_pin_instead": "代わりにPINを使用", + "sec_verifying_passphrase": "パスフレーズを確認しています...", + "sec_verifying_pin": "PINを確認しています...", + "sec_wallet_decrypted_all_keys_imported": "ウォレットの復号に成功しました。すべての鍵をインポートしました。", + "sec_wallet_encrypted_and_pin_set": "ウォレットを暗号化し、PINを設定しました", + "sec_wallet_encrypted_but_pin_vault_failed": "ウォレットは暗号化されましたが、PINボールトの作成に失敗しました", + "sec_wallet_encrypted_restarting_daemon": "ウォレットを暗号化しました。デーモンを再起動しています...", + "sec_wallet_encrypted_successfully": "ウォレットを暗号化しました", + "sec_wallet_locked_title": "ウォレットがロックされています", "security": "セキュリティ", "seed_backup_button": "シードフレーズ", "seed_backup_close": "閉じる", @@ -1458,6 +1640,17 @@ "sweep_to": "集約先:", "sweep_toggle": "ウォレットに集約（鍵は保持しない）", "sweep_tx": "取引:", + "swin_connection_failed": "接続に失敗しました: ", + "swin_connection_successful": "接続に成功しました！\ndragonxd バージョン: ", + "swin_invalid_suffix": "（無効）", + "swin_no_history_file_found": "履歴ファイルが見つかりません", + "swin_rescan_failed": "再スキャンに失敗しました: ", + "swin_rescan_started_from_block": "再スキャンを開始しました。開始ブロック ", + "swin_rescan_to": " 〜 ", + "swin_rpc_client_not_initialized": "RPCクライアントが初期化されていません", + "swin_settings_saved": "設定を保存しました", + "swin_theme_list_refreshed": "テーマ一覧を更新しました", + "swin_ztx_history_cleared": "Zトランザクション履歴を消去しました", "switch_corrupt_body": "このウォレットは破損しているようです。ノードが開けませんでした。バックアップから復元するか、作り直すか、修復を試してください。", "switch_corrupt_repair": "修復を試す（salvage）", "switch_progress_background": "バックグラウンドで続行", diff --git a/res/lang/ko.json b/res/lang/ko.json index 0fab8e7..7615671 100644 --- a/res/lang/ko.json +++ b/res/lang/ko.json @@ -60,6 +60,80 @@ "amount_label": "금액:", "animate_avatars": "아바타 애니메이션", "appearance": "외관", + "appx_back": "뒤로", + "appx_back_up_seed_phrase_title": "시드 문구 백업", + "appx_birthday_block_height": "생성 시점(블록 높이): %llu — 이것도 함께 백업하세요.", + "appx_blockchain_data_deleted": "블록체인 데이터를 삭제했습니다(%d개 항목). 네트워크에서 다시 동기화하기 위해 데몬을 재시작합니다.", + "appx_blockchain_maintenance_in_progress": "블록체인 유지 관리 작업이 이미 진행 중입니다.", + "appx_blockchain_rescan_complete": "블록체인 다시 스캔 완료", + "appx_bootstrap_complete_reconciling": "부트스트랩 완료 — 새 체인 데이터와 지갑을 대조하는 중입니다.", + "appx_cancel": "취소", + "appx_cleaning_up": "정리하는 중...", + "appx_confirm_your_backup": "백업 확인", + "appx_copied_clipboard_autoclears": "복사됨 — 클립보드가 45초 후 자동으로 지워집니다", + "appx_copy": "복사", + "appx_could_not_start_restore": "복구를 시작할 수 없습니다", + "appx_create_failed_prefix": "생성 실패: ", + "appx_creating_your_wallet": "지갑을 생성하는 중…", + "appx_daemon_error": "데몬 오류", + "appx_daemon_reinstall_in_progress": "데몬 재설치가 이미 진행 중입니다.", + "appx_disconnecting": "연결 해제 중...", + "appx_done": "완료", + "appx_dragonxd_output": "dragonxd 출력", + "appx_encrypting_wallet": "지갑 암호화 중...", + "appx_fullnode_lifecycle_unavailable_lite": "풀노드 수명 주기 작업은 라이트 빌드에서 사용할 수 없습니다", + "appx_installing_bundled_daemon": "번들 데몬을 설치하는 중 — 노드가 중지, 업데이트 후 다시 시작됩니다...", + "appx_invalid_payment_uri_prefix": "잘못된 결제 URI: ", + "appx_ive_written_it_down": "적어 두었습니다", + "appx_keep_node_running_and_quit": "노드 유지하고 종료", + "appx_last_block_n": "마지막 블록: %d", + "appx_last_used_wallet_not_found_prefix": "마지막으로 사용한 지갑 파일(", + "appx_last_used_wallet_not_found_suffix": ")을 찾을 수 없어 기본 지갑을 대신 열었습니다. 옮기셨다면 복원한 후 지갑 목록에서 다시 전환하세요.", + "appx_low_spec_mode_disabled": "저사양 모드 비활성화됨", + "appx_low_spec_mode_enabled": "저사양 모드 활성화됨", + "appx_miner_stopped_prefix": "채굴기 중지됨: ", + "appx_miner_stopped_unexpectedly": "채굴기가 예기치 않게 중지되었습니다.", + "appx_n_min_n_sec": "%d분 %d초", + "appx_n_seconds": "%d초", + "appx_no_bundled_daemon_to_install": "이 빌드에는 설치할 번들 데몬이 없습니다", + "appx_no_embedded_daemon_to_install": "이 빌드에는 설치할 내장 데몬이 없습니다", + "appx_node_busy_restarting": "노드가 재시작 중입니다 — 잠시 후 다시 시도하세요.", + "appx_node_rebuilding_witness_cache": "노드가 위트니스 캐시를 재구성하는 중입니다", + "appx_not_next_word": " — 다음 단어가 아닙니다", + "appx_payment_request_loaded": "결제 요청을 불러왔습니다", + "appx_pool_miner_connected_and_hashing": "풀 채굴기가 연결되어 해싱 중입니다.", + "appx_progress_n_of_n": "진행 상황: %d / %d", + "appx_rebuilding_sapling_note_witnesses": "Sapling 노트 위트니스 재구성 중…", + "appx_rebuilding_witness_cache_blocks_left": "위트니스 캐시 재구성 중 %.0f%% — %d개 블록 남음", + "appx_rebuilding_witness_cache_pct": "위트니스 캐시 재구성 중 %.0f%%", + "appx_recovery_phrase_word_count": "복구 문구는 24개 단어여야 합니다 — 현재 %d개입니다.", + "appx_restarting_daemon_rescan_flag": "-rescan 플래그로 데몬을 다시 시작하는 중...", + "appx_restarting_daemon_zapwallettxes": "-zapwallettxes=2로 데몬을 다시 시작하는 중(지갑 복구)...", + "appx_restoring_your_wallet": "지갑을 복구하는 중…", + "appx_seed_backup_warning": "이 24개 단어는 지갑을 복구할 수 있는 유일한 방법입니다. 순서대로 적어 오프라인에 보관하고 절대 공유하지 마세요. 잃어버리면 자금을 영원히 되찾을 수 없습니다.", + "appx_seed_not_backed_up_warning": "시드를 아직 백업하지 않았습니다 — 자금을 잃을 수 있습니다. 그래도 건너뛰시겠습니까?", + "appx_sending_stop_command_to_daemon": "데몬에 중지 명령을 보내는 중...", + "appx_setting_initial_sapling_witnesses": "초기 Sapling 위트니스 설정 중 %.0f%%", + "appx_shutdown_complete": "종료 완료", + "appx_simple_background_disabled": "단순 배경 비활성화됨", + "appx_simple_background_enabled": "단순 배경 활성화됨", + "appx_skip": "건너뛰기", + "appx_skip_anyway": "그래도 건너뛰기", + "appx_still_status_prefix": "아직 \"", + "appx_still_status_suffix": "\" 상태입니다 — 지금 강제 종료하면 체인 데이터가 손상될 수 있습니다.", + "appx_stop_anyway_and_quit": "그래도 중지하고 종료", + "appx_stopping_daemon_deleting_blockchain": "데몬을 중지하고 블록체인 데이터를 삭제하는 중...", + "appx_stopping_node_discards_rebuild": "지금 노드를 중지하면 진행 중인 재구성이 취소되며, 다음에 지갑을 열 때 다시 시작됩니다(몇 분 소요). 대신 노드를 계속 실행할 수 있습니다.", + "appx_stopping_pool_miner": "풀 채굴기를 중지하는 중...", + "appx_syncing_pct_block_n_of_n": "동기화 중 %.1f%% — 블록 %d / %d", + "appx_tap_words_in_order": "저장한 내용을 확인하도록 단어를 올바른 순서대로 탭하세요.", + "appx_theme_effects_disabled": "테마 효과 비활성화됨", + "appx_theme_effects_enabled": "테마 효과 활성화됨", + "appx_theme_prefix": "테마: ", + "appx_use_settings_restart_daemon_hint": "설정 > 데몬 다시 시작을 사용해 다시 시도하세요", + "appx_waiting_for_daemon_to_encrypt_wallet": "데몬이 지갑을 암호화하기를 기다리는 중...", + "appx_wallet_created_and_backed_up": "지갑이 생성되고 백업되었습니다.", + "appx_wallet_open_failed_prefix": "지갑 열기 실패: ", "auto_shield": "채굴 자동 차폐", "av_intro": "채굴 소프트웨어는 종종 잠재적으로 원치 않는 항목으로 표시됩니다. 풀 채굴을 활성화하려면 다음 단계를 따르세요:", "av_open_security": "Windows 보안 열기", @@ -100,6 +174,17 @@ "balance_shielded_fmt": "차폐: %.8f", "balance_syncing_pct": "동기화 중 %.1f%%", "balance_transparent_fmt": "투명: %.8f", + "baltab_market": "시세", + "baltab_market_price_4dp": "시세: $%.4f", + "baltab_market_price_8dp": "시세: $%.8f", + "baltab_pct_change_24h": "%s%.1f%% 24시간", + "baltab_pct_of_total_zaddr": "전체의 %.0f%% · Z-addr %d개", + "baltab_shielded": "실드됨", + "baltab_shielded_amount": "실드됨 %.8f", + "baltab_t_addresses_count": "T-address %d개", + "baltab_total_balance": "총 잔액", + "baltab_transparent": "투명", + "baltab_transparent_amount": "투명 %.8f", "ban": "차단", "banned_peers": "차단된 피어", "block": "블록", @@ -414,6 +499,7 @@ "contacts_shape_square": "사각형", "contacts_shape_tab": "왼쪽 탭", "copied": "복사됨!", + "copied_to_clipboard": "클립보드에 복사됨", "copy": "복사", "copy_address": "전체 주소 복사", "copy_error": "오류 복사", @@ -593,6 +679,63 @@ "general": "일반", "generating": "생성 중", "go_to_receive": "수신으로 이동", + "grpa_current_block_paren": "(현재: %d)", + "grpa_days_ago": "%lld일 전", + "grpa_dbg_addrman": "피어 주소 추적 및 관리", + "grpa_dbg_alert": "경고 시스템 메시지", + "grpa_dbg_bench": "작업 벤치마크 시간 측정", + "grpa_dbg_coindb": "코인 데이터베이스 읽기/쓰기 작업", + "grpa_dbg_db": "Berkeley DB 작업", + "grpa_dbg_estimatefee": "수수료 추정 알고리즘", + "grpa_dbg_http": "HTTP RPC 서버 활동", + "grpa_dbg_libevent": "Libevent 네트워킹 라이브러리", + "grpa_dbg_lock": "락 경합 디버깅", + "grpa_dbg_mempool": "트랜잭션 메모리 풀 활동", + "grpa_dbg_net": "네트워크 연결 및 메시지", + "grpa_dbg_paymentdisclosure": "결제 공개 프로토콜", + "grpa_dbg_pow": "작업 증명 채굴 활동", + "grpa_dbg_proxy": "SOCKS5 프록시 연결", + "grpa_dbg_prune": "블록 정리 작업", + "grpa_dbg_rand": "난수 생성", + "grpa_dbg_reindex": "블록체인 재색인 진행 상황", + "grpa_dbg_rpc": "RPC 명령 처리", + "grpa_dbg_selectcoins": "트랜잭션용 코인 선택", + "grpa_dbg_tor": "Tor 연동 및 회로 정보", + "grpa_dbg_zmq": "ZeroMQ 알림 시스템", + "grpa_dbg_zrpc": "실드(z-addr) RPC 작업", + "grpa_enter_private_key_to_import": "가져올 개인 키를 입력하세요.", + "grpa_error_prefix": "오류: ", + "grpa_hr_ago": "%lld시간 전", + "grpa_invalid_response_from_daemon": "데몬으로부터 잘못된 응답", + "grpa_invalid_suffix": " (유효하지 않음)", + "grpa_min_ago": "%lld분 전", + "grpa_sec_ago": "%lld초 전", + "grpa_seed_demo_chat": "시드 데모 채팅", + "grpa_showing_first_100_of": "... %d개 중 처음 100개 표시", + "grpa_tab_about": "정보", + "grpa_tab_appearance": "화면 표시", + "grpa_tab_backup_data": "백업 및 데이터", + "grpa_tab_chat": "채팅", + "grpa_tab_explorer": "탐색기", + "grpa_tab_node_security": "노드 및 보안", + "grpa_tab_wallet": "지갑", + "grpa_unexpected_getblockhash_result": "예기치 않은 getblockhash 결과", + "grpb_copy": "복사", + "grpb_max": "최대", + "grpb_new_badge_suffix": " [신규]", + "grpb_preview_msg_payment_through": "결제가 완료됐나요? 🙂", + "grpb_preview_msg_sending_rest": "지금 나머지를 보낼게요 👍", + "grpb_preview_msg_yep_confirmed": "네 — 방금 확인했어요 ✅", + "grpb_selected_suffix": "\n(선택됨)", + "grpb_tooltip_address_balance": "%s\n잔액: %.8f %s%s", + "grpb_undo_clear": "지우기 취소", + "grpc_benchmark_inconclusive": "벤치마크 결과가 불확실합니다: 해시레이트 샘플이 기록되지 않았습니다. 풀 연결을 확인한 후 다시 시도하세요.", + "grpc_benchmark_takes_secs": "벤치마크는 약 %d초가 걸리며 채굴을 중단합니다. 시작하려면 다시 클릭하세요.", + "grpc_bootstrap_failed": "부트스트랩 실패", + "grpc_bootstrap_not_initialized": "부트스트랩이 초기화되지 않았습니다", + "grpc_hashrate_fee": "%s 수수료 %s%%", + "grpc_key_not_available": "이 주소에 대한 키를 사용할 수 없습니다", + "grpc_na": "해당 없음", "height": "높이", "help": "도움말", "hidden_tag": " (숨김)", @@ -1239,6 +1382,45 @@ "screenshot_sweep_full": "전체 UI 스윕", "search_icons": "아이콘 검색...", "search_placeholder": "검색...", + "sec_changing_passphrase": "암호문 변경 중...", + "sec_changing_pin": "PIN 변경 중...", + "sec_couldnt_lock_wallet": "지갑을 잠글 수 없습니다 — 아직 잠금 해제 상태입니다. 데몬 연결을 확인하세요.", + "sec_encrypted_backup_suffix": "\n암호화된 백업: wallet.dat.encrypted.bak", + "sec_encrypting_wallet": "지갑 암호화 중...", + "sec_encryption_did_not_complete": "지갑 암호화가 완료되지 않았습니다 — 지갑이 암호화되지 않은 상태입니다. 설정을 열어 암호화를 완료하세요.", + "sec_encryption_failed_prefix": "암호화 실패: ", + "sec_failed_prefix": "실패: ", + "sec_failed_to_create_vault": "볼트 생성에 실패했습니다", + "sec_importing_keys_rescanning": "키를 가져오고 블록체인을 다시 스캔하는 중 — 진행 중에도 지갑을 사용할 수 있습니다", + "sec_incorrect_current_pin": "현재 PIN이 올바르지 않습니다", + "sec_incorrect_passphrase_decrypt": "잘못된 암호문", + "sec_incorrect_passphrase_pin_setup": "잘못된 암호문", + "sec_incorrect_pin_remove": "잘못된 PIN", + "sec_internal_error_change_pin": "내부 오류", + "sec_internal_error_remove_pin": "내부 오류", + "sec_mode_passphrase": " 암호문", + "sec_not_connected_to_daemon": "데몬에 연결되지 않음", + "sec_not_connected_to_daemon_pin": "데몬에 연결되지 않음", + "sec_passphrase_changed_successfully": "암호문이 성공적으로 변경되었습니다", + "sec_pin_changed_successfully": "PIN이 성공적으로 변경되었습니다", + "sec_pin_removed": "PIN이 제거되었습니다", + "sec_pin_set_successfully": "PIN이 성공적으로 설정되었습니다", + "sec_restart_daemon_for_encryption": "암호화를 적용하려면 데몬을 다시 시작하세요.", + "sec_too_many_attempts_wait": "시도 횟수가 너무 많습니다. %.0f초 기다리세요...", + "sec_total_elapsed_fmt": "총 경과 시간: %d분 %02d초", + "sec_unlock_button": "잠금 해제", + "sec_unlock_failed_prefix": "잠금 해제 실패: ", + "sec_unlocking_fmt": "잠금 해제 중%s", + "sec_use_passphrase_instead": "대신 암호문 사용", + "sec_use_pin_instead": "대신 PIN 사용", + "sec_verifying_passphrase": "암호문 확인 중...", + "sec_verifying_pin": "PIN 확인 중...", + "sec_wallet_decrypted_all_keys_imported": "지갑 복호화 완료! 모든 키를 가져왔습니다.", + "sec_wallet_encrypted_and_pin_set": "지갑 암호화 및 PIN 설정 완료", + "sec_wallet_encrypted_but_pin_vault_failed": "지갑은 암호화되었으나 PIN 볼트 설정에 실패했습니다", + "sec_wallet_encrypted_restarting_daemon": "지갑이 암호화되었습니다. 데몬을 다시 시작하는 중...", + "sec_wallet_encrypted_successfully": "지갑이 성공적으로 암호화되었습니다", + "sec_wallet_locked_title": "지갑 잠김", "security": "보안", "seed_backup_button": "시드 문구", "seed_backup_close": "닫기", @@ -1460,6 +1642,17 @@ "sweep_to": "쓸어담은 주소:", "sweep_toggle": "내 지갑으로 쓸어담기 (키 보관 안 함)", "sweep_tx": "거래:", + "swin_connection_failed": "연결 실패: ", + "swin_connection_successful": "연결에 성공했습니다!\ndragonxd 버전: ", + "swin_invalid_suffix": " (유효하지 않음)", + "swin_no_history_file_found": "기록 파일을 찾을 수 없습니다", + "swin_rescan_failed": "다시 스캔 실패: ", + "swin_rescan_started_from_block": "다시 스캔이 시작된 블록 ", + "swin_rescan_to": " ~ ", + "swin_rpc_client_not_initialized": "RPC 클라이언트가 초기화되지 않았습니다", + "swin_settings_saved": "설정이 저장되었습니다", + "swin_theme_list_refreshed": "테마 목록을 새로고침했습니다", + "swin_ztx_history_cleared": "Z-트랜잭션 기록이 삭제되었습니다", "switch_corrupt_body": "이 지갑이 손상된 것 같습니다. 노드가 열 수 없습니다. 백업에서 복원하거나 다시 만들거나 복구를 시도하세요.", "switch_corrupt_repair": "복구 시도(salvage)", "switch_progress_background": "백그라운드에서 계속", diff --git a/res/lang/pt.json b/res/lang/pt.json index c770a5c..bc244ea 100644 --- a/res/lang/pt.json +++ b/res/lang/pt.json @@ -60,6 +60,80 @@ "amount_label": "Valor:", "animate_avatars": "Animar avatares", "appearance": "APARÊNCIA", + "appx_back": "Voltar", + "appx_back_up_seed_phrase_title": "Faça o backup da sua frase-semente", + "appx_birthday_block_height": "Nascimento (altura do bloco): %llu — faça o backup disto também.", + "appx_blockchain_data_deleted": "Dados da blockchain excluídos (%d itens). O daemon está reiniciando para ressincronizar com a rede.", + "appx_blockchain_maintenance_in_progress": "Uma operação de manutenção da blockchain já está em andamento.", + "appx_blockchain_rescan_complete": "Reescaneamento da blockchain concluído", + "appx_bootstrap_complete_reconciling": "Bootstrap concluído — reconciliando sua carteira com os novos dados da chain.", + "appx_cancel": "Cancelar", + "appx_cleaning_up": "Limpando...", + "appx_confirm_your_backup": "Confirme seu backup", + "appx_copied_clipboard_autoclears": "Copiado — a área de transferência será limpa em 45s", + "appx_copy": "Copiar", + "appx_could_not_start_restore": "Não foi possível iniciar a restauração", + "appx_create_failed_prefix": "Falha na criação: ", + "appx_creating_your_wallet": "Criando sua carteira…", + "appx_daemon_error": "Erro do Daemon", + "appx_daemon_reinstall_in_progress": "A reinstalação do daemon já está em andamento.", + "appx_disconnecting": "Desconectando...", + "appx_done": "Concluído", + "appx_dragonxd_output": "saída do dragonxd", + "appx_encrypting_wallet": "Criptografando a carteira...", + "appx_fullnode_lifecycle_unavailable_lite": "As ações de ciclo de vida do nó completo não estão disponíveis na versão lite", + "appx_installing_bundled_daemon": "Instalando o daemon incluído — o nó vai parar, atualizar e reiniciar...", + "appx_invalid_payment_uri_prefix": "URI de pagamento inválida: ", + "appx_ive_written_it_down": "Já anotei", + "appx_keep_node_running_and_quit": "Manter o nó em execução e sair", + "appx_last_block_n": "Último bloco: %d", + "appx_last_used_wallet_not_found_prefix": "Seu último arquivo de carteira usado (", + "appx_last_used_wallet_not_found_suffix": ") não foi encontrado — a carteira padrão foi aberta em seu lugar. Se você o moveu, restaure-o e volte a ele pela lista de carteiras.", + "appx_low_spec_mode_disabled": "Modo de baixo desempenho desativado", + "appx_low_spec_mode_enabled": "Modo de baixo desempenho ativado", + "appx_miner_stopped_prefix": "Minerador parado: ", + "appx_miner_stopped_unexpectedly": "O minerador parou inesperadamente.", + "appx_n_min_n_sec": "%d min %d s", + "appx_n_seconds": "%d segundos", + "appx_no_bundled_daemon_to_install": "Esta versão não tem daemon incluído para instalar", + "appx_no_embedded_daemon_to_install": "Esta versão não tem daemon embutido para instalar", + "appx_node_busy_restarting": "O nó está ocupado reiniciando — tente novamente em instantes.", + "appx_node_rebuilding_witness_cache": "O nó está reconstruindo seu cache de testemunhas", + "appx_not_next_word": " — essa não é a próxima palavra", + "appx_payment_request_loaded": "Solicitação de pagamento carregada", + "appx_pool_miner_connected_and_hashing": "Minerador de pool conectado e processando hashes.", + "appx_progress_n_of_n": "Progresso: %d / %d", + "appx_rebuilding_sapling_note_witnesses": "Reconstruindo testemunhas de notas Sapling…", + "appx_rebuilding_witness_cache_blocks_left": "Reconstruindo cache de testemunhas %.0f%% — %d blocos restantes", + "appx_rebuilding_witness_cache_pct": "Reconstruindo cache de testemunhas %.0f%%", + "appx_recovery_phrase_word_count": "A frase de recuperação deve ter 24 palavras — você tem %d.", + "appx_restarting_daemon_rescan_flag": "Reiniciando o daemon com a flag -rescan...", + "appx_restarting_daemon_zapwallettxes": "Reiniciando o daemon com -zapwallettxes=2 (reparo da carteira)...", + "appx_restoring_your_wallet": "Restaurando sua carteira…", + "appx_seed_backup_warning": "Estas 24 palavras são a ÚNICA forma de restaurar sua carteira. Anote-as na ordem, guarde-as offline e nunca as compartilhe. Se perdê-las, seus fundos desaparecem para sempre.", + "appx_seed_not_backed_up_warning": "Você não fez o backup da sua semente — os fundos podem ser perdidos. Pular mesmo assim?", + "appx_sending_stop_command_to_daemon": "Enviando comando de parada ao daemon...", + "appx_setting_initial_sapling_witnesses": "Definindo testemunhas Sapling iniciais %.0f%%", + "appx_shutdown_complete": "Encerramento concluído", + "appx_simple_background_disabled": "Fundo simples desativado", + "appx_simple_background_enabled": "Fundo simples ativado", + "appx_skip": "Pular", + "appx_skip_anyway": "Pular mesmo assim", + "appx_still_status_prefix": "Ainda \"", + "appx_still_status_suffix": "\" — forçar o encerramento agora pode corromper os dados da chain.", + "appx_stop_anyway_and_quit": "Parar mesmo assim e sair", + "appx_stopping_daemon_deleting_blockchain": "Parando o daemon e excluindo os dados da blockchain...", + "appx_stopping_node_discards_rebuild": "Parar o nó agora descarta a reconstrução em andamento e a reinicia (vários minutos) na próxima vez que você abrir a carteira. Em vez disso, você pode manter o nó em execução.", + "appx_stopping_pool_miner": "Parando o minerador de pool...", + "appx_syncing_pct_block_n_of_n": "Sincronizando %.1f%% — Bloco %d / %d", + "appx_tap_words_in_order": "Toque nas palavras na ordem correta para confirmar que você as salvou.", + "appx_theme_effects_disabled": "Efeitos de tema desativados", + "appx_theme_effects_enabled": "Efeitos de tema ativados", + "appx_theme_prefix": "Tema: ", + "appx_use_settings_restart_daemon_hint": "Use Configurações > Reiniciar Daemon para tentar novamente", + "appx_waiting_for_daemon_to_encrypt_wallet": "Aguardando o daemon criptografar a carteira...", + "appx_wallet_created_and_backed_up": "Carteira criada e com backup feito.", + "appx_wallet_open_failed_prefix": "Falha ao abrir a carteira: ", "auto_shield": "Auto-blindar mineração", "av_intro": "Softwares de mineração costumam ser sinalizados como potencialmente indesejados. Siga estes passos para habilitar a mineração em pool:", "av_open_security": "Abrir Segurança do Windows", @@ -100,6 +174,17 @@ "balance_shielded_fmt": "Blindado: %.8f", "balance_syncing_pct": "Sincronizando %.1f%%", "balance_transparent_fmt": "Transparente: %.8f", + "baltab_market": "Mercado", + "baltab_market_price_4dp": "Mercado: $%.4f", + "baltab_market_price_8dp": "Mercado: $%.8f", + "baltab_pct_change_24h": "%s%.1f%% 24h", + "baltab_pct_of_total_zaddr": "%.0f%% do total · %d Z-addr", + "baltab_shielded": "Blindado", + "baltab_shielded_amount": "Blindado %.8f", + "baltab_t_addresses_count": "%d T-addresses", + "baltab_total_balance": "Saldo Total", + "baltab_transparent": "Transparente", + "baltab_transparent_amount": "Transparente %.8f", "ban": "Banir", "banned_peers": "Pares Banidos", "block": "Bloco", @@ -414,6 +499,7 @@ "contacts_shape_square": "Quadrado", "contacts_shape_tab": "Aba", "copied": "Copiado!", + "copied_to_clipboard": "Copiado para a área de transferência", "copy": "Copiar", "copy_address": "Copiar Endereço Completo", "copy_error": "Copiar Erro", @@ -593,6 +679,63 @@ "general": "Geral", "generating": "Gerando", "go_to_receive": "Ir para Receber", + "grpa_current_block_paren": "(Atual: %d)", + "grpa_days_ago": "há %lld dias", + "grpa_dbg_addrman": "Rastreamento e gerenciamento de endereços de pares", + "grpa_dbg_alert": "Mensagens do sistema de alertas", + "grpa_dbg_bench": "Medições de tempo de benchmark das operações", + "grpa_dbg_coindb": "Operações de leitura/gravação do banco de dados de moedas", + "grpa_dbg_db": "Operações do Berkeley DB", + "grpa_dbg_estimatefee": "Algoritmo de estimativa de taxa", + "grpa_dbg_http": "Atividade do servidor RPC HTTP", + "grpa_dbg_libevent": "Biblioteca de rede Libevent", + "grpa_dbg_lock": "Depuração de contenção de bloqueios", + "grpa_dbg_mempool": "Atividade do pool de memória de transações", + "grpa_dbg_net": "Conexões e mensagens de rede", + "grpa_dbg_paymentdisclosure": "Protocolo de divulgação de pagamento", + "grpa_dbg_pow": "Atividade de mineração de prova de trabalho", + "grpa_dbg_proxy": "Conexões de proxy SOCKS5", + "grpa_dbg_prune": "Operações de poda de blocos", + "grpa_dbg_rand": "Geração de números aleatórios", + "grpa_dbg_reindex": "Progresso da reindexação da blockchain", + "grpa_dbg_rpc": "Processamento de comandos RPC", + "grpa_dbg_selectcoins": "Seleção de moedas para transações", + "grpa_dbg_tor": "Integração com Tor e informações de circuito", + "grpa_dbg_zmq": "Sistema de notificações ZeroMQ", + "grpa_dbg_zrpc": "Operações RPC blindadas (z-address)", + "grpa_enter_private_key_to_import": "Insira uma chave privada para importar.", + "grpa_error_prefix": "Erro: ", + "grpa_hr_ago": "há %lld h", + "grpa_invalid_response_from_daemon": "Resposta inválida do daemon", + "grpa_invalid_suffix": " (inválido)", + "grpa_min_ago": "há %lld min", + "grpa_sec_ago": "há %lld s", + "grpa_seed_demo_chat": "Chat de demonstração da semente", + "grpa_showing_first_100_of": "... mostrando os primeiros 100 de %d", + "grpa_tab_about": "Sobre", + "grpa_tab_appearance": "Aparência", + "grpa_tab_backup_data": "Backup e Dados", + "grpa_tab_chat": "Chat", + "grpa_tab_explorer": "Explorer", + "grpa_tab_node_security": "Nó e Segurança", + "grpa_tab_wallet": "Carteira", + "grpa_unexpected_getblockhash_result": "resultado inesperado de getblockhash", + "grpb_copy": "Copiar", + "grpb_max": "Máx", + "grpb_new_badge_suffix": " [NOVO]", + "grpb_preview_msg_payment_through": "O pagamento foi concluído? 🙂", + "grpb_preview_msg_sending_rest": "Enviando o restante agora 👍", + "grpb_preview_msg_yep_confirmed": "Sim — acabei de confirmar ✅", + "grpb_selected_suffix": "\n(selecionado)", + "grpb_tooltip_address_balance": "%s\nSaldo: %.8f %s%s", + "grpb_undo_clear": "Desfazer Limpar", + "grpc_benchmark_inconclusive": "Benchmark inconclusivo: nenhuma amostra de taxa de hash foi registrada. Verifique a conexão com a pool e tente novamente.", + "grpc_benchmark_takes_secs": "O benchmark leva cerca de %ds e interrompe a mineração. Clique novamente para iniciar.", + "grpc_bootstrap_failed": "Falha no bootstrap", + "grpc_bootstrap_not_initialized": "Bootstrap não inicializado", + "grpc_hashrate_fee": "%s %s%% de taxa", + "grpc_key_not_available": "Chave não disponível para este endereço", + "grpc_na": "N/D", "height": "Altura", "help": "Ajuda", "hidden_tag": " (oculto)", @@ -1240,6 +1383,45 @@ "screenshot_sweep_full": "Varredura completa da interface", "search_icons": "Pesquisar ícones...", "search_placeholder": "Pesquisar...", + "sec_changing_passphrase": "Alterando a frase-senha...", + "sec_changing_pin": "Alterando o PIN...", + "sec_couldnt_lock_wallet": "Não foi possível bloquear a carteira — ela continua desbloqueada. Verifique a conexão com o daemon.", + "sec_encrypted_backup_suffix": "\nBackup criptografado: wallet.dat.encrypted.bak", + "sec_encrypting_wallet": "Criptografando a carteira...", + "sec_encryption_did_not_complete": "A criptografia da carteira não foi concluída — sua carteira NÃO está criptografada. Abra as Configurações para terminar de criptografá-la.", + "sec_encryption_failed_prefix": "Falha na criptografia: ", + "sec_failed_prefix": "Falhou: ", + "sec_failed_to_create_vault": "Falha ao criar o cofre", + "sec_importing_keys_rescanning": "Importando chaves e reescaneando a blockchain — a carteira pode ser usada durante o processo", + "sec_incorrect_current_pin": "PIN atual incorreto", + "sec_incorrect_passphrase_decrypt": "Frase-senha incorreta", + "sec_incorrect_passphrase_pin_setup": "Frase-senha incorreta", + "sec_incorrect_pin_remove": "PIN incorreto", + "sec_internal_error_change_pin": "Erro interno", + "sec_internal_error_remove_pin": "Erro interno", + "sec_mode_passphrase": " Frase-senha", + "sec_not_connected_to_daemon": "Não conectado ao daemon", + "sec_not_connected_to_daemon_pin": "Não conectado ao daemon", + "sec_passphrase_changed_successfully": "Frase-senha alterada com sucesso", + "sec_pin_changed_successfully": "PIN alterado com sucesso", + "sec_pin_removed": "PIN removido", + "sec_pin_set_successfully": "PIN definido com sucesso", + "sec_restart_daemon_for_encryption": "Reinicie o daemon para que a criptografia entre em vigor.", + "sec_too_many_attempts_wait": "Tentativas em excesso. Aguarde %.0f segundos...", + "sec_total_elapsed_fmt": "Tempo total: %dm %02ds", + "sec_unlock_button": "Desbloquear", + "sec_unlock_failed_prefix": "Falha ao desbloquear: ", + "sec_unlocking_fmt": "Desbloqueando%s", + "sec_use_passphrase_instead": "Usar frase-senha", + "sec_use_pin_instead": "Usar PIN", + "sec_verifying_passphrase": "Verificando a frase-senha...", + "sec_verifying_pin": "Verificando o PIN...", + "sec_wallet_decrypted_all_keys_imported": "Carteira descriptografada com sucesso! Todas as chaves importadas.", + "sec_wallet_encrypted_and_pin_set": "Carteira criptografada e PIN definido", + "sec_wallet_encrypted_but_pin_vault_failed": "Carteira criptografada, mas o cofre do PIN falhou", + "sec_wallet_encrypted_restarting_daemon": "Carteira criptografada. Reiniciando o daemon...", + "sec_wallet_encrypted_successfully": "Carteira criptografada com sucesso", + "sec_wallet_locked_title": "Carteira Bloqueada", "security": "SEGURANÇA", "seed_backup_button": "Frase de recuperação", "seed_backup_close": "Fechar", @@ -1461,6 +1643,17 @@ "sweep_to": "Varrido para:", "sweep_toggle": "Varrer para minha carteira (não manter a chave)", "sweep_tx": "Transação:", + "swin_connection_failed": "Falha na conexão: ", + "swin_connection_successful": "Conexão bem-sucedida!\nversão do dragonxd: ", + "swin_invalid_suffix": " (inválido)", + "swin_no_history_file_found": "Nenhum arquivo de histórico encontrado", + "swin_rescan_failed": "Falha no reescaneamento: ", + "swin_rescan_started_from_block": "Reescaneamento iniciado a partir do bloco ", + "swin_rescan_to": " até ", + "swin_rpc_client_not_initialized": "Cliente RPC não inicializado", + "swin_settings_saved": "Configurações salvas", + "swin_theme_list_refreshed": "Lista de temas atualizada", + "swin_ztx_history_cleared": "Histórico de transações Z limpo", "switch_corrupt_body": "Esta carteira parece corrompida — o nó não conseguiu abri-la. Restaure de um backup, recrie-a ou tente repará-la.", "switch_corrupt_repair": "Tentar reparar (salvage)", "switch_progress_background": "Continuar em segundo plano", diff --git a/res/lang/ru.json b/res/lang/ru.json index f4d147e..2c6dd82 100644 --- a/res/lang/ru.json +++ b/res/lang/ru.json @@ -60,6 +60,80 @@ "amount_label": "Сумма:", "animate_avatars": "Анимировать аватары", "appearance": "ВНЕШНИЙ ВИД", + "appx_back": "Назад", + "appx_back_up_seed_phrase_title": "Сохраните seed-фразу", + "appx_birthday_block_height": "Дата создания (высота блока): %llu — сохраните и её.", + "appx_blockchain_data_deleted": "Данные блокчейна удалены (%d элементов). Демон перезапускается для повторной синхронизации с сетью.", + "appx_blockchain_maintenance_in_progress": "Операция обслуживания блокчейна уже выполняется.", + "appx_blockchain_rescan_complete": "Повторное сканирование блокчейна завершено", + "appx_bootstrap_complete_reconciling": "Начальная загрузка завершена — сверка кошелька с новыми данными цепи.", + "appx_cancel": "Отмена", + "appx_cleaning_up": "Очистка...", + "appx_confirm_your_backup": "Подтвердите резервную копию", + "appx_copied_clipboard_autoclears": "Скопировано — буфер обмена очистится через 45 с", + "appx_copy": "Копировать", + "appx_could_not_start_restore": "Не удалось начать восстановление", + "appx_create_failed_prefix": "Ошибка создания: ", + "appx_creating_your_wallet": "Создание кошелька…", + "appx_daemon_error": "Ошибка демона", + "appx_daemon_reinstall_in_progress": "Переустановка демона уже выполняется.", + "appx_disconnecting": "Отключение...", + "appx_done": "Готово", + "appx_dragonxd_output": "вывод dragonxd", + "appx_encrypting_wallet": "Шифрование кошелька...", + "appx_fullnode_lifecycle_unavailable_lite": "Действия жизненного цикла полного узла недоступны в lite-сборке", + "appx_installing_bundled_daemon": "Установка встроенного демона — узел остановится, обновится и перезапустится...", + "appx_invalid_payment_uri_prefix": "Неверный платёжный URI: ", + "appx_ive_written_it_down": "Я записал её", + "appx_keep_node_running_and_quit": "Оставить узел и выйти", + "appx_last_block_n": "Последний блок: %d", + "appx_last_used_wallet_not_found_prefix": "Ваш последний использованный файл кошелька (", + "appx_last_used_wallet_not_found_suffix": ") не найден — вместо него открыт кошелёк по умолчанию. Если вы его переместили, восстановите файл и переключитесь обратно из списка кошельков.", + "appx_low_spec_mode_disabled": "Режим слабого оборудования выключен", + "appx_low_spec_mode_enabled": "Режим слабого оборудования включён", + "appx_miner_stopped_prefix": "Майнер остановлен: ", + "appx_miner_stopped_unexpectedly": "Майнер неожиданно остановился.", + "appx_n_min_n_sec": "%d мин %d сек", + "appx_n_seconds": "%d сек", + "appx_no_bundled_daemon_to_install": "В этой сборке нет встроенного демона для установки", + "appx_no_embedded_daemon_to_install": "В этой сборке нет встроенного демона для установки", + "appx_node_busy_restarting": "Узел занят перезапуском — попробуйте ещё раз через мгновение.", + "appx_node_rebuilding_witness_cache": "Узел перестраивает кэш свидетелей", + "appx_not_next_word": " — это не следующее слово", + "appx_payment_request_loaded": "Запрос на оплату загружен", + "appx_pool_miner_connected_and_hashing": "Пул-майнер подключён и вычисляет хеши.", + "appx_progress_n_of_n": "Прогресс: %d / %d", + "appx_rebuilding_sapling_note_witnesses": "Перестройка свидетелей заметок Sapling…", + "appx_rebuilding_witness_cache_blocks_left": "Перестройка кэша свидетелей %.0f%% — осталось блоков: %d", + "appx_rebuilding_witness_cache_pct": "Перестройка кэша свидетелей %.0f%%", + "appx_recovery_phrase_word_count": "Фраза восстановления должна содержать 24 слова — у вас %d.", + "appx_restarting_daemon_rescan_flag": "Перезапуск демона с флагом -rescan...", + "appx_restarting_daemon_zapwallettxes": "Перезапуск демона с -zapwallettxes=2 (восстановление кошелька)...", + "appx_restoring_your_wallet": "Восстановление кошелька…", + "appx_seed_backup_warning": "Эти 24 слова — ЕДИНСТВЕННЫЙ способ восстановить кошелёк. Запишите их по порядку, храните офлайн и никому не сообщайте. Если вы их потеряете, средства пропадут навсегда.", + "appx_seed_not_backed_up_warning": "Вы не сохранили seed-фразу — средства могут быть потеряны. Всё равно пропустить?", + "appx_sending_stop_command_to_daemon": "Отправка команды остановки демону...", + "appx_setting_initial_sapling_witnesses": "Установка начальных свидетелей Sapling %.0f%%", + "appx_shutdown_complete": "Завершение работы выполнено", + "appx_simple_background_disabled": "Простой фон выключен", + "appx_simple_background_enabled": "Простой фон включён", + "appx_skip": "Пропустить", + "appx_skip_anyway": "Всё равно пропустить", + "appx_still_status_prefix": "Всё ещё \"", + "appx_still_status_suffix": "\" — принудительный выход сейчас может повредить данные цепи.", + "appx_stop_anyway_and_quit": "Всё равно остановить и выйти", + "appx_stopping_daemon_deleting_blockchain": "Остановка демона и удаление данных блокчейна...", + "appx_stopping_node_discards_rebuild": "Остановка узла сейчас отменит текущую перестройку и запустит её заново (несколько минут) при следующем открытии кошелька. Вместо этого можно оставить узел работать.", + "appx_stopping_pool_miner": "Остановка пул-майнера...", + "appx_syncing_pct_block_n_of_n": "Синхронизация %.1f%% — Блок %d / %d", + "appx_tap_words_in_order": "Нажимайте слова в правильном порядке, чтобы подтвердить, что вы их сохранили.", + "appx_theme_effects_disabled": "Эффекты темы выключены", + "appx_theme_effects_enabled": "Эффекты темы включены", + "appx_theme_prefix": "Тема: ", + "appx_use_settings_restart_daemon_hint": "Откройте Настройки > Перезапустить демон, чтобы повторить попытку", + "appx_waiting_for_daemon_to_encrypt_wallet": "Ожидание шифрования кошелька демоном...", + "appx_wallet_created_and_backed_up": "Кошелёк создан, резервная копия сохранена.", + "appx_wallet_open_failed_prefix": "Не удалось открыть кошелёк: ", "auto_shield": "Авто-экранирование майнинга", "av_intro": "Программы для майнинга часто помечаются как потенциально нежелательные. Выполните эти шаги, чтобы включить пул-майнинг:", "av_open_security": "Открыть Безопасность Windows", @@ -100,6 +174,17 @@ "balance_shielded_fmt": "Экранировано: %.8f", "balance_syncing_pct": "Синхронизация %.1f%%", "balance_transparent_fmt": "Прозрачный: %.8f", + "baltab_market": "Рынок", + "baltab_market_price_4dp": "Рынок: $%.4f", + "baltab_market_price_8dp": "Рынок: $%.8f", + "baltab_pct_change_24h": "%s%.1f%% за 24ч", + "baltab_pct_of_total_zaddr": "%.0f%% от общего · %d Z-addr", + "baltab_shielded": "Скрытый", + "baltab_shielded_amount": "Скрытый %.8f", + "baltab_t_addresses_count": "%d T-адресов", + "baltab_total_balance": "Общий баланс", + "baltab_transparent": "Прозрачный", + "baltab_transparent_amount": "Прозрачный %.8f", "ban": "Заблокировать", "banned_peers": "Заблокированные узлы", "block": "Блок", @@ -414,6 +499,7 @@ "contacts_shape_square": "Квадрат", "contacts_shape_tab": "Вкладка", "copied": "Скопировано!", + "copied_to_clipboard": "Скопировано в буфер обмена", "copy": "Копировать", "copy_address": "Копировать полный адрес", "copy_error": "Копировать ошибку", @@ -593,6 +679,63 @@ "general": "Общие", "generating": "Генерация", "go_to_receive": "Перейти к получению", + "grpa_current_block_paren": "(Текущий: %d)", + "grpa_days_ago": "%lld дн назад", + "grpa_dbg_addrman": "Отслеживание и управление адресами узлов", + "grpa_dbg_alert": "Сообщения системы оповещений", + "grpa_dbg_bench": "Замеры производительности операций", + "grpa_dbg_coindb": "Операции чтения/записи базы монет", + "grpa_dbg_db": "Операции Berkeley DB", + "grpa_dbg_estimatefee": "Алгоритм оценки комиссии", + "grpa_dbg_http": "Активность HTTP RPC-сервера", + "grpa_dbg_libevent": "Сетевая библиотека Libevent", + "grpa_dbg_lock": "Отладка конкуренции блокировок", + "grpa_dbg_mempool": "Активность пула транзакций в памяти", + "grpa_dbg_net": "Сетевые соединения и сообщения", + "grpa_dbg_paymentdisclosure": "Протокол раскрытия платежей", + "grpa_dbg_pow": "Активность майнинга proof-of-work", + "grpa_dbg_proxy": "Соединения через прокси SOCKS5", + "grpa_dbg_prune": "Операции обрезки блоков", + "grpa_dbg_rand": "Генерация случайных чисел", + "grpa_dbg_reindex": "Прогресс переиндексации блокчейна", + "grpa_dbg_rpc": "Обработка RPC-команд", + "grpa_dbg_selectcoins": "Выбор монет для транзакций", + "grpa_dbg_tor": "Интеграция Tor и сведения о цепочках", + "grpa_dbg_zmq": "Система уведомлений ZeroMQ", + "grpa_dbg_zrpc": "Скрытые (z-addr) RPC-операции", + "grpa_enter_private_key_to_import": "Введите приватный ключ для импорта.", + "grpa_error_prefix": "Ошибка: ", + "grpa_hr_ago": "%lld ч назад", + "grpa_invalid_response_from_daemon": "Неверный ответ от демона", + "grpa_invalid_suffix": " (неверный)", + "grpa_min_ago": "%lld мин назад", + "grpa_sec_ago": "%lld сек назад", + "grpa_seed_demo_chat": "Демо-чат seed", + "grpa_showing_first_100_of": "... показаны первые 100 из %d", + "grpa_tab_about": "О программе", + "grpa_tab_appearance": "Внешний вид", + "grpa_tab_backup_data": "Резервное копирование и данные", + "grpa_tab_chat": "Чат", + "grpa_tab_explorer": "Обозреватель", + "grpa_tab_node_security": "Узел и безопасность", + "grpa_tab_wallet": "Кошелёк", + "grpa_unexpected_getblockhash_result": "неожиданный результат getblockhash", + "grpb_copy": "Копировать", + "grpb_max": "Макс", + "grpb_new_badge_suffix": " [НОВОЕ]", + "grpb_preview_msg_payment_through": "Платёж прошёл? 🙂", + "grpb_preview_msg_sending_rest": "Отправляю остаток 👍", + "grpb_preview_msg_yep_confirmed": "Да — только что подтвердил ✅", + "grpb_selected_suffix": "\n(выбрано)", + "grpb_tooltip_address_balance": "%s\nБаланс: %.8f %s%s", + "grpb_undo_clear": "Отменить очистку", + "grpc_benchmark_inconclusive": "Бенчмарк не дал результата: не записано ни одной выборки хешрейта. Проверьте соединение с пулом и повторите попытку.", + "grpc_benchmark_takes_secs": "Бенчмарк занимает ~%dс и прерывает майнинг. Нажмите ещё раз для запуска.", + "grpc_bootstrap_failed": "Ошибка начальной загрузки", + "grpc_bootstrap_not_initialized": "Начальная загрузка не инициализирована", + "grpc_hashrate_fee": "%s комиссия %s%%", + "grpc_key_not_available": "Ключ недоступен для этого адреса", + "grpc_na": "Н/Д", "height": "Высота", "help": "Справка", "hidden_tag": " (скрыт)", @@ -1240,6 +1383,45 @@ "screenshot_sweep_full": "Полный обход интерфейса", "search_icons": "Поиск значков...", "search_placeholder": "Поиск...", + "sec_changing_passphrase": "Смена парольной фразы...", + "sec_changing_pin": "Смена PIN...", + "sec_couldnt_lock_wallet": "Не удалось заблокировать кошелёк — он всё ещё разблокирован. Проверьте соединение с демоном.", + "sec_encrypted_backup_suffix": "\nЗашифрованная резервная копия: wallet.dat.encrypted.bak", + "sec_encrypting_wallet": "Шифрование кошелька...", + "sec_encryption_did_not_complete": "Шифрование кошелька не завершено — ваш кошелёк НЕ зашифрован. Откройте настройки, чтобы завершить шифрование.", + "sec_encryption_failed_prefix": "Ошибка шифрования: ", + "sec_failed_prefix": "Ошибка: ", + "sec_failed_to_create_vault": "Не удалось создать хранилище", + "sec_importing_keys_rescanning": "Импорт ключей и повторное сканирование блокчейна — кошелёк доступен во время выполнения", + "sec_incorrect_current_pin": "Неверный текущий PIN", + "sec_incorrect_passphrase_decrypt": "Неверная парольная фраза", + "sec_incorrect_passphrase_pin_setup": "Неверная парольная фраза", + "sec_incorrect_pin_remove": "Неверный PIN", + "sec_internal_error_change_pin": "Внутренняя ошибка", + "sec_internal_error_remove_pin": "Внутренняя ошибка", + "sec_mode_passphrase": " Парольная фраза", + "sec_not_connected_to_daemon": "Нет соединения с демоном", + "sec_not_connected_to_daemon_pin": "Нет соединения с демоном", + "sec_passphrase_changed_successfully": "Парольная фраза успешно изменена", + "sec_pin_changed_successfully": "PIN успешно изменён", + "sec_pin_removed": "PIN удалён", + "sec_pin_set_successfully": "PIN успешно задан", + "sec_restart_daemon_for_encryption": "Перезапустите демон, чтобы шифрование вступило в силу.", + "sec_too_many_attempts_wait": "Слишком много попыток. Подождите %.0f сек...", + "sec_total_elapsed_fmt": "Всего прошло: %dм %02dс", + "sec_unlock_button": "Разблокировать", + "sec_unlock_failed_prefix": "Ошибка разблокировки: ", + "sec_unlocking_fmt": "Разблокировка%s", + "sec_use_passphrase_instead": "Использовать парольную фразу", + "sec_use_pin_instead": "Использовать PIN", + "sec_verifying_passphrase": "Проверка парольной фразы...", + "sec_verifying_pin": "Проверка PIN...", + "sec_wallet_decrypted_all_keys_imported": "Кошелёк успешно расшифрован! Все ключи импортированы.", + "sec_wallet_encrypted_and_pin_set": "Кошелёк зашифрован, PIN задан", + "sec_wallet_encrypted_but_pin_vault_failed": "Кошелёк зашифрован, но не удалось создать хранилище PIN", + "sec_wallet_encrypted_restarting_daemon": "Кошелёк зашифрован. Перезапуск демона...", + "sec_wallet_encrypted_successfully": "Кошелёк успешно зашифрован", + "sec_wallet_locked_title": "Кошелёк заблокирован", "security": "БЕЗОПАСНОСТЬ", "seed_backup_button": "Сид-фраза", "seed_backup_close": "Закрыть", @@ -1461,6 +1643,17 @@ "sweep_to": "Переведено на:", "sweep_toggle": "Перевести в мой кошелёк (не сохранять ключ)", "sweep_tx": "Транзакция:", + "swin_connection_failed": "Ошибка соединения: ", + "swin_connection_successful": "Соединение установлено!\nВерсия dragonxd: ", + "swin_invalid_suffix": " (неверный)", + "swin_no_history_file_found": "Файл истории не найден", + "swin_rescan_failed": "Ошибка повторного сканирования: ", + "swin_rescan_started_from_block": "Повторное сканирование начато с блока ", + "swin_rescan_to": " до ", + "swin_rpc_client_not_initialized": "RPC-клиент не инициализирован", + "swin_settings_saved": "Настройки сохранены", + "swin_theme_list_refreshed": "Список тем обновлён", + "swin_ztx_history_cleared": "История Z-транзакций очищена", "switch_corrupt_body": "Похоже, этот кошелёк повреждён — узел не смог его открыть. Восстановите из резервной копии, создайте заново или попробуйте восстановить.", "switch_corrupt_repair": "Попробовать восстановить (salvage)", "switch_progress_background": "Продолжить в фоне", diff --git a/res/lang/zh.json b/res/lang/zh.json index f88ae5e..3ece838 100644 --- a/res/lang/zh.json +++ b/res/lang/zh.json @@ -60,6 +60,80 @@ "amount_label": "金额：", "animate_avatars": "动画头像", "appearance": "外观", + "appx_back": "返回", + "appx_back_up_seed_phrase_title": "备份你的助记词", + "appx_birthday_block_height": "生日（区块高度）：%llu — 也请一并备份。", + "appx_blockchain_data_deleted": "区块链数据已删除（%d 项）。守护进程正在重启，以从网络重新同步。", + "appx_blockchain_maintenance_in_progress": "已有区块链维护操作正在进行中。", + "appx_blockchain_rescan_complete": "区块链重新扫描完成", + "appx_bootstrap_complete_reconciling": "引导数据完成——正在将你的钱包与新的链数据进行核对。", + "appx_cancel": "取消", + "appx_cleaning_up": "正在清理…", + "appx_confirm_your_backup": "确认你的备份", + "appx_copied_clipboard_autoclears": "已复制——剪贴板将在 45 秒后自动清空", + "appx_copy": "复制", + "appx_could_not_start_restore": "无法开始恢复", + "appx_create_failed_prefix": "创建失败：", + "appx_creating_your_wallet": "正在创建你的钱包…", + "appx_daemon_error": "守护进程错误", + "appx_daemon_reinstall_in_progress": "守护进程重新安装已在进行中。", + "appx_disconnecting": "正在断开连接…", + "appx_done": "完成", + "appx_dragonxd_output": "dragonxd 输出", + "appx_encrypting_wallet": "正在加密钱包…", + "appx_fullnode_lifecycle_unavailable_lite": "全节点生命周期操作在轻量版中不可用", + "appx_installing_bundled_daemon": "正在安装捆绑守护进程——节点将停止、更新并重启…", + "appx_invalid_payment_uri_prefix": "无效的支付 URI：", + "appx_ive_written_it_down": "我已抄写完毕", + "appx_keep_node_running_and_quit": "保持节点运行并退出", + "appx_last_block_n": "最新区块：%d", + "appx_last_used_wallet_not_found_prefix": "找不到你上次使用的钱包文件（", + "appx_last_used_wallet_not_found_suffix": "）——已改为打开默认钱包。如果你移动了它，请恢复该文件，然后从钱包列表中切换回来。", + "appx_low_spec_mode_disabled": "已禁用低配模式", + "appx_low_spec_mode_enabled": "已启用低配模式", + "appx_miner_stopped_prefix": "矿工已停止：", + "appx_miner_stopped_unexpectedly": "矿工意外停止。", + "appx_n_min_n_sec": "%d 分 %d 秒", + "appx_n_seconds": "%d 秒", + "appx_no_bundled_daemon_to_install": "此版本没有可安装的捆绑守护进程", + "appx_no_embedded_daemon_to_install": "此版本没有可安装的内嵌守护进程", + "appx_node_busy_restarting": "节点正忙于重启——请稍后再试。", + "appx_node_rebuilding_witness_cache": "节点正在重建其见证缓存", + "appx_not_next_word": " — 这不是下一个词", + "appx_payment_request_loaded": "支付请求已加载", + "appx_pool_miner_connected_and_hashing": "矿池矿工已连接并正在计算哈希。", + "appx_progress_n_of_n": "进度：%d / %d", + "appx_rebuilding_sapling_note_witnesses": "正在重建 Sapling 票据见证…", + "appx_rebuilding_witness_cache_blocks_left": "正在重建见证缓存 %.0f%% —— 剩余 %d 个区块", + "appx_rebuilding_witness_cache_pct": "正在重建见证缓存 %.0f%%", + "appx_recovery_phrase_word_count": "助记词应为 24 个——你输入了 %d 个。", + "appx_restarting_daemon_rescan_flag": "正在以 -rescan 标志重启守护进程…", + "appx_restarting_daemon_zapwallettxes": "正在以 -zapwallettxes=2 重启守护进程（钱包修复）…", + "appx_restoring_your_wallet": "正在恢复你的钱包…", + "appx_seed_backup_warning": "这 24 个词是恢复钱包的唯一方式。请按顺序抄写、离线保存，切勿泄露给他人。一旦丢失，你的资金将永远无法找回。", + "appx_seed_not_backed_up_warning": "你尚未备份助记词——资金可能丢失。仍要跳过吗？", + "appx_sending_stop_command_to_daemon": "正在向守护进程发送停止命令…", + "appx_setting_initial_sapling_witnesses": "正在设置初始 Sapling 见证 %.0f%%", + "appx_shutdown_complete": "关闭完成", + "appx_simple_background_disabled": "已禁用简约背景", + "appx_simple_background_enabled": "已启用简约背景", + "appx_skip": "跳过", + "appx_skip_anyway": "仍要跳过", + "appx_still_status_prefix": "仍处于“", + "appx_still_status_suffix": "”——现在强制退出可能损坏链数据。", + "appx_stop_anyway_and_quit": "仍要停止并退出", + "appx_stopping_daemon_deleting_blockchain": "正在停止守护进程并删除区块链数据…", + "appx_stopping_node_discards_rebuild": "现在停止节点会丢弃正在进行的重建，下次打开钱包时将重新开始（需要几分钟）。你也可以让节点继续运行。", + "appx_stopping_pool_miner": "正在停止矿池矿工…", + "appx_syncing_pct_block_n_of_n": "正在同步 %.1f%% —— 区块 %d / %d", + "appx_tap_words_in_order": "按正确顺序点击这些词，以确认你已保存。", + "appx_theme_effects_disabled": "已禁用主题特效", + "appx_theme_effects_enabled": "已启用主题特效", + "appx_theme_prefix": "主题：", + "appx_use_settings_restart_daemon_hint": "请使用 设置 > 重启守护进程 重试", + "appx_waiting_for_daemon_to_encrypt_wallet": "正在等待守护进程加密钱包…", + "appx_wallet_created_and_backed_up": "钱包已创建并完成备份。", + "appx_wallet_open_failed_prefix": "钱包打开失败：", "auto_shield": "自动屏蔽挖矿", "av_intro": "挖矿软件经常被标记为潜在有害程序。请按照以下步骤启用矿池挖矿：", "av_open_security": "打开 Windows 安全中心", @@ -100,6 +174,17 @@ "balance_shielded_fmt": "屏蔽：%.8f", "balance_syncing_pct": "同步中 %.1f%%", "balance_transparent_fmt": "透明：%.8f", + "baltab_market": "市价", + "baltab_market_price_4dp": "市价：$%.4f", + "baltab_market_price_8dp": "市价：$%.8f", + "baltab_pct_change_24h": "%s%.1f%% 24小时", + "baltab_pct_of_total_zaddr": "占总额 %.0f%% · %d 个 Z-addr", + "baltab_shielded": "隐蔽", + "baltab_shielded_amount": "隐蔽 %.8f", + "baltab_t_addresses_count": "%d 个 T-address", + "baltab_total_balance": "总余额", + "baltab_transparent": "透明", + "baltab_transparent_amount": "透明 %.8f", "ban": "封禁", "banned_peers": "已封禁节点", "block": "区块", @@ -414,6 +499,7 @@ "contacts_shape_square": "方形", "contacts_shape_tab": "左标签", "copied": "已复制！", + "copied_to_clipboard": "已复制到剪贴板", "copy": "复制", "copy_address": "复制完整地址", "copy_error": "复制错误", @@ -593,6 +679,63 @@ "general": "常规", "generating": "正在生成", "go_to_receive": "前往接收", + "grpa_current_block_paren": "（当前：%d）", + "grpa_days_ago": "%lld 天前", + "grpa_dbg_addrman": "对等节点地址追踪与管理", + "grpa_dbg_alert": "警报系统消息", + "grpa_dbg_bench": "操作的基准计时", + "grpa_dbg_coindb": "币数据库读写操作", + "grpa_dbg_db": "Berkeley DB 操作", + "grpa_dbg_estimatefee": "手续费估算算法", + "grpa_dbg_http": "HTTP RPC 服务器活动", + "grpa_dbg_libevent": "Libevent 网络库", + "grpa_dbg_lock": "锁竞争调试", + "grpa_dbg_mempool": "交易内存池活动", + "grpa_dbg_net": "网络连接与消息", + "grpa_dbg_paymentdisclosure": "支付披露协议", + "grpa_dbg_pow": "工作量证明挖矿活动", + "grpa_dbg_proxy": "SOCKS5 代理连接", + "grpa_dbg_prune": "区块修剪操作", + "grpa_dbg_rand": "随机数生成", + "grpa_dbg_reindex": "区块链重新索引进度", + "grpa_dbg_rpc": "RPC 命令处理", + "grpa_dbg_selectcoins": "交易的币选择", + "grpa_dbg_tor": "Tor 集成与线路信息", + "grpa_dbg_zmq": "ZeroMQ 通知系统", + "grpa_dbg_zrpc": "隐蔽（z-addr）RPC 操作", + "grpa_enter_private_key_to_import": "请输入要导入的私钥。", + "grpa_error_prefix": "错误：", + "grpa_hr_ago": "%lld 小时前", + "grpa_invalid_response_from_daemon": "守护进程返回了无效响应", + "grpa_invalid_suffix": "（无效）", + "grpa_min_ago": "%lld 分钟前", + "grpa_sec_ago": "%lld 秒前", + "grpa_seed_demo_chat": "种子演示聊天", + "grpa_showing_first_100_of": "…显示 %d 项中的前 100 项", + "grpa_tab_about": "关于", + "grpa_tab_appearance": "外观", + "grpa_tab_backup_data": "备份与数据", + "grpa_tab_chat": "聊天", + "grpa_tab_explorer": "浏览器", + "grpa_tab_node_security": "节点与安全", + "grpa_tab_wallet": "钱包", + "grpa_unexpected_getblockhash_result": "意外的 getblockhash 结果", + "grpb_copy": "复制", + "grpb_max": "最大", + "grpb_new_badge_suffix": " [新]", + "grpb_preview_msg_payment_through": "付款到账了吗？🙂", + "grpb_preview_msg_sending_rest": "现在把剩下的发过去 👍", + "grpb_preview_msg_yep_confirmed": "到了——刚刚确认 ✅", + "grpb_selected_suffix": "\n（已选）", + "grpb_tooltip_address_balance": "%s\n余额：%.8f %s%s", + "grpb_undo_clear": "撤销清除", + "grpc_benchmark_inconclusive": "基准测试无结果：未记录到任何算力样本。请检查矿池连接后重试。", + "grpc_benchmark_takes_secs": "基准测试约需 %d 秒并会中断挖矿。再次点击以开始。", + "grpc_bootstrap_failed": "引导失败", + "grpc_bootstrap_not_initialized": "引导未初始化", + "grpc_hashrate_fee": "%s %s%% 手续费", + "grpc_key_not_available": "此地址无可用密钥", + "grpc_na": "不适用", "height": "高度", "help": "帮助", "hidden_tag": " (已隐藏)", @@ -1238,6 +1381,45 @@ "screenshot_sweep_full": "完整 UI 遍历", "search_icons": "搜索图标...", "search_placeholder": "搜索...", + "sec_changing_passphrase": "正在更改密码短语…", + "sec_changing_pin": "正在更改 PIN…", + "sec_couldnt_lock_wallet": "无法锁定钱包——它仍处于解锁状态。请检查守护进程连接。", + "sec_encrypted_backup_suffix": "\n加密备份：wallet.dat.encrypted.bak", + "sec_encrypting_wallet": "正在加密钱包…", + "sec_encryption_did_not_complete": "钱包加密未完成——你的钱包尚未加密。请打开设置以完成加密。", + "sec_encryption_failed_prefix": "加密失败：", + "sec_failed_prefix": "失败：", + "sec_failed_to_create_vault": "创建保险库失败", + "sec_importing_keys_rescanning": "正在导入密钥并重新扫描区块链——期间钱包仍可使用", + "sec_incorrect_current_pin": "当前 PIN 错误", + "sec_incorrect_passphrase_decrypt": "密码短语错误", + "sec_incorrect_passphrase_pin_setup": "密码短语错误", + "sec_incorrect_pin_remove": "PIN 错误", + "sec_internal_error_change_pin": "内部错误", + "sec_internal_error_remove_pin": "内部错误", + "sec_mode_passphrase": " 密码短语", + "sec_not_connected_to_daemon": "未连接到守护进程", + "sec_not_connected_to_daemon_pin": "未连接到守护进程", + "sec_passphrase_changed_successfully": "密码短语更改成功", + "sec_pin_changed_successfully": "PIN 更改成功", + "sec_pin_removed": "PIN 已移除", + "sec_pin_set_successfully": "PIN 设置成功", + "sec_restart_daemon_for_encryption": "请重启守护进程以使加密生效。", + "sec_too_many_attempts_wait": "尝试次数过多。请等待 %.0f 秒…", + "sec_total_elapsed_fmt": "总耗时：%d 分 %02d 秒", + "sec_unlock_button": "解锁", + "sec_unlock_failed_prefix": "解锁失败：", + "sec_unlocking_fmt": "正在解锁%s", + "sec_use_passphrase_instead": "改用密码短语", + "sec_use_pin_instead": "改用 PIN", + "sec_verifying_passphrase": "正在验证密码短语…", + "sec_verifying_pin": "正在验证 PIN…", + "sec_wallet_decrypted_all_keys_imported": "钱包解密成功！所有密钥已导入。", + "sec_wallet_encrypted_and_pin_set": "钱包已加密并已设置 PIN", + "sec_wallet_encrypted_but_pin_vault_failed": "钱包已加密，但 PIN 保险库创建失败", + "sec_wallet_encrypted_restarting_daemon": "钱包已加密。正在重启守护进程…", + "sec_wallet_encrypted_successfully": "钱包加密成功", + "sec_wallet_locked_title": "钱包已锁定", "security": "安全", "seed_backup_button": "助记词", "seed_backup_close": "关闭", @@ -1459,6 +1641,17 @@ "sweep_to": "归集到：", "sweep_toggle": "归集到我的钱包（不保留密钥）", "sweep_tx": "交易：", + "swin_connection_failed": "连接失败：", + "swin_connection_successful": "连接成功！\ndragonxd 版本：", + "swin_invalid_suffix": "（无效）", + "swin_no_history_file_found": "未找到历史文件", + "swin_rescan_failed": "重新扫描失败：", + "swin_rescan_started_from_block": "重新扫描已开始，起始区块 ", + "swin_rescan_to": " 至 ", + "swin_rpc_client_not_initialized": "RPC 客户端未初始化", + "swin_settings_saved": "设置已保存", + "swin_theme_list_refreshed": "主题列表已刷新", + "swin_ztx_history_cleared": "Z 交易历史已清除", "switch_corrupt_body": "此钱包似乎已损坏——节点无法打开它。请从备份恢复、重新创建，或尝试修复。", "switch_corrupt_repair": "尝试修复（salvage）", "switch_progress_background": "在后台继续", diff --git a/src/util/i18n.cpp b/src/util/i18n.cpp index 44c520b..352c006 100644 --- a/src/util/i18n.cpp +++ b/src/util/i18n.cpp @@ -730,6 +730,7 @@ void I18n::loadBuiltinEnglish() strings_["tt_tor"] = "Route daemon connections through the Tor network for anonymity"; strings_["tt_keep_daemon"] = "Daemon will still stop when running the setup wizard"; strings_["tt_stop_external"] = "Applies when connecting to a daemon\nyou started outside this wallet"; + strings_["stratum_host_section"] = "MINING POOL HOSTING"; strings_["stratum_host"] = "Host a mining pool (stratum)"; strings_["tt_stratum_host"] = "Run a RandomX stratum pool server on this node so other RandomX miners can point at this computer. Requires a v1.3.0+ node and a daemon restart to apply."; strings_["stratum_host_hint"] = "Miners connect to this computer on port 22769 (RPC port + 1000) with a RandomX stratum miner. Restart the daemon to apply."; @@ -1540,6 +1541,175 @@ void I18n::loadBuiltinEnglish() strings_["about_version"] = "Version:"; strings_["about_website"] = "Website"; + // --- Help & FAQ --- + strings_["faq"] = "FAQ"; + strings_["faq_title"] = "Help & FAQ"; + strings_["faq_intro"] = "Answers about your wallet and the DragonX node. Search, or browse by topic below."; + strings_["faq_search_hint"] = "Search the FAQ\xE2\x80\xA6"; + strings_["faq_open_tooltip"] = "Help & FAQ"; + strings_["faq_no_results"] = "No results. Try a different search term."; + strings_["faq_group_wallet"] = "Wallet"; + strings_["faq_group_daemon"] = "Daemon"; + + // Wallet subcategory titles + strings_["faq_w_gs_title"] = "Getting Started"; + strings_["faq_w_addr_title"] = "Addresses & Privacy"; + strings_["faq_w_send_title"] = "Sending & Receiving"; + strings_["faq_w_bal_title"] = "Balance & Sync"; + strings_["faq_w_sec_title"] = "Security & Encryption"; + strings_["faq_w_seed_title"] = "Seed Phrase & Backup"; + strings_["faq_w_chat_title"] = "Chat & Contacts"; + strings_["faq_w_set_title"] = "Settings & Appearance"; + // Daemon subcategory titles + strings_["faq_d_node_title"] = "The Full Node"; + strings_["faq_d_sync_title"] = "Sync & Blockchain"; + strings_["faq_d_mgmt_title"] = "Node Management"; + strings_["faq_d_upd_title"] = "Updating the Node"; + strings_["faq_d_mine_title"] = "Mining & Pools"; + strings_["faq_d_net_title"] = "Peers & Network"; + strings_["faq_d_perf_title"] = "Storage & Performance"; + strings_["faq_d_trbl_title"] = "Troubleshooting"; + + // Wallet > Getting Started + strings_["faq_w_gs_1_q"] = "What is ObsidianDragon?"; + strings_["faq_w_gs_1_a"] = "ObsidianDragon is a full-node wallet for DragonX (DRGX). It manages your coins and, on the desktop build, runs a DragonX full node (the daemon) in the background so your wallet verifies the blockchain itself instead of trusting a third-party server.\n\nThink of it as two parts working together: the wallet (keys, balances, sending) and the node (the blockchain and network). The questions here are split the same way \xE2\x80\x94 see the Wallet and Daemon tabs above."; + strings_["faq_w_gs_2_q"] = "How do I create a new wallet?"; + strings_["faq_w_gs_2_a"] = "On first launch the setup wizard creates a wallet for you automatically. New wallets are backed by a secret recovery phrase (a list of words). Write that phrase down and keep it offline \xE2\x80\x94 it is the only way to restore your funds if this computer is lost.\n\nYou can review or back up the phrase any time from Settings > Backup & Data > Seed phrase."; + strings_["faq_w_gs_3_q"] = "How do I restore a wallet I already have?"; + strings_["faq_w_gs_3_a"] = "Use the seed-phrase restore flow if you have a recovery phrase, or copy an existing wallet.dat file into the wallet's data directory before launch.\n\nAfter restoring, the node re-scans the blockchain to find your past transactions, so your balance and history may take a while to appear the first time."; + strings_["faq_w_gs_4_q"] = "What does the first-run setup do?"; + strings_["faq_w_gs_4_a"] = "The wizard lets you pick an appearance/theme, optionally download a bootstrap to speed up the initial blockchain sync, and set up encryption and a PIN. You can skip any step and change all of these later in Settings."; + + // Wallet > Addresses & Privacy + strings_["faq_w_addr_1_q"] = "What's the difference between transparent and shielded addresses?"; + strings_["faq_w_addr_1_a"] = "Transparent addresses (they start with R or t) work like most coins: the amounts and addresses are public on the blockchain.\n\nShielded addresses (z-addresses, starting with zs) use zero-knowledge cryptography \xE2\x80\x94 the amount, sender, and receiver are encrypted on-chain. Balances held in shielded addresses are private."; + strings_["faq_w_addr_2_q"] = "Which address type should I use?"; + strings_["faq_w_addr_2_a"] = "Prefer shielded (z) addresses whenever possible \xE2\x80\x94 they keep your balance and payment history private. DragonX is a privacy coin and shielded is the default for received funds.\n\nUse a transparent address only when a service you interact with cannot handle shielded addresses."; + strings_["faq_w_addr_3_q"] = "Should I reuse an address or make a new one?"; + strings_["faq_w_addr_3_a"] = "For shielded addresses, reuse is fine and does not leak history. For transparent addresses, using a fresh address per payment improves privacy. Create new addresses from the Receive tab."; + strings_["faq_w_addr_4_q"] = "What is 'shielding'?"; + strings_["faq_w_addr_4_a"] = "Shielding moves coins from a transparent address into a shielded one, making them private. Newly mined coins arrive transparent and are shielded for you automatically.\n\nYou can also shield manually from the wallet; a shield is just a special transaction, so it takes a normal confirmation time to complete."; + + // Wallet > Sending & Receiving + strings_["faq_w_send_1_q"] = "How do I send funds?"; + strings_["faq_w_send_1_a"] = "Open the Send tab, paste the recipient's address, enter an amount, and confirm. If the wallet is encrypted you'll be asked to unlock it for the transaction.\n\nSends to shielded addresses are private; sends to transparent addresses are public."; + strings_["faq_w_send_2_q"] = "What fee do I pay?"; + strings_["faq_w_send_2_a"] = "DragonX fees are very low and are set automatically. The fee is shown before you confirm. You do not normally need to change it."; + strings_["faq_w_send_3_q"] = "Can I attach a message to a payment?"; + strings_["faq_w_send_3_a"] = "Yes \xE2\x80\x94 when sending to a shielded (z) address you can include an encrypted memo. Only the recipient can read it. Transparent addresses do not support memos."; + strings_["faq_w_send_4_q"] = "I sent a payment but it says pending \xE2\x80\x94 why?"; + strings_["faq_w_send_4_a"] = "A transaction is 'pending' until it is mined into a block and gains confirmations. This usually takes a minute or two. Shielded transactions also need the node to be synced to build the proof.\n\nIf a send stays pending unusually long, check that the node is connected and synced (see the status bar at the bottom of the window)."; + + // Wallet > Balance & Sync + strings_["faq_w_bal_1_q"] = "Why is my balance 0 or not updating?"; + strings_["faq_w_bal_1_a"] = "While the node is still syncing the blockchain, your balance is incomplete and may read 0 \xE2\x80\x94 the wallet hasn't scanned all of your transactions yet. It fills in once syncing finishes.\n\nWatch the status bar at the bottom: it shows the connection state and block height. Once the node is synced, your balance is accurate."; + strings_["faq_w_bal_2_q"] = "What are confirmations?"; + strings_["faq_w_bal_2_a"] = "Each new block mined on top of the block containing your transaction adds one confirmation. More confirmations mean the payment is more firmly settled. Received funds become spendable after the first confirmation."; + strings_["faq_w_bal_3_q"] = "What's the difference between total and spendable balance?"; + strings_["faq_w_bal_3_a"] = "Total includes funds that are still confirming or are temporarily locked (for example, coins in the middle of being shielded). Spendable is what you can send right now. They converge as transactions confirm."; + + // Wallet > Security & Encryption + strings_["faq_w_sec_1_q"] = "How do I encrypt my wallet?"; + strings_["faq_w_sec_1_a"] = "Open Settings > Node & Security and set a passphrase (the SECURITY section). Encryption protects your private keys on disk, so someone with access to the files still cannot spend your coins.\n\nChoose a strong passphrase and don't lose it \xE2\x80\x94 there is no way to recover an encrypted wallet without it."; + strings_["faq_w_sec_2_q"] = "What is the PIN / lock screen?"; + strings_["faq_w_sec_2_a"] = "The PIN locks the app's screen so balances and actions are hidden when you step away. It's a convenience lock on top of encryption; you set it up during the wizard or in Settings > Node & Security (encrypt the wallet first)."; + strings_["faq_w_sec_3_q"] = "I forgot my passphrase \xE2\x80\x94 can it be recovered?"; + strings_["faq_w_sec_3_a"] = "No. Wallet encryption cannot be bypassed. If you still have your seed recovery phrase, you can restore the wallet from it into a fresh wallet and set a new passphrase. Without either the passphrase or the seed phrase, the funds cannot be recovered."; + + // Wallet > Seed Phrase & Backup + strings_["faq_w_seed_1_q"] = "How do I back up my recovery phrase?"; + strings_["faq_w_seed_1_a"] = "Go to Settings > Backup & Data > Seed phrase. Write the words down on paper in order and store them somewhere safe and offline. Anyone with the phrase can spend your coins, so never store it in a photo, email, or cloud note."; + strings_["faq_w_seed_2_q"] = "My wallet has no recovery phrase \xE2\x80\x94 can I add one?"; + strings_["faq_w_seed_2_a"] = "Older (legacy) wallets weren't seed-based. The wallet can migrate a legacy wallet into a modern seed-backed one: it creates a new seed wallet and sweeps your funds into it. Look for 'Migrate to seed\xE2\x80\xA6' in Settings > Backup & Data. This feature needs the current daemon version."; + strings_["faq_w_seed_3_q"] = "How do I restore from my recovery phrase?"; + strings_["faq_w_seed_3_a"] = "Use the seed-restore flow when setting up a wallet and enter your words in order. The node then re-scans the chain to rebuild your balance and history, which can take a while the first time."; + strings_["faq_w_seed_4_q"] = "Should I also back up wallet.dat?"; + strings_["faq_w_seed_4_a"] = "Your seed phrase is the primary backup and is enough to restore everything. A copy of the wallet.dat file is a convenient secondary backup that also preserves labels and settings. Keep any backup offline and private."; + + // Wallet > Chat & Contacts + strings_["faq_w_chat_1_q"] = "What is the Chat feature?"; + strings_["faq_w_chat_1_a"] = "Chat is an encrypted, on-chain messenger built into the wallet. Messages are sent as private shielded memos, so only you and your contact can read them."; + strings_["faq_w_chat_2_q"] = "How does my chat identity work?"; + strings_["faq_w_chat_2_a"] = "Your chat identity is derived from your wallet's recovery phrase, so it travels with your wallet \xE2\x80\x94 restore the wallet and your identity comes back. You don't create a separate account or password."; + strings_["faq_w_chat_3_q"] = "How do contacts work?"; + strings_["faq_w_chat_3_a"] = "Add a contact by their address in the Contacts tab, optionally with a name and avatar. Contacts can be kept private to the current wallet or shared across all wallets you open on this computer."; + + // Wallet > Settings & Appearance + strings_["faq_w_set_1_q"] = "How do I change the theme?"; + strings_["faq_w_set_1_a"] = "Open Settings > Appearance to pick a theme and accent. Several light and dark skins are included, and effects like blur can be toggled off for lower-powered machines."; + strings_["faq_w_set_2_q"] = "Can I change the language?"; + strings_["faq_w_set_2_a"] = "Yes \xE2\x80\x94 Settings > Appearance has a language selector. The wallet ships with several translations; anything not yet translated falls back to English."; + strings_["faq_w_set_3_q"] = "The text is too small (or too large) \xE2\x80\x94 can I scale it?"; + strings_["faq_w_set_3_a"] = "Use the font-scale option in Settings > Appearance. It scales the whole interface, which is handy on high-resolution (HiDPI) displays where the app might otherwise render small."; + strings_["faq_w_set_4_q"] = "How do I show fiat prices?"; + strings_["faq_w_set_4_a"] = "Enable price fetching in Settings. The wallet then shows an approximate fiat value alongside balances and can display a small market chart. Prices are informational only."; + + // Daemon > The Full Node + strings_["faq_d_node_1_q"] = "What is the daemon (dragonxd)?"; + strings_["faq_d_node_1_a"] = "The daemon, dragonxd, is the DragonX full node. It downloads and verifies the entire blockchain, relays transactions to the network, and answers the wallet's queries. Running your own node means you don't have to trust anyone else's server."; + strings_["faq_d_node_2_q"] = "Embedded vs external node \xE2\x80\x94 what's the difference?"; + strings_["faq_d_node_2_a"] = "By default the wallet launches and manages its own bundled node (embedded) \xE2\x80\x94 you don't have to do anything. If you already run dragonxd yourself, the wallet can connect to that external node instead. The wallet detects which situation it's in and behaves accordingly."; + strings_["faq_d_node_3_q"] = "Why run a full node at all?"; + strings_["faq_d_node_3_a"] = "A full node validates every rule of the blockchain independently, so your wallet trusts math instead of a third party. It also strengthens the network. The trade-off is disk space and an initial sync."; + + // Daemon > Sync & Blockchain + strings_["faq_d_sync_1_q"] = "What does 'Processing blocks' at startup mean?"; + strings_["faq_d_sync_1_a"] = "On launch the node loads and validates blocks before it can serve the wallet. The 'Processing blocks / Applying blocks to build the current chain state' screen is that warm-up. It's normal; the wallet becomes usable once the node finishes and reports its height."; + strings_["faq_d_sync_2_q"] = "What is 'Rebuilding witness cache'?"; + strings_["faq_d_sync_2_a"] = "For your shielded funds the node keeps cryptographic 'witnesses' that let you spend privately. After certain restarts or updates it rebuilds this cache by re-scanning recent blocks. On a wallet with many transactions this can take several minutes and use extra memory.\n\nIt is not stuck \xE2\x80\x94 let it finish. Force-quitting in the middle just makes it restart the rebuild next time."; + strings_["faq_d_sync_3_q"] = "Why is syncing slow when I'm almost caught up?"; + strings_["faq_d_sync_3_a"] = "Near the chain tip, work that scans your wallet (checking balances and notes) competes with the node for the same internal lock, which can slow down connecting the final blocks on a large wallet. Recent versions throttle that scanning so the node can catch up. Staying on a lighter tab (or just waiting) lets it finish faster."; + strings_["faq_d_sync_4_q"] = "How long does the initial sync take?"; + strings_["faq_d_sync_4_a"] = "The first sync downloads and verifies the whole chain and can take a while depending on your connection and disk. You can speed it up dramatically by enabling the bootstrap download in the setup wizard, which fetches a recent verified copy of the chain data."; + + // Daemon > Node Management + strings_["faq_d_mgmt_1_q"] = "How do I start or stop the node?"; + strings_["faq_d_mgmt_1_a"] = "The embedded node starts automatically with the wallet and stops when appropriate, so you normally don't manage it by hand. Advanced controls (including restarting the daemon) live in Settings > Node & Security."; + strings_["faq_d_mgmt_2_q"] = "What does 'close external daemon on exit' do?"; + strings_["faq_d_mgmt_2_a"] = "If you connect the wallet to a node you started yourself, this option decides whether closing the wallet also shuts that node down. Leave it off if you want your node to keep running after you close the wallet."; + strings_["faq_d_mgmt_3_q"] = "Where is the blockchain and wallet data stored?"; + strings_["faq_d_mgmt_3_a"] = "Node and wallet data live in the DragonX data directory under your user profile (for example, in AppData on Windows or your home folder on Linux/macOS). The blockchain is the large part; keep enough free disk space for it to grow."; + + // Daemon > Updating the Node + strings_["faq_d_upd_1_q"] = "How do I update the node?"; + strings_["faq_d_upd_1_a"] = "Open Settings > Node & Security > Daemon binary and use 'Check for updates\xE2\x80\xA6'. The wallet downloads the latest verified node build and installs it; the new version takes effect the next time the daemon starts."; + strings_["faq_d_upd_2_q"] = "Can I install a specific node version?"; + strings_["faq_d_upd_2_a"] = "Yes \xE2\x80\x94 the update dialog lists every release so you can pick a specific or older build. Be cautious downgrading: an older node may not accept blockchain data written by a newer one and could need a re-index."; + strings_["faq_d_upd_3_q"] = "Is the update safe?"; + strings_["faq_d_upd_3_a"] = "Every downloaded node archive is verified against a checksum and a cryptographic signature before it's installed. If verification fails, the wallet refuses the update."; + + // Daemon > Mining & Pools + strings_["faq_d_mine_1_q"] = "How do I mine DragonX?"; + strings_["faq_d_mine_1_a"] = "The Mining tab lets you mine with your CPU. DragonX uses the RandomX algorithm, which is designed for regular processors. Set the number of threads and start \xE2\x80\x94 rewards accrue to your wallet."; + strings_["faq_d_mine_2_q"] = "Solo vs pool mining \xE2\x80\x94 which should I choose?"; + strings_["faq_d_mine_2_a"] = "Solo mining sends rewards straight to you but pays only when you find a block, which is infrequent unless you have a lot of hashrate. Pool mining shares work with others for smaller, steadier payouts. The Mining tab supports both."; + strings_["faq_d_mine_3_q"] = "How do I update the miner?"; + strings_["faq_d_mine_3_a"] = "The Mining tab's pool section has an 'Update miner\xE2\x80\xA6' button that downloads, verifies, and installs the latest optimized DragonX miner build. Like the node updater, each download is checksum- and signature-verified before install."; + strings_["faq_d_mine_4_q"] = "Can I host a mining pool?"; + strings_["faq_d_mine_4_a"] = "The current node can run a built-in stratum server so other miners can point at your machine. There's a toggle for it under Settings > Node & Security. By default it only listens locally; exposing it to other computers requires opening it up deliberately."; + + // Daemon > Peers & Network + strings_["faq_d_net_1_q"] = "The wallet shows no peers or connections \xE2\x80\x94 what's wrong?"; + strings_["faq_d_net_1_a"] = "Right after launch the node needs a moment to find peers, so a brief '0 peers' is normal. If it persists, check your internet connection and that a firewall isn't blocking the node. The node finds peers automatically through built-in seeds."; + strings_["faq_d_net_2_q"] = "Is my connection to the network encrypted?"; + strings_["faq_d_net_2_a"] = "Yes \xE2\x80\x94 DragonX nodes talk to each other over TLS, so peer connections are encrypted. The wallet also talks to its own node over a secure local channel."; + + // Daemon > Storage & Performance + strings_["faq_d_perf_1_q"] = "How much disk does the node use, and can I tune memory?"; + strings_["faq_d_perf_1_a"] = "The blockchain is the large item and grows over time, so keep several gigabytes free. The node uses a database cache for speed; the bundled defaults are tuned for typical machines. Advanced users can adjust the node's database cache by editing dbcache in its config file (DRAGONX.conf)."; + strings_["faq_d_perf_2_q"] = "How do I make the initial sync faster?"; + strings_["faq_d_perf_2_a"] = "Enable the bootstrap download (offered in the setup wizard) to fetch a recent, verified copy of the chain instead of validating every block from scratch. A fast disk (SSD) also helps a lot."; + + // Daemon > Troubleshooting + strings_["faq_d_trbl_1_q"] = "The node seems stuck on 'Activating best chain' \xE2\x80\x94 is it frozen?"; + strings_["faq_d_trbl_1_a"] = "Usually not. On a large wallet the node can spend several minutes rebuilding shielded witnesses or applying blocks, during which it looks paused and may be slow to answer. Give it time \xE2\x80\x94 the debug log (Settings) shows steady progress if it's working.\n\nAvoid force-quitting during this phase; it restarts the work from scratch next launch."; + strings_["faq_d_trbl_2_q"] = "What is 'degraded mode'?"; + strings_["faq_d_trbl_2_a"] = "If a wallet file is recovered but part of its key data is missing, the node may open it in a limited 'degraded' mode where it can't derive new addresses or shield funds. The safest fix is to restore from your seed recovery phrase into a fresh wallet."; + strings_["faq_d_trbl_3_q"] = "When should I re-index or re-scan?"; + strings_["faq_d_trbl_3_a"] = "A re-scan makes the wallet re-read the chain to rediscover your transactions (useful after importing keys). A re-index rebuilds the node's blockchain database and is only needed if that database is corrupted or incompatible after a version change. Both can take a while; start them from Settings > Node & Security."; + strings_["faq_d_trbl_4_q"] = "The node is using a lot of memory \xE2\x80\x94 is that normal?"; + strings_["faq_d_trbl_4_a"] = "Memory use spikes during heavy work like a witness rebuild or an initial sync, then drops back down once it finishes. Sustained high memory at idle is unusual \xE2\x80\x94 restarting the wallet clears it. On a low-RAM machine, make sure other memory-heavy apps aren't competing."; + // --- Address Book Dialog --- strings_["address_book_add"] = "Add Address"; strings_["address_book_add_new"] = "Add New"; @@ -2354,6 +2524,217 @@ void I18n::loadBuiltinEnglish() strings_["explorer_hash_not_found"] = "No block or transaction found for this hash"; strings_["explorer_not_connected"] = "Not connected to daemon — cannot look up a block or transaction hash"; strings_["explorer_no_results"] = "No matching cached blocks"; + + // ---- i18n audit 2026-09: wrap previously-hardcoded UI strings ---- + // app_security.cpp — encryption / PIN / lock flow + strings_["sec_restart_daemon_for_encryption"] = "Please restart your daemon for encryption to take effect."; + strings_["sec_encrypting_wallet"] = "Encrypting wallet..."; + strings_["sec_wallet_encrypted_restarting_daemon"] = "Wallet encrypted. Restarting daemon..."; + strings_["sec_wallet_encrypted_successfully"] = "Wallet encrypted successfully"; + strings_["sec_encryption_failed_prefix"] = "Encryption failed: "; + strings_["sec_wallet_encrypted_and_pin_set"] = "Wallet encrypted & PIN set"; + strings_["sec_wallet_encrypted_but_pin_vault_failed"] = "Wallet encrypted but PIN vault failed"; + strings_["sec_couldnt_lock_wallet"] = "Couldn't lock the wallet — it is still unlocked. Check the daemon connection."; + strings_["sec_changing_passphrase"] = "Changing passphrase..."; + strings_["sec_passphrase_changed_successfully"] = "Passphrase changed successfully"; + strings_["sec_failed_prefix"] = "Failed: "; + strings_["sec_encryption_did_not_complete"] = "Wallet encryption did not complete — your wallet is NOT encrypted. Open Settings to finish encrypting it."; + strings_["sec_wallet_locked_title"] = "Wallet Locked"; + strings_["sec_too_many_attempts_wait"] = "Too many attempts. Wait %.0f seconds..."; + strings_["sec_mode_passphrase"] = " Passphrase"; + strings_["sec_use_passphrase_instead"] = "Use passphrase instead"; + strings_["sec_use_pin_instead"] = "Use PIN instead"; + strings_["sec_unlocking_fmt"] = "Unlocking%s"; + strings_["sec_unlock_button"] = "Unlock"; + strings_["sec_not_connected_to_daemon"] = "Not connected to daemon"; + strings_["sec_unlock_failed_prefix"] = "Unlock failed: "; + strings_["sec_incorrect_passphrase_decrypt"] = "Incorrect passphrase"; + strings_["sec_importing_keys_rescanning"] = "Importing keys & rescanning blockchain — wallet is usable while this runs"; + strings_["sec_encrypted_backup_suffix"] = "\nEncrypted backup: wallet.dat.encrypted.bak"; + strings_["sec_wallet_decrypted_all_keys_imported"] = "Wallet decrypted successfully! All keys imported."; + strings_["sec_total_elapsed_fmt"] = "Total elapsed: %dm %02ds"; + strings_["sec_verifying_passphrase"] = "Verifying passphrase..."; + strings_["sec_incorrect_passphrase_pin_setup"] = "Incorrect passphrase"; + strings_["sec_pin_set_successfully"] = "PIN set successfully"; + strings_["sec_failed_to_create_vault"] = "Failed to create vault"; + strings_["sec_not_connected_to_daemon_pin"] = "Not connected to daemon"; + strings_["sec_changing_pin"] = "Changing PIN..."; + strings_["sec_pin_changed_successfully"] = "PIN changed successfully"; + strings_["sec_incorrect_current_pin"] = "Incorrect current PIN"; + strings_["sec_internal_error_change_pin"] = "Internal error"; + strings_["sec_verifying_pin"] = "Verifying PIN..."; + strings_["sec_pin_removed"] = "PIN removed"; + strings_["sec_incorrect_pin_remove"] = "Incorrect PIN"; + strings_["sec_internal_error_remove_pin"] = "Internal error"; + + // app.cpp — wizard, seed backup, shutdown, daemon/miner lifecycle + strings_["appx_creating_your_wallet"] = "Creating your wallet…"; + strings_["appx_create_failed_prefix"] = "Create failed: "; + strings_["appx_back_up_seed_phrase_title"] = "Back up your seed phrase"; + strings_["appx_seed_backup_warning"] = "These 24 words are the ONLY way to restore your wallet. Write them down in order, store them offline, and never share them. If you lose them, your funds are gone forever."; + strings_["appx_birthday_block_height"] = "Birthday (block height): %llu — back this up too."; + strings_["appx_ive_written_it_down"] = "I've written it down"; + strings_["appx_copy"] = "Copy"; + strings_["appx_skip_anyway"] = "Skip anyway"; + strings_["appx_skip"] = "Skip"; + strings_["appx_seed_not_backed_up_warning"] = "You have not backed up your seed — funds could be lost. Skip anyway?"; + strings_["appx_confirm_your_backup"] = "Confirm your backup"; + strings_["appx_tap_words_in_order"] = "Tap the words in the correct order to confirm you saved them."; + strings_["appx_progress_n_of_n"] = "Progress: %d / %d"; + strings_["appx_not_next_word"] = " — that's not the next word"; + strings_["appx_done"] = "Done"; + strings_["appx_wallet_created_and_backed_up"] = "Wallet created and backed up."; + strings_["appx_back"] = "Back"; + strings_["appx_restoring_your_wallet"] = "Restoring your wallet…"; + strings_["appx_recovery_phrase_word_count"] = "Recovery phrase should be 24 words — you have %d."; + strings_["appx_could_not_start_restore"] = "Could not start restore"; + strings_["appx_node_rebuilding_witness_cache"] = "Node is rebuilding its witness cache"; + strings_["appx_stopping_node_discards_rebuild"] = "Stopping the node now discards the in-progress rebuild and restarts it (several minutes) the next time you open the wallet. You can keep the node running instead."; + strings_["appx_keep_node_running_and_quit"] = "Keep node running & quit"; + strings_["appx_stop_anyway_and_quit"] = "Stop anyway & quit"; + strings_["appx_cancel"] = "Cancel"; + strings_["appx_last_used_wallet_not_found_prefix"] = "Your last-used wallet file ("; + strings_["appx_last_used_wallet_not_found_suffix"] = ") was not found — opened the default wallet instead. If you moved it, restore it and switch back from the wallet list."; + strings_["appx_wallet_open_failed_prefix"] = "Wallet open failed: "; + strings_["appx_blockchain_rescan_complete"] = "Blockchain rescan complete"; + strings_["appx_miner_stopped_unexpectedly"] = "Miner stopped unexpectedly."; + strings_["appx_miner_stopped_prefix"] = "Miner stopped: "; + strings_["appx_pool_miner_connected_and_hashing"] = "Pool miner connected and hashing."; + strings_["appx_bootstrap_complete_reconciling"] = "Bootstrap complete — reconciling your wallet with the new chain data."; + strings_["appx_blockchain_data_deleted"] = "Blockchain data deleted (%d items). The daemon is restarting to re-sync from the network."; + strings_["appx_invalid_payment_uri_prefix"] = "Invalid payment URI: "; + strings_["appx_payment_request_loaded"] = "Payment request loaded"; + strings_["appx_fullnode_lifecycle_unavailable_lite"] = "Full-node lifecycle actions are unavailable in lite build"; + strings_["appx_blockchain_maintenance_in_progress"] = "A blockchain maintenance operation is already in progress."; + strings_["appx_node_busy_restarting"] = "The node is busy restarting — try again in a moment."; + strings_["appx_restarting_daemon_rescan_flag"] = "Restarting daemon with -rescan flag..."; + strings_["appx_restarting_daemon_zapwallettxes"] = "Restarting daemon with -zapwallettxes=2 (wallet repair)..."; + strings_["appx_no_bundled_daemon_to_install"] = "This build has no bundled daemon to install"; + strings_["appx_no_embedded_daemon_to_install"] = "This build has no embedded daemon to install"; + strings_["appx_daemon_reinstall_in_progress"] = "The daemon reinstall is already in progress."; + strings_["appx_installing_bundled_daemon"] = "Installing bundled daemon — the node will stop, update, and restart..."; + strings_["appx_stopping_daemon_deleting_blockchain"] = "Stopping daemon and deleting blockchain data..."; + strings_["appx_stopping_pool_miner"] = "Stopping pool miner..."; + strings_["appx_disconnecting"] = "Disconnecting..."; + strings_["appx_sending_stop_command_to_daemon"] = "Sending stop command to daemon..."; + strings_["appx_cleaning_up"] = "Cleaning up..."; + strings_["appx_shutdown_complete"] = "Shutdown complete"; + strings_["appx_n_seconds"] = "%d seconds"; + strings_["appx_n_min_n_sec"] = "%d min %d sec"; + strings_["appx_still_status_prefix"] = "Still \""; + strings_["appx_still_status_suffix"] = "\" — force quitting now may corrupt chain data."; + strings_["appx_rebuilding_witness_cache_blocks_left"] = "Rebuilding witness cache %.0f%% — %d blocks left"; + strings_["appx_rebuilding_witness_cache_pct"] = "Rebuilding witness cache %.0f%%"; + strings_["appx_setting_initial_sapling_witnesses"] = "Setting initial Sapling witnesses %.0f%%"; + strings_["appx_rebuilding_sapling_note_witnesses"] = "Rebuilding Sapling note witnesses…"; + strings_["appx_syncing_pct_block_n_of_n"] = "Syncing %.1f%% — Block %d / %d"; + strings_["appx_last_block_n"] = "Last block: %d"; + strings_["appx_encrypting_wallet"] = "Encrypting wallet..."; + strings_["appx_waiting_for_daemon_to_encrypt_wallet"] = "Waiting for daemon to encrypt wallet..."; + strings_["appx_daemon_error"] = "Daemon Error"; + strings_["appx_use_settings_restart_daemon_hint"] = "Use Settings > Restart Daemon to try again"; + strings_["appx_copied_clipboard_autoclears"] = "Copied — clipboard auto-clears in 45s"; + strings_["appx_dragonxd_output"] = "dragonxd output"; + strings_["appx_theme_prefix"] = "Theme: "; + strings_["appx_low_spec_mode_enabled"] = "Low-spec mode enabled"; + strings_["appx_low_spec_mode_disabled"] = "Low-spec mode disabled"; + strings_["appx_theme_effects_enabled"] = "Theme effects enabled"; + strings_["appx_theme_effects_disabled"] = "Theme effects disabled"; + strings_["appx_simple_background_enabled"] = "Simple background enabled"; + strings_["appx_simple_background_disabled"] = "Simple background disabled"; + + // balance_tab.cpp + strings_["baltab_shielded_amount"] = "Shielded %.8f"; + strings_["baltab_transparent_amount"] = "Transparent %.8f"; + strings_["baltab_market_price_4dp"] = "Market: $%.4f"; + strings_["baltab_market_price_8dp"] = "Market: $%.8f"; + strings_["baltab_pct_of_total_zaddr"] = "%.0f%% of total · %d Z-addr"; + strings_["baltab_t_addresses_count"] = "%d T-addresses"; + strings_["baltab_pct_change_24h"] = "%s%.1f%% 24h"; + strings_["baltab_total_balance"] = "Total Balance"; + strings_["baltab_shielded"] = "Shielded"; + strings_["baltab_transparent"] = "Transparent"; + strings_["baltab_market"] = "Market"; + + // settings_window.cpp + strings_["swin_invalid_suffix"] = " (invalid)"; + strings_["swin_theme_list_refreshed"] = "Theme list refreshed"; + strings_["swin_connection_successful"] = "Connection successful!\ndragonxd version: "; + strings_["swin_connection_failed"] = "Connection failed: "; + strings_["swin_rpc_client_not_initialized"] = "RPC client not initialized"; + strings_["swin_rescan_started_from_block"] = "Rescan started from block "; + strings_["swin_rescan_to"] = " to "; + strings_["swin_rescan_failed"] = "Rescan failed: "; + strings_["swin_ztx_history_cleared"] = "Z-transaction history cleared"; + strings_["swin_no_history_file_found"] = "No history file found"; + strings_["swin_settings_saved"] = "Settings saved"; + + // settings_page.cpp / explorer_tab.cpp / block_info_dialog.cpp + strings_["grpa_tab_appearance"] = "Appearance"; + strings_["grpa_tab_wallet"] = "Wallet"; + strings_["grpa_tab_backup_data"] = "Backup & Data"; + strings_["grpa_tab_node_security"] = "Node & Security"; + strings_["grpa_tab_explorer"] = "Explorer"; + strings_["grpa_tab_chat"] = "Chat"; + strings_["grpa_tab_about"] = "About"; + strings_["grpa_enter_private_key_to_import"] = "Enter a private key to import."; + strings_["grpa_invalid_suffix"] = " (invalid)"; + strings_["grpa_seed_demo_chat"] = "Seed demo chat"; + strings_["grpa_dbg_addrman"] = "Peer address tracking and management"; + strings_["grpa_dbg_alert"] = "Alert system messages"; + strings_["grpa_dbg_bench"] = "Benchmark timings for operations"; + strings_["grpa_dbg_coindb"] = "Coin database read/write operations"; + strings_["grpa_dbg_db"] = "Berkeley DB operations"; + strings_["grpa_dbg_estimatefee"] = "Fee estimation algorithm"; + strings_["grpa_dbg_http"] = "HTTP RPC server activity"; + strings_["grpa_dbg_libevent"] = "Libevent networking library"; + strings_["grpa_dbg_lock"] = "Lock contention debugging"; + strings_["grpa_dbg_mempool"] = "Transaction memory pool activity"; + strings_["grpa_dbg_net"] = "Network connections and messages"; + strings_["grpa_dbg_paymentdisclosure"] = "Payment disclosure protocol"; + strings_["grpa_dbg_pow"] = "Proof-of-work mining activity"; + strings_["grpa_dbg_proxy"] = "SOCKS5 proxy connections"; + strings_["grpa_dbg_prune"] = "Block pruning operations"; + strings_["grpa_dbg_rand"] = "Random number generation"; + strings_["grpa_dbg_reindex"] = "Blockchain reindexing progress"; + strings_["grpa_dbg_rpc"] = "RPC command processing"; + strings_["grpa_dbg_selectcoins"] = "Coin selection for transactions"; + strings_["grpa_dbg_tor"] = "Tor integration and circuit info"; + strings_["grpa_dbg_zmq"] = "ZeroMQ notification system"; + strings_["grpa_dbg_zrpc"] = "Shielded (z-addr) RPC operations"; + strings_["grpa_sec_ago"] = "%lld sec ago"; + strings_["grpa_min_ago"] = "%lld min ago"; + strings_["grpa_hr_ago"] = "%lld hr ago"; + strings_["grpa_days_ago"] = "%lld days ago"; + strings_["grpa_showing_first_100_of"] = "... showing first 100 of %d"; + strings_["grpa_error_prefix"] = "Error: "; + strings_["grpa_invalid_response_from_daemon"] = "Invalid response from daemon"; + strings_["grpa_current_block_paren"] = "(Current: %d)"; + strings_["grpa_unexpected_getblockhash_result"] = "unexpected getblockhash result"; + + // receive / chat / send / transaction_details + strings_["grpb_new_badge_suffix"] = " [NEW]"; + strings_["grpb_tooltip_address_balance"] = "%s\nBalance: %.8f %s%s"; + strings_["grpb_selected_suffix"] = "\n(selected)"; + strings_["grpb_preview_msg_payment_through"] = "Did the payment go through? 🙂"; + strings_["grpb_preview_msg_yep_confirmed"] = "Yep — just confirmed ✅"; + strings_["grpb_preview_msg_sending_rest"] = "Sending the rest now 👍"; + strings_["grpb_max"] = "Max"; + strings_["grpb_undo_clear"] = "Undo Clear"; + strings_["grpb_copy"] = "Copy"; + + // bootstrap / mining_* / key_export + strings_["grpc_bootstrap_not_initialized"] = "Bootstrap not initialized"; + strings_["grpc_bootstrap_failed"] = "Bootstrap failed"; + strings_["grpc_na"] = "N/A"; + strings_["grpc_key_not_available"] = "Key not available for this address"; + strings_["grpc_benchmark_takes_secs"] = "Benchmark takes ~%ds and interrupts mining. Click again to start."; + strings_["grpc_hashrate_fee"] = "%s %s%% fee"; + strings_["grpc_benchmark_inconclusive"] = "Benchmark inconclusive: no hashrate samples were recorded. Check the pool connection and try again."; + + // misc pre-existing missing keys + strings_["copied_to_clipboard"] = "Copied to clipboard"; + } const char* I18n::translate(const char* key) const From d27f387d6d34ddcf989abbd3676312ba429a964b Mon Sep 17 00:00:00 2001 From: DanS Date: Tue, 1 Sep 2026 19:37:16 -0500 Subject: [PATCH 83/89] feat(ui): in-app FAQ, DPI-scaling audit fixes, mining/stratum polish + localize strings Bundles the session's UI work (the touched files carry several of these changes together, so they are committed as one coherent UI batch): - FAQ: new RenderFaqDialog + data-driven faq_content, opened from a status-bar "?" (and the Windows title bar), styled like the Wallets modal with search, Wallet/Daemon tabs, and smooth scroll. - DPI/font-scale audit: multiply hand-drawn absolute geometry by Layout::dpiScale() across ~30 files so nothing renders native-size at HiDPI / font_scale 1.5 (verified with a full sweep at 1.5x). - Mining: chart now fills the horizontal space; thread stepper +/- buttons match the input-box height; move the stratum-host toggle into Node & Security (v1.3.0+). - Settings: fix the auto-shield status text overlapping the grid. - Sidebar: drop the peer-count badge on the Network button. - i18n: wrap 193 hardcoded literals with TR() (keys/translations added in the preceding i18n commit), so the security/PIN/lock flow, seed-backup wizard, and witness-rebuild dialog localize. Co-Authored-By: Claude Opus 4.8 (1M context) --- CMakeLists.txt | 4 + res/themes/ui.toml | 5 + src/app.cpp | 266 ++++++++++-------- src/app.h | 21 ++ src/app_security.cpp | 89 +++--- src/app_sweep.cpp | 15 + src/ui/effects/theme_effects.cpp | 20 +- src/ui/material/draw_helpers.h | 21 +- src/ui/pages/settings_page.cpp | 139 +++++---- src/ui/sidebar.h | 16 +- src/ui/windows/address_transfer_dialog.h | 5 +- src/ui/windows/balance_components.cpp | 2 +- src/ui/windows/balance_tab.cpp | 102 +++---- src/ui/windows/block_info_dialog.cpp | 8 +- src/ui/windows/bootstrap_download_dialog.h | 4 +- src/ui/windows/chat_tab.cpp | 6 +- src/ui/windows/console_tab.cpp | 2 +- src/ui/windows/explorer_tab.cpp | 12 +- src/ui/windows/faq_content.cpp | 115 ++++++++ src/ui/windows/faq_content.h | 41 +++ src/ui/windows/faq_dialog.cpp | 201 +++++++++++++ src/ui/windows/faq_dialog.h | 18 ++ src/ui/windows/key_export_dialog.cpp | 11 +- src/ui/windows/market_tab.cpp | 6 +- src/ui/windows/mining_controls.cpp | 9 +- src/ui/windows/mining_earnings.cpp | 4 +- src/ui/windows/mining_stats.cpp | 9 +- src/ui/windows/mining_tab.cpp | 3 +- src/ui/windows/peers_tab.cpp | 8 +- src/ui/windows/receive_tab.cpp | 22 +- src/ui/windows/send_tab.cpp | 15 +- src/ui/windows/settings_window.cpp | 24 +- src/ui/windows/transaction_details_dialog.cpp | 4 +- src/ui/windows/transactions_tab.cpp | 4 +- src/ui/windows/wallets_dialog.h | 2 +- 35 files changed, 867 insertions(+), 366 deletions(-) create mode 100644 src/ui/windows/faq_content.cpp create mode 100644 src/ui/windows/faq_content.h create mode 100644 src/ui/windows/faq_dialog.cpp create mode 100644 src/ui/windows/faq_dialog.h diff --git a/CMakeLists.txt b/CMakeLists.txt index ba26f5d..f48d852 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -521,6 +521,8 @@ set(APP_SOURCES src/ui/windows/settings_window.cpp src/ui/pages/settings_page.cpp src/ui/windows/about_dialog.cpp + src/ui/windows/faq_dialog.cpp + src/ui/windows/faq_content.cpp src/ui/windows/key_export_dialog.cpp src/ui/windows/transaction_details_dialog.cpp src/ui/windows/qr_popup_dialog.cpp @@ -657,6 +659,8 @@ set(APP_HEADERS src/ui/windows/console_tab_helpers.h src/ui/windows/settings_window.h src/ui/windows/about_dialog.h + src/ui/windows/faq_dialog.h + src/ui/windows/faq_content.h src/ui/windows/key_export_dialog.h src/ui/windows/transaction_details_dialog.h src/ui/windows/qr_popup_dialog.h diff --git a/res/themes/ui.toml b/res/themes/ui.toml index ef6cbee..f9cc512 100644 --- a/res/themes/ui.toml +++ b/res/themes/ui.toml @@ -965,6 +965,11 @@ edition-label = { position = 120 } link-button = { width = 100, font = "button-sm" } close-button = { width = 120, font = "button", align = "center" } +[dialogs.faq] +width = 860.0 +height = 660.0 +window = { width = 860, height = 660 } + [dialogs.settings] width = 600.0 height = 550.0 diff --git a/src/app.cpp b/src/app.cpp index 0843d9c..ee66ec5 100644 --- a/src/app.cpp +++ b/src/app.cpp @@ -37,6 +37,7 @@ #include "ui/windows/market_tab.h" #include "ui/windows/settings_window.h" #include "ui/windows/about_dialog.h" +#include "ui/windows/faq_dialog.h" #include "embedded/IconsMaterialDesign.h" #include "ui/windows/key_export_dialog.h" #include "ui/windows/transaction_details_dialog.h" @@ -410,8 +411,8 @@ bool App::init() settings_->setActiveWalletFile("wallet.dat"); settings_->save(); ui::Notifications::instance().warning( - "Your last-used wallet file (" + active + ") was not found — opened the default wallet " - "instead. If you moved it, restore it and switch back from the wallet list.", 20.0f); + std::string(TR("appx_last_used_wallet_not_found_prefix")) + active + + TR("appx_last_used_wallet_not_found_suffix"), 20.0f); } } } @@ -805,7 +806,7 @@ void App::update() const std::string& err = lite_wallet_->lastOpenError(); if (!err.empty() && err != lite_open_error_) { lite_open_error_ = err; - ui::Notifications::instance().error(std::string("Wallet open failed: ") + err, 8.0f); + ui::Notifications::instance().error(std::string(TR("appx_wallet_open_failed_prefix")) + err, 8.0f); } } // Suppress the status bar's full-node connection-detail line in lite ("" and "Connected" @@ -989,7 +990,7 @@ void App::update() // poll (which hits the still-running pre-restart daemon, rescanning=false) // would fire a false "complete" the instant rescan was clicked. if (user_initiated_rescan_) { - ui::Notifications::instance().success("Blockchain rescan complete"); + ui::Notifications::instance().success(TR("appx_blockchain_rescan_complete")); user_initiated_rescan_ = false; // surfaced once; not for background rebuilds } resetWitnessRescanProgress(); @@ -1027,8 +1028,8 @@ void App::update() state_.pool_mining.hashrate_15m = 0.0; pool_starting_.store(false, std::memory_order_relaxed); const std::string err = xmrig_manager_->getLastError(); - ui::Notifications::instance().error(err.empty() ? "Miner stopped unexpectedly." - : ("Miner stopped: " + err)); + ui::Notifications::instance().error(err.empty() ? TR("appx_miner_stopped_unexpectedly") + : (std::string(TR("appx_miner_stopped_prefix")) + err)); } // Poll xmrig stats every ~2 seconds (use a simple toggle) @@ -1053,7 +1054,7 @@ void App::update() // Pool mining has a connect delay — announce once it's actually connected/hashing. if (pool_starting_.load(std::memory_order_relaxed) && (ps.connected || ps.hashrate_10s > 0.0)) { pool_starting_.store(false, std::memory_order_relaxed); - ui::Notifications::instance().success("Pool miner connected and hashing."); + ui::Notifications::instance().success(TR("appx_pool_miner_connected_and_hashing")); } // Get memory directly from OS (more reliable than API) double memMB = xmrig_manager_->getMemoryUsageMB(); @@ -1095,7 +1096,7 @@ void App::update() const std::string& status = scan.lastStatus; if (scan.finished) { if (state_.sync.rescanning && user_initiated_rescan_) { - ui::Notifications::instance().success("Blockchain rescan complete"); + ui::Notifications::instance().success(TR("appx_blockchain_rescan_complete")); user_initiated_rescan_ = false; // surfaced once; not for background rebuilds } // Witness rebuild finishes with the rescan it's part of. @@ -1301,7 +1302,7 @@ void App::update() !runtime_rescan_active_ && !bootstrap_downloading_ && state_.sync.blocks > 1) { // wait until the tip is known so the probe has a real range post_bootstrap_rescan_pending_ = false; - ui::Notifications::instance().info("Bootstrap complete — reconciling your wallet with the new chain data."); + ui::Notifications::instance().info(TR("appx_bootstrap_complete_reconciling")); detectLowestAvailableBlockHeight([this](bool ok, int lowest, bool fullHistory) { if (ok && !fullHistory) { runtimeRescan(lowest); // bootstrapped/pruned: rescan from the snapshot base @@ -1323,7 +1324,16 @@ void App::update() if (!state_.warming_up && !runtime_rescan_active_) { if (network_refresh_.consumeDue(RefreshTimer::Transactions)) { if (shouldRunWalletTransactionRefresh() && shouldRefreshTransactions()) { - refreshTransactionData(); + // Throttle the routine new-block full history rescan (z_listreceivedbyaddress — + // O(mapWallet), holds cs_main) by its measured cost, so a large wallet doesn't + // re-scan every block and starve connection near the tip. Bypass when there's an + // explicit need: a dirty set, an in-progress multi-cycle shielded scan (which must + // continue to completion), or an in-flight send — all need fresh data immediately. + const bool txExplicitNeed = transactions_dirty_ || shielded_history_scan_pending_ || + hasTransactionSendProgress() || !send_txids_.empty(); + if (txExplicitNeed || txRefreshDue()) { + refreshTransactionData(); + } } else if (walletDataPage && shouldRefreshRecentTransactions()) { refreshRecentTransactionData(); } @@ -1339,7 +1349,13 @@ void App::update() fastScanChatMemos(); } if (network_refresh_.consumeDue(RefreshTimer::Addresses)) { - if (walletDataPage || addresses_dirty_ || hasTransactionSendProgress()) { + // Explicit need (a changed address set, or an in-flight send tracking its change output) + // must refresh now; the routine periodic poll on a wallet page is throttled by the last + // address scan's measured cost (addressRefreshDue) — this is the z_listunspent hammering + // that was starving cs_main while synced on a large wallet. + if (addresses_dirty_ || hasTransactionSendProgress()) { + refreshAddressData(); + } else if (walletDataPage && addressRefreshDue()) { refreshAddressData(); } } @@ -1396,7 +1412,7 @@ void App::handleGlobalShortcuts() settings_->setSkinId(skins[cur].id); settings_->save(); } - ui::Notifications::instance().info("Theme: " + skins[cur].name); + ui::Notifications::instance().info(std::string(TR("appx_theme_prefix")) + skins[cur].name); } } } @@ -1433,7 +1449,7 @@ void App::handleGlobalShortcuts() ui::effects::ThemeEffects::instance().setReducedTransparency(!settings_->getThemeEffectsEnabled()); } } - ui::Notifications::instance().info(newLow ? "Low-spec mode enabled" : "Low-spec mode disabled"); + ui::Notifications::instance().info(newLow ? TR("appx_low_spec_mode_enabled") : TR("appx_low_spec_mode_disabled")); } // Keyboard shortcut: Ctrl+Down to toggle theme effects (Shift excluded) @@ -1445,7 +1461,7 @@ void App::handleGlobalShortcuts() settings_->setThemeEffectsEnabled(newState); settings_->save(); } - ui::Notifications::instance().info(newState ? "Theme effects enabled" : "Theme effects disabled"); + ui::Notifications::instance().info(newState ? TR("appx_theme_effects_enabled") : TR("appx_theme_effects_disabled")); } // Keyboard shortcut: Ctrl+Up to toggle simple gradient background @@ -1454,7 +1470,7 @@ void App::handleGlobalShortcuts() settings_->setGradientBackground(newGrad); ui::schema::SkinManager::instance().setGradientMode(newGrad); settings_->save(); - ui::Notifications::instance().info(newGrad ? "Simple background enabled" : "Simple background disabled"); + ui::Notifications::instance().info(newGrad ? TR("appx_simple_background_enabled") : TR("appx_simple_background_disabled")); } // Debug: Ctrl+Shift+W to re-show first-run wizard (set to false to disable) @@ -1595,8 +1611,9 @@ void App::render() { int deletedN = pending_delete_result_.exchange(-1, std::memory_order_relaxed); if (deletedN >= 0) { - ui::Notifications::instance().success("Blockchain data deleted (" + std::to_string(deletedN) + - " items). The daemon is restarting to re-sync from the network."); + char deletedMsg[160]; + snprintf(deletedMsg, sizeof(deletedMsg), TR("appx_blockchain_data_deleted"), deletedN); + ui::Notifications::instance().success(deletedMsg); } } @@ -2138,6 +2155,10 @@ void App::render() ui::RenderAboutDialog(this, &show_about_); } + if (show_faq_) { + ui::RenderFaqDialog(this, &show_faq_); + } + // Lite first-run welcome: prompt to create/restore when no wallet file exists yet. renderLiteFirstRunPrompt(); // Lite send-time unlock prompt (shown when a spend is attempted on a locked wallet). @@ -2881,6 +2902,31 @@ void App::renderStatusBar() occupiedX = bellX; } + // Help (?) — sits just left of the alert bell, on every platform. A plain, subtle question + // mark (no circle) that opens the FAQ. + { + ImFont* helpFont = ui::material::Type().iconSmall(); + ImGui::PushFont(helpFont); + const float helpGlyphW = ImGui::CalcTextSize(ICON_MD_QUESTION_MARK).x; + ImGui::PopFont(); + const float helpW = helpGlyphW + 10.0f * dp; + const float helpH = helpFont->LegacySize + 4.0f * dp; + const float helpX = occupiedX - helpW - gap; + + ImGui::SameLine(helpX); + ui::material::IconButtonStyle hst; + hst.color = ui::material::OnSurfaceMedium(); + hst.hoverColor = ui::material::OnSurface(); + hst.hoverBg = ui::material::StateHover(); + hst.bgRounding = 4.0f * dp; + hst.tooltip = TR("faq_open_tooltip"); + if (ui::material::IconButton("##HelpFaq", ICON_MD_QUESTION_MARK, helpFont, + ImVec2(helpW, helpH), hst)) { + show_faq_ = true; + } + occupiedX = helpX; + } + // Version always at far right ImGui::SameLine(versionX); ImGui::Text("%s", versionBuf); @@ -3005,7 +3051,8 @@ void App::renderLiteFirstRunPrompt() if (ImGui::BeginPopupModal("##LiteFirstRun", nullptr, ImGuiWindowFlags_AlwaysAutoResize | ImGuiWindowFlags_NoTitleBar)) { - const float btnW = 170.0f; + const float dp = ui::Layout::dpiScale(); + const float btnW = 170.0f * dp; if (step == 0) { // ── Welcome ────────────────────────────────────────────────────────── @@ -3013,7 +3060,7 @@ void App::renderLiteFirstRunPrompt() ImGui::TextUnformatted(TR("lite_welcome_title")); ImGui::PopFont(); ImGui::Spacing(); - ImGui::PushTextWrapPos(ImGui::GetCursorPosX() + 360.0f); + ImGui::PushTextWrapPos(ImGui::GetCursorPosX() + 360.0f * dp); ImGui::TextUnformatted(TR("lite_welcome_msg")); ImGui::PopTextWrapPos(); ImGui::Spacing(); ImGui::Spacing(); @@ -3021,7 +3068,7 @@ void App::renderLiteFirstRunPrompt() if (creating) { // Async create (with server failover) is in flight — driven to completion by // App::update()'s pumpAsyncOpen(). Poll the controller for the outcome. - ImGui::TextUnformatted("Creating your wallet\xE2\x80\xA6"); + ImGui::TextUnformatted(TR("appx_creating_your_wallet")); if (lite_wallet_->walletOpen()) { auto s = lite_wallet_->exportSeed(); // read the new seed back (local, fast) if (s.ok && !s.seedPhrase.empty()) { @@ -3039,7 +3086,7 @@ void App::renderLiteFirstRunPrompt() } else if (!lite_wallet_->openInProgress() && !lite_wallet_->lastOpenError().empty()) { ui::Notifications::instance().warning( - std::string("Create failed: ") + lite_wallet_->lastOpenError()); + std::string(TR("appx_create_failed_prefix")) + lite_wallet_->lastOpenError()); creating = false; // back to the buttons so the user can retry } } else { @@ -3065,14 +3112,12 @@ void App::renderLiteFirstRunPrompt() } else if (step == 1) { // ── Reveal the seed + birthday with backup warnings ───────────────────── ImGui::PushFont(ui::material::Type().subtitle1()); - ImGui::TextUnformatted("Back up your seed phrase"); + ImGui::TextUnformatted(TR("appx_back_up_seed_phrase_title")); ImGui::PopFont(); ImGui::Spacing(); - ImGui::PushTextWrapPos(ImGui::GetCursorPosX() + 380.0f); + ImGui::PushTextWrapPos(ImGui::GetCursorPosX() + 380.0f * dp); ImGui::PushStyleColor(ImGuiCol_Text, ui::material::ReadableError()); - ImGui::TextUnformatted("These 24 words are the ONLY way to restore your wallet. " - "Write them down in order, store them offline, and never share " - "them. If you lose them, your funds are gone forever."); + ImGui::TextUnformatted(TR("appx_seed_backup_warning")); ImGui::PopStyleColor(); ImGui::PopTextWrapPos(); ImGui::Spacing(); @@ -3082,17 +3127,17 @@ void App::renderLiteFirstRunPrompt() char cell[96]; snprintf(cell, sizeof(cell), "%2zu. %s", i + 1, words[i].c_str()); ImGui::TextUnformatted(cell); - if ((i % 4) != 3 && i + 1 < words.size()) ImGui::SameLine(((i % 4) + 1) * 130.0f); + if ((i % 4) != 3 && i + 1 < words.size()) ImGui::SameLine(((i % 4) + 1) * 130.0f * dp); } ImGui::Spacing(); char bday[80]; - snprintf(bday, sizeof(bday), "Birthday (block height): %llu — back this up too.", birthday); + snprintf(bday, sizeof(bday), TR("appx_birthday_block_height"), birthday); ImGui::PushStyleColor(ImGuiCol_Text, ui::material::OnSurfaceMedium()); ImGui::TextUnformatted(bday); ImGui::PopStyleColor(); ImGui::Spacing(); ImGui::Spacing(); - if (ui::material::TactileButton("I've written it down", ImVec2(btnW, 0))) { + if (ui::material::TactileButton(TR("appx_ive_written_it_down"), ImVec2(btnW, 0))) { chips.clear(); for (const auto& w : words) chips.emplace_back(w, false); std::mt19937 rng{std::random_device{}()}; @@ -3102,9 +3147,9 @@ void App::renderLiteFirstRunPrompt() step = 2; } ImGui::SameLine(); - if (ui::material::TactileButton("Copy", ImVec2(80, 0))) copySecretToClipboard(seed); + if (ui::material::TactileButton(TR("appx_copy"), ImVec2(80 * dp, 0))) copySecretToClipboard(seed); ImGui::SameLine(); - if (ui::material::TactileButton(skipConfirm ? "Skip anyway" : "Skip", ImVec2(120, 0))) { + if (ui::material::TactileButton(skipConfirm ? TR("appx_skip_anyway") : TR("appx_skip"), ImVec2(120, 0))) { if (!skipConfirm) { skipConfirm = true; // require a second, deliberate click } else { @@ -3116,27 +3161,26 @@ void App::renderLiteFirstRunPrompt() ImGui::Spacing(); ImGui::PushTextWrapPos(ImGui::GetCursorPosX() + 380.0f); ImGui::PushStyleColor(ImGuiCol_Text, ui::material::ReadableError()); - ImGui::TextUnformatted("You have not backed up your seed — funds could be lost. " - "Skip anyway?"); + ImGui::TextUnformatted(TR("appx_seed_not_backed_up_warning")); ImGui::PopStyleColor(); ImGui::PopTextWrapPos(); } } else if (step == 2) { // ── Verify: tap the words in order ────────────────────────────────────── ImGui::PushFont(ui::material::Type().subtitle1()); - ImGui::TextUnformatted("Confirm your backup"); + ImGui::TextUnformatted(TR("appx_confirm_your_backup")); ImGui::PopFont(); ImGui::Spacing(); ImGui::PushTextWrapPos(ImGui::GetCursorPosX() + 380.0f); - ImGui::TextUnformatted("Tap the words in the correct order to confirm you saved them."); + ImGui::TextUnformatted(TR("appx_tap_words_in_order")); ImGui::PopTextWrapPos(); ImGui::Spacing(); - ImGui::TextDisabled("Progress: %d / %d", progress, (int)words.size()); + ImGui::TextDisabled(TR("appx_progress_n_of_n"), progress, (int)words.size()); if (ImGui::GetTime() < wrongFlashUntil) { ImGui::SameLine(); ImGui::PushStyleColor(ImGuiCol_Text, ui::material::ReadableError()); - ImGui::TextUnformatted(" — that's not the next word"); + ImGui::TextUnformatted(TR("appx_not_next_word")); ImGui::PopStyleColor(); } ImGui::Spacing(); @@ -3145,9 +3189,9 @@ void App::renderLiteFirstRunPrompt() ImGui::PushID((int)i); if (chips[i].second) { ImGui::BeginDisabled(); - ui::material::TactileButton(chips[i].first.c_str(), ImVec2(125, 0)); + ui::material::TactileButton(chips[i].first.c_str(), ImVec2(125 * dp, 0)); ImGui::EndDisabled(); - } else if (ui::material::TactileButton(chips[i].first.c_str(), ImVec2(125, 0))) { + } else if (ui::material::TactileButton(chips[i].first.c_str(), ImVec2(125 * dp, 0))) { if (progress < (int)words.size() && chips[i].first == words[progress]) { chips[i].second = true; // correct next word ++progress; @@ -3162,15 +3206,15 @@ void App::renderLiteFirstRunPrompt() const bool verified = progress == (int)words.size(); if (!verified) ImGui::BeginDisabled(); - if (ui::material::TactileButton("Done", ImVec2(btnW, 0))) { - ui::Notifications::instance().success("Wallet created and backed up.", 6.0f); + if (ui::material::TactileButton(TR("appx_done"), ImVec2(btnW, 0))) { + ui::Notifications::instance().success(TR("appx_wallet_created_and_backed_up"), 6.0f); finish(); } if (!verified) ImGui::EndDisabled(); ImGui::SameLine(); - if (ui::material::TactileButton("Back", ImVec2(80, 0))) { skipConfirm = false; step = 1; } + if (ui::material::TactileButton(TR("appx_back"), ImVec2(80, 0))) { skipConfirm = false; step = 1; } ImGui::SameLine(); - if (ui::material::TactileButton(skipConfirm ? "Skip anyway" : "Skip", ImVec2(120, 0))) { + if (ui::material::TactileButton(skipConfirm ? TR("appx_skip_anyway") : TR("appx_skip"), ImVec2(120, 0))) { if (!skipConfirm) { skipConfirm = true; // require a second, deliberate click } else { @@ -3182,8 +3226,7 @@ void App::renderLiteFirstRunPrompt() ImGui::Spacing(); ImGui::PushTextWrapPos(ImGui::GetCursorPosX() + 380.0f); ImGui::PushStyleColor(ImGuiCol_Text, ui::material::ReadableError()); - ImGui::TextUnformatted("You have not backed up your seed — funds could be lost. " - "Skip anyway?"); + ImGui::TextUnformatted(TR("appx_seed_not_backed_up_warning")); ImGui::PopStyleColor(); ImGui::PopTextWrapPos(); } @@ -3200,7 +3243,7 @@ void App::renderLiteFirstRunPrompt() if (restoring) { // Async restore (with server failover) in flight — driven by pumpAsyncOpen(). - ImGui::TextUnformatted("Restoring your wallet\xE2\x80\xA6"); + ImGui::TextUnformatted(TR("appx_restoring_your_wallet")); if (lite_wallet_->walletOpen()) { ui::Notifications::instance().success(TR("lite_restore_ok"), 6.0f); finish(); // wipes restoreSeed; the wallet then syncs from the lite server @@ -3212,10 +3255,10 @@ void App::renderLiteFirstRunPrompt() } else { ImGui::TextUnformatted(TR("lite_restore_seed_label")); ImGui::InputTextMultiline("##LiteRestoreSeed", restoreSeed, sizeof(restoreSeed), - ImVec2(380.0f, ImGui::GetTextLineHeight() * 3.2f)); + ImVec2(380.0f * dp, ImGui::GetTextLineHeight() * 3.2f)); ImGui::Spacing(); ImGui::TextUnformatted(TR("lite_restore_birthday_label")); - ImGui::SetNextItemWidth(160.0f); + ImGui::SetNextItemWidth(160.0f * dp); ImGui::InputInt("##LiteRestoreBirthday", &restoreBirthday); if (restoreBirthday < 0) restoreBirthday = 0; @@ -3242,8 +3285,10 @@ void App::renderLiteFirstRunPrompt() if (!seedTrim.empty() && !seedLenOk) { ImGui::PushStyleColor(ImGuiCol_Text, ImGui::ColorConvertU32ToFloat4(ui::material::Warning())); ImGui::PushTextWrapPos(ImGui::GetCursorPosX() + 380.0f); - ImGui::TextUnformatted(("Recovery phrase should be 24 words — you have " + - std::to_string(seedWords) + ".").c_str()); + char recoveryWordsMsg[96]; + snprintf(recoveryWordsMsg, sizeof(recoveryWordsMsg), + TR("appx_recovery_phrase_word_count"), seedWords); + ImGui::TextUnformatted(recoveryWordsMsg); ImGui::PopTextWrapPos(); ImGui::PopStyleColor(); ImGui::Spacing(); @@ -3260,13 +3305,13 @@ void App::renderLiteFirstRunPrompt() restoring = true; } else { restoreErr = lite_wallet_->lastOpenError().empty() - ? std::string("Could not start restore") + ? std::string(TR("appx_could_not_start_restore")) : lite_wallet_->lastOpenError(); } } ImGui::EndDisabled(); ImGui::SameLine(); - if (ui::material::TactileButton("Back", ImVec2(80, 0))) { + if (ui::material::TactileButton(TR("appx_back"), ImVec2(80, 0))) { sodium_memzero(restoreSeed, sizeof(restoreSeed)); restoreErr.clear(); step = 0; @@ -3290,17 +3335,18 @@ void App::renderLiteUnlockPrompt() ImGuiCond_Appearing, ImVec2(0.5f, 0.5f)); if (ImGui::BeginPopupModal("##LiteUnlock", nullptr, ImGuiWindowFlags_AlwaysAutoResize | ImGuiWindowFlags_NoTitleBar)) { + const float dp = ui::Layout::dpiScale(); ImGui::PushFont(ui::material::Type().subtitle1()); ImGui::TextUnformatted(TR("lite_unlock_title")); ImGui::PopFont(); ImGui::Spacing(); ImGui::TextUnformatted(TR("lite_unlock_msg")); ImGui::Spacing(); - ImGui::SetNextItemWidth(280.0f); + ImGui::SetNextItemWidth(280.0f * dp); const bool entered = ImGui::InputText("##LiteUnlockPassModal", pass, sizeof(pass), ImGuiInputTextFlags_Password | ImGuiInputTextFlags_EnterReturnsTrue); ImGui::Spacing(); - const float btnW = 130.0f; + const float btnW = 130.0f * dp; bool doUnlock = ui::material::TactileButton(TR("lite_unlock_btn"), ImVec2(btnW, 0)) || entered; if (doUnlock) { const bool ok = lite_wallet_->unlockWallet(pass); @@ -5072,7 +5118,7 @@ void App::handlePaymentURI(const std::string& uri) auto payment = util::parsePaymentURI(uri); if (!payment.valid) { - ui::Notifications::instance().error("Invalid payment URI: " + payment.error); + ui::Notifications::instance().error(std::string(TR("appx_invalid_payment_uri_prefix")) + payment.error); return; } @@ -5087,7 +5133,7 @@ void App::handlePaymentURI(const std::string& uri) setCurrentPage(ui::NavPage::Send); // Notify user - std::string msg = "Payment request loaded"; + std::string msg = TR("appx_payment_request_loaded"); if (payment.amount > 0) { char buf[64]; snprintf(buf, sizeof(buf), " for %.8f DRGX", payment.amount); @@ -5436,7 +5482,7 @@ bool App::stopDaemonForWalletSwitch() void App::rescanBlockchain() { if (!supportsFullNodeLifecycleActions()) { - ui::Notifications::instance().warning("Full-node lifecycle actions are unavailable in lite build"); + ui::Notifications::instance().warning(TR("appx_fullnode_lifecycle_unavailable_lite")); return; } @@ -5451,17 +5497,17 @@ void App::rescanBlockchain() // Re-entrancy guard: a rescan/repair (both drive state_.sync.rescanning) or this exact task already // running would stomp each other — a second confirm must not launch a duplicate operation. if (state_.sync.rescanning || async_tasks_.isRunning(decision.taskName)) { - ui::Notifications::instance().warning("A blockchain maintenance operation is already in progress."); + ui::Notifications::instance().warning(TR("appx_blockchain_maintenance_in_progress")); return; } // Don't race a wallet switch / seed-adopt / encryption restart, which drive their own daemon stop/start. if (daemon_restarting_) { - ui::Notifications::instance().warning("The node is busy restarting — try again in a moment."); + ui::Notifications::instance().warning(TR("appx_node_busy_restarting")); return; } DEBUG_LOGF("[App] Starting blockchain rescan - stopping daemon first\n"); - ui::Notifications::instance().info("Restarting daemon with -rescan flag..."); + ui::Notifications::instance().info(TR("appx_restarting_daemon_rescan_flag")); // Initialize rescan state for status bar display. rescan_confirmed_active_ stays false until we // actually observe the restarted daemon rescanning — so the first poll (which may still reach the @@ -5491,7 +5537,7 @@ void App::rescanBlockchain() void App::repairWallet() { if (!supportsFullNodeLifecycleActions()) { - ui::Notifications::instance().warning("Full-node lifecycle actions are unavailable in lite build"); + ui::Notifications::instance().warning(TR("appx_fullnode_lifecycle_unavailable_lite")); return; } @@ -5504,16 +5550,16 @@ void App::repairWallet() } if (state_.sync.rescanning || async_tasks_.isRunning(decision.taskName)) { - ui::Notifications::instance().warning("A blockchain maintenance operation is already in progress."); + ui::Notifications::instance().warning(TR("appx_blockchain_maintenance_in_progress")); return; } if (daemon_restarting_) { - ui::Notifications::instance().warning("The node is busy restarting — try again in a moment."); + ui::Notifications::instance().warning(TR("appx_node_busy_restarting")); return; } DEBUG_LOGF("[App] Starting wallet repair (-zapwallettxes=2) - stopping daemon first\n"); - ui::Notifications::instance().info("Restarting daemon with -zapwallettxes=2 (wallet repair)..."); + ui::Notifications::instance().info(TR("appx_restarting_daemon_zapwallettxes")); // -zapwallettxes=2 deletes and rebuilds every wallet tx/note record, then rescans the whole // chain — so reuse the rescan status UI (status bar + warmup-end completion detection). Same @@ -5542,11 +5588,11 @@ void App::repairWallet() void App::reinstallBundledDaemon() { if (!supportsFullNodeLifecycleActions()) { - ui::Notifications::instance().warning("Full-node lifecycle actions are unavailable in lite build"); + ui::Notifications::instance().warning(TR("appx_fullnode_lifecycle_unavailable_lite")); return; } if (!resources::getBundledDaemonInfo().available) { - ui::Notifications::instance().warning("This build has no bundled daemon to install"); + ui::Notifications::instance().warning(TR("appx_no_bundled_daemon_to_install")); return; } // Require embedded-daemon *support*, but NOT an active daemon_controller_. When the wallet is @@ -5554,17 +5600,17 @@ void App::reinstallBundledDaemon() // we can still RPC-stop that node, overwrite the binaries, and bring up our own managed daemon — // which is exactly the state that previously blocked "Install bundled" with a cryptic warning. if (!supportsEmbeddedDaemon()) { - ui::Notifications::instance().warning("This build has no embedded daemon to install"); + ui::Notifications::instance().warning(TR("appx_no_embedded_daemon_to_install")); return; } if (async_tasks_.isRunning("reinstall-daemon")) { - ui::Notifications::instance().warning("The daemon reinstall is already in progress."); + ui::Notifications::instance().warning(TR("appx_daemon_reinstall_in_progress")); return; } DEBUG_LOGF("[App] Reinstalling bundled daemon binary — stopping daemon first\n"); - ui::Notifications::instance().info("Installing bundled daemon — the node will stop, update, and restart..."); + ui::Notifications::instance().info(TR("appx_installing_bundled_daemon")); async_tasks_.submit("reinstall-daemon", [this](const util::AsyncTaskManager::Token& token) { AppDaemonLifecycleRuntime runtime(*this); @@ -5596,7 +5642,7 @@ void App::reinstallBundledDaemon() void App::deleteBlockchainData() { if (!supportsFullNodeLifecycleActions()) { - ui::Notifications::instance().warning("Full-node lifecycle actions are unavailable in lite build"); + ui::Notifications::instance().warning(TR("appx_fullnode_lifecycle_unavailable_lite")); return; } @@ -5609,12 +5655,12 @@ void App::deleteBlockchainData() } if (state_.sync.rescanning || async_tasks_.isRunning(decision.taskName)) { - ui::Notifications::instance().warning("A blockchain maintenance operation is already in progress."); + ui::Notifications::instance().warning(TR("appx_blockchain_maintenance_in_progress")); return; } DEBUG_LOGF("[App] Deleting blockchain data - stopping daemon first\n"); - ui::Notifications::instance().info("Stopping daemon and deleting blockchain data..."); + ui::Notifications::instance().info(TR("appx_stopping_daemon_deleting_blockchain")); daemon_controller_->prepareLifecycleOperation(decision, settings_.get()); async_tasks_.submit(decision.taskName, [this, decision](const util::AsyncTaskManager::Token& token) { @@ -5719,7 +5765,7 @@ void App::beginShutdown() // Stop xmrig pool miner before stopping the daemon if (xmrig_manager_ && xmrig_manager_->isRunning()) { - shutdown_status_ = "Stopping pool miner..."; + shutdown_status_ = TR("appx_stopping_pool_miner"); xmrig_manager_->stop(3000); } @@ -5731,7 +5777,7 @@ void App::beginShutdown() // Worker join + RPC disconnect happen in shutdown(). if (!daemon_controller_) { DEBUG_LOGF("beginShutdown: no embedded daemon, disconnecting only\n"); - shutdown_status_ = "Disconnecting..."; + shutdown_status_ = TR("appx_disconnecting"); if (settings_) { settings_->save(); } @@ -5762,15 +5808,15 @@ void App::beginShutdown() // modal "Please wait" dialog). shutdown_thread_ = std::thread([this]() { DEBUG_LOGF("shutdown thread: calling stopEmbeddedDaemon()\n"); - shutdown_status_ = "Sending stop command to daemon..."; + shutdown_status_ = TR("appx_sending_stop_command_to_daemon"); // Send RPC stop command stopEmbeddedDaemon(); DEBUG_LOGF("shutdown thread: daemon stopped, disconnecting RPC\n"); - shutdown_status_ = "Cleaning up..."; + shutdown_status_ = TR("appx_cleaning_up"); DEBUG_LOGF("shutdown thread: complete\n"); - shutdown_status_ = "Shutdown complete"; + shutdown_status_ = TR("appx_shutdown_complete"); shutdown_complete_ = true; }); } @@ -5883,18 +5929,16 @@ void App::renderDaemonStopConfirm() if (ImGui::BeginPopupModal("##DaemonStopConfirm", nullptr, ImGuiWindowFlags_AlwaysAutoResize | ImGuiWindowFlags_NoTitleBar)) { if (Type().subtitle1()) ImGui::PushFont(Type().subtitle1()); - ImGui::TextUnformatted("Node is rebuilding its witness cache"); + ImGui::TextUnformatted(TR("appx_node_rebuilding_witness_cache")); if (Type().subtitle1()) ImGui::PopFont(); ImGui::Spacing(); ImGui::PushTextWrapPos(ImGui::GetFontSize() * 26.0f); - ImGui::TextUnformatted( - "Stopping the node now discards the in-progress rebuild and restarts it (several minutes) " - "the next time you open the wallet. You can keep the node running instead."); + ImGui::TextUnformatted(TR("appx_stopping_node_discards_rebuild")); ImGui::PopTextWrapPos(); ImGui::Spacing(); ImGui::Spacing(); - if (TactileButton("Keep node running & quit", ImVec2(0, 0))) { + if (TactileButton(TR("appx_keep_node_running_and_quit"), ImVec2(0, 0))) { shutdown_keep_daemon_override_ = true; shutdown_confirmed_ = true; daemon_stop_confirm_open_ = false; @@ -5905,7 +5949,7 @@ void App::renderDaemonStopConfirm() ImGui::PushStyleColor(ImGuiCol_Button, ImGui::ColorConvertU32ToFloat4(WithAlpha(Error(), 210))); ImGui::PushStyleColor(ImGuiCol_ButtonHovered, ImGui::ColorConvertU32ToFloat4(Error())); ImGui::PushStyleColor(ImGuiCol_ButtonActive, ImGui::ColorConvertU32ToFloat4(WithAlpha(Error(), 160))); - const bool stopAnyway = TactileButton("Stop anyway & quit", ImVec2(0, 0)); + const bool stopAnyway = TactileButton(TR("appx_stop_anyway_and_quit"), ImVec2(0, 0)); ImGui::PopStyleColor(3); if (stopAnyway) { shutdown_confirmed_ = true; @@ -5914,7 +5958,7 @@ void App::renderDaemonStopConfirm() ImGui::CloseCurrentPopup(); } ImGui::SameLine(); - if (TactileButton("Cancel", ImVec2(0, 0))) { + if (TactileButton(TR("appx_cancel"), ImVec2(0, 0))) { daemon_stop_confirm_open_ = false; // abort the quit; stay open ImGui::CloseCurrentPopup(); } @@ -5930,6 +5974,7 @@ void App::renderDaemonStopConfirm() void App::renderShutdownScreen() { using namespace ui::material; + const float dp = ui::Layout::dpiScale(); auto shutElem = [](const char* key, float fb) { float v = ui::schema::UI().drawElement("components.shutdown", key).size; return v >= 0 ? v : fb; @@ -5983,7 +6028,7 @@ void App::renderShutdownScreen() // ------------------------------------------------------------------- float lineH = ImGui::GetTextLineHeightWithSpacing(); float titleH = Type().h5() ? Type().h5()->LegacySize : lineH * 1.5f; - float spinnerD = shutElem("spinner-radius", 20.0f) * 2.0f + 12.0f; + float spinnerD = shutElem("spinner-radius", 20.0f) * dp * 2.0f + 12.0f * dp; float statusH = lineH * 2.0f; float sepH = lineH; float panelH = shutElem("panel-max-height", 160.0f); @@ -6014,10 +6059,10 @@ void App::renderShutdownScreen() // 2. Animated arc spinner // ------------------------------------------------------------------- { - float r = shutElem("spinner-radius", 20.0f); - float thick = shutElem("spinner-thickness", 3.0f); + float r = shutElem("spinner-radius", 20.0f) * dp; + float thick = shutElem("spinner-thickness", 3.0f) * dp; // Screen-space centre for draw list - ImVec2 sc(wp.x + cx, wp.y + ImGui::GetCursorPosY() + r + 2.0f); + ImVec2 sc(wp.x + cx, wp.y + ImGui::GetCursorPosY() + r + 2.0f * dp); // Background ring (dim) dl->PathArcTo(sc, r, 0.0f, kPi * 2.0f, 48); @@ -6031,7 +6076,7 @@ void App::renderShutdownScreen() dl->PathStroke(ui::schema::UI().resolveColor("var(--spinner-active)", IM_COL32(255, 218, 0, 200)), 0, thick); // Advance cursor past the spinner - ImGui::Dummy(ImVec2(0, r * 2.0f + 8.0f)); + ImGui::Dummy(ImVec2(0, r * 2.0f + 8.0f * dp)); } ImGui::Spacing(); @@ -6056,9 +6101,9 @@ void App::renderShutdownScreen() char elapsed[64]; int secs = (int)shutdown_timer_; if (secs < 60) - snprintf(elapsed, sizeof(elapsed), "%d seconds", secs); + snprintf(elapsed, sizeof(elapsed), TR("appx_n_seconds"), secs); else - snprintf(elapsed, sizeof(elapsed), "%d min %d sec", secs / 60, secs % 60); + snprintf(elapsed, sizeof(elapsed), TR("appx_n_min_n_sec"), secs / 60, secs % 60); ImGui::PushFont(Type().caption()); ImVec2 ts = ImGui::CalcTextSize(elapsed); @@ -6078,7 +6123,8 @@ void App::renderShutdownScreen() // State-aware caution: while the status is a daemon flush/exit step, force-quitting risks the // chainstate; say so instead of a bare button. if (shutdownStalled && !curShut.empty()) { - std::string stalledMsg = "Still \"" + curShut + "\" — force quitting now may corrupt chain data."; + std::string stalledMsg = std::string(TR("appx_still_status_prefix")) + curShut + + TR("appx_still_status_suffix"); ImVec2 ms = ImGui::CalcTextSize(stalledMsg.c_str()); ImGui::SetCursorPosX(cx - ms.x * 0.5f); ImGui::PushStyleColor(ImGuiCol_Text, ImGui::ColorConvertU32ToFloat4(Warning())); @@ -6087,7 +6133,7 @@ void App::renderShutdownScreen() ImGui::Spacing(); } const char* forceLabel = TR("force_quit"); - ImVec2 btnSize(ImGui::CalcTextSize(forceLabel).x + 32.0f, 0); + ImVec2 btnSize(ImGui::CalcTextSize(forceLabel).x + 32.0f * dp, 0); ImGui::SetCursorPosX(cx - btnSize.x * 0.5f); ImGui::PushStyleColor(ImGuiCol_Button, ImVec4(0.6f, 0.15f, 0.15f, 0.9f)); ImGui::PushStyleColor(ImGuiCol_ButtonHovered, ImVec4(0.75f, 0.2f, 0.2f, 1.0f)); @@ -6117,7 +6163,7 @@ void App::renderShutdownScreen() ImGui::Spacing(); ImGui::Spacing(); - float btnW = 120.0f; + float btnW = 120.0f * dp; float totalW = btnW * 2 + ImGui::GetStyle().ItemSpacing.x; ImGui::SetCursorPosX((ImGui::GetWindowWidth() - totalW) * 0.5f); @@ -6149,7 +6195,7 @@ void App::renderShutdownScreen() ImVec2 p0(wp.x + pad, wp.y + ImGui::GetCursorPosY()); ImVec2 p1(wp.x + vp_size.x - pad, p0.y); dl->AddLine(p0, p1, ui::schema::UI().resolveColor("var(--status-divider)", IM_COL32(255, 255, 255, 30)), 1.0f); - ImGui::Dummy(ImVec2(0, 4.0f)); + ImGui::Dummy(ImVec2(0, 4.0f * dp)); } ImGui::Spacing(); @@ -6182,7 +6228,7 @@ void App::renderShutdownScreen() ImGui::GetCursorPosY() + panelPad)); ImGui::PushFont(Type().caption()); ImGui::PushStyleColor(ImGuiCol_Text, ImVec4(0.45f, 0.45f, 0.50f, 1.0f)); - ImGui::TextUnformatted("dragonxd output"); + ImGui::TextUnformatted(TR("appx_dragonxd_output")); ImGui::PopStyleColor(); ImGui::PopFont(); @@ -6222,7 +6268,7 @@ void App::renderShutdownScreen() // Advance cursor past the panel float panelBottom = panelMax.y - wp.y; - ImGui::SetCursorPosY(panelBottom + 4.0f); + ImGui::SetCursorPosY(panelBottom + 4.0f * dp); ImGui::Dummy(ImVec2(0, 0)); } } @@ -6417,14 +6463,14 @@ void App::renderLoadingOverlay(float contentH) char wbuf[128]; if (state_.sync.witness_phase == 2 && progress > 0.01f && state_.sync.witness_remaining > 0) - snprintf(wbuf, sizeof(wbuf), "Rebuilding witness cache %.0f%% — %d blocks left", + snprintf(wbuf, sizeof(wbuf), TR("appx_rebuilding_witness_cache_blocks_left"), progress * 100.0f, state_.sync.witness_remaining); else if (state_.sync.witness_phase == 2 && progress > 0.01f) - snprintf(wbuf, sizeof(wbuf), "Rebuilding witness cache %.0f%%", progress * 100.0f); + snprintf(wbuf, sizeof(wbuf), TR("appx_rebuilding_witness_cache_pct"), progress * 100.0f); else if (progress > 0.01f) - snprintf(wbuf, sizeof(wbuf), "Setting initial Sapling witnesses %.0f%%", progress * 100.0f); + snprintf(wbuf, sizeof(wbuf), TR("appx_setting_initial_sapling_witnesses"), progress * 100.0f); else - snprintf(wbuf, sizeof(wbuf), "Rebuilding Sapling note witnesses…"); + snprintf(wbuf, sizeof(wbuf), "%s", TR("appx_rebuilding_sapling_note_witnesses")); ImFont* capFont = Type().caption(); if (!capFont) capFont = ImGui::GetFont(); ImVec2 ts = capFont->CalcTextSizeA(capFont->LegacySize, FLT_MAX, 0.0f, wbuf); @@ -6462,7 +6508,7 @@ void App::renderLoadingOverlay(float contentH) // Progress text — "Syncing 45.2% — Block 123456 / 234567" char syncBuf[128]; - snprintf(syncBuf, sizeof(syncBuf), "Syncing %.1f%% — Block %d / %d", + snprintf(syncBuf, sizeof(syncBuf), TR("appx_syncing_pct_block_n_of_n"), progress * 100.0f, state_.sync.blocks, state_.sync.headers); ImFont* capFont = Type().caption(); if (!capFont) capFont = ImGui::GetFont(); @@ -6474,7 +6520,7 @@ void App::renderLoadingOverlay(float contentH) } else if (!state_.connected && state_.sync.blocks > 0) { // Show last known block height while reconnecting char blockBuf[64]; - snprintf(blockBuf, sizeof(blockBuf), "Last block: %d", state_.sync.blocks); + snprintf(blockBuf, sizeof(blockBuf), TR("appx_last_block_n"), state_.sync.blocks); ImFont* capFont = Type().caption(); if (!capFont) capFont = ImGui::GetFont(); ImVec2 ts = capFont->CalcTextSizeA(capFont->LegacySize, FLT_MAX, 0.0f, blockBuf); @@ -6493,8 +6539,8 @@ void App::renderLoadingOverlay(float contentH) if (!capFont) capFont = ImGui::GetFont(); const char* encLabel = encrypt_in_progress_ - ? "Encrypting wallet..." - : "Waiting for daemon to encrypt wallet..."; + ? TR("appx_encrypting_wallet") + : TR("appx_waiting_for_daemon_to_encrypt_wallet"); ImVec2 ts = capFont->CalcTextSizeA(capFont->LegacySize, FLT_MAX, 0.0f, encLabel); ImU32 encCol = IM_COL32(255, 218, 0, 200); dl->AddText(capFont, capFont->LegacySize, @@ -6529,7 +6575,7 @@ void App::renderLoadingOverlay(float contentH) if (!bodyFont2) bodyFont2 = ImGui::GetFont(); // Error title - const char* errTitle = "Daemon Error"; + const char* errTitle = TR("appx_daemon_error"); ImVec2 ts = bodyFont2->CalcTextSizeA(bodyFont2->LegacySize, FLT_MAX, 0.0f, errTitle); dl->AddText(bodyFont2, bodyFont2->LegacySize, ImVec2(wp.x + cx - ts.x * 0.5f, curY), @@ -6549,7 +6595,7 @@ void App::renderLoadingOverlay(float contentH) } // Crash count hint if (daemon_controller_->crashCount() >= 3) { - const char* hint = "Use Settings > Restart Daemon to try again"; + const char* hint = TR("appx_use_settings_restart_daemon_hint"); ImVec2 hs2 = capFont->CalcTextSizeA(capFont->LegacySize, FLT_MAX, 0.0f, hint); dl->AddText(capFont, capFont->LegacySize, ImVec2(wp.x + cx - hs2.x * 0.5f, curY), @@ -6822,7 +6868,7 @@ void App::copySecretToClipboard(const std::string& secret) clipboard_secret_hash_ = secret.empty() ? 0 : h; clipboard_clear_deadline_ = secret.empty() ? 0.0 : (ImGui::GetTime() + 45.0); if (!secret.empty()) - ui::Notifications::instance().info("Copied — clipboard auto-clears in 45s", 4.0f); + ui::Notifications::instance().info(TR("appx_copied_clipboard_autoclears"), 4.0f); } void App::clearSecretClipboardIfArmed() @@ -6916,7 +6962,7 @@ std::string App::buildDiagnosticsReport() void App::restartDaemon() { if (!supportsFullNodeLifecycleActions()) { - ui::Notifications::instance().warning("Full-node lifecycle actions are unavailable in lite build"); + ui::Notifications::instance().warning(TR("appx_fullnode_lifecycle_unavailable_lite")); return; } @@ -6956,7 +7002,7 @@ void App::restartDaemon() void App::reindexBlockDatabase() { if (!supportsFullNodeLifecycleActions()) { - ui::Notifications::instance().warning("Full-node lifecycle actions are unavailable in lite build"); + ui::Notifications::instance().warning(TR("appx_fullnode_lifecycle_unavailable_lite")); return; } if (!daemon_controller_) return; diff --git a/src/app.h b/src/app.h index 9509600..15645f6 100644 --- a/src/app.h +++ b/src/app.h @@ -462,6 +462,7 @@ public: return 0; } void showAboutDialog() { show_about_ = true; } + void showFaqDialog() { show_faq_ = true; } // Legacy tab compat — maps int to NavPage void setCurrentTab(int tab); @@ -800,6 +801,7 @@ private: // balance poll discards per-note data). Mirrors chat_fast_scan_in_flight_. bool chat_note_scan_in_flight_ = false; double chat_note_scan_last_ = 0.0; // ImGui time of the last note scan (rate limit) + double chat_note_scan_ms_ = 0.0; // measured cost of the last note scan (adaptive back-off) // Most-recent chain tip, cached across refreshes: a lite refresh model that carries spendableOutputs // may NOT carry sync status that same cycle (tolerated partial refresh), so verifiedSelfNoteCount reads // this cache rather than requiring the current model to have both — else the budget flickers to 0. @@ -809,6 +811,9 @@ private: // Coordinator helpers (both variants unless noted; see app_network.cpp). void refreshChatNoteBudget(const wallet::LiteWalletAppRefreshModel& model); // lite: recompute caches on a fresh model void refreshChatNoteBudgetNode(); // full node: rate-limited z_listunspent worker scan + // Feeds the SAME chat send-budget from an already-collected z_listunspent (the address refresh), + // so the dedicated scan above is skipped while the address refresh is active (dedup — see #3). + void updateChatNoteBudgetFromUnspent(const std::vector& unspentNotes); void pumpChatNoteBuffer(); // per-frame: drain the queue / build the buffer int verifiedSelfNoteCount(const wallet::LiteWalletAppRefreshModel& model); // lite int pipelineSelfNoteCount(const wallet::LiteWalletAppRefreshModel& model); // lite @@ -877,6 +882,8 @@ private: void fastScanChatMemos(); bool chat_fast_scan_in_flight_ = false; // guard against overlapping fast-scan RPCs float chat_fast_scan_accum_ = 0.0f; // seconds since the last fast-scan (dedicated ~2.5s poll) + double chat_fast_scan_last_ = 0.0; // ImGui time of the last 0-conf fast scan (adaptive back-off) + double chat_fast_scan_ms_ = 0.0; // measured cost of the last fast scan (z_listreceivedbyaddress) bool font_rebuild_requested_ = false; // set by requestFontRebuild(); consumed in preFrame() // Lite first-run welcome prompt: dismissed for the session once the user picks an action. bool lite_firstrun_dismissed_ = false; @@ -1028,6 +1035,7 @@ private: bool show_demo_window_ = false; bool show_settings_ = false; bool show_about_ = false; + bool show_faq_ = false; bool show_import_key_ = false; bool show_export_key_ = false; bool show_backup_ = false; @@ -1143,6 +1151,14 @@ private: std::time_t sync_settle_until_ = 0; // hold the sync-throttle until this wall-clock time (0 = not settling) double last_balance_scan_ms_ = 0.0; // measured cost of the last z_gettotalbalance scan bool force_balance_refresh_ = false; // a wallet mutation forces the next balance poll through the throttle + // Same adaptive back-off applied to the other two O(mapWallet) scans that hold the daemon's cs_main: + // the address scan (z_listunspent) and the history scan (z_listreceivedbyaddress). Without this, a + // large shielded wallet re-scans them every tab cadence (~seconds each), saturating cs_main and + // starving block connection near the tip (where effectivelySyncing() reads false). See + // addressRefreshDue() / txRefreshDue(); only the routine periodic poll is throttled — explicit + // refreshes (tab switch, dirty set, in-flight send) call the refresh directly and bypass this. + double last_address_scan_ms_ = 0.0; // measured cost of the last address scan + double last_tx_scan_ms_ = 0.0; // measured cost of the last history scan // Auto-clear for secrets copied to the clipboard. Only a hash of the copied secret is kept. std::uint64_t clipboard_secret_hash_ = 0; double clipboard_clear_deadline_ = 0.0; @@ -1498,6 +1514,11 @@ private: void applyRefreshPolicy(ui::NavPage page); bool effectivelySyncing() const; // syncing, or within the post-sync settle window (hysteresis) bool balanceRefreshDue() const; // adaptive: enough time elapsed given the last balance-scan cost? + bool addressRefreshDue() const; // same adaptive back-off for the address scan (z_listunspent) + bool txRefreshDue() const; // same adaptive back-off for the history scan (z_listreceivedbyaddress) + // Shared duty-cycle rule: a scan may resume only once (lastScanMs / kScanDutyCycle) has elapsed since + // lastUpdate, so any single O(mapWallet) scan can occupy at most ~kScanDutyCycle of wall-clock. + bool scanRefreshDue(std::int64_t lastUpdate, double lastScanMs) const; bool currentPageNeedsWalletDataRefresh() const; bool shouldRunWalletTransactionRefresh() const; bool shouldRefreshTransactions() const; diff --git a/src/app_security.cpp b/src/app_security.cpp index 07731ea..8ba1ba2 100644 --- a/src/app_security.cpp +++ b/src/app_security.cpp @@ -300,14 +300,14 @@ void App::restartDaemonAfterEncryption(const char* taskName, bool announceRestar }); } else { ui::Notifications::instance().warning( - "Please restart your daemon for encryption to take effect."); + TR("sec_restart_daemon_for_encryption")); } } void App::encryptWalletWithPassphrase(const std::string& passphrase) { if (!rpc_ || !rpc_->isConnected()) return; encrypt_in_progress_ = true; - encrypt_status_ = "Encrypting wallet..."; + encrypt_status_ = TR("sec_encrypting_wallet"); if (worker_) { worker_->post([this, passphrase]() mutable -> rpc::RPCWorker::MainCb { @@ -317,7 +317,7 @@ void App::encryptWalletWithPassphrase(const std::string& passphrase) { if (result.encrypted) { return [this]() { encrypt_in_progress_ = false; - encrypt_status_ = "Wallet encrypted. Restarting daemon..."; + encrypt_status_ = TR("sec_wallet_encrypted_restarting_daemon"); DEBUG_LOGF("[App] Wallet encrypted — restarting daemon\n"); // Immediately update local encryption state so the @@ -336,7 +336,7 @@ void App::encryptWalletWithPassphrase(const std::string& passphrase) { } ui::Notifications::instance().info( - "Wallet encrypted successfully", 5.0f); + TR("sec_wallet_encrypted_successfully"), 5.0f); // The daemon shuts itself down after encryptwallet. // Update connection_status_ so the loading overlay @@ -348,11 +348,11 @@ void App::encryptWalletWithPassphrase(const std::string& passphrase) { std::string err = result.error; return [this, err]() { encrypt_in_progress_ = false; - encrypt_status_ = "Encryption failed: " + err; + encrypt_status_ = std::string(TR("sec_encryption_failed_prefix")) + err; DEBUG_LOGF("[App] encryptwallet failed: %s\n", err.c_str()); ui::Notifications::instance().error( - "Encryption failed: " + err); + std::string(TR("sec_encryption_failed_prefix")) + err); // Return to passphrase entry on failure if (show_encrypt_dialog_ && @@ -393,7 +393,7 @@ void App::processDeferredEncryption() { std::string pin = std::move(deferredEncryption.pin); encrypt_in_progress_ = true; - encrypt_status_ = "Encrypting wallet..."; + encrypt_status_ = TR("sec_encrypting_wallet"); if (worker_) { worker_->post([this, request = services::WalletSecurityController::DeferredEncryptionSnapshot{std::move(passphrase), std::move(pin)}]() mutable -> rpc::RPCWorker::MainCb { @@ -413,13 +413,13 @@ void App::processDeferredEncryption() { if (result.pinStored) { settings_->setPinEnabled(true); settings_->save(); - ui::Notifications::instance().info("Wallet encrypted & PIN set", 5.0f); + ui::Notifications::instance().info(TR("sec_wallet_encrypted_and_pin_set"), 5.0f); } else { ui::Notifications::instance().warning( - "Wallet encrypted but PIN vault failed"); + TR("sec_wallet_encrypted_but_pin_vault_failed")); } } else { - ui::Notifications::instance().info("Wallet encrypted successfully", 5.0f); + ui::Notifications::instance().info(TR("sec_wallet_encrypted_successfully"), 5.0f); } wallet_security_.clearDeferredEncryption(); @@ -432,9 +432,9 @@ void App::processDeferredEncryption() { std::string err = result.error; return [this, err]() { encrypt_in_progress_ = false; - encrypt_status_ = "Encryption failed: " + err; + encrypt_status_ = std::string(TR("sec_encryption_failed_prefix")) + err; DEBUG_LOGF("[App] Deferred encryptwallet failed: %s\n", err.c_str()); - ui::Notifications::instance().error("Encryption failed: " + err); + ui::Notifications::instance().error(std::string(TR("sec_encryption_failed_prefix")) + err); wallet_security_.clearDeferredEncryption(); }; } @@ -531,7 +531,7 @@ void App::lockWallet() { 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); + TR("sec_couldnt_lock_wallet"), 12.0f); } } }; @@ -541,7 +541,7 @@ void App::lockWallet() { void App::changePassphrase(const std::string& oldPass, const std::string& newPass) { if (!rpc_ || !rpc_->isConnected() || !worker_) return; encrypt_in_progress_ = true; - encrypt_status_ = "Changing passphrase..."; + encrypt_status_ = TR("sec_changing_passphrase"); auto* w = (fast_worker_ && fast_worker_->isRunning()) ? fast_worker_.get() : worker_.get(); auto* r = (fast_rpc_ && fast_rpc_->isConnected()) ? fast_rpc_.get() : rpc_.get(); @@ -574,9 +574,9 @@ void App::changePassphrase(const std::string& oldPass, const std::string& newPas memset(change_confirm_buf_, 0, sizeof(change_confirm_buf_)); unlockTransactionHistoryCacheWithPassphrase(newPass); storeTransactionHistoryCacheIfAvailable(); - ui::Notifications::instance().info("Passphrase changed successfully"); + ui::Notifications::instance().info(TR("sec_passphrase_changed_successfully")); } else { - encrypt_status_ = "Failed: " + err_msg; + encrypt_status_ = std::string(TR("sec_failed_prefix")) + err_msg; } util::SecureVault::secureZero(newPass.data(), newPass.size()); }; @@ -637,8 +637,7 @@ void App::refreshWalletEncryptionState() { !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); + TR("sec_encryption_did_not_complete"), 30.0f); } if (state_.transactions.empty()) { loadTransactionHistoryCacheIfAvailable(); @@ -951,7 +950,7 @@ void App::renderLockScreen() { ImU32 textCol = ui::material::OnSurface(); { - const char* title = "Wallet Locked"; + const char* title = TR("sec_wallet_locked_title"); ImVec2 ts = titleFont->CalcTextSizeA(titleFont->LegacySize, FLT_MAX, 0, title); dl->AddText(titleFont, titleFont->LegacySize, ImVec2(cardX + (cardW - ts.x) * 0.5f, cy), textCol, title); @@ -964,7 +963,7 @@ void App::renderLockScreen() { if (lock_lockout_timer_ < 0) lock_lockout_timer_ = 0; char msg[128]; - snprintf(msg, sizeof(msg), "Too many attempts. Wait %.0f seconds...", lock_lockout_timer_); + snprintf(msg, sizeof(msg), TR("sec_too_many_attempts_wait"), lock_lockout_timer_); ImVec2 ms = captionFont->CalcTextSizeA(captionFont->LegacySize, FLT_MAX, 0, msg); dl->AddText(captionFont, captionFont->LegacySize, ImVec2(cardX + (cardW - ms.x) * 0.5f, cy), ui::material::Warning(), msg); @@ -977,10 +976,10 @@ void App::renderLockScreen() { // Mode toggle (PIN / Passphrase) — only show if PIN vault exists if (hasPinVault) { const char* modeIcon = lock_use_pin_ ? ICON_MD_DIALPAD : ICON_MD_PASSWORD; - const char* modeText = lock_use_pin_ ? " PIN" : " Passphrase"; + const char* modeText = lock_use_pin_ ? " PIN" : TR("sec_mode_passphrase"); const char* switchLabel = lock_use_pin_ - ? "Use passphrase instead" - : "Use PIN instead"; + ? TR("sec_use_passphrase_instead") + : TR("sec_use_pin_instead"); // Current mode indicator — icon with icon font, text with caption font ImFont* iconFont = ui::material::Type().iconSmall(); @@ -1082,7 +1081,7 @@ void App::renderLockScreen() { if (lock_unlock_in_progress_) { // Animated spinner dots char msg[64]; - snprintf(msg, sizeof(msg), "Unlocking%s", ui::material::LoadingDots()); + snprintf(msg, sizeof(msg), TR("sec_unlocking_fmt"), ui::material::LoadingDots()); ImVec2 ms = captionFont->CalcTextSizeA(captionFont->LegacySize, FLT_MAX, 0, msg); dl->AddText(captionFont, captionFont->LegacySize, ImVec2(cardX + (cardW - ms.x) * 0.5f, cy), @@ -1106,7 +1105,7 @@ void App::renderLockScreen() { ImGui::PushStyleColor(ImGuiCol_Text, ImGui::ColorConvertU32ToFloat4(ui::material::OnPrimary())); ImGui::PushStyleVar(ImGuiStyleVar_FrameRounding, 8.0f * dp); ImGui::BeginDisabled(!canSubmit); - bool btnClicked = ui::material::TactileButton("Unlock", ImVec2(unlockW, unlockH)); + bool btnClicked = ui::material::TactileButton(TR("sec_unlock_button"), ImVec2(unlockW, unlockH)); ImGui::EndDisabled(); ImGui::PopStyleVar(); ImGui::PopStyleColor(3); @@ -1160,7 +1159,7 @@ void App::renderLockScreen() { r->call("walletpassphrase", {passphrase, timeout}); rpcOk = true; } else { - rpcErr = "Not connected to daemon"; + rpcErr = TR("sec_not_connected_to_daemon"); } } catch (const std::exception& e) { rpcErr = e.what(); @@ -1176,7 +1175,7 @@ void App::renderLockScreen() { // so route through applyUnlockFailure so the lockout curve applies // (this path previously bumped the counter but skipped the lockout math). return [this, rpcErr, passphrase = std::move(passphrase)]() mutable { - applyUnlockFailure("Unlock failed: " + rpcErr); + applyUnlockFailure(std::string(TR("sec_unlock_failed_prefix")) + rpcErr); util::SecureVault::secureZero(passphrase.data(), passphrase.size()); }; } @@ -1579,7 +1578,7 @@ void App::renderDecryptWalletDialog() { if (!passphrase.empty()) sodium_memzero(&passphrase[0], passphrase.size()); if (!unlock.ok) { return [this]() { - wallet_security_workflow_.failEntry("Incorrect passphrase"); + wallet_security_workflow_.failEntry(TR("sec_incorrect_passphrase_decrypt")); }; } @@ -1695,7 +1694,7 @@ void App::renderDecryptWalletDialog() { }); ui::Notifications::instance().info( - "Importing keys & rescanning blockchain — wallet is usable while this runs", + TR("sec_importing_keys_rescanning"), 8.0f); }; }); @@ -1714,7 +1713,7 @@ void App::renderDecryptWalletDialog() { wallet_security_workflow_.finishImport(); ui::Notifications::instance().error( err + - "\nEncrypted backup: wallet.dat.encrypted.bak", + TR("sec_encrypted_backup_suffix"), 12.0f); }; }); @@ -1740,7 +1739,7 @@ void App::renderDecryptWalletDialog() { refreshPeerInfo(); ui::Notifications::instance().success( - "Wallet decrypted successfully! All keys imported.", + TR("sec_wallet_decrypted_all_keys_imported"), 8.0f); DEBUG_LOGF("[App] Wallet decrypted successfully\n"); }; @@ -1862,7 +1861,7 @@ void App::renderDecryptWalletDialog() { int tMins = (int)(totalElapsed / 60); int tSecs = (int)(totalElapsed % 60); ImGui::Spacing(); - ImGui::TextDisabled("Total elapsed: %dm %02ds", tMins, tSecs); + ImGui::TextDisabled(TR("sec_total_elapsed_fmt"), tMins, tSecs); } // ---- Phase 2: Success ---- @@ -1965,7 +1964,7 @@ void App::renderPinDialogs() { ImGui::BeginDisabled(!valid || pin_in_progress_); if (ui::material::TactileButton(TR("settings_set_pin"), ImVec2(btnW, 40))) { pin_in_progress_ = true; - pin_status_ = "Verifying passphrase..."; + pin_status_ = TR("sec_verifying_passphrase"); // Verify passphrase + store vault on worker thread to avoid // blocking the UI with Argon2id key derivation. @@ -1985,7 +1984,7 @@ void App::renderPinDialogs() { if (!passphrase.empty()) util::SecureVault::secureZero(&passphrase[0], passphrase.size()); if (!pin.empty()) util::SecureVault::secureZero(&pin[0], pin.size()); return [this]() { - pin_status_ = "Incorrect passphrase"; + pin_status_ = TR("sec_incorrect_passphrase_pin_setup"); pin_in_progress_ = false; }; } @@ -2009,15 +2008,15 @@ void App::renderPinDialogs() { pin_status_.clear(); pin_in_progress_ = false; show_pin_setup_ = false; - ui::Notifications::instance().info("PIN set successfully"); + ui::Notifications::instance().info(TR("sec_pin_set_successfully")); } else { - pin_status_ = "Failed to create vault"; + pin_status_ = TR("sec_failed_to_create_vault"); pin_in_progress_ = false; } }; }); } else { - pin_status_ = "Not connected to daemon"; + pin_status_ = TR("sec_not_connected_to_daemon_pin"); pin_in_progress_ = false; } } @@ -2082,7 +2081,7 @@ void App::renderPinDialogs() { ImGui::BeginDisabled(!valid || pin_in_progress_); if (ui::material::TactileButton(TR("settings_change_pin"), ImVec2(-1, 40))) { pin_in_progress_ = true; - pin_status_ = "Changing PIN..."; + pin_status_ = TR("sec_changing_pin"); std::string oldPin(pin_old_buf_); std::string newPinCopy = newPin; memset(pin_old_buf_, 0, sizeof(pin_old_buf_)); @@ -2098,15 +2097,15 @@ void App::renderPinDialogs() { pin_status_.clear(); pin_in_progress_ = false; show_pin_change_ = false; - ui::Notifications::instance().info("PIN changed successfully"); + ui::Notifications::instance().info(TR("sec_pin_changed_successfully")); } else { - pin_status_ = "Incorrect current PIN"; + pin_status_ = TR("sec_incorrect_current_pin"); pin_in_progress_ = false; } }; }); } else { - pin_status_ = "Internal error"; + pin_status_ = TR("sec_internal_error_change_pin"); pin_in_progress_ = false; } } @@ -2147,7 +2146,7 @@ void App::renderPinDialogs() { ImGui::BeginDisabled(!valid || pin_in_progress_); if (ui::material::TactileButton(TR("settings_remove_pin"), ImVec2(-1, 40))) { pin_in_progress_ = true; - pin_status_ = "Verifying PIN..."; + pin_status_ = TR("sec_verifying_pin"); std::string oldPin(pin_old_buf_); memset(pin_old_buf_, 0, sizeof(pin_old_buf_)); @@ -2167,15 +2166,15 @@ void App::renderPinDialogs() { pin_status_.clear(); pin_in_progress_ = false; show_pin_remove_ = false; - ui::Notifications::instance().info("PIN removed"); + ui::Notifications::instance().info(TR("sec_pin_removed")); } else { - pin_status_ = "Incorrect PIN"; + pin_status_ = TR("sec_incorrect_pin_remove"); pin_in_progress_ = false; } }; }); } else { - pin_status_ = "Internal error"; + pin_status_ = TR("sec_internal_error_remove_pin"); pin_in_progress_ = false; } } diff --git a/src/app_sweep.cpp b/src/app_sweep.cpp index 963b278..b7309f3 100644 --- a/src/app_sweep.cpp +++ b/src/app_sweep.cpp @@ -310,6 +310,8 @@ void App::buildSweepCatalog() [](App& a) { ui::BootstrapDownloadDialog::show(&a); }, [](App&) { ui::BootstrapDownloadDialog::hide(); }); add("modal-backup", ui::NavPage::Overview, [](App& a) { a.show_backup_ = true; }, [](App& a) { a.show_backup_ = false; a.backup_status_.clear(); }); + add("modal-faq", ui::NavPage::Overview, + [](App& a) { a.show_faq_ = true; }, [](App& a) { a.show_faq_ = false; }); // Encrypt-wallet dialog — the redesigned passphrase-entry phase (never fires the async encrypt). add("modal-encrypt", ui::NavPage::Settings, [](App& a) { a.encrypt_dialog_phase_ = EncryptDialogPhase::PassphraseEntry; a.show_encrypt_dialog_ = true; }, @@ -708,9 +710,22 @@ void App::startSweepImpl(bool full) if (sweep_current_theme_only_) sweep_skins_.assign(1, ui::schema::SkinManager::instance().activeSkinId()); + // DEV/TEST hook (dormant unless the env is set): DRAGONX_SWEEP_ONLY="send,receive" restricts the + // sweep to the named surfaces and the dark skin, so a slow large-window run captures just the tab + // under review instead of all surfaces x every skin. + const char* sweepOnly = std::getenv("DRAGONX_SWEEP_ONLY"); + std::string sweepOnlyStr = sweepOnly ? sweepOnly : ""; + if (!sweepOnlyStr.empty()) sweep_skins_.assign(1, std::string("dark")); + sweep_full_ = full; if (full) { capture_mode_ = true; installDemoWalletData(); } buildSweepCatalog(); + if (!sweepOnlyStr.empty()) { + std::vector keep; + for (const auto& t : sweep_targets_) + if (sweepOnlyStr.find(t.name) != std::string::npos) keep.push_back(t); + sweep_targets_.swap(keep); + } if (sweep_targets_.empty()) { if (full) { clearDemoWalletData(); capture_mode_ = false; sweep_full_ = false; } return; } sweep_dir_ = full ? screenshotFullDir() : screenshotDir(); diff --git a/src/ui/effects/theme_effects.cpp b/src/ui/effects/theme_effects.cpp index d799060..104faf4 100644 --- a/src/ui/effects/theme_effects.cpp +++ b/src/ui/effects/theme_effects.cpp @@ -5,6 +5,7 @@ #include "theme_effects.h" #include "low_spec.h" #include "../schema/ui_schema.h" +#include "../layout.h" #include #include #include @@ -58,6 +59,7 @@ void ThemeEffects::beginFrame() { void ThemeEffects::loadFromTheme() { auto& S = schema::UI(); + const float dp = Layout::dpiScale(); auto eff = [&](const char* name) { return S.drawElement("effects", name); }; @@ -98,7 +100,7 @@ void ThemeEffects::loadFromTheme() { // ---- Shimmer ---- shimmer_.enabled = eff("shimmer-enabled").sizeOr(0.0f) > 0.5f; shimmer_.speed = eff("shimmer-speed").sizeOr(0.12f); - shimmer_.width = eff("shimmer-width").sizeOr(80.0f); + shimmer_.width = eff("shimmer-width").sizeOr(80.0f) * dp; shimmer_.alpha = eff("shimmer-alpha").sizeOr(0.06f); shimmer_.angle = eff("shimmer-angle").sizeOr(30.0f); // Shimmer color: read from the schema's color resolver @@ -124,7 +126,7 @@ void ThemeEffects::loadFromTheme() { glow_pulse_.speed = eff("glow-pulse-speed").sizeOr(2.0f); glow_pulse_.minAlpha = eff("glow-pulse-min-alpha").sizeOr(0.0f); glow_pulse_.maxAlpha = eff("glow-pulse-max-alpha").sizeOr(0.15f); - glow_pulse_.radius = eff("glow-pulse-radius").sizeOr(4.0f); + glow_pulse_.radius = eff("glow-pulse-radius").sizeOr(4.0f) * dp; auto glowColorElem = eff("glow-pulse-color"); if (!glowColorElem.color.empty()) { glow_pulse_.color = S.resolveColor(glowColorElem.color, IM_COL32(255, 218, 0, 255)); @@ -136,7 +138,7 @@ void ThemeEffects::loadFromTheme() { edge_trace_.enabled = eff("edge-trace-enabled").sizeOr(0.0f) > 0.5f; edge_trace_.speed = eff("edge-trace-speed").sizeOr(0.3f); edge_trace_.length = eff("edge-trace-length").sizeOr(0.20f); - edge_trace_.thickness = eff("edge-trace-thickness").sizeOr(1.5f); + edge_trace_.thickness = eff("edge-trace-thickness").sizeOr(1.5f) * dp; edge_trace_.alpha = eff("edge-trace-alpha").sizeOr(0.6f); auto edgeColorElem = eff("edge-trace-color"); if (!edgeColorElem.color.empty()) { @@ -149,7 +151,7 @@ void ThemeEffects::loadFromTheme() { ember_rise_.enabled = eff("ember-rise-enabled").sizeOr(0.0f) > 0.5f; ember_rise_.count = (int)eff("ember-rise-count").sizeOr(8.0f); ember_rise_.speed = eff("ember-rise-speed").sizeOr(0.4f); - ember_rise_.particleSize = eff("ember-rise-particle-size").sizeOr(1.5f); + ember_rise_.particleSize = eff("ember-rise-particle-size").sizeOr(1.5f) * dp; ember_rise_.alpha = eff("ember-rise-alpha").sizeOr(0.5f); auto emberColorElem = eff("ember-rise-color"); if (!emberColorElem.color.empty()) { @@ -165,7 +167,7 @@ void ThemeEffects::loadFromTheme() { // accent (e.g. Obsidian) are unaffected; Jade turns it on as its hero. gradient_border_.panels = eff("gradient-border-panels").sizeOr(0.0f) > 0.5f; gradient_border_.speed = eff("gradient-border-speed").sizeOr(0.15f); - gradient_border_.thickness = eff("gradient-border-thickness").sizeOr(1.5f); + gradient_border_.thickness = eff("gradient-border-thickness").sizeOr(1.5f) * dp; gradient_border_.alpha = eff("gradient-border-alpha").sizeOr(0.6f); auto gbColorA = eff("gradient-border-color-a"); if (!gbColorA.color.empty()) { @@ -194,7 +196,7 @@ void ThemeEffects::loadFromTheme() { sandstorm_.count = (int)eff("sandstorm-count").sizeOr(80.0f); sandstorm_.speed = eff("sandstorm-speed").sizeOr(0.35f); sandstorm_.windAngle = eff("sandstorm-wind-angle").sizeOr(15.0f); - sandstorm_.particleSize = eff("sandstorm-particle-size").sizeOr(1.5f); + sandstorm_.particleSize = eff("sandstorm-particle-size").sizeOr(1.5f) * dp; sandstorm_.alpha = eff("sandstorm-alpha").sizeOr(0.35f); sandstorm_.gustSpeed = eff("sandstorm-gust-speed").sizeOr(0.07f); sandstorm_.gustStrength = eff("sandstorm-gust-strength").sizeOr(0.4f); @@ -694,6 +696,7 @@ void ThemeEffects::drawEdgeTrace(ImDrawList* dl, ImVec2 pMin, ImVec2 pMax, void ThemeEffects::drawEmberRise(ImDrawList* dl, ImVec2 pMin, ImVec2 pMax) const { if (!enabled_ || !ember_rise_.enabled) return; + const float dp = Layout::dpiScale(); float w = pMax.x - pMin.x; float h = pMax.y - pMin.y; if (w <= 0 || h <= 0) return; @@ -707,7 +710,7 @@ void ThemeEffects::drawEmberRise(ImDrawList* dl, ImVec2 pMin, ImVec2 pMax) const // Deterministic pseudo-random x position per particle // Simple hash: sin of large prime multiples float xHash = std::sin((float)(i + 1) * 127.1f) * 0.5f + 0.5f; - float xDrift = std::sin(time_ * 0.7f + i * 2.4f) * 4.0f; // gentle sway + float xDrift = std::sin(time_ * 0.7f + i * 2.4f) * 4.0f * dp; // gentle sway float x = pMin.x + w * xHash + xDrift; float y = pMax.y - phase * (h + 8.0f); // rise from bottom past top @@ -745,6 +748,7 @@ void ThemeEffects::drawEmberRise(ImDrawList* dl, ImVec2 pMin, ImVec2 pMax) const void ThemeEffects::drawViewportEmbers(ImDrawList* dl) const { if (!enabled_ || !ember_rise_.enabled) return; + const float dp = Layout::dpiScale(); ImGuiViewport* vp = ImGui::GetMainViewport(); float vpW = vp->WorkSize.x; float vpH = vp->WorkSize.y; @@ -765,7 +769,7 @@ void ThemeEffects::drawViewportEmbers(ImDrawList* dl) const { float xHash = std::sin((float)(i + 1) * 127.1f) * 43758.5453f; xHash = xHash - (int)xHash; // fractional part if (xHash < 0) xHash += 1.0f; - float xDrift = std::sin(time_ * 0.5f + i * 1.7f) * 8.0f; + float xDrift = std::sin(time_ * 0.5f + i * 1.7f) * 8.0f * dp; float x = vpX + vpW * xHash + xDrift; float y = vpY + vpH * (1.0f - phase); // rise from bottom to top diff --git a/src/ui/material/draw_helpers.h b/src/ui/material/draw_helpers.h index 688fcfd..f7cbd52 100644 --- a/src/ui/material/draw_helpers.h +++ b/src/ui/material/draw_helpers.h @@ -925,7 +925,7 @@ inline void DrawStatCard(ImDrawList* dl, // Draw a full-height rounded rect with card rounding (left corners) // and clip to stripe width so the shape follows the corner radius. if ((card.accentCol & IM_COL32_A_MASK) != 0) { - float stripeW = 4.0f; + float stripeW = 4.0f * Layout::dpiScale(); dl->PushClipRect(cMin, ImVec2(cMin.x + stripeW, cMax.y), true); dl->AddRectFilled(cMin, cMax, card.accentCol, rnd, ImDrawFlags_RoundCornersLeft); @@ -1282,7 +1282,8 @@ inline bool DrawDialogTitleBar(const char* title, bool* p_open, ImU32 accent_col ImDrawList* dl = ImGui::GetWindowDrawList(); ImVec2 winPos = ImGui::GetWindowPos(); float winWidth = ImGui::GetWindowWidth(); - float barHeight = 36.0f; + const float dp = Layout::dpiScale(); + float barHeight = 36.0f * dp; // Get accent color from theme if not provided if (!accent_col) { @@ -1306,15 +1307,15 @@ inline bool DrawDialogTitleBar(const char* title, bool* p_open, ImU32 accent_col ImFont* titleFont = Type().subtitle1(); ImGui::PushFont(titleFont); ImVec2 titleSize = ImGui::CalcTextSize(title); - float titleX = barMin.x + 16.0f; + float titleX = barMin.x + 16.0f * dp; float titleY = barMin.y + (barHeight - titleSize.y) * 0.5f; DrawTextShadow(dl, ImVec2(titleX, titleY), OnSurface(), title); ImGui::PopFont(); // Close button (X) on right side if (p_open) { - float btnSize = 24.0f; - float btnX = barMax.x - btnSize - 12.0f; + float btnSize = 24.0f * dp; + float btnX = barMax.x - btnSize - 12.0f * dp; float btnY = barMin.y + (barHeight - btnSize) * 0.5f; ImVec2 btnMin(btnX, btnY); ImVec2 btnMax(btnX + btnSize, btnY + btnSize); @@ -1327,7 +1328,7 @@ inline bool DrawDialogTitleBar(const char* title, bool* p_open, ImU32 accent_col // Button background on hover if (hovered) { - dl->AddRectFilled(btnMin, btnMax, IM_COL32(255, 255, 255, held ? 40 : 25), 4.0f); + dl->AddRectFilled(btnMin, btnMax, IM_COL32(255, 255, 255, held ? 40 : 25), 4.0f * dp); } // Draw X icon @@ -1348,7 +1349,7 @@ inline bool DrawDialogTitleBar(const char* title, bool* p_open, ImU32 accent_col } // Reserve space for title bar so content starts below it - ImGui::SetCursorPosY(ImGui::GetCursorPosY() + barHeight + 8.0f); + ImGui::SetCursorPosY(ImGui::GetCursorPosY() + barHeight + 8.0f * dp); return closeClicked; } @@ -1648,7 +1649,7 @@ inline bool BeginOverlayDialog(const OverlayDialogSpec& spec) // Fill/border alpha govern every overlay dialog's card boundary — kept well above the default // glass panel so the card reads as a distinct surface over busy backdrops (tx lists, mining // tiles, chat) while staying translucent rather than opaque. - cardGlass.rounding = 16.0f; cardGlass.fillAlpha = 60; cardGlass.borderAlpha = 90; cardGlass.borderWidth = 1.0f; + cardGlass.rounding = 16.0f * dp; cardGlass.fillAlpha = 60; cardGlass.borderAlpha = 90; cardGlass.borderWidth = 1.0f; DrawGlassPanel(dl, cardMin, cardMax, cardGlass); } @@ -1662,8 +1663,8 @@ inline bool BeginOverlayDialog(const OverlayDialogSpec& spec) // Content child. ImGui::SetCursorScreenPos(ImVec2(cardX, cardY)); - ImGui::PushStyleVar(ImGuiStyleVar_ChildRounding, floating ? 20.0f : 16.0f); - ImGui::PushStyleVar(ImGuiStyleVar_WindowPadding, floating ? ImVec2(28, 20) : ImVec2(28, 24)); + ImGui::PushStyleVar(ImGuiStyleVar_ChildRounding, floating ? 20.0f * dp : 16.0f * dp); + ImGui::PushStyleVar(ImGuiStyleVar_WindowPadding, floating ? ImVec2(28 * dp, 20 * dp) : ImVec2(28 * dp, 24 * dp)); ImGui::PushStyleColor(ImGuiCol_ChildBg, ImVec4(0, 0, 0, 0)); // transparent (glass/blur behind) // A card with a known height is a fixed frame (fixed-height dialogs, and auto-height dialogs whose // content overflowed the viewport); otherwise the child auto-resizes to its content. diff --git a/src/ui/pages/settings_page.cpp b/src/ui/pages/settings_page.cpp index 25f2539..70e8f5d 100644 --- a/src/ui/pages/settings_page.cpp +++ b/src/ui/pages/settings_page.cpp @@ -580,11 +580,11 @@ enum SettingsTab { TAB_APPEARANCE = 0, TAB_WALLET, TAB_BACKUP, TAB_NODE, TAB_EXP static void renderSettingsTabBar(float availWidth) { using namespace material; struct T { int id; const char* label; const char* idstr; }; - static const T tabs[] = { - {TAB_APPEARANCE, "Appearance", "##stabA"}, {TAB_WALLET, "Wallet", "##stabW"}, - {TAB_BACKUP, "Backup & Data", "##stabB"}, {TAB_NODE, "Node & Security", "##stabN"}, - {TAB_EXPLORER, "Explorer", "##stabE"}, {TAB_CHAT, "Chat", "##stabC"}, - {TAB_ABOUT, "About", "##stabT"}, + const T tabs[] = { + {TAB_APPEARANCE, TR("grpa_tab_appearance"), "##stabA"}, {TAB_WALLET, TR("grpa_tab_wallet"), "##stabW"}, + {TAB_BACKUP, TR("grpa_tab_backup_data"), "##stabB"}, {TAB_NODE, TR("grpa_tab_node_security"), "##stabN"}, + {TAB_EXPLORER, TR("grpa_tab_explorer"), "##stabE"}, {TAB_CHAT, TR("grpa_tab_chat"), "##stabC"}, + {TAB_ABOUT, TR("grpa_tab_about"), "##stabT"}, }; ImDrawList* dl = ImGui::GetWindowDrawList(); ImFont* f = Type().body2(); @@ -811,7 +811,7 @@ void RenderSettingsPage(App* app) { if (!skin.valid) { ImGui::PushStyleColor(ImGuiCol_Text, ImVec4(1.0f, 0.3f, 0.3f, 1.0f)); ImGui::BeginDisabled(true); - std::string lbl = skin.name + " (invalid)"; + std::string lbl = skin.name + TR("grpa_invalid_suffix"); ImGui::Selectable(lbl.c_str(), false); ImGui::EndDisabled(); ImGui::PopStyleColor(); @@ -1196,14 +1196,25 @@ void RenderSettingsPage(App* app) { // O1: when a v1.3.0+ node auto-shields coinbase itself, show its real state — the checkbox // above only governs the wallet's own fallback shielder (which defers to the node). Nothing // renders on pre-1.3.0 daemons (never probed), so their behaviour is unchanged. - if (app && app->daemonAutoShieldProbed()) { + // This status must NOT flow with ImGui's cursor: the checkbox grid is absolutely positioned + // (SetCursorScreenPos at rowY), so a normal-flow Text would land under the auto-shield checkbox + // and the next grid row (Use Tor / Keep daemon) would draw on top of it. Instead, draw it on its + // own full-width row at the grid's current rowY, wrapped to the card, then advance rowY past it. + if (app && app->daemonAutoShieldProbed() && + (app->daemonAutoShieldActive() || !app->daemonAutoShieldDisabledReason().empty())) { + ImGui::SetCursorScreenPos(ImVec2(cx, rowY)); + ImGui::PushTextWrapPos((cx + cw) - ImGui::GetWindowPos().x); // wrap to the card content width if (app->daemonAutoShieldActive()) { ImGui::TextColored(ImVec4(0.40f, 0.78f, 0.40f, 1.0f), " %s", TR("autoshield_by_node")); if (!app->daemonAutoShieldAddress().empty()) ImGui::TextDisabled(" %s", app->daemonAutoShieldAddress().c_str()); - } else if (!app->daemonAutoShieldDisabledReason().empty()) { + } else { ImGui::TextDisabled(" %s", app->daemonAutoShieldDisabledReason().c_str()); } + ImGui::PopTextWrapPos(); + last = ImGui::GetCursorScreenPos().y; // cursor is now below the status text + rowY = last + gp; // next grid row starts below it + c = 0; } CB(TrId("use_tor", "tor"), &s_settingsState.use_tor); if (ImGui::IsItemHovered()) material::Tooltip("%s", TR("tt_tor")); @@ -1214,26 +1225,7 @@ void RenderSettingsPage(App* app) { if (CB(TrId("stop_external", "stop_ext"), &s_settingsState.stop_external_daemon)) saveSettingsPageState(app->settings()); if (ImGui::IsItemHovered()) material::Tooltip("%s", TR("tt_stop_external")); - - // O2: host a RandomX stratum pool from this node. Only offered on daemons that implement - // it (v1.3.0+, version encoded major*1e6+minor*1e4+rev*100+build), so we never show a - // toggle that does nothing. Takes effect on the next daemon start/restart. Blank allow-IP - // = loopback only (safe); a subnet opens it to that LAN. - if (app->state().daemon_version >= 1030000) { - if (CB(TrId("stratum_host", "strat_host"), &s_settingsState.stratum_host)) - saveSettingsPageState(app->settings()); - if (ImGui::IsItemHovered()) material::Tooltip("%s", TR("tt_stratum_host")); - if (s_settingsState.stratum_host) { - ImGui::TextDisabled(" %s", TR("stratum_host_hint")); - ImGui::SetNextItemWidth(220.0f * Layout::dpiScale()); - if (ImGui::InputTextWithHint("##stratumallowip", TR("stratum_allowip_hint"), - s_settingsState.stratum_allowip, sizeof(s_settingsState.stratum_allowip))) - saveSettingsPageState(app->settings()); - if (s_settingsState.stratum_allowip[0] != '\0') - ImGui::TextColored(ImVec4(0.95f, 0.75f, 0.25f, 1.0f), " %s", - TR("stratum_expose_warn")); - } - } + // (Stratum pool hosting lives in the Node & Security tab — it's a node feature.) } if (CB(TrId("verbose_logging", "verbose"), &s_settingsState.verbose_logging)) { dragonx::util::Logger::instance().setVerbose(s_settingsState.verbose_logging); @@ -1697,7 +1689,7 @@ void RenderSettingsPage(App* app) { ImGui::AlignTextToFramePadding(); ImGui::TextUnformatted(TR("lite_birthday_label")); ImGui::SameLine(leftX - sectionOrigin.x + liteLabelW); - ImGui::SetNextItemWidth(std::min(160.0f, liteInputW)); + ImGui::SetNextItemWidth(std::min(160.0f * dp, liteInputW)); ImGui::InputInt("##LiteRestoreBirthday", &s_settingsState.lite_restore_birthday); if (ImGui::IsItemHovered()) material::Tooltip("%s", TR("tt_lite_restore_birthday")); if (s_settingsState.lite_restore_birthday < 0) s_settingsState.lite_restore_birthday = 0; @@ -1709,7 +1701,7 @@ void RenderSettingsPage(App* app) { ImGui::AlignTextToFramePadding(); ImGui::TextUnformatted(TR("lite_account_label")); ImGui::SameLine(leftX - sectionOrigin.x + liteLabelW); - ImGui::SetNextItemWidth(std::min(160.0f, liteInputW)); + ImGui::SetNextItemWidth(std::min(160.0f * dp, liteInputW)); ImGui::InputInt("##LiteRestoreAccount", &s_settingsState.lite_restore_account); if (ImGui::IsItemHovered()) material::Tooltip("%s", TR("tt_lite_restore_account")); if (s_settingsState.lite_restore_account < 0) s_settingsState.lite_restore_account = 0; @@ -1889,7 +1881,7 @@ void RenderSettingsPage(App* app) { while (!liteKey.empty() && (liteKey.front()==' '||liteKey.front()=='\t'||liteKey.front()=='\n'||liteKey.front()=='\r')) liteKey.erase(liteKey.begin()); while (!liteKey.empty() && (liteKey.back()==' '||liteKey.back()=='\t'||liteKey.back()=='\n'||liteKey.back()=='\r')) liteKey.pop_back(); if (liteKey.empty()) { - s_settingsState.lite_backup_status = "Enter a private key to import."; + s_settingsState.lite_backup_status = TR("grpa_enter_private_key_to_import"); } else { const auto r = app->liteWallet()->importKey(liteKey); sodium_memzero(s_settingsState.lite_import_key, sizeof(s_settingsState.lite_import_key)); @@ -2650,6 +2642,10 @@ void RenderSettingsPage(App* app) { if (material::ActionButton("##aboutbug", TR("report_bug"), ICON_MD_BUG_REPORT, AT::Secondary)) util::Platform::openUrl("https://git.dragonx.is/dragonx/ObsidianDragon/issues"); if (ImGui::IsItemHovered()) material::Tooltip("%s", TR("tt_report_bug")); + lf.next(material::ActionButtonWidth(TR("faq"), ICON_MD_QUESTION_MARK)); + if (material::ActionButton("##aboutfaq", TR("faq"), ICON_MD_QUESTION_MARK, AT::Secondary)) + app->showFaqDialog(); + if (ImGui::IsItemHovered()) material::Tooltip("%s", TR("faq_open_tooltip")); } const float rightBottom = ImGui::GetCursorScreenPos().y; @@ -2676,6 +2672,33 @@ void RenderSettingsPage(App* app) { if (s_settingsState.current_tab == TAB_NODE) ImGui::Dummy(ImVec2(0, gap)); + // ==================================================================== + // MINING POOL HOSTING — run this node's built-in RandomX stratum server so other miners can point + // at this machine. It's a node feature, so it belongs here (not the Wallet tab). Full-node only, and + // only on a daemon new enough to implement -stratum (v1.3.0+, version encoded + // major*1e6+minor*1e4+rev*100+build). Takes effect on the next daemon start/restart; a blank allow-IP + // keeps it loopback-only (safe), a subnet opens it to that LAN. + // ==================================================================== + if (app->supportsFullNodeLifecycleActions() && s_settingsState.current_tab == TAB_NODE && + app->state().daemon_version >= 1030000) { + Type().textColored(TypeStyle::Overline, OnSurfaceMedium(), TR("stratum_host_section")); + ImGui::Dummy(ImVec2(0, Layout::spacingXs())); + material::GlassCardScope card(dl, availWidth, pad, bottomPad, glassSpec); + if (ImGui::Checkbox(TR("stratum_host"), &s_settingsState.stratum_host)) + saveSettingsPageState(app->settings()); + if (ImGui::IsItemHovered()) material::Tooltip("%s", TR("tt_stratum_host")); + if (s_settingsState.stratum_host) { + ImGui::TextDisabled(" %s", TR("stratum_host_hint")); + ImGui::SetNextItemWidth(220.0f * Layout::dpiScale()); + if (ImGui::InputTextWithHint("##stratumallowip", TR("stratum_allowip_hint"), + s_settingsState.stratum_allowip, sizeof(s_settingsState.stratum_allowip))) + saveSettingsPageState(app->settings()); + if (s_settingsState.stratum_allowip[0] != '\0') + ImGui::TextColored(ImVec4(0.95f, 0.75f, 0.25f, 1.0f), " %s", + TR("stratum_expose_warn")); + } + } + // ==================================================================== // DEBUG OPTIONS — collapsible card (full-node only: holds the screenshot sweep + the dragonxd // daemon debug= categories written to DRAGONX.conf; lite has no daemon). Shown on the Node tab. @@ -2738,7 +2761,7 @@ void RenderSettingsPage(App* app) { if (chat::hushChatFeatureEnabledAtBuild()) { // Populate the Chat tab with demo conversations so the sweep captures its real UI. ImGui::SameLine(); - if (TactileButton("Seed demo chat", ImVec2(0, 0), S.resolveFont("button"))) + if (TactileButton(TR("grpa_seed_demo_chat"), ImVec2(0, 0), S.resolveFont("button"))) app->seedChatDemoData(); if (ImGui::IsItemHovered()) material::Tooltip("%s", TR("tt_seed_demo_chat")); } @@ -2765,29 +2788,29 @@ void RenderSettingsPage(App* app) { "paymentdisclosure", "pow", "proxy", "prune", "rand", "reindex", "rpc", "selectcoins", "tor", "zmq", "zrpc" }; - static const char* debugTips[] = { - "Peer address tracking and management", - "Alert system messages", - "Benchmark timings for operations", - "Coin database read/write operations", - "Berkeley DB operations", - "Fee estimation algorithm", - "HTTP RPC server activity", - "Libevent networking library", - "Lock contention debugging", - "Transaction memory pool activity", - "Network connections and messages", - "Payment disclosure protocol", - "Proof-of-work mining activity", - "SOCKS5 proxy connections", - "Block pruning operations", - "Random number generation", - "Blockchain reindexing progress", - "RPC command processing", - "Coin selection for transactions", - "Tor integration and circuit info", - "ZeroMQ notification system", - "Shielded (z-addr) RPC operations" + const char* debugTips[] = { + TR("grpa_dbg_addrman"), + TR("grpa_dbg_alert"), + TR("grpa_dbg_bench"), + TR("grpa_dbg_coindb"), + TR("grpa_dbg_db"), + TR("grpa_dbg_estimatefee"), + TR("grpa_dbg_http"), + TR("grpa_dbg_libevent"), + TR("grpa_dbg_lock"), + TR("grpa_dbg_mempool"), + TR("grpa_dbg_net"), + TR("grpa_dbg_paymentdisclosure"), + TR("grpa_dbg_pow"), + TR("grpa_dbg_proxy"), + TR("grpa_dbg_prune"), + TR("grpa_dbg_rand"), + TR("grpa_dbg_reindex"), + TR("grpa_dbg_rpc"), + TR("grpa_dbg_selectcoins"), + TR("grpa_dbg_tor"), + TR("grpa_dbg_zmq"), + TR("grpa_dbg_zrpc") }; constexpr int numCats = sizeof(debugCats) / sizeof(debugCats[0]); @@ -3037,7 +3060,7 @@ void RenderSettingsPage(App* app) { ImGui::TextWrapped("%s", TR("rescan_bootstrapped_msg")); ImGui::Spacing(); ImGui::Text("%s", TR("rescan_from_height")); - ImGui::SetNextItemWidth(160.0f); + ImGui::SetNextItemWidth(160.0f * dp); ImGui::InputInt("##rescanHeight", &s_settingsState.rescan_start_height); if (s_settingsState.rescan_start_height < 0) s_settingsState.rescan_start_height = 0; } else { @@ -3051,12 +3074,12 @@ void RenderSettingsPage(App* app) { ImGui::Spacing(); float btnW = (ImGui::GetContentRegionAvail().x - ImGui::GetStyle().ItemSpacing.x) * 0.5f; - if (material::TactileButton(TrId("cancel", "rescan_cancel").c_str(), ImVec2(btnW, 40))) { + if (material::TactileButton(TrId("cancel", "rescan_cancel").c_str(), ImVec2(btnW, 40 * dp))) { s_settingsState.confirm_rescan = false; } ImGui::SameLine(); ImGui::BeginDisabled(detecting); - if (material::TactileButton(TrId("rescan", "rescan_confirm").c_str(), ImVec2(btnW, 40))) { + if (material::TactileButton(TrId("rescan", "rescan_confirm").c_str(), ImVec2(btnW, 40 * dp))) { if (bootstrapped) { app->runtimeRescan(s_settingsState.rescan_start_height); } else { diff --git a/src/ui/sidebar.h b/src/ui/sidebar.h index 8badf4d..e5b81ca 100644 --- a/src/ui/sidebar.h +++ b/src/ui/sidebar.h @@ -219,7 +219,7 @@ inline void DrawGlassCutout(ImDrawList* dl, ImVec2 mn, ImVec2 mx, float lineW = s_cc.lineW; // --- Outer glow pass: wider, softer dark edge on top-left --- - float glowExpand = s_cc.glowExpand; + float glowExpand = s_cc.glowExpand * Layout::dpiScale(); int glowA = (int)s_cc.glowAlpha; float glowLineW = s_cc.glowLineW; { @@ -289,6 +289,7 @@ inline void DrawGlassBevelButton(ImDrawList* dl, ImVec2 mn, ImVec2 mx, // inner pass gives crisp bevel edge. All use AddRect with rounding so // every layer follows the rounded corners perfectly — no clip rects needed. { + const float dp = Layout::dpiScale(); float cx = (mn.x + mx.x) * 0.5f; float cy = (mn.y + mx.y) * 0.5f; @@ -304,7 +305,7 @@ inline void DrawGlassBevelButton(ImDrawList* dl, ImVec2 mn, ImVec2 mx, struct BevelPass { float expand; float lineW; float fadeStart; float fadeEnd; }; BevelPass passes[] = { - { 0.5f, 0.75f, 0.30f, 0.55f }, // Outer glow (thin) + { 0.5f * dp, 0.75f, 0.30f, 0.55f }, // Outer glow (thin) { 0.0f, 0.75f, 0.38f, 0.58f }, // Inner crisp bevel }; @@ -387,7 +388,7 @@ inline void DrawGlassBevelButton(ImDrawList* dl, ImVec2 mn, ImVec2 mx, } } if (depth > s_ic.threshold) { - float baseInset = s_ic.inset; + float baseInset = s_ic.inset * Layout::dpiScale(); int shadowMax = (int)(s_ic.maxAlpha * depth); float fadeRatio = s_ic.fadeRatio; float bW = mx.x - mn.x - baseInset * 2.0f; @@ -487,7 +488,7 @@ inline bool RenderSidebar(NavPage& current, float sidebarWidth, float contentHei float fixedH = stripH; // collapse strip for (int i = 0; i < (int)NavPage::Count_; ++i) if (IsNavPageVisible(kNavItems[i].page) && kNavItems[i].section_label && showLabels) - fixedH += olFsz + 2.0f + sectionLabelPadBot; // section label + pad below + fixedH += olFsz + 2.0f * dp + sectionLabelPadBot; // section label + pad below fixedH += bottomPadding + stripH; // exit area float baseFlexH = baseNavGap; @@ -525,7 +526,7 @@ inline bool RenderSidebar(NavPage& current, float sidebarWidth, float contentHei if (showLabels) { curY += sectionGap; if (nSectionLabels < 4) sectionLabelY[nSectionLabels++] = curY; - curY += olFsz + 2.0f + sectionLabelPadBot; + curY += olFsz + 2.0f * dp + sectionLabelPadBot; } else { curY += sectionGap * 0.4f; if (nSeparators < 4) separatorY[nSeparators++] = curY; @@ -653,7 +654,7 @@ inline bool RenderSidebar(NavPage& current, float sidebarWidth, float contentHei fx.drawShimmer(dl, indMin, indMax, btnRnd); fx.drawGradientBorderShift(dl, indMin, indMax, btnRnd); } - DrawGlassCutout(dl, indMin, indMax, btnRnd, 1.5f); + DrawGlassCutout(dl, indMin, indMax, btnRnd, 1.5f * dp); DrawGlassBevelButton(dl, indMin, indMax, btnRnd, btnDepth, 18); buttonRects.push_back({indMin, indMax, btnRnd}); } @@ -684,7 +685,6 @@ inline bool RenderSidebar(NavPage& current, float sidebarWidth, float contentHei bool itemHasBadge = (item.page == NavPage::History && status.unconfirmedTxCount > 0) || (item.page == NavPage::Mining && status.miningActive) || - (item.page == NavPage::Peers && status.peerCount > 0) || (item.page == NavPage::Chat && status.chatUnreadCount > 0); float badgeReserve = 0.0f; if (itemHasBadge) { @@ -732,8 +732,6 @@ inline bool RenderSidebar(NavPage& current, float sidebarWidth, float contentHei badgeCol = Warning(); badgeTextCol = OnWarning(); } else if (item.page == NavPage::Mining && status.miningActive) { dotOnly = true; badgeCol = Success(); - } else if (item.page == NavPage::Peers && status.peerCount > 0) { - badgeCount = status.peerCount; } else if (item.page == NavPage::Chat && status.chatUnreadCount > 0) { badgeCount = status.chatUnreadCount; } diff --git a/src/ui/windows/address_transfer_dialog.h b/src/ui/windows/address_transfer_dialog.h index ede349d..8fed81e 100644 --- a/src/ui/windows/address_transfer_dialog.h +++ b/src/ui/windows/address_transfer_dialog.h @@ -93,7 +93,7 @@ public: // Arrow { float arrowCX = ImGui::GetContentRegionAvail().x * 0.5f; - ImGui::SetCursorPosX(arrowCX - 8.0f); + ImGui::SetCursorPosX(arrowCX - 8.0f * dp); ImFont* iconFont = Type().iconMed(); float fsz = ScaledFontSize(iconFont); ImVec2 pos = ImGui::GetCursorScreenPos(); @@ -312,7 +312,8 @@ private: ImGui::Spacing(); ImGui::Spacing(); - float btnW = 120.0f; + const float dp = Layout::dpiScale(); + float btnW = 120.0f * dp; ImGui::SetCursorPosX((ImGui::GetContentRegionAvail().x - btnW) * 0.5f); if (TactileButton(TR("close"), ImVec2(btnW, 0))) { s_open = false; diff --git a/src/ui/windows/balance_components.cpp b/src/ui/windows/balance_components.cpp index 34849fc..523f7dc 100644 --- a/src/ui/windows/balance_components.cpp +++ b/src/ui/windows/balance_components.cpp @@ -264,7 +264,7 @@ void RenderSharedAddressList(App* app, float listH, float availW, } else if (rows.empty()) { float cw = ImGui::GetContentRegionAvail().x; float ch = ImGui::GetContentRegionAvail().y; - if (ch < 60) ch = 60; + if (ch < 60.0f * dp) ch = 60.0f * dp; const char* emptyMsg = addr_search[0] ? TR("no_addresses_match") : TR("no_addresses_yet"); ImVec2 msgSz = ImGui::CalcTextSize(emptyMsg); ImGui::SetCursorPosX((cw - msgSz.x) * 0.5f); diff --git a/src/ui/windows/balance_tab.cpp b/src/ui/windows/balance_tab.cpp index c84be7e..c46deb0 100644 --- a/src/ui/windows/balance_tab.cpp +++ b/src/ui/windows/balance_tab.cpp @@ -302,9 +302,9 @@ static void RenderBalanceClassic(App* app) float cardPadLg = (classicPadOverride >= 0.0f) ? classicPadOverride : Layout::spacingLg(); // Card height: must fit the Market card's content (overline + price + 24h) - const float ovGap = S.drawElement("tabs.balance", "overline-value-gap").sizeOr(6.0f); - const float valGap = S.drawElement("tabs.balance", "value-caption-gap").sizeOr(4.0f); - const float tickGap = S.drawElement("tabs.balance.classic", "ticker-gap").sizeOr(4.0f); + const float ovGap = S.drawElement("tabs.balance", "overline-value-gap").sizeOr(6.0f) * dp; + const float valGap = S.drawElement("tabs.balance", "value-caption-gap").sizeOr(4.0f) * dp; + const float tickGap = S.drawElement("tabs.balance.classic", "ticker-gap").sizeOr(4.0f) * dp; float marketContentH = cardPadLg + ovFont->LegacySize + ovGap + sub1->LegacySize + 2.0f * dp @@ -323,7 +323,7 @@ static void RenderBalanceClassic(App* app) // Helper: draw accent stripe on left edge, clipped to card rounded corners. // We draw a full-size rounded rect (left corners only) and clip it to the // stripe width so the shape itself follows the card rounding. - const float accentW = S.drawElement("tabs.balance", "accent-width").sizeOr(4.0f); + const float accentW = S.drawElement("tabs.balance", "accent-width").sizeOr(4.0f) * dp; auto drawAccent = [&](const ImVec2& cMin, const ImVec2& cMax, ImU32 col) { dl->PushClipRect(cMin, ImVec2(cMin.x + accentW, cMax.y), true); dl->AddRectFilled(cMin, cMax, col, cardSpec.rounding, @@ -446,7 +446,7 @@ static void RenderBalanceClassic(App* app) 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); + ImVec2 pillSz = DrawPill(dl, ImVec2(cx, cy), buf, capFont, fg, bg, bd, ImVec2(4.0f * dp, 2.0f * dp)); // 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")); @@ -456,7 +456,7 @@ static void RenderBalanceClassic(App* app) // Hover glow if (material::IsRectHovered(cMin, cMax)) { dl->AddRect(cMin, cMax, IM_COL32(255, 255, 255, (int)S.drawElement("tabs.balance", "hover-glow-alpha").sizeOr(40.0f)), - cardSpec.rounding, 0, S.drawElement("tabs.balance", "hover-glow-thickness").sizeOr(1.5f)); + cardSpec.rounding, 0, S.drawElement("tabs.balance", "hover-glow-thickness").sizeOr(1.5f) * dp); } } @@ -487,7 +487,7 @@ static void RenderBalanceClassic(App* app) { float privPct = (s_dispTotal > 1e-9) ? (float)(s_dispShielded / s_dispTotal * 100.0) : 0.0f; - snprintf(buf, sizeof(buf), "%.0f%% of total · %d Z-addr", + snprintf(buf, sizeof(buf), TR("baltab_pct_of_total_zaddr"), privPct, (int)state.z_addresses.size()); dl->AddText(capFont, capFont->LegacySize, ImVec2(cx, cy), WithAlpha(Success(), 160), buf); @@ -498,8 +498,8 @@ static void RenderBalanceClassic(App* app) snprintf(buf, sizeof(buf), "+%.4f", state.unconfirmed_balance); ImVec2 ts = capFont->CalcTextSizeA( capFont->LegacySize, 10000, 0, buf); - float bp = S.drawElement("tabs.balance.classic", "unconfirmed-badge-padding").sizeOr(4.0f); - float br = S.drawElement("tabs.balance.classic", "unconfirmed-badge-rounding").sizeOr(4.0f); + float bp = S.drawElement("tabs.balance.classic", "unconfirmed-badge-padding").sizeOr(4.0f) * dp; + float br = S.drawElement("tabs.balance.classic", "unconfirmed-badge-rounding").sizeOr(4.0f) * dp; ImVec2 bMin(cMax.x - ts.x - bp * 3, cMin.y + cardPadLg); ImVec2 bMax(cMax.x - bp, bMin.y + ts.y + bp); @@ -513,7 +513,7 @@ static void RenderBalanceClassic(App* app) // Hover glow + click to Receive if (material::IsRectHovered(cMin, cMax)) { dl->AddRect(cMin, cMax, IM_COL32(255, 255, 255, (int)S.drawElement("tabs.balance", "hover-glow-alpha").sizeOr(40.0f)), - cardSpec.rounding, 0, S.drawElement("tabs.balance", "hover-glow-thickness").sizeOr(1.5f)); + cardSpec.rounding, 0, S.drawElement("tabs.balance", "hover-glow-thickness").sizeOr(1.5f) * dp); ImGui::SetMouseCursor(ImGuiMouseCursor_Hand); if (ImGui::IsMouseClicked(0)) app->setCurrentPage(NavPage::Receive); @@ -543,7 +543,7 @@ static void RenderBalanceClassic(App* app) OnSurfaceMedium(), DRAGONX_TICKER); cy += sub1->LegacySize + valGap; - snprintf(buf, sizeof(buf), "%d T-addresses", + snprintf(buf, sizeof(buf), TR("baltab_t_addresses_count"), (int)state.t_addresses.size()); dl->AddText(capFont, capFont->LegacySize, ImVec2(cx, cy), OnSurfaceDisabled(), buf); @@ -551,7 +551,7 @@ static void RenderBalanceClassic(App* app) // Hover glow + click to Receive if (material::IsRectHovered(cMin, cMax)) { dl->AddRect(cMin, cMax, IM_COL32(255, 255, 255, (int)S.drawElement("tabs.balance", "hover-glow-alpha").sizeOr(40.0f)), - cardSpec.rounding, 0, S.drawElement("tabs.balance", "hover-glow-thickness").sizeOr(1.5f)); + cardSpec.rounding, 0, S.drawElement("tabs.balance", "hover-glow-thickness").sizeOr(1.5f) * dp); ImGui::SetMouseCursor(ImGuiMouseCursor_Hand); if (ImGui::IsMouseClicked(0)) app->setCurrentPage(NavPage::Receive); @@ -589,7 +589,7 @@ static void RenderBalanceClassic(App* app) [](unsigned char c){ return (char)std::toupper(c); }); float textW = std::max(pSz.x + tickGap + usdSz.x, ovFont->CalcTextSizeA(ovFont->LegacySize, 10000, 0, marketLabel.c_str()).x); - float sparkGap = S.drawElement("tabs.balance.classic", "sparkline-gap").sizeOr(12.0f); + float sparkGap = S.drawElement("tabs.balance.classic", "sparkline-gap").sizeOr(12.0f) * dp; float sparkLeft = cx + textW + sparkGap; float sparkRight = cMax.x - cardPadLg; @@ -611,7 +611,7 @@ static void RenderBalanceClassic(App* app) bool pos = market.change_24h >= 0; ImU32 chgCol = pos ? Success() : Error(); - snprintf(buf, sizeof(buf), "%s%.1f%% 24h", + snprintf(buf, sizeof(buf), TR("baltab_pct_change_24h"), pos ? "+" : "", market.change_24h); dl->AddText(capFont, capFont->LegacySize, ImVec2(cx, cy), chgCol, buf); @@ -633,7 +633,7 @@ static void RenderBalanceClassic(App* app) // Hover glow + click to Market if (material::IsRectHovered(cMin, cMax)) { dl->AddRect(cMin, cMax, IM_COL32(255, 255, 255, (int)S.drawElement("tabs.balance", "hover-glow-alpha").sizeOr(40.0f)), - cardSpec.rounding, 0, S.drawElement("tabs.balance", "hover-glow-thickness").sizeOr(1.5f)); + cardSpec.rounding, 0, S.drawElement("tabs.balance", "hover-glow-thickness").sizeOr(1.5f) * dp); ImGui::SetMouseCursor(ImGuiMouseCursor_Hand); if (ImGui::IsMouseClicked(0)) app->setCurrentPage(NavPage::Market); @@ -790,20 +790,20 @@ static void RenderBalanceDonut(App* app) { ImFont* capFont = Type().caption(); ImFont* body2 = Type().body2(); - float legendDotR = S.drawElement("tabs.balance.donut", "legend-dot-radius").sizeOr(4.0f); - float legendXOff = S.drawElement("tabs.balance.donut", "legend-x-offset").sizeOr(14.0f); - float legendLineGap = S.drawElement("tabs.balance.donut", "legend-line-gap").sizeOr(6.0f); - float legendSectionGap = S.drawElement("tabs.balance.donut", "legend-section-gap").sizeOr(10.0f); + float legendDotR = S.drawElement("tabs.balance.donut", "legend-dot-radius").sizeOr(4.0f) * dp; + float legendXOff = S.drawElement("tabs.balance.donut", "legend-x-offset").sizeOr(14.0f) * dp; + float legendLineGap = S.drawElement("tabs.balance.donut", "legend-line-gap").sizeOr(6.0f) * dp; + float legendSectionGap = S.drawElement("tabs.balance.donut", "legend-section-gap").sizeOr(10.0f) * dp; // Shielded legend dl->AddCircleFilled(ImVec2(legendX + 5 * dp, legendY + capFont->LegacySize * 0.5f), legendDotR, Success()); - snprintf(buf, sizeof(buf), "Shielded %.8f", s_dispShielded); + snprintf(buf, sizeof(buf), TR("baltab_shielded_amount"), s_dispShielded); dl->AddText(capFont, capFont->LegacySize, ImVec2(legendX + legendXOff, legendY), Success(), buf); legendY += capFont->LegacySize + legendLineGap; // Transparent legend dl->AddCircleFilled(ImVec2(legendX + 5 * dp, legendY + capFont->LegacySize * 0.5f), legendDotR, Warning()); - snprintf(buf, sizeof(buf), "Transparent %.8f", s_dispTransparent); + snprintf(buf, sizeof(buf), TR("baltab_transparent_amount"), s_dispTransparent); dl->AddText(capFont, capFont->LegacySize, ImVec2(legendX + legendXOff, legendY), Warning(), buf); legendY += capFont->LegacySize + legendSectionGap; @@ -811,15 +811,15 @@ static void RenderBalanceDonut(App* app) { const auto& market = state.market; if (market.price_usd > 0) { if (market.price_usd >= 0.01) - snprintf(buf, sizeof(buf), "Market: $%.4f", market.price_usd); + snprintf(buf, sizeof(buf), TR("baltab_market_price_4dp"), market.price_usd); else - snprintf(buf, sizeof(buf), "Market: $%.8f", market.price_usd); + snprintf(buf, sizeof(buf), TR("baltab_market_price_8dp"), market.price_usd); dl->AddText(capFont, capFont->LegacySize, ImVec2(legendX + legendXOff, legendY), OnSurfaceMedium(), buf); legendY += capFont->LegacySize + 4 * dp; bool pos = market.change_24h >= 0; - snprintf(buf, sizeof(buf), "%s%.1f%% 24h", pos ? "+" : "", market.change_24h); + snprintf(buf, sizeof(buf), TR("baltab_pct_change_24h"), pos ? "+" : "", market.change_24h); dl->AddText(capFont, capFont->LegacySize, ImVec2(legendX + legendXOff, legendY), pos ? Success() : Error(), buf); } @@ -946,7 +946,7 @@ static void RenderBalanceConsolidated(App* app) { float divY = cardMin.y + cardH * S.drawElement("tabs.balance.consolidated", "divider-y-ratio").sizeOr(0.55f); dl->AddLine(ImVec2(cardMin.x + pad, divY), ImVec2(cardMax.x - pad, divY), IM_COL32(255, 255, 255, (int)S.drawElement("tabs.balance.consolidated", "divider-alpha").sizeOr(20.0f)), - S.drawElement("tabs.balance.consolidated", "divider-thickness").sizeOr(1.0f)); + S.drawElement("tabs.balance.consolidated", "divider-thickness").sizeOr(1.0f) * dp); // Bottom half: proportion bars float barY = divY + Layout::spacingSm(); @@ -1122,7 +1122,7 @@ static void RenderBalanceDashboard(App* app) { // Accent stripe — clipped to tile rounded corners { - float aw = S.drawElement("tabs.balance", "accent-width").sizeOr(4.0f); + float aw = S.drawElement("tabs.balance", "accent-width").sizeOr(4.0f) * dp; dl->PushClipRect(tMin, ImVec2(tMin.x + aw, tMax.y), true); dl->AddRectFilled(tMin, tMax, tiles[i].accent, tileSpec.rounding, ImDrawFlags_RoundCornersLeft); @@ -1159,7 +1159,7 @@ static void RenderBalanceDashboard(App* app) { // Click if (material::IsRectHovered(tMin, tMax)) { dl->AddRect(tMin, tMax, IM_COL32(255, 255, 255, (int)S.drawElement("tabs.balance", "hover-glow-alpha").sizeOr(40.0f)), - tileSpec.rounding, 0, S.drawElement("tabs.balance", "hover-glow-thickness").sizeOr(1.5f)); + tileSpec.rounding, 0, S.drawElement("tabs.balance", "hover-glow-thickness").sizeOr(1.5f) * dp); ImGui::SetMouseCursor(ImGuiMouseCursor_Hand); if (ImGui::IsMouseClicked(0)) app->setCurrentPage(tiles[i].nav); @@ -1208,7 +1208,7 @@ static void RenderBalanceVerticalStack(App* app) { // Font-content floor per row: icon + label + value must fit float vstackRowFontFloor = std::max(body2->LegacySize, capFont->LegacySize) + Layout::spacingSm() * 2; - float rowGap = S.drawElement("tabs.balance.vertical-stack", "row-gap").sizeOr(2.0f); + float rowGap = S.drawElement("tabs.balance.vertical-stack", "row-gap").sizeOr(2.0f) * dp; float vstackFontFloor = vstackRowFontFloor * 4 + rowGap * 3; float vstackCardH = S.drawElement("tabs.balance.vertical-stack", "card-height").size; float stackH; @@ -1238,10 +1238,10 @@ static void RenderBalanceVerticalStack(App* app) { }; RowInfo rowInfos[4] = { - {"Total Balance", ICON_MD_ACCOUNT_BALANCE_WALLET, S.resolveColor("var(--accent-total)", OnSurface()), s_dispTotal, 1.0f}, - {"Shielded", ICON_MD_SHIELD, S.resolveColor("var(--accent-shielded)", Success()), s_dispShielded, shieldRatio}, - {"Transparent", ICON_MD_CIRCLE, S.resolveColor("var(--accent-transparent)", Warning()), s_dispTransparent, transRatio}, - {"Market", ICON_MD_TRENDING_UP, S.resolveColor("var(--accent-action)", Primary()), state.market.price_usd, 0.0f}, + {TR("baltab_total_balance"), ICON_MD_ACCOUNT_BALANCE_WALLET, S.resolveColor("var(--accent-total)", OnSurface()), s_dispTotal, 1.0f}, + {TR("baltab_shielded"), ICON_MD_SHIELD, S.resolveColor("var(--accent-shielded)", Success()), s_dispShielded, shieldRatio}, + {TR("baltab_transparent"), ICON_MD_CIRCLE, S.resolveColor("var(--accent-transparent)", Warning()), s_dispTransparent, transRatio}, + {TR("baltab_market"), ICON_MD_TRENDING_UP, S.resolveColor("var(--accent-action)", Primary()), state.market.price_usd, 0.0f}, }; for (int i = 0; i < 4; i++) { @@ -1296,7 +1296,7 @@ static void RenderBalanceVerticalStack(App* app) { // Proportion bar (for shielded/transparent rows — fills gap between label and amount) if (i == 1 || i == 2) { ImVec2 labelSz = capFont->CalcTextSizeA(capFont->LegacySize, 10000, 0, rowInfos[i].label); - float barGap = S.drawElement("tabs.balance.vertical-stack", "sparkline-gap").sizeOr(12.0f); + float barGap = S.drawElement("tabs.balance.vertical-stack", "sparkline-gap").sizeOr(12.0f) * dp; float barPad = S.drawElement("tabs.balance.vertical-stack", "sparkline-pad").sizeOr(4.0f); float barH = std::max( S.drawElement("tabs.balance.vertical-stack", "bar-min-height").sizeOr(3.0f), @@ -1326,8 +1326,8 @@ static void RenderBalanceVerticalStack(App* app) { // Sparkline in the gap between label and 24h change if (state.market.price_history.size() >= 2) { ImVec2 labelSz = capFont->CalcTextSizeA(capFont->LegacySize, 10000, 0, rowInfos[i].label); - float sparkGap = S.drawElement("tabs.balance.vertical-stack", "sparkline-gap").sizeOr(12.0f); - float sparkPad = S.drawElement("tabs.balance.vertical-stack", "sparkline-pad").sizeOr(4.0f); + float sparkGap = S.drawElement("tabs.balance.vertical-stack", "sparkline-gap").sizeOr(12.0f) * dp; + float sparkPad = S.drawElement("tabs.balance.vertical-stack", "sparkline-pad").sizeOr(4.0f) * dp; float sparkLeft = px + labelSz.x + sparkGap; float sparkRight = chgX - sparkGap; if (sparkLeft < sparkRight) { @@ -1387,8 +1387,8 @@ static void RenderBalanceVertical2x2(App* app) { ImFont* iconFont = Type().iconSmall(); // Font-content floor per row: caption text + vertical padding float v2x2RowFontFloor = capFont->LegacySize + Layout::spacingSm() * 2; - float rowGap = S.drawElement(cfgSec, "row-gap").sizeOr(2.0f); - float colGap = S.drawElement(cfgSec, "col-gap").sizeOr(8.0f); + float rowGap = S.drawElement(cfgSec, "row-gap").sizeOr(2.0f) * dp; + float colGap = S.drawElement(cfgSec, "col-gap").sizeOr(8.0f) * dp; float v2x2FontFloor = v2x2RowFontFloor * 2 + rowGap; float cardHOverride = S.drawElement(cfgSec, "card-height").size; float stackH; @@ -1431,13 +1431,13 @@ static void RenderBalanceVertical2x2(App* app) { CellInfo cells[2][2] = { // Row 0: Total Balance (left), Shielded (right) { - {"Total Balance", ICON_MD_ACCOUNT_BALANCE_WALLET, S.resolveColor("var(--accent-total)", OnSurface()), s_dispTotal, 1.0f, false, false}, - {"Shielded", ICON_MD_SHIELD, S.resolveColor("var(--accent-shielded)", Success()), s_dispShielded, shieldRatio, false, true}, + {TR("baltab_total_balance"), ICON_MD_ACCOUNT_BALANCE_WALLET, S.resolveColor("var(--accent-total)", OnSurface()), s_dispTotal, 1.0f, false, false}, + {TR("baltab_shielded"), ICON_MD_SHIELD, S.resolveColor("var(--accent-shielded)", Success()), s_dispShielded, shieldRatio, false, true}, }, // Row 1: Market (left), Transparent (right) { - {"Market", ICON_MD_TRENDING_UP, S.resolveColor("var(--accent-action)", Primary()), state.market.price_usd, 0.0f, true, false}, - {"Transparent", ICON_MD_CIRCLE, S.resolveColor("var(--accent-transparent)", Warning()), s_dispTransparent, transRatio, false, true}, + {TR("baltab_market"), ICON_MD_TRENDING_UP, S.resolveColor("var(--accent-action)", Primary()), state.market.price_usd, 0.0f, true, false}, + {TR("baltab_transparent"), ICON_MD_CIRCLE, S.resolveColor("var(--accent-transparent)", Warning()), s_dispTransparent, transRatio, false, true}, }, }; @@ -1519,8 +1519,8 @@ static void RenderBalanceVertical2x2(App* app) { // Sparkline between label and 24h change if (state.market.price_history.size() >= 2) { ImVec2 labelSz = capFont->CalcTextSizeA(capFont->LegacySize, 10000, 0, cell.label); - float sparkGap = S.drawElement(cfgSec, "sparkline-gap").sizeOr(12.0f); - float sparkPad = S.drawElement(cfgSec, "sparkline-pad").sizeOr(4.0f); + float sparkGap = S.drawElement(cfgSec, "sparkline-gap").sizeOr(12.0f) * dp; + float sparkPad = S.drawElement(cfgSec, "sparkline-pad").sizeOr(4.0f) * dp; float sparkLeft = px + labelSz.x + sparkGap; float sparkRight = chgX - sparkGap; if (sparkLeft < sparkRight) { @@ -1665,7 +1665,7 @@ static void RenderBalanceShield(App* app) { ImVec2 needleTip(gaugeCx + cosf(needleAngle) * needleLen, gaugeCy + sinf(needleAngle) * needleLen); dl->AddLine(ImVec2(gaugeCx, gaugeCy), needleTip, gaugeCol, - S.drawElement("tabs.balance.shield", "needle-thickness").sizeOr(2.0f)); + S.drawElement("tabs.balance.shield", "needle-thickness").sizeOr(2.0f) * dp); // Center text: percentage ImFont* sub1 = Type().subtitle1(); @@ -1956,7 +1956,7 @@ static void RenderBalanceTwoRow(App* app) { } RenderSyncBar(app, dl, vs); - ImGui::Dummy(ImVec2(0, S.drawElement("tabs.balance.two-row", "sync-gap").sizeOr(2.0f))); + ImGui::Dummy(ImVec2(0, S.drawElement("tabs.balance.two-row", "sync-gap").sizeOr(2.0f) * dp)); // Row 2: 3 mini-cards inline { @@ -1979,7 +1979,7 @@ static void RenderBalanceTwoRow(App* app) { S.drawElement("tabs.balance.two-row", "mini-rounding-min").sizeOr(4.0f), glassRound * S.drawElement("tabs.balance.two-row", "mini-rounding-ratio").sizeOr(0.5f)); ImFont* capFont = Type().caption(); - float indicatorR = S.drawElement("tabs.balance.two-row", "indicator-radius").sizeOr(3.0f); + float indicatorR = S.drawElement("tabs.balance.two-row", "indicator-radius").sizeOr(3.0f) * dp; int balDecimals = (int)S.drawElement("tabs.balance.two-row", "balance-decimals").sizeOr(4.0f); float twoRowPadOverride = S.drawElement("tabs.balance.two-row", "card-padding").size; float miniPad = (twoRowPadOverride >= 0.0f) ? twoRowPadOverride : Layout::spacingSm(); @@ -2054,8 +2054,8 @@ static void RenderBalanceTwoRow(App* app) { // Sparkline between price and percentage if (market.price_history.size() >= 2) { - float sparkGap = S.drawElement("tabs.balance.two-row", "sparkline-gap").sizeOr(6.0f); - float sparkPad = S.drawElement("tabs.balance.two-row", "sparkline-pad").sizeOr(4.0f); + float sparkGap = S.drawElement("tabs.balance.two-row", "sparkline-gap").sizeOr(6.0f) * dp; + float sparkPad = S.drawElement("tabs.balance.two-row", "sparkline-pad").sizeOr(4.0f) * dp; float sparkLeft = cx + priceSz.x + sparkGap; float sparkRightEdge = sparkRight - sparkGap; if (sparkLeft < sparkRightEdge) { @@ -2153,10 +2153,10 @@ static void RenderBalanceMinimal(App* app) { { ImGui::Dummy(ImVec2(0, Layout::spacingSm())); ImVec2 sepPos = ImGui::GetCursorScreenPos(); - float dashLen = S.drawElement("tabs.balance.minimal", "dash-length").sizeOr(6.0f); - float gapLen = S.drawElement("tabs.balance.minimal", "dash-gap").sizeOr(4.0f); + float dashLen = S.drawElement("tabs.balance.minimal", "dash-length").sizeOr(6.0f) * dp; + float gapLen = S.drawElement("tabs.balance.minimal", "dash-gap").sizeOr(4.0f) * dp; float sepAlpha = S.drawElement("tabs.balance.minimal", "separator-alpha").sizeOr(25.0f); - float sepThick = S.drawElement("tabs.balance.minimal", "separator-thickness").sizeOr(1.0f); + float sepThick = S.drawElement("tabs.balance.minimal", "separator-thickness").sizeOr(1.0f) * dp; float x = sepPos.x; float endX = sepPos.x + availW; while (x < endX) { diff --git a/src/ui/windows/block_info_dialog.cpp b/src/ui/windows/block_info_dialog.cpp index 7ce979c..2a661ca 100644 --- a/src/ui/windows/block_info_dialog.cpp +++ b/src/ui/windows/block_info_dialog.cpp @@ -59,7 +59,7 @@ static void handleBlockResponseUnified(const json& result, const std::string& er s_loading = false; if (!error.empty()) { - s_error = "Error: " + error; + s_error = std::string(TR("grpa_error_prefix")) + error; return; } @@ -84,7 +84,7 @@ static void handleBlockResponseUnified(const json& result, const std::string& er s_has_data = true; } else { - s_error = "Invalid response from daemon"; + s_error = TR("grpa_invalid_response_from_daemon"); } } @@ -125,7 +125,7 @@ void BlockInfoDialog::render(App* app) // Current block info if (state.sync.blocks > 0) { - ImGui::TextDisabled("(Current: %d)", state.sync.blocks); + ImGui::TextDisabled(TR("grpa_current_block_paren"), state.sync.blocks); } ImGui::SameLine(); @@ -152,7 +152,7 @@ void BlockInfoDialog::render(App* app) rpc::RPCClient::TraceScope trace("Explorer / Block info"); auto hashResult = rpc->call("getblockhash", {height}); if (!hashResult.is_string()) { - error = "unexpected getblockhash result"; + error = TR("grpa_unexpected_getblockhash_result"); } else { block = rpc->call("getblock", {hashResult.get()}); } diff --git a/src/ui/windows/bootstrap_download_dialog.h b/src/ui/windows/bootstrap_download_dialog.h index 251341a..bed3f97 100644 --- a/src/ui/windows/bootstrap_download_dialog.h +++ b/src/ui/windows/bootstrap_download_dialog.h @@ -144,7 +144,7 @@ private: if (!s_bootstrap) { s_state = State::Failed; - s_errorMsg = "Bootstrap not initialized"; + s_errorMsg = TR("grpc_bootstrap_not_initialized"); return; } @@ -227,7 +227,7 @@ private: s_state = State::Done; } else { s_errorMsg = finalProg.error; - if (s_errorMsg.empty()) s_errorMsg = "Bootstrap failed"; + if (s_errorMsg.empty()) s_errorMsg = TR("grpc_bootstrap_failed"); s_state = State::Failed; } s_bootstrap.reset(); diff --git a/src/ui/windows/chat_tab.cpp b/src/ui/windows/chat_tab.cpp index 6427233..2f90cd9 100644 --- a/src/ui/windows/chat_tab.cpp +++ b/src/ui/windows/chat_tab.cpp @@ -425,9 +425,9 @@ void RenderChatSettingsPreview(App* app, float width) { struct PMsg { const char* body; bool outgoing; bool startGroup; bool lastInGroup; std::string meta; }; const std::string peer = "Ava"; const PMsg msgs[] = { - { u8"Did the payment go through? \U0001F642", false, true, true, peer + " " + t1 }, - { u8"Yep — just confirmed ✅", true, true, false, std::string(TR("chat_you")) + " " + t2 }, - { u8"Sending the rest now \U0001F44D", true, false, true, std::string() }, + { TR("grpb_preview_msg_payment_through"), false, true, true, peer + " " + t1 }, + { TR("grpb_preview_msg_yep_confirmed"), true, true, false, std::string(TR("chat_you")) + " " + t2 }, + { TR("grpb_preview_msg_sending_rest"), true, false, true, std::string() }, }; const int N = 3; diff --git a/src/ui/windows/console_tab.cpp b/src/ui/windows/console_tab.cpp index d6246c8..c5b618e 100644 --- a/src/ui/windows/console_tab.cpp +++ b/src/ui/windows/console_tab.cpp @@ -337,7 +337,7 @@ void ConsoleTab::render(ConsoleCommandExecutor& exec) float outputH = ComputeConsoleOutputHeight( availHeight, input_height, - schema::UI().drawElement("tabs.console", "output-min-height").size, + schema::UI().drawElement("tabs.console", "output-min-height").size * Layout::dpiScale(), schema::UI().drawElement("tabs.console", "output-min-height-ratio").size); ImDrawList* dlOut = ImGui::GetWindowDrawList(); diff --git a/src/ui/windows/explorer_tab.cpp b/src/ui/windows/explorer_tab.cpp index 266fb1c..9b67e92 100644 --- a/src/ui/windows/explorer_tab.cpp +++ b/src/ui/windows/explorer_tab.cpp @@ -108,13 +108,13 @@ static const char* relativeTime(int64_t timestamp) { int64_t diff = now - timestamp; if (diff < 0) diff = 0; if (diff < 60) - snprintf(buf, sizeof(buf), "%lld sec ago", (long long)diff); + snprintf(buf, sizeof(buf), TR("grpa_sec_ago"), (long long)diff); else if (diff < 3600) - snprintf(buf, sizeof(buf), "%lld min ago", (long long)(diff / 60)); + snprintf(buf, sizeof(buf), TR("grpa_min_ago"), (long long)(diff / 60)); else if (diff < 86400) - snprintf(buf, sizeof(buf), "%lld hr ago", (long long)(diff / 3600)); + snprintf(buf, sizeof(buf), TR("grpa_hr_ago"), (long long)(diff / 3600)); else - snprintf(buf, sizeof(buf), "%lld days ago", (long long)(diff / 86400)); + snprintf(buf, sizeof(buf), TR("grpa_days_ago"), (long long)(diff / 86400)); return buf; } @@ -1216,7 +1216,7 @@ static void renderBlockDetailModal(App* app) { txDL->AddRectFilled(rowStart, ImVec2(rowStart.x + txContentW, rowStart.y + txRowH), WithAlpha(OnSurface(), 10), - S.drawElement("tabs.explorer", "row-rounding").size); + S.drawElement("tabs.explorer", "row-rounding").size * dp); ImGui::SetMouseCursor(ImGuiMouseCursor_Hand); material::Tooltip("%s", txid.c_str()); } @@ -1315,7 +1315,7 @@ static void renderBlockDetailModal(App* app) { } if (s_detail_txids.size() > 100) { - snprintf(buf, sizeof(buf), "... showing first 100 of %d", (int)s_detail_txids.size()); + snprintf(buf, sizeof(buf), TR("grpa_showing_first_100_of"), (int)s_detail_txids.size()); ImGui::TextDisabled("%s", buf); } } diff --git a/src/ui/windows/faq_content.cpp b/src/ui/windows/faq_content.cpp new file mode 100644 index 0000000..d67a979 --- /dev/null +++ b/src/ui/windows/faq_content.cpp @@ -0,0 +1,115 @@ +// DragonX Wallet - ImGui Edition +// Copyright 2024-2026 The Hush Developers +// Released under the GPLv3 + +#include "faq_content.h" + +namespace dragonx { +namespace ui { +namespace faq { + +// ── Wallet group ─────────────────────────────────────────────────────────── +const std::vector& walletFaq() +{ + static const std::vector kWallet = { + { "faq_w_gs_title", { + { "faq_w_gs_1_q", "faq_w_gs_1_a" }, + { "faq_w_gs_2_q", "faq_w_gs_2_a" }, + { "faq_w_gs_3_q", "faq_w_gs_3_a" }, + { "faq_w_gs_4_q", "faq_w_gs_4_a" }, + }}, + { "faq_w_addr_title", { + { "faq_w_addr_1_q", "faq_w_addr_1_a" }, + { "faq_w_addr_2_q", "faq_w_addr_2_a" }, + { "faq_w_addr_3_q", "faq_w_addr_3_a" }, + { "faq_w_addr_4_q", "faq_w_addr_4_a" }, + }}, + { "faq_w_send_title", { + { "faq_w_send_1_q", "faq_w_send_1_a" }, + { "faq_w_send_2_q", "faq_w_send_2_a" }, + { "faq_w_send_3_q", "faq_w_send_3_a" }, + { "faq_w_send_4_q", "faq_w_send_4_a" }, + }}, + { "faq_w_bal_title", { + { "faq_w_bal_1_q", "faq_w_bal_1_a" }, + { "faq_w_bal_2_q", "faq_w_bal_2_a" }, + { "faq_w_bal_3_q", "faq_w_bal_3_a" }, + }}, + { "faq_w_sec_title", { + { "faq_w_sec_1_q", "faq_w_sec_1_a" }, + { "faq_w_sec_2_q", "faq_w_sec_2_a" }, + { "faq_w_sec_3_q", "faq_w_sec_3_a" }, + }}, + { "faq_w_seed_title", { + { "faq_w_seed_1_q", "faq_w_seed_1_a" }, + { "faq_w_seed_2_q", "faq_w_seed_2_a" }, + { "faq_w_seed_3_q", "faq_w_seed_3_a" }, + { "faq_w_seed_4_q", "faq_w_seed_4_a" }, + }}, + { "faq_w_chat_title", { + { "faq_w_chat_1_q", "faq_w_chat_1_a" }, + { "faq_w_chat_2_q", "faq_w_chat_2_a" }, + { "faq_w_chat_3_q", "faq_w_chat_3_a" }, + }}, + { "faq_w_set_title", { + { "faq_w_set_1_q", "faq_w_set_1_a" }, + { "faq_w_set_2_q", "faq_w_set_2_a" }, + { "faq_w_set_3_q", "faq_w_set_3_a" }, + { "faq_w_set_4_q", "faq_w_set_4_a" }, + }}, + }; + return kWallet; +} + +// ── Daemon group (full-node only) ────────────────────────────────────────── +const std::vector& daemonFaq() +{ + static const std::vector kDaemon = { + { "faq_d_node_title", { + { "faq_d_node_1_q", "faq_d_node_1_a" }, + { "faq_d_node_2_q", "faq_d_node_2_a" }, + { "faq_d_node_3_q", "faq_d_node_3_a" }, + }}, + { "faq_d_sync_title", { + { "faq_d_sync_1_q", "faq_d_sync_1_a" }, + { "faq_d_sync_2_q", "faq_d_sync_2_a" }, + { "faq_d_sync_3_q", "faq_d_sync_3_a" }, + { "faq_d_sync_4_q", "faq_d_sync_4_a" }, + }}, + { "faq_d_mgmt_title", { + { "faq_d_mgmt_1_q", "faq_d_mgmt_1_a" }, + { "faq_d_mgmt_2_q", "faq_d_mgmt_2_a" }, + { "faq_d_mgmt_3_q", "faq_d_mgmt_3_a" }, + }}, + { "faq_d_upd_title", { + { "faq_d_upd_1_q", "faq_d_upd_1_a" }, + { "faq_d_upd_2_q", "faq_d_upd_2_a" }, + { "faq_d_upd_3_q", "faq_d_upd_3_a" }, + }}, + { "faq_d_mine_title", { + { "faq_d_mine_1_q", "faq_d_mine_1_a" }, + { "faq_d_mine_2_q", "faq_d_mine_2_a" }, + { "faq_d_mine_3_q", "faq_d_mine_3_a" }, + { "faq_d_mine_4_q", "faq_d_mine_4_a" }, + }}, + { "faq_d_net_title", { + { "faq_d_net_1_q", "faq_d_net_1_a" }, + { "faq_d_net_2_q", "faq_d_net_2_a" }, + }}, + { "faq_d_perf_title", { + { "faq_d_perf_1_q", "faq_d_perf_1_a" }, + { "faq_d_perf_2_q", "faq_d_perf_2_a" }, + }}, + { "faq_d_trbl_title", { + { "faq_d_trbl_1_q", "faq_d_trbl_1_a" }, + { "faq_d_trbl_2_q", "faq_d_trbl_2_a" }, + { "faq_d_trbl_3_q", "faq_d_trbl_3_a" }, + { "faq_d_trbl_4_q", "faq_d_trbl_4_a" }, + }}, + }; + return kDaemon; +} + +} // namespace faq +} // namespace ui +} // namespace dragonx diff --git a/src/ui/windows/faq_content.h b/src/ui/windows/faq_content.h new file mode 100644 index 0000000..274d674 --- /dev/null +++ b/src/ui/windows/faq_content.h @@ -0,0 +1,41 @@ +// DragonX Wallet - ImGui Edition +// Copyright 2024-2026 The Hush Developers +// Released under the GPLv3 +// +// FAQ content model. The FAQ screen is data-driven: this header exposes the two +// top-level groups (Wallet, Daemon) as ordered lists of subcategories, each a list +// of question/answer entries. Every string is an i18n KEY (looked up with TR at +// render time), so wording + translations live in src/util/i18n.cpp + res/lang/*.json +// and never require touching UI code. Add a Q&A by appending a {qKey,aKey} pair here +// and its two strings to loadBuiltinEnglish(). + +#pragma once + +#include + +namespace dragonx { +namespace ui { +namespace faq { + +// One question and its answer, both i18n keys. The answer may contain "\n\n" +// paragraph breaks; it is rendered wrapped. Keep answers free of printf specifiers +// (%d/%s/…) — the i18n layer rejects translations whose format signature drifts. +struct FaqEntry { + const char* questionKey; + const char* answerKey; +}; + +// A named group of questions. titleKey is an i18n key for the subcategory header. +struct FaqSubcategory { + const char* titleKey; + std::vector entries; +}; + +// The two top-level groups. daemonFaq() is full-node material and is only shown when +// the build supports full-node lifecycle actions (see App::supportsFullNodeLifecycleActions()). +const std::vector& walletFaq(); +const std::vector& daemonFaq(); + +} // namespace faq +} // namespace ui +} // namespace dragonx diff --git a/src/ui/windows/faq_dialog.cpp b/src/ui/windows/faq_dialog.cpp new file mode 100644 index 0000000..aafb2b7 --- /dev/null +++ b/src/ui/windows/faq_dialog.cpp @@ -0,0 +1,201 @@ +// DragonX Wallet - ImGui Edition +// Copyright 2024-2026 The Hush Developers +// Released under the GPLv3 + +#include "faq_dialog.h" +#include "faq_content.h" +#include "../../app.h" +#include "../../util/i18n.h" +#include "../../util/text_format.h" +#include "../../embedded/IconsMaterialDesign.h" +#include "../schema/ui_schema.h" +#include "../layout.h" +#include "../material/type.h" +#include "../material/colors.h" +#include "../material/draw_helpers.h" +#include "imgui.h" + +#include +#include +#include +#include + +namespace dragonx { +namespace ui { + +namespace { + +// Persists across frames (the dialog is re-entered each frame while open). Group 0 = Wallet, +// 1 = Daemon. `expanded` keys are FaqEntry::questionKey (stable string literals from faq_content). +struct FaqDialogState { + int group = 0; + char search[128] = ""; + std::unordered_map expanded; +}; +FaqDialogState s_faq; + +bool entryMatches(const faq::FaqEntry& e, const char* query) +{ + return util::containsIgnoreCase(TR(e.questionKey), query) || + util::containsIgnoreCase(TR(e.answerKey), query); +} + +// One answer body: wrapped, muted. Shared by the collapsible (non-search) and search paths. +void renderAnswer(const char* answerKey) +{ + ImGui::Indent(Layout::spacingMd()); + ImGui::PushFont(material::Type().body2()); + ImGui::PushStyleColor(ImGuiCol_Text, ImGui::ColorConvertU32ToFloat4(material::OnSurfaceMedium())); + ImGui::TextWrapped("%s", TR(answerKey)); + ImGui::PopStyleColor(); + ImGui::PopFont(); + ImGui::Unindent(Layout::spacingMd()); + ImGui::Dummy(ImVec2(0, Layout::spacingSm())); +} + +} // namespace + +void RenderFaqDialog(App* app, bool* p_open) +{ + auto& S = schema::UI(); + auto win = S.window("dialogs.faq"); + const float dp = Layout::dpiScale(); + + const bool daemonAvailable = app && app->supportsFullNodeLifecycleActions(); + if (!daemonAvailable) s_faq.group = 0; // no Daemon tab in lite builds + + // Floating "BlurFloat" modal, matching the Wallets dialog: live-blur backdrop, no boxed card, a + // plain heading (no ✕ — a Close button sits at the bottom). Roomy fixed width; height capped to the + // viewport so the content flexes + scrolls on small / HiDPI screens. + const float vpH = ImGui::GetMainViewport()->Size.y; + const float wantH = (win.height > 0 ? win.height : 640.0f) * dp; + material::OverlayDialogSpec spec; + spec.title = TR("faq_title"); + spec.p_open = p_open; + spec.style = material::OverlayStyle::BlurFloat; + spec.cardWidth = (win.width > 0 ? win.width : 860.0f); + spec.cardHeight = std::min(wantH, vpH * 0.86f) / dp; + spec.idSuffix = "faq"; + if (!material::BeginOverlayDialog(spec)) { + return; + } + // Esc closes (ImGui consumes Esc itself while the search box is being edited, so this only + // fires when the field isn't capturing it). + if (ImGui::IsKeyPressed(ImGuiKey_Escape)) *p_open = false; + + // Subtitle under the plain heading, matching the Wallets dialog's intro caption. + material::Type().textColored(material::TypeStyle::Caption, material::OnSurfaceMedium(), TR("faq_intro")); + ImGui::Dummy(ImVec2(0, Layout::spacingSm())); + + const float contentW = ImGui::GetContentRegionAvail().x; + + // ── Group tabs: Wallet | Daemon ── + { + const int nTabs = daemonAvailable ? 2 : 1; + const float gap = ImGui::GetStyle().ItemSpacing.x; + const float tabW = (contentW - gap * (nTabs - 1)) / static_cast(nTabs); + auto tab = [&](const char* label, int idx) { + const bool active = (s_faq.group == idx); + if (active) { + ImGui::PushStyleColor(ImGuiCol_Button, ImGui::ColorConvertU32ToFloat4(material::Primary())); + ImGui::PushStyleColor(ImGuiCol_Text, ImGui::ColorConvertU32ToFloat4(material::OnPrimary())); + } + if (material::TactileButton(label, ImVec2(tabW, 0))) s_faq.group = idx; + if (active) ImGui::PopStyleColor(2); + }; + tab(TR("faq_group_wallet"), 0); + if (daemonAvailable) { ImGui::SameLine(); tab(TR("faq_group_daemon"), 1); } + } + + ImGui::Dummy(ImVec2(0, Layout::spacingXs())); + + // ── Search ── + ImGui::SetNextItemWidth(contentW); + ImGui::InputTextWithHint("##FaqSearch", TR("faq_search_hint"), s_faq.search, sizeof(s_faq.search)); + const bool searching = s_faq.search[0] != '\0'; + + ImGui::Dummy(ImVec2(0, Layout::spacingSm())); + + // ── Scrollable Q&A body ── (reserve room for the Close button footer below) + const float footerH = ImGui::GetFrameHeightWithSpacing() + Layout::spacingMd(); + float bodyH = ImGui::GetContentRegionAvail().y - footerH; + if (bodyH < 80.0f * dp) bodyH = 80.0f * dp; + // Inner padding gives the content breathing room and, on the right, a clear gap to the LEFT of the + // scrollbar (WindowPadding.x is exactly that gap); the scrollbar itself is made chunkier than the + // app default. NoScrollWithMouse + ApplySmoothScroll gives the wheel eased scrolling, matching the + // Wallets dialog / Settings page (ApplySmoothScroll owns the wheel input and lerps ScrollY). + ImGui::PushStyleVar(ImGuiStyleVar_WindowPadding, ImVec2(Layout::spacingMd(), Layout::spacingXs())); + ImGui::PushStyleVar(ImGuiStyleVar_ScrollbarSize, 16.0f * dp); + ImGui::BeginChild("##FaqScroll", ImVec2(0, bodyH), false, + ImGuiWindowFlags_NoMove | ImGuiWindowFlags_NoScrollWithMouse); + material::ApplySmoothScroll(); + ImDrawList* dl = ImGui::GetWindowDrawList(); + + const auto& groups = (s_faq.group == 1 && daemonAvailable) ? faq::daemonFaq() : faq::walletFaq(); + bool anyShown = false; + + bool firstSection = true; + for (const auto& subcat : groups) { + // Collect the entries visible under the current search. + std::vector visible; + for (const auto& e : subcat.entries) { + if (!searching || entryMatches(e, s_faq.search)) visible.push_back(&e); + } + if (visible.empty()) continue; + + // Section break: generous space above every section after the first, so topic groups read as + // clearly separated bands rather than one uniform list. + if (!firstSection) ImGui::Dummy(ImVec2(0, Layout::spacingLg())); + firstSection = false; + anyShown = true; + + // Section header — accent overline + a thin full-width rule beneath it, anchoring the group + // above its (brighter, normal-case) question rows. + material::Type().textColored(material::TypeStyle::Overline, + material::Primary(), TR(subcat.titleKey)); + { + const ImVec2 rp = ImGui::GetCursorScreenPos(); + const float rw = ImGui::GetContentRegionAvail().x; + dl->AddLine(ImVec2(rp.x, rp.y + dp), ImVec2(rp.x + rw, rp.y + dp), + material::Divider(), 1.0f * dp); + } + ImGui::Dummy(ImVec2(0, Layout::spacingSm())); + + for (const auto* e : visible) { + const float rowW = ImGui::GetContentRegionAvail().x; + if (searching) { + // Search results: show question + answer directly (no collapsing). + ImGui::PushFont(material::Type().subtitle2()); + ImGui::TextWrapped("%s", TR(e->questionKey)); + ImGui::PopFont(); + renderAnswer(e->answerKey); + } else { + bool& exp = s_faq.expanded[e->questionKey]; + std::string id = std::string("##faq_") + e->questionKey; + material::CollapsibleHeader(dl, id.c_str(), TR(e->questionKey), exp, rowW, + material::Type().subtitle2(), material::OnSurface()); + if (exp) renderAnswer(e->answerKey); + } + } + } + + if (!anyShown) { + ImGui::Dummy(ImVec2(0, Layout::spacingLg())); + ImGui::PushStyleColor(ImGuiCol_Text, ImGui::ColorConvertU32ToFloat4(material::OnSurfaceMedium())); + ImGui::TextWrapped("%s", TR("faq_no_results")); + ImGui::PopStyleColor(); + } + + ImGui::EndChild(); + ImGui::PopStyleVar(2); // ScrollbarSize, WindowPadding + + // Close button footer (BlurFloat has no ✕ in the heading). + const float closeW = 120.0f * dp; + material::BeginOverlayDialogFooter(closeW, false); + if (material::TactileButton(TR("close"), ImVec2(closeW, 0))) *p_open = false; + + material::EndOverlayDialog(); +} + +} // namespace ui +} // namespace dragonx diff --git a/src/ui/windows/faq_dialog.h b/src/ui/windows/faq_dialog.h new file mode 100644 index 0000000..99f07dd --- /dev/null +++ b/src/ui/windows/faq_dialog.h @@ -0,0 +1,18 @@ +// DragonX Wallet - ImGui Edition +// Copyright 2024-2026 The Hush Developers +// Released under the GPLv3 + +#pragma once + +namespace dragonx { +class App; +namespace ui { + +// Renders the Help & FAQ modal. Call every frame while *p_open is true; the dialog +// clears *p_open itself on close (✕ / click-outside / Esc). Content is data-driven +// (see faq_content.h) and grouped into Wallet and Daemon tabs; the Daemon tab is +// hidden on builds without full-node lifecycle support. +void RenderFaqDialog(App* app, bool* p_open); + +} // namespace ui +} // namespace dragonx diff --git a/src/ui/windows/key_export_dialog.cpp b/src/ui/windows/key_export_dialog.cpp index cb65482..b0c2104 100644 --- a/src/ui/windows/key_export_dialog.cpp +++ b/src/ui/windows/key_export_dialog.cpp @@ -173,7 +173,7 @@ void KeyExportDialog::render(App* app) s_key = found; s_show_key = wantViewing; // viewing keys are less sensitive } else { - s_error = r.ok ? std::string("Key not available for this address") : r.error; + s_error = r.ok ? std::string(TR("grpc_key_not_available")) : r.error; } wallet::secureWipeLiteSecret(found); s_fetching = false; @@ -240,14 +240,15 @@ void KeyExportDialog::render(App* app) ImGui::TextDisabled("%s", TR("key_export_click_retrieve")); } else { // Key fetched. Layout: [ key text (click-to-copy) + Show/Hide below ] [ QR | square ]. - const float gap = 12.0f; + const float dp = Layout::dpiScale(); + const float gap = 12.0f * dp; const float avail = ImGui::GetContentRegionAvail().x; // Larger, responsive QR: ~30% of the content width, clamped to a comfortable range. float qrSize = avail * 0.30f; - if (qrSize < 200.0f) qrSize = 200.0f; - if (qrSize > 340.0f) qrSize = 340.0f; + if (qrSize < 200.0f * dp) qrSize = 200.0f * dp; + if (qrSize > 340.0f * dp) qrSize = 340.0f * dp; float keyW = avail - qrSize - gap; - const bool sideBySide = keyW >= 200.0f; // too narrow -> stack the QR under the key + const bool sideBySide = keyW >= 200.0f * dp; // too narrow -> stack the QR under the key if (!sideBySide) keyW = avail; // Chunk for readability, but keep a Bech32 HRP (e.g. "secret-extended-key-main") intact diff --git a/src/ui/windows/market_tab.cpp b/src/ui/windows/market_tab.cpp index 2a5008b..d4b8a2c 100644 --- a/src/ui/windows/market_tab.cpp +++ b/src/ui/windows/market_tab.cpp @@ -1580,7 +1580,7 @@ static void mktDrawPriceHero(const MktCtx& cx) } } else { const char* status = market.price_loading ? TR("market_price_loading") : TR("market_price_unavailable"); - DrawTextShadow(dl, sub1, sub1->LegacySize, ImVec2(cx0, cy + 10), OnSurfaceDisabled(), status); + DrawTextShadow(dl, sub1, sub1->LegacySize, ImVec2(cx0, cy + 10 * dp), OnSurfaceDisabled(), status); if (!market.price_loading && !market.price_error.empty()) { std::string errorText = market.price_error; float maxErrorW = cardMax.x - cx0 - Layout::spacingLg(); @@ -1590,7 +1590,7 @@ static void mktDrawPriceHero(const MktCtx& cx) } if (errorText.size() < market.price_error.size()) errorText += "..."; dl->AddText(capFont, capFont->LegacySize, - ImVec2(cx0, cy + 10 + sub1->LegacySize + Layout::spacingXs()), + ImVec2(cx0, cy + 10 * dp + sub1->LegacySize + Layout::spacingXs()), Warning(), errorText.c_str()); } } @@ -1874,7 +1874,7 @@ static void mktDrawPriceChart(const MktCtx& cx) : (tk == ticks - 1) ? plotRight - lblSz.x : xpos - lblSz.x * 0.5f; dl->AddText(capFont, capFont->LegacySize, - ImVec2(lx, plotBottom + 4), OnSurfaceDisabled(), tlbl); + ImVec2(lx, plotBottom + 4 * mktDp), OnSurfaceDisabled(), tlbl); } } diff --git a/src/ui/windows/mining_controls.cpp b/src/ui/windows/mining_controls.cpp index 7e7e2a7..0a318b6 100644 --- a/src/ui/windows/mining_controls.cpp +++ b/src/ui/windows/mining_controls.cpp @@ -153,7 +153,12 @@ void RenderMiningControls(App* app, const WalletState& state, const MiningInfo& } }; ImFont* stepFont = Type().iconSmall(); - const float fieldH = capFont->LegacySize + 6.0f * dp; + // Match the -/+ button height to the InputInt's actual frame height (GetFrameHeight == + // fontSize + 2*FramePadding.y, evaluated with the same font/style the input renders with, + // since nothing pushes a font between here and the InputInt below). This keeps the buttons + // the SAME height as the number box and top-aligned with it at sy — previously fieldH was + // capFont+6px, shorter than the box, so they sat misaligned. + const float fieldH = ImGui::GetFrameHeight(); const float sideW = fieldH; // square -/+ buttons const float fieldW = 46.0f * dp; const float g = 2.0f * dp; @@ -544,7 +549,7 @@ void RenderMiningControls(App* app, const WalletState& state, const MiningInfo& s_benchConfirm = true; char msg[128]; snprintf(msg, sizeof(msg), - "Benchmark takes ~%ds and interrupts mining. Click again to start.", + TR("grpc_benchmark_takes_secs"), (int)(s_benchmark.totalEstimatedSecs() + 0.5f)); Notifications::instance().warning(msg); } else { diff --git a/src/ui/windows/mining_earnings.cpp b/src/ui/windows/mining_earnings.cpp index b7f3d31..eba9ad6 100644 --- a/src/ui/windows/mining_earnings.cpp +++ b/src/ui/windows/mining_earnings.cpp @@ -220,7 +220,7 @@ void RenderMiningEarnings(App* app, const WalletState& state, const MiningInfo& if (estActive) snprintf(estVal, sizeof(estVal), "~%.4f", estDaily); else - snprintf(estVal, sizeof(estVal), "N/A"); + snprintf(estVal, sizeof(estVal), "%s", TR("grpc_na")); // Disclose in pool mode that Est. Daily is a rough solo-equivalent (before the pool fee), so the // number isn't silently mismatched to its plain "Est. Daily" label. (M-05) const char* estSub = (s_pool_mode && estActive) ? TR("mining_est_daily_pool_sub") : nullptr; @@ -475,7 +475,7 @@ void RenderMiningEarnings(App* app, const WalletState& state, const MiningInfo& else if (totalRAM > 0) snprintf(sysBuf, sizeof(sysBuf), "-- / %.0f GB", totalRAM / 1024.0); else - snprintf(sysBuf, sizeof(sysBuf), "N/A"); + snprintf(sysBuf, sizeof(sysBuf), "%s", TR("grpc_na")); float sysTextW = capFont->CalcTextSizeA(capFont->LegacySize, 10000, 0, sysBuf).x; float sysTextX = barX + barW - textPadX - sysTextW; diff --git a/src/ui/windows/mining_stats.cpp b/src/ui/windows/mining_stats.cpp index f705bd5..d700837 100644 --- a/src/ui/windows/mining_stats.cpp +++ b/src/ui/windows/mining_stats.cpp @@ -326,7 +326,7 @@ static void RenderLeftPoolCard(App* app, const WalletState& state, ImDrawList* d ? it->second.feePercent : kp.feePercent; if (feePct >= 0.0) - snprintf(right, sizeof(right), "%s %s%% fee", hrStr.c_str(), + snprintf(right, sizeof(right), TR("grpc_hashrate_fee"), hrStr.c_str(), FormatFeePercent(feePct).c_str()); else snprintf(right, sizeof(right), "%s", hrStr.c_str()); @@ -421,9 +421,10 @@ void RenderMiningStats(const WalletState& state, const MiningInfo& mining, // centered ~1000dp band inside the panel's padded content region; the // glass panel itself still fills rightW, leftover -> side margin. const float rightContentW = rightW - pad * 2.0f; - const float chartBandW = std::min(rightContentW, 1000.0f * dp); - const float chartBandX = rightMin.x + pad - + std::max(0.0f, (rightContentW - chartBandW) * 0.5f); + // Fill the panel's content width so the chart extends across the whole panel on a wide window. + // (Previously capped at ~1000dp and centered, which left large empty margins either side.) + const float chartBandW = rightContentW; + const float chartBandX = rightMin.x + pad; // Right panel: live log (if toggled + available) else the sparkline. if (showLogView) { diff --git a/src/ui/windows/mining_tab.cpp b/src/ui/windows/mining_tab.cpp index 3749c87..b6368f8 100644 --- a/src/ui/windows/mining_tab.cpp +++ b/src/ui/windows/mining_tab.cpp @@ -263,8 +263,7 @@ static void RenderMiningTabContent(App* app) } if (benchmarkUpdate.inconclusive) { Notifications::instance().warning( - "Benchmark inconclusive: no hashrate samples were recorded. " - "Check the pool connection and try again."); + TR("grpc_benchmark_inconclusive")); } } diff --git a/src/ui/windows/peers_tab.cpp b/src/ui/windows/peers_tab.cpp index b1ecb62..ac06880 100644 --- a/src/ui/windows/peers_tab.cpp +++ b/src/ui/windows/peers_tab.cpp @@ -380,7 +380,7 @@ void RenderPeersTab(App* app) if (tlsCount == totalPeers) { ImFont* iconFont = Type().iconSmall(); ImVec2 txtSize = sub1->CalcTextSizeA(sub1->LegacySize, FLT_MAX, 0, buf); - dl->AddText(iconFont, iconFont->LegacySize, ImVec2(cx + txtSize.x + 4, valY), Success(), ICON_MD_CHECK); + dl->AddText(iconFont, iconFont->LegacySize, ImVec2(cx + txtSize.x + 4 * dp, valY), Success(), ICON_MD_CHECK); } } else { dl->AddText(sub1, sub1->LegacySize, ImVec2(cx, valY), OnSurfaceDisabled(), "\xE2\x80\x94"); @@ -695,7 +695,7 @@ void RenderPeersTab(App* app) ImVec2 pillMin(dirX - S.drawElement("tabs.peers", "dir-pill-padding").size * dp, cy + S.drawElement("tabs.peers", "dir-pill-y-offset").size * dp); ImVec2 pillMax(dirX + dirSz.x + S.drawElement("tabs.peers", "dir-pill-padding").size * dp, cy + capFont->LegacySize + S.drawElement("tabs.peers", "dir-pill-y-bottom").size * dp); dl->AddRectFilled(pillMin, pillMax, dirBg, S.drawElement("tabs.peers", "dir-pill-rounding").size * dp); - dl->AddText(capFont, capFont->LegacySize, ImVec2(dirX, cy + 2), dirFg, dirLabel); + dl->AddText(capFont, capFont->LegacySize, ImVec2(dirX, cy + 2 * dp), dirFg, dirLabel); } { @@ -745,9 +745,9 @@ void RenderPeersTab(App* app) ImU32 tlsBg = WithAlpha(Success(), 25); ImU32 tlsFg = WithAlpha(Success(), 200); ImVec2 tlsMin(badgeX, cy2); - ImVec2 tlsMax(tlsMin.x + tlsBadgeW, tlsMin.y + capFont->LegacySize + 2); + ImVec2 tlsMax(tlsMin.x + tlsBadgeW, tlsMin.y + capFont->LegacySize + 2 * dp); dl->AddRectFilled(tlsMin, tlsMax, tlsBg, S.drawElement("tabs.peers", "tls-badge-rounding").size * dp); - dl->AddText(capFont, capFont->LegacySize, ImVec2(tlsMin.x + 4, cy2 + 1), tlsFg, "TLS"); + dl->AddText(capFont, capFont->LegacySize, ImVec2(tlsMin.x + 4 * dp, cy2 + 1 * dp), tlsFg, "TLS"); } else { dl->AddText(capFont, capFont->LegacySize, ImVec2(badgeX, cy2), WithAlpha(Error(), 140), TR("peers_no_tls")); diff --git a/src/ui/windows/receive_tab.cpp b/src/ui/windows/receive_tab.cpp index 6464539..b15c86d 100644 --- a/src/ui/windows/receive_tab.cpp +++ b/src/ui/windows/receive_tab.cpp @@ -259,11 +259,11 @@ static void RenderAddressDropdown(App* app, float width) { snprintf(buf, sizeof(buf), "%s %s (%s) \xe2\x80\x94 %.8f %s%s", tag, lblIt->second.c_str(), trunc.c_str(), addr.balance, DRAGONX_TICKER, - isNew ? " [NEW]" : ""); + isNew ? TR("grpb_new_badge_suffix") : ""); } else { snprintf(buf, sizeof(buf), "%s %s \xe2\x80\x94 %.8f %s%s", tag, trunc.c_str(), addr.balance, DRAGONX_TICKER, - isNew ? " [NEW]" : ""); + isNew ? TR("grpb_new_badge_suffix") : ""); } ImGui::PushID(static_cast(i)); @@ -272,9 +272,9 @@ static void RenderAddressDropdown(App* app, float width) { s_cached_qr_data.clear(); // Force QR regeneration } if (ImGui::IsItemHovered()) { - material::Tooltip("%s\nBalance: %.8f %s%s", + material::Tooltip(TR("grpb_tooltip_address_balance"), addr.address.c_str(), addr.balance, DRAGONX_TICKER, - isCurrent ? "\n(selected)" : ""); + isCurrent ? TR("grpb_selected_suffix") : ""); } ImGui::PopID(); } @@ -716,17 +716,17 @@ void RenderReceiveTab(App* app) ImU32 iconCol = ImGui::GetColorU32(ImGuiCol_Text); float ss = iconW * 0.5f; float cx = startX + ss; - float ag = S.drawElement("tabs.receive", "swap-icon-arrow-gap").size; + float ag = S.drawElement("tabs.receive", "swap-icon-arrow-gap").size * cardDp; float al = ss * S.drawElement("tabs.receive", "swap-icon-arrow-length-ratio").size; - float hss = S.drawElement("tabs.receive", "swap-icon-arrowhead-size").size; + float hss = S.drawElement("tabs.receive", "swap-icon-arrowhead-size").size * cardDp; float ay1 = cy - ag; - dl->AddLine(ImVec2(cx - al, ay1), ImVec2(cx + al, ay1), iconCol, S.drawElement("tabs.receive", "swap-icon-line-thickness").size); + dl->AddLine(ImVec2(cx - al, ay1), ImVec2(cx + al, ay1), iconCol, S.drawElement("tabs.receive", "swap-icon-line-thickness").size * cardDp); dl->AddTriangleFilled( ImVec2(cx + al, ay1), ImVec2(cx + al - hss, ay1 - hss), ImVec2(cx + al - hss, ay1 + hss), iconCol); float ay2 = cy + ag; - dl->AddLine(ImVec2(cx + al, ay2), ImVec2(cx - al, ay2), iconCol, S.drawElement("tabs.receive", "swap-icon-line-thickness").size); + dl->AddLine(ImVec2(cx + al, ay2), ImVec2(cx - al, ay2), iconCol, S.drawElement("tabs.receive", "swap-icon-line-thickness").size * cardDp); dl->AddTriangleFilled( ImVec2(cx - al, ay2), ImVec2(cx - al + hss, ay2 - hss), @@ -744,8 +744,8 @@ void RenderReceiveTab(App* app) ImGui::Dummy(ImVec2(0, Layout::spacingXs())); float chipRound = schema::UI().drawElement("tabs.receive", "chip-rounding").size; - float chipGap = schema::UI().drawElement("tabs.receive", "chip-gap").size; - float chipH = schema::UI().drawElement("tabs.receive", "chip-height").size; + float chipGap = schema::UI().drawElement("tabs.receive", "chip-gap").size * cardDp; + float chipH = schema::UI().drawElement("tabs.receive", "chip-height").size * cardDp; struct Preset { const char* label; double amount; }; Preset presets[] = { @@ -873,7 +873,7 @@ void RenderReceiveTab(App* app) RenderQRCode(s_qr_texture, qrSize); } else { ImGui::Dummy(ImVec2(qrSize, qrSize)); - ImVec2 textPos(qrPanelMin.x + totalQrSize * 0.5f - S.drawElement("tabs.receive", "qr-unavailable-text-offset").size, + ImVec2 textPos(qrPanelMin.x + totalQrSize * 0.5f - S.drawElement("tabs.receive", "qr-unavailable-text-offset").size * cardDp, qrPanelMin.y + totalQrSize * 0.5f); dl->AddText(capFont, capFont->LegacySize, textPos, OnSurfaceDisabled(), TR("qr_unavailable")); diff --git a/src/ui/windows/send_tab.cpp b/src/ui/windows/send_tab.cpp index b9609ec..5d0ab8d 100644 --- a/src/ui/windows/send_tab.cpp +++ b/src/ui/windows/send_tab.cpp @@ -364,7 +364,8 @@ static void RenderAddressSuggestions(const WalletState& state, float width, cons if (suggestions.empty()) return; ImGui::PushStyleColor(ImGuiCol_ChildBg, ImGui::ColorConvertU32ToFloat4(schema::UI().resolveColor(schema::UI().drawElement("tabs.send", "suggestion-bg-color").color))); - float sugH = std::min((float)suggestions.size() * schema::UI().drawElement("tabs.send", "suggestion-row-height").size + schema::UI().drawElement("tabs.send", "suggestion-list-padding").size, schema::UI().drawElement("tabs.send", "suggestion-max-height").size); + const float dp = Layout::dpiScale(); + float sugH = std::min((float)suggestions.size() * schema::UI().drawElement("tabs.send", "suggestion-row-height").size * dp + schema::UI().drawElement("tabs.send", "suggestion-list-padding").size * dp, schema::UI().drawElement("tabs.send", "suggestion-max-height").size * dp); ImGui::BeginChild(childId, ImVec2(width, sugH), true); for (size_t si = 0; si < suggestions.size(); si++) { int sugTrunc = (int)schema::UI().drawElement("tabs.send", "suggestion-trunc-len").size; @@ -387,13 +388,14 @@ static void RenderAddressSuggestions(const WalletState& state, float width, cons // ============================================================================ static void RenderFeeTierSelector(const char* suffix = "") { auto& S = schema::UI(); + const float dp = Layout::dpiScale(); const char* feeLabels[] = { TR("send_fee_low"), TR("send_fee_normal"), TR("send_fee_high") }; const double feeValues[] = { FEE_LOW, FEE_NORMAL, FEE_HIGH }; ImGui::PushStyleColor(ImGuiCol_Button, ImVec4(0, 0, 0, 0)); ImGui::PushStyleVar(ImGuiStyleVar_FrameRounding, schema::UI().drawElement("tabs.send", "fee-rounding").size); for (int fi = 0; fi < 3; fi++) { - if (fi > 0) ImGui::SameLine(0, S.drawElement("tabs.send", "fee-tier-gap").size); + if (fi > 0) ImGui::SameLine(0, S.drawElement("tabs.send", "fee-tier-gap").size * dp); bool active = (s_fee_tier == fi); if (active) { ImGui::PushStyleColor(ImGuiCol_Button, ImGui::ColorConvertU32ToFloat4(IM_COL32(255, 255, 255, (int)S.drawElement("tabs.send", "fee-tier-active-bg-alpha").size))); @@ -515,7 +517,7 @@ static void RenderAmountBar(ImDrawList* dl, double available, float innerW, // Max button — use caption font to fit bar height ImGui::SameLine(0, gap); char maxId[32]; - snprintf(maxId, sizeof(maxId), "Max%s", suffix); + snprintf(maxId, sizeof(maxId), "%s%s", TR("grpb_max"), suffix); if (TactileButton(maxId, ImVec2(maxBtnW, barH), capFont)) { s_amount = maxAmount; s_send_max = true; @@ -976,6 +978,7 @@ static void RenderActionButtons(App* app, float width, float vScale, bool is_valid_address, double available, const char* suffix = "") { auto& S = schema::UI(); + const float dp = Layout::dpiScale(); const auto& state = app->getWalletState(); double total = s_amount + s_fee; // Block spending from a view-only source (imported viewing key, no spending key) — it would only @@ -1065,12 +1068,12 @@ static void RenderActionButtons(App* app, float width, float vScale, if (ImGui::BeginPopup(confirmClearId)) { ImGui::Text("%s", TR("send_clear_fields")); ImGui::Spacing(); - if (TactileButton(TR("send_yes_clear"), ImVec2(schema::UI().drawElement("tabs.send", "clear-confirm-yes-width").size, 0), S.resolveFont("button"))) { + if (TactileButton(TR("send_yes_clear"), ImVec2(schema::UI().drawElement("tabs.send", "clear-confirm-yes-width").size * dp, 0), S.resolveFont("button"))) { ClearFormWithUndo(); ImGui::CloseCurrentPopup(); } ImGui::SameLine(); - if (TactileButton(TR("send_keep"), ImVec2(schema::UI().drawElement("tabs.send", "clear-confirm-keep-width").size, 0), S.resolveFont("button"))) { + if (TactileButton(TR("send_keep"), ImVec2(schema::UI().drawElement("tabs.send", "clear-confirm-keep-width").size * dp, 0), S.resolveFont("button"))) { ImGui::CloseCurrentPopup(); } ImGui::EndPopup(); @@ -1086,7 +1089,7 @@ static void RenderActionButtons(App* app, float width, float vScale, ImGui::PushStyleColor(ImGuiCol_Button, ImGui::ColorConvertU32ToFloat4(WithAlpha(Warning(), (int)S.drawElement("tabs.send", "undo-btn-bg-alpha").size))); ImGui::PushStyleColor(ImGuiCol_ButtonHovered, ImGui::ColorConvertU32ToFloat4(WithAlpha(Warning(), (int)S.drawElement("tabs.send", "undo-btn-hover-alpha").size))); char undoId[32]; - snprintf(undoId, sizeof(undoId), "Undo Clear%s", suffix); + snprintf(undoId, sizeof(undoId), "%s%s", TR("grpb_undo_clear"), suffix); if (TactileButton(undoId, ImVec2(width, btnH), S.resolveFont("button"))) { RestoreFormSnapshot(); Notifications::instance().info(TR("send_form_restored")); diff --git a/src/ui/windows/settings_window.cpp b/src/ui/windows/settings_window.cpp index 490c241..21c255c 100644 --- a/src/ui/windows/settings_window.cpp +++ b/src/ui/windows/settings_window.cpp @@ -216,7 +216,7 @@ void RenderSettingsWindow(App* app, bool* p_open) if (!skin.valid) { ImGui::PushStyleColor(ImGuiCol_Text, ImVec4(1.0f, 0.3f, 0.3f, 1.0f)); ImGui::BeginDisabled(true); - std::string label = skin.name + " (invalid)"; + std::string label = skin.name + TR("swin_invalid_suffix"); ImGui::Selectable(label.c_str(), false); ImGui::EndDisabled(); ImGui::PopStyleColor(); @@ -261,7 +261,7 @@ void RenderSettingsWindow(App* app, bool* p_open) ImGui::PushFont(material::Type().iconSmall()); if (material::StyledButton(ICON_REFRESH_THEMES, ImVec2(0, 0))) { skinMgr.refresh(); - Notifications::instance().info("Theme list refreshed"); + Notifications::instance().info(TR("swin_theme_list_refreshed")); } ImGui::PopFont(); if (ImGui::IsItemHovered()) { @@ -425,14 +425,14 @@ void RenderSettingsWindow(App* app, bool* p_open) app->rpc()->getInfo([](const nlohmann::json& result, const std::string& error) { if (error.empty()) { std::string version = result.value("version", "unknown"); - std::string msg = "Connection successful!\ndragonxd version: " + version; + std::string msg = std::string(TR("swin_connection_successful")) + version; Notifications::instance().success(msg); } else { - Notifications::instance().error("Connection failed: " + error); + Notifications::instance().error(std::string(TR("swin_connection_failed")) + error); } }); } else { - Notifications::instance().error("RPC client not initialized"); + Notifications::instance().error(TR("swin_rpc_client_not_initialized")); } } @@ -455,15 +455,15 @@ void RenderSettingsWindow(App* app, bool* p_open) if (error.empty()) { int start = result.value("start_height", 0); int end = result.value("stop_height", 0); - std::string msg = "Rescan started from block " + std::to_string(start) + - " to " + std::to_string(end); + std::string msg = std::string(TR("swin_rescan_started_from_block")) + std::to_string(start) + + TR("swin_rescan_to") + std::to_string(end); Notifications::instance().success(msg); } else { - Notifications::instance().error("Rescan failed: " + error); + Notifications::instance().error(std::string(TR("swin_rescan_failed")) + error); } }); } else { - Notifications::instance().error("RPC client not initialized"); + Notifications::instance().error(TR("swin_rpc_client_not_initialized")); } } ImGui::TextDisabled(" %s", TR("settings_rescan_desc")); @@ -503,9 +503,9 @@ void RenderSettingsWindow(App* app, bool* p_open) if (doConfirm) { std::string ztx_file = util::Platform::getDragonXDataDir() + "ztx_history.json"; if (util::Platform::deleteFile(ztx_file)) { - Notifications::instance().success("Z-transaction history cleared"); + Notifications::instance().success(TR("swin_ztx_history_cleared")); } else { - Notifications::instance().info("No history file found"); + Notifications::instance().info(TR("swin_no_history_file_found")); } s_confirm_clear_ztx = false; } @@ -568,7 +568,7 @@ void RenderSettingsWindow(App* app, bool* p_open) // Save/Cancel buttons if (material::StyledButton(TR("save"), ImVec2(saveBtn.width, 0), S.resolveFont(saveBtn.font))) { saveSettingsFromUI(app->settings()); - Notifications::instance().success("Settings saved"); + Notifications::instance().success(TR("swin_settings_saved")); *p_open = false; } ImGui::SameLine(); diff --git a/src/ui/windows/transaction_details_dialog.cpp b/src/ui/windows/transaction_details_dialog.cpp index 77121d6..c533f41 100644 --- a/src/ui/windows/transaction_details_dialog.cpp +++ b/src/ui/windows/transaction_details_dialog.cpp @@ -124,7 +124,7 @@ void TransactionDetailsDialog::render(App* app) ImGui::SetNextItemWidth(txidInput.width); // negative = fill, reserving |width| px for the Copy button (a content-region margin, not raw px — must NOT be dpi-scaled) ImGui::InputText("##TxID", txid_buf, sizeof(txid_buf), ImGuiInputTextFlags_ReadOnly); ImGui::SameLine(); - if (material::StyledButton("Copy##TxID", ImVec2(copyBtn.width, 0), S.resolveFont(copyBtn.font))) { + if (material::StyledButton((std::string(TR("grpb_copy")) + "##TxID").c_str(), ImVec2(copyBtn.width, 0), S.resolveFont(copyBtn.font))) { ImGui::SetClipboardText(tx.txid.c_str()); } @@ -150,7 +150,7 @@ void TransactionDetailsDialog::render(App* app) ImGui::InputText("##Address", addr_buf, sizeof(addr_buf), ImGuiInputTextFlags_ReadOnly); } ImGui::SameLine(); - if (material::StyledButton("Copy##Addr", ImVec2(copyBtn.width, 0), S.resolveFont(copyBtn.font))) { + if (material::StyledButton((std::string(TR("grpb_copy")) + "##Addr").c_str(), ImVec2(copyBtn.width, 0), S.resolveFont(copyBtn.font))) { ImGui::SetClipboardText(tx.address.c_str()); } } diff --git a/src/ui/windows/transactions_tab.cpp b/src/ui/windows/transactions_tab.cpp index 21fbc9f..0bba8ef 100644 --- a/src/ui/windows/transactions_tab.cpp +++ b/src/ui/windows/transactions_tab.cpp @@ -263,10 +263,10 @@ void RenderTransactionsTab(App* app) int idx_map[] = {-1, 1, 0, 2}; int idx = idx_map[type_filter]; float xOff = idx * (cardW + cardGap); - ImVec2 acMin(origin.x + xOff, origin.y + cardH - 3); + ImVec2 acMin(origin.x + xOff, origin.y + cardH - 3 * vs); ImVec2 acMax(origin.x + xOff + cardW, origin.y + cardH); ImU32 acCol = (type_filter == 1) ? redCol : (type_filter == 2) ? greenCol : goldCol; - dl->AddRectFilled(acMin, acMax, acCol, 2.0f); + dl->AddRectFilled(acMin, acMax, acCol, 2.0f * hs); } ImGui::Dummy(ImVec2(availWidth, cardH)); diff --git a/src/ui/windows/wallets_dialog.h b/src/ui/windows/wallets_dialog.h index a5a66b7..eb1f27c 100644 --- a/src/ui/windows/wallets_dialog.h +++ b/src/ui/windows/wallets_dialog.h @@ -100,7 +100,7 @@ public: const float headH = Type().h6()->LegacySize + Layout::spacingXs() // framework h6 title + Type().caption()->LegacySize + Layout::spacingSm() // intro + gap + ctrlRow + Layout::spacingSm(); // sort control row + gap - const float padV = 48.0f; // content-child padding (top+bottom) + margin + const float padV = 48.0f * dp; // content-child padding (top+bottom) + margin // Size to content, but cap at a viewport fraction: with many wallets on a small / HiDPI // screen the content-sized card could exceed the window (the framework would clip a too-tall // card, footer and all). When capped, the wallet list flexes + scrolls and the controls From a60a2f8e39e9ef7c57831172f9a6dc05bcfbd97f Mon Sep 17 00:00:00 2001 From: DanS Date: Tue, 1 Sep 2026 22:54:36 -0500 Subject: [PATCH 84/89] fix(ui): stop sidebar badges from displacing button text MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit The Chat/History nav buttons centered their icon+label in a region that shrank when a badge (unread count / mining dot) was present, and the "has badge" test read the LIVE count — so the text jumped sideways the moment a count toggled (e.g. a new chat message arrived). Reserve badge clearance by whether the page CAN show a badge (constant per item), center in the full button width regardless, and cap the label with symmetric clearance so a long label still can't run under the corner badge. Co-Authored-By: Claude Opus 4.8 (1M context) --- src/ui/sidebar.h | 26 ++++++++++++++++---------- 1 file changed, 16 insertions(+), 10 deletions(-) diff --git a/src/ui/sidebar.h b/src/ui/sidebar.h index e5b81ca..758c6fc 100644 --- a/src/ui/sidebar.h +++ b/src/ui/sidebar.h @@ -679,15 +679,18 @@ inline bool RenderSidebar(NavPage& current, float sidebarWidth, float contentHei ImU32 textCol = selected ? Primary() : (pageNeedsUnlock ? OnSurfaceDisabled() : OnSurfaceMedium()); if (showLabels) { - // Reserve room for a badge (if this item will draw one) so the - // label centers in the space to the left of it instead of - // running underneath the badge circle. - bool itemHasBadge = - (item.page == NavPage::History && status.unconfirmedTxCount > 0) || - (item.page == NavPage::Mining && status.miningActive) || - (item.page == NavPage::Chat && status.chatUnreadCount > 0); + // The badge is a fixed top-right corner overlay, so it must NOT move + // the icon+label — otherwise the text jumps sideways the moment a live + // count toggles the badge on/off. Reserve clearance from whether the + // page CAN show a badge (constant per item), never from the current + // count, and keep the icon+label centered in the FULL button width so + // the text position and size stay identical with or without a badge. + bool itemBadgeCapable = + item.page == NavPage::History || + item.page == NavPage::Mining || + item.page == NavPage::Chat; float badgeReserve = 0.0f; - if (itemHasBadge) { + if (itemBadgeCapable) { bool dotOnlyReserve = (item.page == NavPage::Mining); float badgeRReserve = dotOnlyReserve ? badgeRadiusDot : badgeRadiusNumber; float badgeInsetXReserve = sde("badge-inset-x", 6.0f); @@ -697,14 +700,17 @@ inline bool RenderSidebar(NavPage& current, float sidebarWidth, float contentHei ImFont* font = selected ? Type().subtitle2() : Type().body2(); float lblFsz = ScaledFontSize(font); float btnW = indMax.x - indMin.x; - float maxLabelW = btnW - iconS * 2.0f - iconLabelGap - Layout::spacingXs() * 2 - badgeReserve; + // Clearance is symmetric (2x) because the group stays centered in the + // full width: reserving on both sides keeps the label's right edge clear + // of the right-side corner badge without shifting the center off-axis. + float maxLabelW = btnW - iconS * 2.0f - iconLabelGap - Layout::spacingXs() * 2 - badgeReserve * 2.0f; ImVec2 labelSz = font->CalcTextSizeA(lblFsz, 1000.0f, 0.0f, NavLabel(item)); if (labelSz.x > maxLabelW && maxLabelW > 0) { lblFsz *= maxLabelW / labelSz.x; labelSz = font->CalcTextSizeA(lblFsz, 1000.0f, 0.0f, NavLabel(item)); } float totalW = iconS * 2.0f + iconLabelGap + labelSz.x; - float btnCX = (indMin.x + indMax.x - badgeReserve) * 0.5f; + float btnCX = (indMin.x + indMax.x) * 0.5f; float startX = btnCX - totalW * 0.5f; DrawNavIcon(dl, item.page, startX + iconS, iconCY, iconS, textCol); From 0a042df8e0b763c6ac79924fb6f4a60cf7c92e7e Mon Sep 17 00:00:00 2001 From: DanS Date: Tue, 1 Sep 2026 22:54:51 -0500 Subject: [PATCH 85/89] feat(chat): per-conversation delete (revive + block); memoize chat/badge render MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Adds a per-conversation "delete" with two modes, and removes the per-frame rescans of the chat history that shared these files. Delete conversation (header trash icon → confirm dialog): - Delete (revive-on-new-message): clears local history and tombstones the messages (new chat_deleted table, keyed dedup hashes) so the every-few- seconds memo re-scan can't re-import them; a genuinely NEW message (new txid) revives the thread. - Delete & block: removes history WITHOUT a tombstone and records the cid as blocked (settings); ChatService::ingest drops that conversation's messages — old and future — until unblocked from the "Blocked" manager, which then re-imports the conversation from chain. - Local-only (messages remain on-chain; the peer keeps their copy). deleteConversation() deletes the DB rows FIRST and only then mutates the store, so a failed write can't leave the two diverged. Unit-tested (revive / tombstone-survives-reload / block / unblock) and adversarially reviewed (store/DB divergence, half-open DB, revive-unread). Performance (chat + badge hot paths, from the perf audit): - ChatStore gains revision(); the Chat unread badge is now a single O(N) no-alloc pass cached on it (was O(conversations x messages) copy+sort every frame). The conversation list and open thread are memoized on revision() (+ show-hidden and AddressBook::revision() for peer-name resolution). - AddressBook gains revision() so an in-place contact rename invalidates the chat memo (an edit keeps entries().size() constant). Co-Authored-By: Claude Opus 4.8 (1M context) --- src/app.h | 19 +++ src/app_network.cpp | 37 ++++-- src/chat/chat_database.cpp | 88 ++++++++++++- src/chat/chat_database.h | 14 +++ src/chat/chat_service.cpp | 29 +++++ src/chat/chat_service.h | 15 +++ src/chat/chat_store.cpp | 31 +++++ src/chat/chat_store.h | 19 +++ src/config/settings.cpp | 14 +++ src/config/settings.h | 21 ++++ src/data/address_book.cpp | 8 +- src/data/address_book.h | 11 +- src/ui/windows/chat_tab.cpp | 241 ++++++++++++++++++++++++++++++++---- src/util/i18n.cpp | 17 +++ tests/test_phase4.cpp | 92 ++++++++++++++ 15 files changed, 611 insertions(+), 45 deletions(-) diff --git a/src/app.h b/src/app.h index 15645f6..610e0b3 100644 --- a/src/app.h +++ b/src/app.h @@ -760,6 +760,22 @@ private: // wallets. In-memory only (resets on app restart). std::map chat_seen_watermark_; + // ── Per-frame render caches (avoid O(N) recompute every frame; see the respective call sites) ── + // Chat nav-badge unread count — recomputed only when the store revision changes or after a short + // interval (mute/hide/seen changes don't bump the store). See App::chatUnreadCount(). + mutable std::uint64_t chat_unread_rev_ = ~0ull; // ~0 forces the first compute + mutable int chat_unread_cached_ = 0; + mutable double chat_unread_computed_at_ = 0.0; + // Sidebar unconfirmed-tx badge — recomputed only when the tx list changes (keyed on last_tx_update + + // size), not every frame. See App::render(). + std::int64_t sb_unconf_key_ts_ = -1; + std::size_t sb_unconf_key_n_ = 0; + int sb_unconf_count_ = 0; + // Daemon-memory probe is expensive (/proc scan on Linux, popen on macOS); throttle it to ~1.5s so the + // Mining tab's per-frame read doesn't hammer the OS. See App::getDaemonMemoryUsageMB(). + mutable double daemon_mem_cached_mb_ = 0.0; + mutable double daemon_mem_probe_at_ = 0.0; + // ── Chat note buffer (BOTH variants) ──────────────────────────────────────────────────────── // Each chat message is a shielded tx that spends a note; its change needs a few confirmations before // it's spendable again (lite: backend ANCHOR_OFFSET+1 = 5; full node: z_sendmany minconf = 1), so @@ -835,6 +851,9 @@ public: int chatUnreadCount() const; // Mark a conversation read up to latestTs (called by the Chat tab while a thread is displayed). void markChatConversationSeen(const std::string& cid, std::int64_t latestTs); + // Drop the seen-watermark for a conversation (used on revive-delete so a re-imported message — even one + // whose stamped time predates the deleted thread's last message — still badges as unread). + void forgetChatConversationSeen(const std::string& cid); private: // Provision the chat identity once the wallet seed is reachable+unlocked (per-tick, both // variants); derives via deriveChatIdentityFromSecret and wipes the secret. No-op when the diff --git a/src/app_network.cpp b/src/app_network.cpp index cc2f979..a987c54 100644 --- a/src/app_network.cpp +++ b/src/app_network.cpp @@ -1458,18 +1458,26 @@ void App::processWalletSwitchRevert() int App::chatUnreadCount() const { if (!chat::hushChatFeatureEnabledAtBuild() || !chat_service_.hasIdentity()) return 0; - int unread = 0; + // This is called every frame from render() to size the Chat nav badge. Recompute only when the store + // actually changed (new/removed messages bump revision()) or after a short interval (to pick up + // mute/hide/seen changes, which don't bump the store). Previously it ran a full O(conversations x + // messages) scan that COPIED and stable_sorted every conversation's messages, every frame. const auto& store = chat_service_.store(); - for (const auto& cid : store.conversationIds()) { - if (settings_ && settings_->isChatMuted(cid)) continue; // muted conversations don't badge (Q10) - if (settings_ && settings_->isChatHidden(cid)) continue; // hidden conversations don't badge - std::int64_t seen = 0; - const auto it = chat_seen_watermark_.find(cid); - if (it != chat_seen_watermark_.end()) seen = it->second; - for (const auto& m : store.conversation(cid)) - if (m.direction == chat::ChatDirection::Incoming && m.timestamp > seen) ++unread; + const std::uint64_t rev = store.revision(); + const double now = ImGui::GetTime(); + if (rev != chat_unread_rev_ || now - chat_unread_computed_at_ > 0.25) { + chat_unread_cached_ = store.countUnread( + [this](const std::string& cid) { // excluded from the badge + return settings_ && (settings_->isChatMuted(cid) || settings_->isChatHidden(cid)); + }, + [this](const std::string& cid) -> std::int64_t { // seen watermark + const auto it = chat_seen_watermark_.find(cid); + return it != chat_seen_watermark_.end() ? it->second : 0; + }); + chat_unread_rev_ = rev; + chat_unread_computed_at_ = now; } - return unread; + return chat_unread_cached_; } void App::markChatConversationSeen(const std::string& cid, std::int64_t latestTs) @@ -1477,6 +1485,11 @@ void App::markChatConversationSeen(const std::string& cid, std::int64_t latestTs if (latestTs > 0) chat_seen_watermark_[cid] = latestTs; } +void App::forgetChatConversationSeen(const std::string& cid) +{ + chat_seen_watermark_.erase(cid); +} + void App::wipePendingTransactionHistoryCachePassphrase() { if (!pending_transaction_history_cache_passphrase_.empty()) { @@ -3041,6 +3054,10 @@ void App::provisionChatIdentityFromSecret(std::string secret) // Persistence: unlock the seed-derived chat DB with the SAME secret and rehydrate the store // with prior messages (decrypted at rest under a key only this seed can derive). chat_service_.setPersistence(&chat_db_); + // A blocked conversation's messages are dropped at ingest (old + future) until it is unblocked. + chat_service_.setBlockedPredicate([this](const std::string& cid) { + return settings_ && settings_->isChatBlocked(cid); + }); if (chat_db_.unlockWithSecret(trimmed)) { chat_service_.loadFromDatabase(); // Baseline unread: treat everything already in the store at load as read, so only messages diff --git a/src/chat/chat_database.cpp b/src/chat/chat_database.cpp index 13d697f..f533819 100644 --- a/src/chat/chat_database.cpp +++ b/src/chat/chat_database.cpp @@ -89,6 +89,7 @@ bool ChatDatabase::unlockWithSecret(const std::string& secret) lock(); return false; } + loadTombstones(); return true; } @@ -97,11 +98,13 @@ void ChatDatabase::lock() sodium_memzero(key_.data(), key_.size()); key_ready_ = false; wallet_tag_.clear(); + tombstones_.clear(); } bool ChatDatabase::append(const ChatMessage& message) { if (!key_ready_ || !ensureOpen()) return false; + if (isTombstoned(message)) return false; // locally deleted — don't re-persist on a chain re-scan std::vector nonce; std::vector cipher; @@ -193,13 +196,79 @@ std::vector ChatDatabase::load() void ChatDatabase::clearWallet() { if (wallet_tag_.empty() || !ensureOpen()) return; + for (const char* sql : {"DELETE FROM chat_messages WHERE wallet_tag = ?", + "DELETE FROM chat_deleted WHERE wallet_tag = ?"}) { + sqlite3_stmt* stmt = nullptr; + if (sqlite3_prepare_v2(db_, sql, -1, &stmt, nullptr) != SQLITE_OK) continue; + sqlite3_bind_text(stmt, 1, wallet_tag_.c_str(), -1, SQLITE_TRANSIENT); + sqlite3_step(stmt); + sqlite3_finalize(stmt); + } + tombstones_.clear(); +} + +bool ChatDatabase::deleteMessages(const std::vector& messages, bool tombstone) +{ + if (!key_ready_ || !ensureOpen()) return false; + if (messages.empty()) return true; + + if (!exec("BEGIN")) return false; + bool ok = true; + for (const auto& m : messages) { + const std::string dedup = dedupHash(m.txid, m.payload_position); + + sqlite3_stmt* del = nullptr; + if (sqlite3_prepare_v2(db_, "DELETE FROM chat_messages WHERE wallet_tag = ? AND dedup_hash = ?", + -1, &del, nullptr) == SQLITE_OK) { + sqlite3_bind_text(del, 1, wallet_tag_.c_str(), -1, SQLITE_TRANSIENT); + sqlite3_bind_text(del, 2, dedup.c_str(), -1, SQLITE_TRANSIENT); + if (sqlite3_step(del) != SQLITE_DONE) ok = false; + sqlite3_finalize(del); + } else { + ok = false; + } + + if (tombstone) { + sqlite3_stmt* ins = nullptr; + if (sqlite3_prepare_v2(db_, + "INSERT OR IGNORE INTO chat_deleted (wallet_tag, dedup_hash) VALUES (?, ?)", + -1, &ins, nullptr) == SQLITE_OK) { + sqlite3_bind_text(ins, 1, wallet_tag_.c_str(), -1, SQLITE_TRANSIENT); + sqlite3_bind_text(ins, 2, dedup.c_str(), -1, SQLITE_TRANSIENT); + if (sqlite3_step(ins) != SQLITE_DONE) ok = false; + sqlite3_finalize(ins); + } else { + ok = false; + } + } + } + if (!exec(ok ? "COMMIT" : "ROLLBACK")) ok = false; + // Only reflect the tombstones in the in-memory cache once they are durably committed. + if (ok && tombstone) + for (const auto& m : messages) tombstones_.insert(dedupHash(m.txid, m.payload_position)); + return ok; +} + +bool ChatDatabase::isTombstoned(const ChatMessage& message) const +{ + if (!key_ready_ || tombstones_.empty()) return false; + return tombstones_.count(dedupHash(message.txid, message.payload_position)) > 0; +} + +void ChatDatabase::loadTombstones() +{ + tombstones_.clear(); + if (!key_ready_ || !ensureOpen()) return; sqlite3_stmt* stmt = nullptr; - if (sqlite3_prepare_v2(db_, "DELETE FROM chat_messages WHERE wallet_tag = ?", -1, &stmt, nullptr) - != SQLITE_OK) { + if (sqlite3_prepare_v2(db_, "SELECT dedup_hash FROM chat_deleted WHERE wallet_tag = ?", + -1, &stmt, nullptr) != SQLITE_OK) { return; } sqlite3_bind_text(stmt, 1, wallet_tag_.c_str(), -1, SQLITE_TRANSIENT); - sqlite3_step(stmt); + while (sqlite3_step(stmt) == SQLITE_ROW) { + const auto* h = reinterpret_cast(sqlite3_column_text(stmt, 0)); + if (h) tombstones_.insert(h); + } sqlite3_finalize(stmt); } @@ -260,11 +329,18 @@ bool ChatDatabase::exec(const char* sql) bool ChatDatabase::createSchema() { - return exec("CREATE TABLE IF NOT EXISTS chat_messages (" + if (!exec("CREATE TABLE IF NOT EXISTS chat_messages (" + "wallet_tag TEXT NOT NULL, " + "dedup_hash TEXT NOT NULL, " + "nonce BLOB NOT NULL, " + "payload BLOB NOT NULL, " + "PRIMARY KEY (wallet_tag, dedup_hash))")) + return false; + // Tombstones for locally-deleted messages (dedup_hash only — the same keyed, non-revealing hash the + // message rows use). A chain re-scan checks this so a deleted message never re-imports. + return exec("CREATE TABLE IF NOT EXISTS chat_deleted (" "wallet_tag TEXT NOT NULL, " "dedup_hash TEXT NOT NULL, " - "nonce BLOB NOT NULL, " - "payload BLOB NOT NULL, " "PRIMARY KEY (wallet_tag, dedup_hash))"); } diff --git a/src/chat/chat_database.h b/src/chat/chat_database.h index 1156a60..550c0ae 100644 --- a/src/chat/chat_database.h +++ b/src/chat/chat_database.h @@ -16,6 +16,7 @@ #include #include #include +#include #include struct sqlite3; @@ -54,8 +55,20 @@ public: void clearWallet(); // delete the unlocked wallet's rows + // Per-conversation local delete. Removes the given messages' rows; when `tombstone` is true it also + // records their (txid,position) dedup keys so a chain re-scan never re-imports them — this backs the + // "delete, but a NEW message revives the thread" path. With `tombstone` false the rows are simply + // removed (used by "delete & block", where a settings-level cid block suppresses re-import until the + // user unblocks, at which point the history re-imports from chain). Atomic; no-op while locked. + bool deleteMessages(const std::vector& messages, bool tombstone); + + // True if this message's (txid,position) was locally deleted with a tombstone. Checked against an + // in-memory cache loaded on unlock — O(1), no SQL. False while locked. + bool isTombstoned(const ChatMessage& message) const; + private: bool ensureOpen(); + void loadTombstones(); // populate tombstones_ from chat_deleted for the unlocked wallet bool exec(const char* sql); bool createSchema(); std::string dedupHash(const std::string& txid, std::size_t position) const; @@ -74,6 +87,7 @@ private: std::array key_{}; // AEAD storage key (seed-derived) std::string wallet_tag_; // seed-derived row partition (a keyed hash, hex) bool key_ready_ = false; + std::unordered_set tombstones_; // dedup_hash cache of locally-deleted messages }; } // namespace dragonx::chat diff --git a/src/chat/chat_service.cpp b/src/chat/chat_service.cpp index df97bff..e817a10 100644 --- a/src/chat/chat_service.cpp +++ b/src/chat/chat_service.cpp @@ -28,6 +28,10 @@ int ChatService::ingest(const std::vector& metadata std::int64_t fallbackTimestamp, std::vector* newIncomingCids) { if (!has_identity_) return 0; + // Persistence is attached but not unlocked (e.g. the DB failed to open with the seed): we can't + // consult tombstones, so ingesting now would resurface locally-deleted messages into the store. + // Skip until the DB is usable — chat is degraded anyway without its store. + if (db_ && !db_->hasKey()) return 0; const std::string myPubKey = chatIdentityPublicKeyHex(identity_); @@ -62,6 +66,13 @@ int ChatService::ingest(const std::vector& metadata } message.payload_position = meta.payload_position; + // Suppress locally-removed conversations before the (relatively costly) decrypt. A blocked cid + // is dropped outright (old + future messages) until unblocked; a tombstoned (txid,position) was + // deleted with "revive on new message", so only that exact message is skipped — a new message + // in the same conversation has a different txid and flows through normally. + if (blocked_pred_ && blocked_pred_(message.conversation_id)) continue; + if (db_ && db_->isTombstoned(message)) continue; + if (meta.type == HushChatHeaderType::ContactRequest) { message.kind = ChatMessageKind::ContactRequest; message.body = meta.payload_memo; // plaintext request text @@ -92,10 +103,28 @@ int ChatService::ingest(const std::vector& metadata void ChatService::loadFromDatabase() { if (!db_) return; for (const auto& message : db_->load()) { + // Never surface a blocked conversation, even if a prior "delete & block" failed to remove its + // rows (defense-in-depth): the ingest guard already drops live scans, this covers the reload path. + if (blocked_pred_ && blocked_pred_(message.conversation_id)) continue; store_.append(message); } } +bool ChatService::deleteConversation(const std::string& conversationId, bool block) { + // Delete the persisted rows FIRST and only mutate the in-memory view if that succeeds. Doing it the + // other way round means a failed DB write (disk full / locked) would empty the store while the rows + // survive — and on the next reload the conversation silently reappears with no tombstone. + // Revive-on-new-message => tombstone the removed rows so a re-scan won't re-import them. + // Block => remove the rows without a tombstone; the caller's blocked predicate suppresses re-import + // until unblocked, at which point the conversation re-imports from chain. + if (db_) { + std::vector msgs = store_.conversation(conversationId); // snapshot (copy) + if (!db_->deleteMessages(msgs, /*tombstone=*/!block)) return false; + } + store_.eraseConversation(conversationId); + return true; +} + std::string ChatService::identityPublicKeyHex() const { if (!has_identity_) return {}; return chatIdentityPublicKeyHex(identity_); diff --git a/src/chat/chat_service.h b/src/chat/chat_service.h index af9d5d9..b570560 100644 --- a/src/chat/chat_service.h +++ b/src/chat/chat_service.h @@ -11,6 +11,7 @@ #include "chat_store.h" #include +#include #include #include #include @@ -55,6 +56,19 @@ public: // the seed-derived key) into the in-memory store. No-op without an unlocked database. void loadFromDatabase(); + // Set a predicate returning true for a BLOCKED conversation id. ingest() drops those messages + // entirely (they are never stored or persisted) until the predicate stops returning true — this is + // how "delete & block" suppresses old and future messages. Typically wired to Settings::isChatBlocked. + void setBlockedPredicate(std::function pred) { blocked_pred_ = std::move(pred); } + + // Locally delete a conversation: remove its messages from the store and the database. When `block` + // is false, the removed messages are tombstoned so a chain re-scan won't re-import them, but a + // genuinely NEW message (new txid) revives the thread. When `block` is true, the rows are removed + // WITHOUT a tombstone (the caller also records the cid as blocked via the predicate above); unblocking + // later lets the conversation re-import from chain. Returns false (leaving the store untouched) if the + // persisted rows couldn't be removed, so the caller can avoid a store/DB divergence. + bool deleteConversation(const std::string& conversationId, bool block); + // --- Outgoing (compose) --- // My chat public key (hex), or "" without an identity — goes in an outgoing header's "p". std::string identityPublicKeyHex() const; @@ -90,6 +104,7 @@ private: bool has_identity_ = false; ChatStore store_; ChatDatabase* db_ = nullptr; // optional; not owned + std::function blocked_pred_; // true => cid is blocked (drop its messages) }; } // namespace dragonx::chat diff --git a/src/chat/chat_store.cpp b/src/chat/chat_store.cpp index 82cf76b..b493f90 100644 --- a/src/chat/chat_store.cpp +++ b/src/chat/chat_store.cpp @@ -13,6 +13,7 @@ std::string ChatStore::dedupKey(const ChatMessage& message) { bool ChatStore::append(const ChatMessage& message) { if (!seen_.insert(dedupKey(message)).second) return false; messages_.push_back(message); + ++revision_; return true; } @@ -38,12 +39,24 @@ const ChatMessage* ChatStore::updateDelivery(const std::string& txid, ChatDelive for (auto& message : messages_) { if (message.txid == txid) { message.delivery = delivery; + ++revision_; return &message; } } return nullptr; } +int ChatStore::countUnread(const std::function& excluded, + const std::function& seenFor) const { + int unread = 0; + for (const auto& m : messages_) { + if (m.direction != ChatDirection::Incoming) continue; + if (excluded && excluded(m.conversation_id)) continue; + if (m.timestamp > seenFor(m.conversation_id)) ++unread; + } + return unread; +} + std::vector ChatStore::conversationIds() const { std::vector ids; std::unordered_set seenIds; @@ -53,9 +66,27 @@ std::vector ChatStore::conversationIds() const { return ids; } +std::vector ChatStore::eraseConversation(const std::string& conversationId) { + std::vector removed; + std::vector kept; + kept.reserve(messages_.size()); + for (auto& m : messages_) { + if (m.conversation_id == conversationId) { + seen_.erase(dedupKey(m)); + removed.push_back(std::move(m)); + } else { + kept.push_back(std::move(m)); + } + } + messages_.swap(kept); + if (!removed.empty()) ++revision_; + return removed; +} + void ChatStore::clear() { messages_.clear(); seen_.clear(); + ++revision_; } } // namespace dragonx::chat diff --git a/src/chat/chat_store.h b/src/chat/chat_store.h index 3c923e8..4ab6bf2 100644 --- a/src/chat/chat_store.h +++ b/src/chat/chat_store.h @@ -5,6 +5,8 @@ #include "chat_message.h" +#include +#include #include #include #include @@ -38,15 +40,32 @@ public: return out; } + // Remove every message in a conversation from the in-memory view and return the removed messages + // (so the caller can delete/tombstone their persisted rows). Re-appends are prevented by the ingest + // guard (blocked-cid predicate / DB tombstone), not here. + std::vector eraseConversation(const std::string& conversationId); + std::size_t size() const { return messages_.size(); } bool empty() const { return messages_.empty(); } void clear(); + // Monotonic counter bumped on every mutation (append / updateDelivery change / eraseConversation / + // clear). Callers memoize expensive per-frame reads (conversation-list build, unread count) against it + // so they only rebuild when the store actually changed. + std::uint64_t revision() const { return revision_; } + + // Count unread incoming messages in a SINGLE pass over the store: an incoming message counts when its + // cid is not `excluded` and its timestamp is newer than `seenFor(cid)`. Avoids the per-conversation + // copy+sort that conversation() does — the count doesn't need ordering. + int countUnread(const std::function& excluded, + const std::function& seenFor) const; + private: static std::string dedupKey(const ChatMessage& message); std::vector messages_; std::unordered_set seen_; + std::uint64_t revision_ = 0; }; } // namespace dragonx::chat diff --git a/src/config/settings.cpp b/src/config/settings.cpp index e6c05ad..2274f28 100644 --- a/src/config/settings.cpp +++ b/src/config/settings.cpp @@ -157,6 +157,13 @@ bool Settings::load(const std::string& path) for (const auto& c : j["hidden_chat_cids"]) if (c.is_string()) hidden_chat_cids_.push_back(c.get()); } + if (j.contains("blocked_chat_convs") && j["blocked_chat_convs"].is_array()) { + blocked_chat_convs_.clear(); + for (const auto& c : j["blocked_chat_convs"]) + if (c.is_object() && c.contains("cid") && c["cid"].is_string()) + blocked_chat_convs_.push_back({c["cid"].get(), + c.value("name", std::string())}); + } // Chat-tab customization (re-clamped through the setters so hand-edited JSON stays in range). loadScalar(j, "chat_emoji_color", chat_emoji_color_); loadScalar(j, "chat_poll_rate_sec", chat_poll_rate_sec_); setChatPollRateSec(chat_poll_rate_sec_); @@ -461,6 +468,13 @@ bool Settings::save(const std::string& path) j["hidden_chat_cids"] = json::array(); for (const auto& c : hidden_chat_cids_) j["hidden_chat_cids"].push_back(c); + j["blocked_chat_convs"] = json::array(); + for (const auto& b : blocked_chat_convs_) { + json o; + o["cid"] = b.cid; + o["name"] = b.name; + j["blocked_chat_convs"].push_back(o); + } j["chat_emoji_color"] = chat_emoji_color_; j["chat_poll_rate_sec"] = chat_poll_rate_sec_; j["chat_bubble_style"] = chat_bubble_style_; diff --git a/src/config/settings.h b/src/config/settings.h index 4017575..5b2b0a9 100644 --- a/src/config/settings.h +++ b/src/config/settings.h @@ -144,6 +144,26 @@ public: hidden_chat_cids_.end()); } + // Blocked chat conversations (by cid). Unlike hide (reversible, keeps messages), block DELETES the + // local history AND suppresses every message for the cid — old and future — until you unblock, at + // which point the conversation re-imports from the chain. The last-known peer name is kept so the + // "Blocked" list can label the entry (its messages are gone from the local store). + struct BlockedChatConv { std::string cid; std::string name; }; + bool isChatBlocked(const std::string& cid) const { + for (const auto& b : blocked_chat_convs_) if (b.cid == cid) return true; + return false; + } + void setChatBlocked(const std::string& cid, const std::string& name, bool blocked) { + const bool already = isChatBlocked(cid); + if (blocked && !already) blocked_chat_convs_.push_back({cid, name}); + else if (!blocked && already) + blocked_chat_convs_.erase( + std::remove_if(blocked_chat_convs_.begin(), blocked_chat_convs_.end(), + [&](const BlockedChatConv& b) { return b.cid == cid; }), + blocked_chat_convs_.end()); + } + const std::vector& blockedChatConversations() const { return blocked_chat_convs_; } + // ── Chat-tab customization (chat settings modal + Settings → Chat & Contacts) ────── bool getChatEmojiColor() const { return chat_emoji_color_; } void setChatEmojiColor(bool v) { chat_emoji_color_ = v; } @@ -559,6 +579,7 @@ private: std::string chat_reply_zaddr_; std::vector muted_chat_cids_; // muted chat conversations by cid (Q10) std::vector hidden_chat_cids_; // hidden chat conversations by cid + std::vector blocked_chat_convs_; // blocked chat conversations (cid + last-known name) // Chat-tab customization (chat settings modal + Settings → Chat & Contacts). bool chat_emoji_color_ = true; // true = color (needs FreeType; falls back to mono if absent), false = monochrome float chat_poll_rate_sec_ = 2.5f; // 0-conf chat fast-scan cadence (full node) diff --git a/src/data/address_book.cpp b/src/data/address_book.cpp index 9893406..0c36d4d 100644 --- a/src/data/address_book.cpp +++ b/src/data/address_book.cpp @@ -68,8 +68,9 @@ bool AddressBook::load() } DEBUG_LOGF("Address book loaded: %zu entries\n", entries_.size()); + ++revision_; return true; - + } catch (const std::exception& e) { DEBUG_LOGF("Error loading address book: %s\n", e.what()); return false; @@ -121,6 +122,7 @@ bool AddressBook::addEntry(const AddressBookEntry& entry) } entries_.push_back(entry); + ++revision_; return save(); } @@ -136,6 +138,7 @@ bool AddressBook::updateEntry(size_t index, const AddressBookEntry& entry) } entries_[index] = entry; + ++revision_; return save(); } @@ -146,6 +149,7 @@ bool AddressBook::removeEntry(size_t index) } entries_.erase(entries_.begin() + index); + ++revision_; return save(); } @@ -159,7 +163,7 @@ int AddressBook::reattachLegacyScopes(const std::string& scopeId) e.scope = scopeId; ++rescoped; } - if (rescoped > 0) save(); + if (rescoped > 0) { ++revision_; save(); } return rescoped; } diff --git a/src/data/address_book.h b/src/data/address_book.h index 1c4ae02..5c2127b 100644 --- a/src/data/address_book.h +++ b/src/data/address_book.h @@ -4,6 +4,7 @@ #pragma once +#include #include #include @@ -121,11 +122,18 @@ public: */ size_t size() const { return entries_.size(); } + /** + * @brief Monotonic counter bumped on every content change (add/update/remove/load/sweep). Consumers + * (e.g. the chat conversation-list memo) key their caches off this so an IN-PLACE edit — a rename or + * address change that keeps size() constant — still invalidates them. + */ + std::uint64_t revision() const { return revision_; } + /** * @brief UI-sweep ONLY: replace the in-memory entries WITHOUT persisting to disk, so the sweep can * seed demo contacts and restore the real book without a disk write. Do not use outside the sweep. */ - void sweepSetEntries(std::vector e) { entries_ = std::move(e); } + void sweepSetEntries(std::vector e) { entries_ = std::move(e); ++revision_; } /** * @brief Check if empty @@ -134,6 +142,7 @@ public: private: std::vector entries_; + std::uint64_t revision_ = 0; std::string file_path_; }; diff --git a/src/ui/windows/chat_tab.cpp b/src/ui/windows/chat_tab.cpp index 2f90cd9..400833c 100644 --- a/src/ui/windows/chat_tab.cpp +++ b/src/ui/windows/chat_tab.cpp @@ -93,6 +93,10 @@ char s_new_zaddr[128] = ""; char s_new_msg[256] = ""; char s_search[80] = ""; // conversation-list filter (Q8) bool s_show_hidden = false; // when on, the list also shows hidden conversations (with an Unhide action) +bool s_show_delete_confirm = false; // "Delete conversation?" confirm overlay (revive vs block) +std::string s_delete_cid; // conversation targeted by the delete confirm +std::string s_delete_name; // its peer name (for the confirm copy / block-list label) +bool s_show_blocked = false; // blocked-conversations manager overlay (unblock) bool s_show_emoji_picker = false; // emoji picker overlay — fills the conversation-list pane while open char s_emoji_search[48] = ""; // emoji picker keyword filter @@ -523,6 +527,16 @@ struct ConvSummary { bool hidden = false; // shown only while "Show hidden" is on }; +// Per-frame memoization of the conversation-list build and the open-thread message list (both otherwise +// rescan + copy + sort the whole chat history every frame). File-scope so ResetChatTab() can reset them +// on a wallet switch; the hide/unhide/rename handlers reset s_convsKey directly to force a rebuild. +std::vector s_convs; +int s_convsHidden = 0; +std::uint64_t s_convsKey = ~0ull; +std::string s_threadCid; +std::uint64_t s_threadRev = ~0ull; +std::vector s_threadMsgs; + // Centered, muted, wrapped hint for the empty states. void centeredHint(const char* text) { ImVec2 avail = ImGui::GetContentRegionAvail(); @@ -725,32 +739,46 @@ void RenderChatTab(App* app) } // Build conversation summaries (single scan per conversation), sorted by most-recent activity. - std::vector convs; - int hiddenCount = 0; - for (const auto& cid : store.conversationIds()) { - const bool hidden = app->settings() && app->settings()->isChatHidden(cid); - if (hidden) ++hiddenCount; - if (hidden && !s_show_hidden) continue; // filtered out unless "Show hidden" is on - const auto messages = store.conversation(cid); - if (messages.empty()) continue; - ConvSummary c; - c.cid = cid; - c.hidden = hidden; - c.count = static_cast(messages.size()); - for (const auto& m : messages) { // pin to the EARLIEST (establishing) peer z-addr / key (B2 — the - if (c.peerZaddr.empty() && !m.peer_zaddr.empty()) c.peerZaddr = m.peer_zaddr; // memo header rides - if (c.peerPubKey.empty() && !m.peer_public_key_hex.empty()) c.peerPubKey = m.peer_public_key_hex; // outside the AEAD) + // MEMOIZED: this previously rescanned + copied + sorted the ENTIRE chat history every frame. Rebuild + // only when the store changed (revision), the show-hidden toggle flipped, or the contact list grew + // (peerName resolution). Hide/unhide and rename don't move any of those, so those handlers force a + // rebuild by resetting s_convsKey (delete/block already bump the store revision). s_convsKey is reset + // in ResetChatTab on wallet switch. + const std::uint64_t convsKey = + store.revision() * 1000003ull + + static_cast(s_show_hidden ? 1 : 0) + + (book.revision() << 20); // book.revision() catches in-place contact edits (rename) that keep size() + if (convsKey != s_convsKey) { + s_convs.clear(); + s_convsHidden = 0; + for (const auto& cid : store.conversationIds()) { + const bool hidden = app->settings() && app->settings()->isChatHidden(cid); + if (hidden) ++s_convsHidden; + if (hidden && !s_show_hidden) continue; // filtered out unless "Show hidden" is on + const auto messages = store.conversation(cid); + if (messages.empty()) continue; + ConvSummary c; + c.cid = cid; + c.hidden = hidden; + c.count = static_cast(messages.size()); + for (const auto& m : messages) { // pin to the EARLIEST (establishing) peer z-addr / key (B2 — the + if (c.peerZaddr.empty() && !m.peer_zaddr.empty()) c.peerZaddr = m.peer_zaddr; // memo header rides + if (c.peerPubKey.empty() && !m.peer_public_key_hex.empty()) c.peerPubKey = m.peer_public_key_hex; // outside the AEAD) + } + const auto& last = messages.back(); + c.lastBody = last.body; + c.lastTs = last.timestamp; + const int idx = c.peerZaddr.empty() ? -1 : book.findByAddress(c.peerZaddr); + c.peerName = (idx >= 0) ? book.entries()[idx].label + : shorten(!c.peerZaddr.empty() ? c.peerZaddr : cid); + s_convs.push_back(std::move(c)); } - const auto& last = messages.back(); - c.lastBody = last.body; - c.lastTs = last.timestamp; - const int idx = c.peerZaddr.empty() ? -1 : book.findByAddress(c.peerZaddr); - c.peerName = (idx >= 0) ? book.entries()[idx].label - : shorten(!c.peerZaddr.empty() ? c.peerZaddr : cid); - convs.push_back(std::move(c)); + std::sort(s_convs.begin(), s_convs.end(), + [](const ConvSummary& a, const ConvSummary& b) { return a.lastTs > b.lastTs; }); + s_convsKey = convsKey; } - std::sort(convs.begin(), convs.end(), - [](const ConvSummary& a, const ConvSummary& b) { return a.lastTs > b.lastTs; }); + std::vector& convs = s_convs; + int hiddenCount = s_convsHidden; // Keep the selection valid (only when there is something to select). if (!convs.empty() && @@ -845,6 +873,15 @@ void RenderChatTab(App* app) ImGui::SetNextItemWidth(-FLT_MIN); ImGui::InputTextWithHint("##chatsearch", TR("chat_search"), s_search, sizeof(s_search)); } + // Blocked-conversations manager opener — only when at least one is blocked. Blocked convs have no + // stored messages (deleted), so they can't appear in the list; this opens a small manager to unblock. + const int blockedCount = app->settings() ? (int)app->settings()->blockedChatConversations().size() : 0; + if (blockedCount > 0) { + const std::string bl = std::string(TR("chat_blocked_manage")) + " (" + std::to_string(blockedCount) + ")"; + ImGui::PushStyleColor(ImGuiCol_Text, material::OnSurfaceMedium()); + if (ImGui::SmallButton(bl.c_str())) s_show_blocked = true; + ImGui::PopStyleColor(); + } const std::string search = s_search; ImGui::Separator(); if (convs.empty()) { @@ -1018,7 +1055,7 @@ void RenderChatTab(App* app) // The toolbar's left edge is known up front (from the button count). A rename (edit) icon is // shown whenever there's an address to save the contact under; the settings "notch" gear is // always the rightmost icon. - const int nBtns = 4 + (hasAddr ? 1 : 0); + const int nBtns = 5 + (hasAddr ? 1 : 0); // export, mute, hide, delete, settings (+rename) const float toolbarLeft = rightX - (nBtns * ib + (nBtns - 1) * gap); // Compact address + lock (or waiting-chip) metrics, reserved to the right of the name. @@ -1069,6 +1106,7 @@ void RenderChatTab(App* app) } else { Notifications::instance().error(TR("address_book_exists")); } + s_convsKey = ~0ull; // peerName changed — force the conversation-list memo to rebuild } s_rename_cid.clear(); } else if (cancel) { @@ -1170,6 +1208,21 @@ void RenderChatTab(App* app) s_selected_cid.clear(); Notifications::instance().info(TR("chat_hidden_toast")); } + s_convsKey = ~0ull; // hidden-state changed — force the conversation-list memo to rebuild + } + bx += ib + gap; + } + // Delete — clears this conversation's LOCAL history. Destructive (and offers a + // "delete & block" variant), so it opens a confirm dialog rather than acting inline. + { + ImGui::SetCursorScreenPos(ImVec2(bx, by)); + material::IconButtonStyle a = base; + a.tooltip = TR("chat_delete"); + a.hoverColor = material::Error(); + if (material::IconButton("##hdr_delete", ICON_MD_DELETE_OUTLINE, ifont, ImVec2(ib, ib), a)) { + s_delete_cid = sel->cid; + s_delete_name = sel->peerName; + s_show_delete_confirm = true; } bx += ib + gap; } @@ -1278,7 +1331,15 @@ void RenderChatTab(App* app) const float groupGap = (compact ? 4.0f : 7.0f) * dp; const float msgGap = (compact ? 2.0f : 3.0f) * dp; const ImU32 accentBase = bubbleAccentColor(cs ? cs->getChatBubbleAccent() : 0); - const auto messages = store.conversation(s_selected_cid); + // MEMOIZED: store.conversation() linear-scans ALL messages across ALL conversations and + // copies+sorts the match every call. Rebuild only when the open thread or the store changes, + // not every frame while the thread is simply being read/scrolled. + if (s_selected_cid != s_threadCid || store.revision() != s_threadRev) { + s_threadMsgs = store.conversation(s_selected_cid); + s_threadCid = s_selected_cid; + s_threadRev = store.revision(); + } + const auto& messages = s_threadMsgs; // Grouping + per-day separators (Tier 1). Same-sender messages within kGroupWindow share // one meta header and stack tightly; a date pill is drawn once per calendar day. const std::int64_t nowTs = static_cast(std::time(nullptr)); @@ -1820,6 +1881,122 @@ void RenderChatTab(App* app) } } + // ---- Delete-conversation confirm (revive-on-new-message vs delete & block) ---- + if (s_show_delete_confirm) { + const float dp = Layout::dpiScale(); + material::OverlayDialogSpec ov; + ov.title = TR("chat_delete_title"); + ov.p_open = &s_show_delete_confirm; // X / backdrop closes it (no-op) + ov.style = material::OverlayStyle::BlurFloat; + ov.cardWidth = 500.0f; ov.idSuffix = "chatdelete"; + if (material::BeginOverlayDialog(ov)) { + ImGui::PushTextWrapPos(0.0f); + ImGui::TextUnformatted((std::string(TR("chat_delete_body_prefix")) + s_delete_name + + TR("chat_delete_body_suffix")).c_str()); + ImGui::Dummy(ImVec2(0, Layout::spacingXs())); + ImGui::PushStyleColor(ImGuiCol_Text, material::OnSurfaceMedium()); + ImGui::TextUnformatted(TR("chat_delete_revive_note")); + ImGui::Dummy(ImVec2(0, Layout::spacingXs())); + ImGui::TextUnformatted(TR("chat_delete_local_note")); + ImGui::PopStyleColor(); + ImGui::PopTextWrapPos(); + ImGui::Dummy(ImVec2(0, Layout::spacingMd())); + + auto doDelete = [&](bool block) { + // Delete first — if the persisted rows can't be removed, change nothing else (no block, + // no toast) so the store and DB can't diverge. + if (!app->chatService().deleteConversation(s_delete_cid, block)) { + Notifications::instance().error(TR("chat_delete_failed")); + s_show_delete_confirm = false; + s_delete_cid.clear(); s_delete_name.clear(); + return; + } + if (app->settings()) { + if (block) app->settings()->setChatBlocked(s_delete_cid, s_delete_name, true); + app->settings()->setChatHidden(s_delete_cid, false); // clear any prior hide flag + app->settings()->save(); + } + // Revive mode: forget the seen-watermark so a re-imported message badges as unread even if + // its stamped time predates the deleted thread. Block mode keeps it, so an unblock-restored + // history doesn't all re-badge. + if (!block) app->forgetChatConversationSeen(s_delete_cid); + if (s_selected_cid == s_delete_cid) s_selected_cid.clear(); + Notifications::instance().info(block ? TR("chat_blocked_toast") : TR("chat_deleted_toast")); + s_show_delete_confirm = false; + s_delete_cid.clear(); s_delete_name.clear(); + }; + + auto textW = [&](const char* t) { + return ImGui::CalcTextSize(t).x + ImGui::GetStyle().FramePadding.x * 2.0f + 20.0f * dp; + }; + const float gap2 = Layout::spacingSm(); + const float wDel = std::max(100.0f * dp, textW(TR("chat_delete_confirm"))); + const float wBlk = std::max(130.0f * dp, textW(TR("chat_delete_block"))); + const float wCan = std::max(90.0f * dp, textW(TR("chat_cancel"))); + material::BeginOverlayDialogFooter(wDel + wBlk + wCan + gap2 * 2.0f, /*drawSeparator=*/false); + + ImGui::PushStyleColor(ImGuiCol_Button, ImGui::ColorConvertU32ToFloat4(material::WithAlpha(material::Error(), 205))); + ImGui::PushStyleColor(ImGuiCol_ButtonHovered, ImGui::ColorConvertU32ToFloat4(material::Error())); + ImGui::PushStyleColor(ImGuiCol_ButtonActive, ImGui::ColorConvertU32ToFloat4(material::WithAlpha(material::Error(), 235))); + ImGui::PushStyleColor(ImGuiCol_Text, ImGui::ColorConvertU32ToFloat4(material::OnError())); + const bool doDel = material::TactileButton(TR("chat_delete_confirm"), ImVec2(wDel, 0)); + ImGui::SameLine(0, gap2); + const bool doBlk = material::TactileButton(TR("chat_delete_block"), ImVec2(wBlk, 0)); + ImGui::PopStyleColor(4); + ImGui::SameLine(0, gap2); + const bool doCancel = material::TactileButton(TR("chat_cancel"), ImVec2(wCan, 0)); + + if (doDel) doDelete(false); + if (doBlk) doDelete(true); + if (doCancel) { s_show_delete_confirm = false; s_delete_cid.clear(); s_delete_name.clear(); } + + material::EndOverlayDialog(); + } + } + + // ---- Blocked-conversations manager (unblock) ---- + if (s_show_blocked) { + const float dp = Layout::dpiScale(); + material::OverlayDialogSpec ov; + ov.title = TR("chat_blocked_title"); + ov.p_open = &s_show_blocked; + ov.style = material::OverlayStyle::BlurFloat; + ov.cardWidth = 500.0f; ov.idSuffix = "chatblocked"; + if (material::BeginOverlayDialog(ov)) { + ImGui::PushTextWrapPos(0.0f); + ImGui::PushStyleColor(ImGuiCol_Text, material::OnSurfaceMedium()); + ImGui::TextUnformatted(TR("chat_blocked_desc")); + ImGui::PopStyleColor(); + ImGui::PopTextWrapPos(); + ImGui::Dummy(ImVec2(0, Layout::spacingSm())); + + if (app->settings()) { + // Copy so unblocking (which mutates the settings vector) during iteration is safe. + const auto blocked = app->settings()->blockedChatConversations(); + std::string unblockCid; + for (const auto& b : blocked) { + ImGui::PushID(b.cid.c_str()); + const std::string label = b.name.empty() ? shorten(b.cid, 10, 6) : b.name; + const float bw = ImGui::CalcTextSize(TR("chat_unblock")).x + + ImGui::GetStyle().FramePadding.x * 2.0f + 16.0f * dp; + ImGui::AlignTextToFramePadding(); + ImGui::TextUnformatted(label.c_str()); + ImGui::SameLine(); + ImGui::SetCursorPosX(ImGui::GetCursorPosX() + ImGui::GetContentRegionAvail().x - bw); + if (material::TactileButton(TR("chat_unblock"), ImVec2(bw, 0))) unblockCid = b.cid; + ImGui::PopID(); + } + if (!unblockCid.empty()) { + app->settings()->setChatBlocked(unblockCid, "", false); + app->settings()->save(); + Notifications::instance().info(TR("chat_unblocked_toast")); // re-imports on the next chat scan + if (app->settings()->blockedChatConversations().empty()) s_show_blocked = false; + } + } + material::EndOverlayDialog(); + } + } + // ---- Chat customization modal (opened by the header settings "notch") — house BlurFloat overlay ---- if (s_show_chat_settings) { material::OverlayDialogSpec ov; @@ -1883,6 +2060,18 @@ void ResetChatTab() s_rename_focus = false; s_show_new_convo = false; s_show_chat_settings = false; + s_show_delete_confirm = false; + s_delete_cid.clear(); + s_delete_name.clear(); + s_show_blocked = false; + // Drop the per-frame memoization caches so the next wallet doesn't briefly render the previous one's + // conversations/thread (store.revision() is monotonic and would rebuild anyway, but be explicit). + s_convs.clear(); + s_convsHidden = 0; + s_convsKey = ~0ull; + s_threadCid.clear(); + s_threadRev = ~0ull; + s_threadMsgs.clear(); } void RenderChatSettingsControls(App* app, float contentWidth, bool drawCards) diff --git a/src/util/i18n.cpp b/src/util/i18n.cpp index 352c006..e2657c4 100644 --- a/src/util/i18n.cpp +++ b/src/util/i18n.cpp @@ -259,6 +259,23 @@ void I18n::loadBuiltinEnglish() strings_["chat_emoji_search"] = "Search emoji"; strings_["chat_hide_hidden"] = "Hide hidden"; strings_["chat_hidden_toast"] = "Conversation hidden — a new message brings it back"; + // Delete conversation (local cache) — revive-on-new-message vs delete & block + strings_["chat_delete"] = "Delete conversation"; + strings_["chat_delete_title"] = "Delete conversation?"; + strings_["chat_delete_body_prefix"] = "Delete your local copy of the conversation with "; + strings_["chat_delete_body_suffix"] = "?"; + strings_["chat_delete_revive_note"] = "\"Delete\" clears the history on this device. If they message you again, the conversation comes back."; + strings_["chat_delete_local_note"] = "This only affects this device — the messages stay on the blockchain and the other person keeps their copy."; + strings_["chat_delete_confirm"] = "Delete"; + strings_["chat_delete_block"] = "Delete & block"; + strings_["chat_deleted_toast"] = "Conversation deleted"; + strings_["chat_delete_failed"] = "Couldn't delete the conversation — nothing was changed."; + strings_["chat_blocked_toast"] = "Conversation deleted & blocked"; + strings_["chat_blocked_manage"] = "Blocked"; + strings_["chat_blocked_title"] = "Blocked conversations"; + strings_["chat_blocked_desc"] = "Blocked conversations are removed and their messages are dropped — old and new — until you unblock. Unblocking re-imports the conversation from the chain."; + strings_["chat_unblock"] = "Unblock"; + strings_["chat_unblocked_toast"] = "Conversation unblocked"; strings_["chat_pick_contact"] = "Choose from contacts\xE2\x80\xA6"; strings_["chat_no_z_contacts"] = "No shielded-address contacts yet"; strings_["chat_copy_address_tip"] = "Click to copy address"; diff --git a/tests/test_phase4.cpp b/tests/test_phase4.cpp index 9c5f775..e909b23 100644 --- a/tests/test_phase4.cpp +++ b/tests/test_phase4.cpp @@ -7006,6 +7006,97 @@ void testHushChatDatabase() scrub(dbPath); scrub(dbPath2); } +// Per-conversation local delete: (1) "delete, revive on new message" tombstones the removed messages so +// a chain re-scan can't re-import them — but a NEW txid in the same conversation flows through; the +// tombstone survives a DB reload. (2) "delete & block" removes the rows WITHOUT a tombstone and relies on +// a blocked-cid predicate to drop messages while blocked; unblocking re-imports the conversation. +void testHushChatDeleteConversation() +{ + using namespace dragonx::chat; + namespace fs = std::filesystem; + + const std::string dbPath = (fs::temp_directory_path() / "drgx_chat_del_test.sqlite").string(); + auto scrub = [](const std::string& p) { fs::remove(p); fs::remove(p + "-wal"); fs::remove(p + "-shm"); }; + scrub(dbPath); + + ChatKeyPair alice, bob; + ChatIdentityResult ra = deriveChatIdentityFromSecret("del-alice", alice, true); + ChatIdentityResult rb = deriveChatIdentityFromSecret("del-bob", bob, true); + + // Build one incoming (alice->bob) metadata entry. encryptOutgoing produces a fresh ciphertext each + // call, but dedup/tombstone key off (txid, position) only, so re-using the same txids re-scans them. + auto mkMeta = [&](const std::string& txid, const std::string& cid, const std::string& body) { + std::string e, ct; + EXPECT_TRUE(encryptOutgoing(alice, rb.public_key_hex, body, e, ct) == ChatCryptoStatus::Ok); + HushChatTransactionMetadata m; + m.txid = txid; m.type = HushChatHeaderType::Message; m.conversation_id = cid; + m.reply_zaddr = "zs-alice"; m.sender_public_key_hex = ra.public_key_hex; + m.secretstream_header_hex = e; m.payload_memo = ct; m.payload_position = 1; + return m; + }; + std::vector convX{ mkMeta("dx1", "conv-x", "x-one"), + mkMeta("dx2", "conv-x", "x-two") }; + std::vector convY{ mkMeta("dy1", "conv-y", "y-one") }; + + // (1) Delete with revive-on-new-message. + { + ChatDatabase db(dbPath); + EXPECT_TRUE(db.unlockWithSecret("del-seed")); + ChatService svc; svc.setIdentity(bob); svc.setPersistence(&db); + EXPECT_EQ(svc.ingest(convX, {}, 100), 2); + EXPECT_EQ(svc.ingest(convY, {}, 100), 1); + EXPECT_EQ((int)svc.store().size(), 3); + + EXPECT_TRUE(svc.deleteConversation("conv-x", /*block=*/false)); + EXPECT_EQ((int)svc.store().conversation("conv-x").size(), 0); + EXPECT_EQ((int)svc.store().conversation("conv-y").size(), 1); // untouched + + EXPECT_EQ(svc.ingest(convX, {}, 100), 0); // re-scan: tombstoned, not re-imported + EXPECT_EQ((int)svc.store().conversation("conv-x").size(), 0); + + std::vector convXnew{ mkMeta("dx3", "conv-x", "x-three") }; + EXPECT_EQ(svc.ingest(convXnew, {}, 200), 1); // NEW txid revives the thread + EXPECT_EQ((int)svc.store().conversation("conv-x").size(), 1); + EXPECT_EQ(svc.store().conversation("conv-x")[0].body, std::string("x-three")); + } + + // (2) Tombstone survives a DB reload into a fresh service. + { + ChatDatabase db(dbPath); + EXPECT_TRUE(db.unlockWithSecret("del-seed")); + ChatService svc; svc.setIdentity(bob); svc.setPersistence(&db); + svc.loadFromDatabase(); + EXPECT_EQ((int)svc.store().conversation("conv-x").size(), 1); // only the revived dx3 persisted + EXPECT_EQ(svc.store().conversation("conv-x")[0].body, std::string("x-three")); + EXPECT_EQ(svc.ingest(convX, {}, 100), 0); // dx1/dx2 still tombstoned after reload + EXPECT_EQ((int)svc.store().conversation("conv-x").size(), 1); + } + + // (3) Delete & block, then unblock. + { + ChatDatabase db(dbPath); + EXPECT_TRUE(db.unlockWithSecret("del-seed")); + ChatService svc; svc.setIdentity(bob); svc.setPersistence(&db); + svc.loadFromDatabase(); + bool blocked = false; + svc.setBlockedPredicate([&](const std::string& cid) { return blocked && cid == "conv-y"; }); + + EXPECT_EQ((int)svc.store().conversation("conv-y").size(), 1); + blocked = true; + EXPECT_TRUE(svc.deleteConversation("conv-y", /*block=*/true)); + EXPECT_EQ((int)svc.store().conversation("conv-y").size(), 0); + EXPECT_EQ(svc.ingest(convY, {}, 100), 0); // suppressed by the predicate (no tombstone) + EXPECT_EQ((int)svc.store().conversation("conv-y").size(), 0); + + blocked = false; // unblock + EXPECT_EQ(svc.ingest(convY, {}, 100), 1); // re-imported from chain + EXPECT_EQ((int)svc.store().conversation("conv-y").size(), 1); + EXPECT_EQ(svc.store().conversation("conv-y")[0].body, std::string("y-one")); + } + + scrub(dbPath); +} + // Phase 4: outgoing memo construction round-trips through the receive parser + decrypt, and // ChatService compose/recordOutgoing echoes into the store. void testHushChatOutgoing() @@ -7456,6 +7547,7 @@ int main() testHushChatReceivePath(); testHushChatService(); testHushChatDatabase(); + testHushChatDeleteConversation(); testHushChatOutgoing(); testHushChatTransport(); testHushChatShuffledReceive(); From d9fa00bb38d19a5cddb28780c280d5fc9b785779 Mon Sep 17 00:00:00 2001 From: DanS Date: Tue, 1 Sep 2026 22:55:04 -0500 Subject: [PATCH 86/89] perf: memoize per-frame render hot paths (console, transactions, recent lists) MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Immediate-mode render functions re-run every frame; these rebuilt O(N) state each time even when nothing changed. From a 6-lens perf audit, each finding verified on a hot-path basis: - Console: ConsoleModel gains revision(); the full-model filter scan and the glyph-by-glyph text-layout pass (BuildConsoleLayout) rebuild only when the model / filter / wrap-width / zoom change — previously it re-shaped up to 10,000 lines every frame even when idle/scrolled. clear() force-invalidates the memo mid-render (no OOB on the just-emptied visible set). - Transactions: the summary-card totals memoize behind the tab's existing FNV-1a fingerprint (also folds away a now-duplicate O(N) display-key pass). - Send / Receive recent lists: early-exit the prefix scan (state.transactions is kept newest-first) instead of filtering the whole tx history every frame. - network_refresh_service: O(new x total) txid find-and-replace -> hash map. - Sidebar unconfirmed-tx badge cached on last_tx_update + tx count; the daemon-memory probe (/proc scan on Linux, popen on macOS) throttled to ~1.5s. Co-Authored-By: Claude Opus 4.8 (1M context) --- src/app.cpp | 25 +++- src/services/network_refresh_service.cpp | 44 +++--- src/ui/windows/console_model.cpp | 3 + src/ui/windows/console_model.h | 6 + src/ui/windows/console_tab.cpp | 42 +++++- src/ui/windows/console_tab.h | 9 ++ src/ui/windows/receive_tab.cpp | 21 +-- src/ui/windows/send_tab.cpp | 21 +-- src/ui/windows/transactions_tab.cpp | 171 +++++++++++++++-------- 9 files changed, 238 insertions(+), 104 deletions(-) diff --git a/src/app.cpp b/src/app.cpp index ee66ec5..4e87716 100644 --- a/src/app.cpp +++ b/src/app.cpp @@ -1806,7 +1806,10 @@ void App::render() // long confirmed (the other leg holds the real count). So: a txid with ANY confirmed leg is // confirmed, and we count UNIQUE unconfirmed txids — otherwise the badge sticks on stale 0-conf // legs of already-confirmed transactions and double-counts multi-leg ones. - { + // Recompute only when the tx list actually changed (last_tx_update is bumped on every tx refresh; + // size() catches same-second content changes). Otherwise this built two unordered_sets over the whole + // wallet tx list every frame just to size a badge. + if (state_.last_tx_update != sb_unconf_key_ts_ || state_.transactions.size() != sb_unconf_key_n_) { std::unordered_set confirmedTxids; for (const auto& tx : state_.transactions) { if (tx.confirmations >= 1) confirmedTxids.insert(tx.txid); @@ -1817,8 +1820,11 @@ void App::render() unconfirmedTxids.insert(tx.txid); } } - sbStatus.unconfirmedTxCount = static_cast(unconfirmedTxids.size()); + sb_unconf_count_ = static_cast(unconfirmedTxids.size()); + sb_unconf_key_ts_ = state_.last_tx_update; + sb_unconf_key_n_ = state_.transactions.size(); } + sbStatus.unconfirmedTxCount = sb_unconf_count_; // Sidebar minimum height from ui.toml schema (DPI-scaled). const float sbMinHeight = sbde("min-height", 360.0f); @@ -5695,17 +5701,26 @@ bool App::stopDaemonForBootstrap() double App::getDaemonMemoryUsageMB() const { + // The Mining tab reads this every frame, but the probe is expensive (Linux embedded/external paths + // scan /proc; macOS forks a shell). Throttle to ~1.5s so a 60Hz caller doesn't hammer the OS. + const double now = ImGui::GetTime(); + if (daemon_mem_probe_at_ > 0.0 && now - daemon_mem_probe_at_ < 1.5) + return daemon_mem_cached_mb_; + daemon_mem_probe_at_ = now; + + double result = 0.0; // If we have an embedded daemon with a tracked process handle, use it // directly — more reliable than a process scan since we own the handle. if (daemon_controller_ && daemon_controller_->isRunning()) { double mb = daemon_controller_->memoryUsageMB(); daemon_mem_diag_ = "embedded"; - if (mb > 0.0) return mb; + result = (mb > 0.0) ? mb : util::Platform::getDaemonMemoryUsageMB(); } else { daemon_mem_diag_ = "process scan"; + result = util::Platform::getDaemonMemoryUsageMB(); // external daemon } - // Fall back to platform-level process scan (external daemon) - return util::Platform::getDaemonMemoryUsageMB(); + daemon_mem_cached_mb_ = result; + return result; } // ============================================================================ diff --git a/src/services/network_refresh_service.cpp b/src/services/network_refresh_service.cpp index 0763966..2d79484 100644 --- a/src/services/network_refresh_service.cpp +++ b/src/services/network_refresh_service.cpp @@ -1108,6 +1108,22 @@ NetworkRefreshService::TransactionRefreshResult NetworkRefreshService::collectRe ? &hushChatReceivedOutputs : nullptr; + // Index result.transactions by (txid, type) once so the two replace-loops below + // can find-and-replace in O(1) instead of a nested linear scan over the full + // (potentially thousands-large) tx list on every 'recent' refresh cycle. The map + // holds the index of the FIRST occurrence of each key (preserving the linear + // scan's break-on-first-match), and is kept in sync on every append so a later + // entry in the same cycle still finds an earlier appended one — exactly as the + // re-scanned vector did before. + auto txKey = [](const TransactionInfo& tx) { + return tx.txid + '\x1f' + tx.type; + }; + std::unordered_map byKey; + byKey.reserve(result.transactions.size()); + for (std::size_t i = 0; i < result.transactions.size(); ++i) { + byKey.emplace(txKey(result.transactions[i]), i); // keep first-occurrence index + } + try { std::set recentTxids; std::vector recentTransactions; @@ -1115,15 +1131,13 @@ NetworkRefreshService::TransactionRefreshResult NetworkRefreshService::collectRe appendTransparentTransactions(recentTransactions, recentTxids, transactions, snapshot.miningAddresses); for (auto& recent : recentTransactions) { - bool replaced = false; - for (auto& existing : result.transactions) { - if (existing.txid == recent.txid && existing.type == recent.type) { - existing = recent; - replaced = true; - break; - } + auto it = byKey.find(txKey(recent)); + if (it != byKey.end()) { + result.transactions[it->second] = recent; + } else { + byKey.emplace(txKey(recent), result.transactions.size()); + result.transactions.push_back(std::move(recent)); } - if (!replaced) result.transactions.push_back(std::move(recent)); } } catch (const std::exception& e) { DEBUG_LOGF("recent listtransactions error: %s\n", e.what()); @@ -1149,15 +1163,13 @@ NetworkRefreshService::TransactionRefreshResult NetworkRefreshService::collectRe snapshot.miningAddresses, hushChatReceivedOutputsPtr); for (auto& scanned : scannedTransactions) { - bool replaced = false; - for (auto& existing : result.transactions) { - if (existing.txid == scanned.txid && existing.type == scanned.type) { - existing = scanned; - replaced = true; - break; - } + auto it = byKey.find(txKey(scanned)); + if (it != byKey.end()) { + result.transactions[it->second] = scanned; + } else { + byKey.emplace(txKey(scanned), result.transactions.size()); + result.transactions.push_back(std::move(scanned)); } - if (!replaced) result.transactions.push_back(std::move(scanned)); } if (currentBlockHeight >= 0) result.shieldedScanHeights[address] = currentBlockHeight; ++result.shieldedAddressesScanned; diff --git a/src/ui/windows/console_model.cpp b/src/ui/windows/console_model.cpp index c4de6dc..a17d085 100644 --- a/src/ui/windows/console_model.cpp +++ b/src/ui/windows/console_model.cpp @@ -37,18 +37,21 @@ ConsoleModel::DrainResult ConsoleModel::drain() lines_.pop_front(); ++result.popped; } + ++revision_; // deque changed — lets the view memoize its filter/layout passes return result; } void ConsoleModel::clear() { lines_.clear(); + ++revision_; } bool ConsoleModel::toggleCollapsed(std::size_t i) { if (i >= lines_.size() || lines_[i].foldSpan <= 0) return false; lines_[i].collapsed = !lines_[i].collapsed; + ++revision_; // fold change alters which lines are visible return lines_[i].collapsed; } diff --git a/src/ui/windows/console_model.h b/src/ui/windows/console_model.h index ba25497..aa402f2 100644 --- a/src/ui/windows/console_model.h +++ b/src/ui/windows/console_model.h @@ -22,6 +22,7 @@ #include "console_channel.h" #include +#include #include #include #include @@ -76,11 +77,16 @@ public: const ConsoleModelLine& operator[](std::size_t i) const { return lines_[i]; } const ConsoleModelLine& back() const { return lines_.back(); } + // Monotonic counter bumped whenever the visible deque changes (drain added/evicted lines, clear, + // fold toggle). The view memoizes its per-frame filter + text-layout passes against this. + std::uint64_t revision() const { return revision_; } + private: const std::size_t max_lines_; std::deque lines_; // visible model — main thread only std::vector pending_; // guarded by ingest_mutex_ std::mutex ingest_mutex_; + std::uint64_t revision_ = 0; }; } // namespace ui diff --git a/src/ui/windows/console_tab.cpp b/src/ui/windows/console_tab.cpp index c5b618e..88c7c62 100644 --- a/src/ui/windows/console_tab.cpp +++ b/src/ui/windows/console_tab.cpp @@ -820,11 +820,23 @@ void ConsoleTab::renderOutput() // segment records which bytes of the source text appear on that visual row, so // hit-testing and selection highlight can map screen positions to exact char offsets. float wrap_width = ClampConsoleWrapWidth(ImGui::GetContentRegionAvail().x, padX); - ImFontConsoleMeasure measure(ImGui::GetFont(), ImGui::GetFontSize()); - layout_ = BuildConsoleLayout( - static_cast(visible_indices_.size()), - [this](int vi) -> const std::string& { return model_[visible_indices_[vi]].text; }, - wrap_width, line_height, interLineGap, measure); + // Memoize the text-shaping pass: rebuild only when the visible set, wrap width, line height, gap or + // zoom changed. Otherwise this re-wrapped and re-measured every visible line (glyph-by-glyph) every + // frame, even while idle/scrolled. layout_ is a member, so the cached geometry stays valid for + // drawVisibleLines / screenToTextPos when we skip the rebuild. + std::uint64_t layoutKey = vis_generation_ * 1000003ull; + layoutKey = layoutKey * 131ull + static_cast(wrap_width * 16.0f); + layoutKey = layoutKey * 131ull + static_cast(line_height * 16.0f); + layoutKey = layoutKey * 131ull + static_cast(interLineGap * 16.0f); + layoutKey = layoutKey * 131ull + static_cast(s_console_zoom * 1000.0f); + if (layoutKey != layout_key_) { + ImFontConsoleMeasure measure(ImGui::GetFont(), ImGui::GetFontSize()); + layout_ = BuildConsoleLayout( + static_cast(visible_indices_.size()), + [this](int vi) -> const std::string& { return model_[visible_indices_[vi]].text; }, + wrap_width, line_height, interLineGap, measure); + layout_key_ = layoutKey; + } // Mouse/keyboard interaction (wheel-up detach, selection drag, Ctrl+C/A). Raw IO bypasses // the child window's event consumption. @@ -891,6 +903,20 @@ void ConsoleTab::renderOutput() void ConsoleTab::computeVisibleLines(bool& hasTextFilter, std::string& filterLower) { + // Memoize: rebuild the visible set only when the model changed or the filter state changed. + // Otherwise this scanned the entire (up to 10k-line) model with a per-line filter predicate every + // frame. The out-params + filter_match_count_/folding_active_ are members that stay valid until the + // key moves, so an early return leaves last frame's (still-correct) results in place. + std::uint64_t visKey = model_.revision() * 1000003ull; + for (const char* p = filter_text_; *p; ++p) visKey = visKey * 131ull + static_cast(*p); + visKey = visKey * 2ull + (s_daemon_messages_enabled ? 1u : 0u); + visKey = visKey * 2ull + (s_errors_only_enabled ? 1u : 0u); + visKey = visKey * 2ull + (s_rpc_trace_enabled ? 1u : 0u); + visKey = visKey * 2ull + (s_app_messages_enabled ? 1u : 0u); + if (visKey == vis_key_) return; // nothing that affects the visible set changed + vis_key_ = visKey; + ++vis_generation_; // the layout pass keys off this + ConsoleOutputFilter outputFilter{filter_text_, s_daemon_messages_enabled, s_errors_only_enabled, s_rpc_trace_enabled, s_app_messages_enabled}; @@ -2079,6 +2105,12 @@ void ConsoleTab::clear() // line indices) here to avoid an out-of-bounds crash. computeVisibleLines() rebuilds them next frame. visible_indices_.clear(); selection_.clear(); + // Force both memoized passes to rebuild: renderOutput() runs later THIS frame against the now-empty + // visible_indices_, and computeVisibleLines() recomputes next frame — without these resets the layout + // memo would skip the rebuild and keep stale geometry for the just-emptied set. + vis_key_ = ~0ull; + layout_key_ = ~0ull; + ++vis_generation_; stop_confirm_pending_ = false; // a pending 'stop' confirmation is cancelled by clearing addLine(TR("console_cleared"), ConsoleChannel::Info); } diff --git a/src/ui/windows/console_tab.h b/src/ui/windows/console_tab.h index 13a64d2..f7b8607 100644 --- a/src/ui/windows/console_tab.h +++ b/src/ui/windows/console_tab.h @@ -15,6 +15,7 @@ #include "../../rpc/rpc_client.h" #include "../../rpc/rpc_worker.h" +#include #include #include #include @@ -188,6 +189,14 @@ private: bool has_text_filter_ = false; // computed once per frame (before the toolbar draws it) std::string filter_lower_; // lowercased filter needle for match highlighting + // Memoization keys so the two expensive per-frame passes rebuild only on change (not every frame): + // computeVisibleLines (filter scan over the whole model) is keyed on the model revision + filter + // state; BuildConsoleLayout (glyph-by-glyph text shaping of every visible line) is keyed on the + // resulting visible-set generation + wrap width + line height/zoom. + std::uint64_t vis_key_ = ~0ull; // key of the last computeVisibleLines + std::uint64_t vis_generation_ = 0; // bumped whenever visible_indices_ is rebuilt + std::uint64_t layout_key_ = ~0ull; // key of the last BuildConsoleLayout + // Wrap layout for the visible lines (segments + per-line heights + cumulative Y), // recomputed each frame by the pure BuildConsoleLayout (console_text_layout.h) and // consumed by the renderer + hit-testing. diff --git a/src/ui/windows/receive_tab.cpp b/src/ui/windows/receive_tab.cpp index b15c86d..7e8bbef 100644 --- a/src/ui/windows/receive_tab.cpp +++ b/src/ui/windows/receive_tab.cpp @@ -370,20 +370,25 @@ static void RenderRecentReceived(const AddressInfo& /* addr */, S.drawElement("tabs.balance", "recent-tx-icon-size").size * hs); ImU32 recvCol = Success(); - // Collect matching transactions - std::vector recvs; - for (const auto& tx : state.transactions) { - if (tx.type != "receive" && tx.type != "mined") continue; - recvs.push_back(&tx); - } - // Grow the list to fill the dead space beneath the (fixed-height) receive card: // fit as many newest-first rows as the remaining region can show, instead of a // fixed 4. The child scrolls if the real history exceeds what fits, so nothing is // lost. A floor of 4 keeps the section substantial when the region is short. + // Compute maxRows BEFORE the collect loop so the scan can stop early (below). float listH = std::max(rowH, ImGui::GetContentRegionAvail().y); size_t maxRows = std::max(4, (size_t)std::floor(listH / rowH)); - if (recvs.size() > maxRows) recvs.resize(maxRows); // newest-first + + // Collect matching transactions. state.transactions is newest-first, so the first + // maxRows matches ARE exactly the rows we render — stop scanning once we have them + // instead of filtering the entire history every frame (mirrors RenderSharedRecentTx + // in balance_components.cpp). + std::vector recvs; + recvs.reserve(maxRows); + for (const auto& tx : state.transactions) { + if (tx.type != "receive" && tx.type != "mined") continue; + recvs.push_back(&tx); + if (recvs.size() >= maxRows) break; // newest-first: prefix is all we show + } ImGui::BeginChild("##RecentReceivedRows", ImVec2(width, listH), false, ImGuiWindowFlags_NoBackground); diff --git a/src/ui/windows/send_tab.cpp b/src/ui/windows/send_tab.cpp index 5d0ab8d..8766eb4 100644 --- a/src/ui/windows/send_tab.cpp +++ b/src/ui/windows/send_tab.cpp @@ -1120,20 +1120,25 @@ static void RenderRecentSends(const WalletState& state, float width, ImFont* cap S.drawElement("tabs.balance", "recent-tx-icon-size").size * hs); ImU32 sendCol = Error(); - // Collect matching transactions - std::vector sends; - for (const auto& tx : state.transactions) { - if (tx.type != "send" && tx.type != "shield") continue; - sends.push_back(&tx); - } - // Grow the list to fill the dead space beneath the (fixed-height) compose card: // fit as many newest-first rows as the remaining region can show, instead of a // fixed 4. The child scrolls if the real history exceeds what fits, so nothing is // lost. A floor of 4 keeps the section substantial when the region is short. + // Row budget is hoisted above the collect loop (it only needs the remaining region + // height + row height, no per-row state) so the scan can early-exit. float listH = std::max(rowH, ImGui::GetContentRegionAvail().y); size_t maxRows = std::max(4, (size_t)std::floor(listH / rowH)); - if (sends.size() > maxRows) sends.resize(maxRows); // newest-first + + // Collect matching transactions. state.transactions is newest-first, so scan only a + // bounded prefix and stop once maxRows matches are gathered (mirrors the early-exit in + // balance_components.cpp:RenderSharedRecentTx) instead of filtering the whole history. + std::vector sends; + sends.reserve(maxRows); + for (const auto& tx : state.transactions) { + if (tx.type != "send" && tx.type != "shield") continue; + sends.push_back(&tx); + if (sends.size() == maxRows) break; // newest-first: enough rows to fill the region + } ImGui::BeginChild("##RecentSendRows", ImVec2(width, listH), false, ImGuiWindowFlags_NoBackground); diff --git a/src/ui/windows/transactions_tab.cpp b/src/ui/windows/transactions_tab.cpp index 0bba8ef..3312cc7 100644 --- a/src/ui/windows/transactions_tab.cpp +++ b/src/ui/windows/transactions_tab.cpp @@ -23,6 +23,7 @@ #include #include #include +#include #include #include #include @@ -186,53 +187,106 @@ void RenderTransactionsTab(App* app) // Summary Cards — Received | Sent | Mined // ================================================================ { - int recvCount = 0, sendCount = 0, minedCount = 0; - double recvTotal = 0.0, sendTotal = 0.0, minedTotal = 0.0; - - // Identify autoshield legs (same txid with a "send" leg and a "receive"-to-z leg): - // that pair is a single internal shielding move — shown as one "Shield" row in the - // list below — not income or spending. Counting both legs double-counts the amount - // into BOTH the Sent and Received totals, so the cards disagree with the list. - // Mirror the list's pairing logic and exclude both legs from the totals. - std::unordered_map> summaryTxidMap; - for (size_t i = 0; i < state.transactions.size(); i++) - summaryTxidMap[state.transactions[i].txid].push_back(i); - std::vector isShieldLeg(state.transactions.size(), false); - for (const auto& kv : summaryTxidMap) { - if (kv.second.size() < 2) continue; - int send_i = -1, recv_i = -1; - for (size_t si : kv.second) { - const auto& stx = state.transactions[si]; - if (stx.type == "send" && send_i < 0) send_i = (int)si; - else if (stx.type == "receive" && recv_i < 0 && - !stx.address.empty() && stx.address[0] == 'z') recv_i = (int)si; - } - if (send_i >= 0 && recv_i >= 0) { - isShieldLeg[send_i] = true; - isShieldLeg[recv_i] = true; - // The list shows the merged shield under the "Sent" filter, so count it there too — - // otherwise the Sent card reads 0 while the Sent list is non-empty. Use the shielded - // (receive-leg) amount, which is what the merged row displays. - sendCount++; - sendTotal += std::abs(state.transactions[recv_i].amount); + // Content fingerprint over state.transactions, shared by the summary-card totals (below) and + // the display-list memoization (further down). This is a cheap, allocation-free FNV-1a hash + // computed ONCE per frame and folds in every field the *totals* and the *displayed rows* + // depend on: tx count, last update time, and per-tx txid (drives autoshield pairing), + // amount (drives the totals — bit-exact), confirmations, timestamp, type, and address. It is + // sort-independent (s_sort_mode is NOT folded here); the display key mixes s_sort_mode on top + // so a sort change re-sorts the display cache without invalidating the totals (which don't + // depend on order). NB vs. the old display key: this additionally folds full txid + amount + + // full type/address (not just first char), which the summary totals require — the old key + // omitted them, so it could not have gated the totals correctly. + std::uint64_t contentKey; + { + std::uint64_t h = 1469598103934665603ULL; // FNV-1a offset basis + auto mix = [&h](std::uint64_t v) { h = (h ^ v) * 1099511628211ULL; }; + auto mixBytes = [&mix](const std::string& s) { + mix(s.size()); + for (unsigned char c : s) mix(static_cast(c)); + }; + mix(state.transactions.size()); + mix(static_cast(state.last_tx_update)); + for (const auto& t : state.transactions) { + mixBytes(t.txid); + std::uint64_t amtBits = 0; + std::memcpy(&amtBits, &t.amount, sizeof(double)); // bit-exact fold of the double + mix(amtBits); + mix(static_cast(t.confirmations)); + mix(static_cast(t.timestamp)); + mixBytes(t.type); + mixBytes(t.address); } + contentKey = h; } - for (size_t i = 0; i < state.transactions.size(); i++) { - if (isShieldLeg[i]) continue; // internal shielding move — not received or sent - const auto& tx = state.transactions[i]; - if (tx.type == "receive") { - recvCount++; - recvTotal += std::abs(tx.amount); - } else if (tx.type == "send") { - sendCount++; - sendTotal += std::abs(tx.amount); - } else if (tx.type == "generate" || tx.type == "immature" || tx.type == "mined") { - minedCount++; - minedTotal += std::abs(tx.amount); + // Summary-card totals: Received / Sent / Mined (counts + amounts). These are three static + // numbers that only change when the tx list changes, so memoize them behind contentKey and + // recompute only when it moves. File-scope-style function statics persist across wallet + // switches, but a switch/refresh mutates state.transactions (count, txids, amounts …), which + // bumps contentKey, so the sentinel initial key + change detection covers that for free. + static int s_recvCount = 0, s_sendCount = 0, s_minedCount = 0; + static double s_recvTotal = 0.0, s_sendTotal = 0.0, s_minedTotal = 0.0; + static std::uint64_t s_summaryKey = 0; // sentinel; first frame always recomputes + + if (contentKey != s_summaryKey) { + int recvCount = 0, sendCount = 0, minedCount = 0; + double recvTotal = 0.0, sendTotal = 0.0, minedTotal = 0.0; + + // Identify autoshield legs (same txid with a "send" leg and a "receive"-to-z leg): + // that pair is a single internal shielding move — shown as one "Shield" row in the + // list below — not income or spending. Counting both legs double-counts the amount + // into BOTH the Sent and Received totals, so the cards disagree with the list. + // Mirror the list's pairing logic and exclude both legs from the totals. + std::unordered_map> summaryTxidMap; + for (size_t i = 0; i < state.transactions.size(); i++) + summaryTxidMap[state.transactions[i].txid].push_back(i); + std::vector isShieldLeg(state.transactions.size(), false); + for (const auto& kv : summaryTxidMap) { + if (kv.second.size() < 2) continue; + int send_i = -1, recv_i = -1; + for (size_t si : kv.second) { + const auto& stx = state.transactions[si]; + if (stx.type == "send" && send_i < 0) send_i = (int)si; + else if (stx.type == "receive" && recv_i < 0 && + !stx.address.empty() && stx.address[0] == 'z') recv_i = (int)si; + } + if (send_i >= 0 && recv_i >= 0) { + isShieldLeg[send_i] = true; + isShieldLeg[recv_i] = true; + // The list shows the merged shield under the "Sent" filter, so count it there too — + // otherwise the Sent card reads 0 while the Sent list is non-empty. Use the shielded + // (receive-leg) amount, which is what the merged row displays. + sendCount++; + sendTotal += std::abs(state.transactions[recv_i].amount); + } } + + for (size_t i = 0; i < state.transactions.size(); i++) { + if (isShieldLeg[i]) continue; // internal shielding move — not received or sent + const auto& tx = state.transactions[i]; + if (tx.type == "receive") { + recvCount++; + recvTotal += std::abs(tx.amount); + } else if (tx.type == "send") { + sendCount++; + sendTotal += std::abs(tx.amount); + } else if (tx.type == "generate" || tx.type == "immature" || tx.type == "mined") { + minedCount++; + minedTotal += std::abs(tx.amount); + } + } + + s_recvCount = recvCount; s_recvTotal = recvTotal; + s_sendCount = sendCount; s_sendTotal = sendTotal; + s_minedCount = minedCount; s_minedTotal = minedTotal; + s_summaryKey = contentKey; } + // Render from the cached totals (identical values — only the recomputation is skipped). + const int recvCount = s_recvCount, sendCount = s_sendCount, minedCount = s_minedCount; + const double recvTotal = s_recvTotal, sendTotal = s_sendTotal, minedTotal = s_minedTotal; + float availWidth = ImGui::GetContentRegionAvail().x; float cardGap = cGap; float cardW = (availWidth - 2 * cardGap) / 3.0f; @@ -346,31 +400,24 @@ void RenderTransactionsTab(App* app) // // This merge + sort is O(N log N) with several heap allocations, so it is MEMOIZED: it only // rebuilds when the underlying transactions actually change, not every frame. The cache key - // is a cheap, allocation-free FNV-1a fingerprint over the fields that affect the displayed - // rows (count, last update time, and each tx's confirmations / timestamp / type+address - // first char). A new block bumps every confirmation, so the key changes and we rebuild; - // between changes (the common case while the user reads/scrolls) we reuse the cache. The - // result is already sorted newest-first by the refresh service, but we re-sort here to apply - // the "pending first" ordering — also folded into the memoized build. + // reuses the shared per-frame contentKey computed above (a cheap, allocation-free FNV-1a + // fingerprint over count / last update time / every tx's txid+amount+confirmations+timestamp+ + // type+address) and mixes in s_sort_mode on top, so the display cache also rebuilds on a sort + // change. contentKey already folds in more than the display list strictly needs (amount, + // full txid/type/address) — a superset, so any change that would have flipped the old + // per-first-char key still flips this one. A new block bumps every confirmation, so the key + // changes and we rebuild; between changes (the common case while the user reads/scrolls) we + // reuse the cache. The result is already sorted newest-first by the refresh service, but we + // re-sort here to apply the "pending first" ordering — also folded into the memoized build. static std::vector s_display_cache; static std::uint64_t s_display_cache_key = 0; static bool s_display_cache_valid = false; - std::uint64_t displayKey; - { - std::uint64_t h = 1469598103934665603ULL; // FNV-1a offset basis - auto mix = [&h](std::uint64_t v) { h = (h ^ v) * 1099511628211ULL; }; - mix(state.transactions.size()); - mix(static_cast(state.last_tx_update)); - mix(static_cast(s_sort_mode)); // re-sort the cache when the mode changes - for (const auto& t : state.transactions) { - mix(static_cast(t.confirmations)); - mix(static_cast(t.timestamp)); - mix(t.type.empty() ? 0u : static_cast(t.type[0])); - mix(t.address.empty() ? 0u : static_cast(t.address[0])); - } - displayKey = h; - } + // Derive the display key from the shared contentKey (avoids a second full pass over the + // transactions) plus the sort mode — the only display-affecting input contentKey omits. + std::uint64_t displayKey = + (contentKey ^ (static_cast(s_sort_mode) + 0x9E3779B97F4A7C15ULL)) + * 1099511628211ULL; if (!s_display_cache_valid || displayKey != s_display_cache_key) { s_display_cache.clear(); From 43c7be55c650fad826af7469c4ceba2ed758ba50 Mon Sep 17 00:00:00 2001 From: DanS Date: Tue, 1 Sep 2026 23:42:37 -0500 Subject: [PATCH 87/89] fix(ui): relocate + reword node auto-shield status; add chat-management FAQ entry MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit - Auto-shield status: the node's z_autoshieldstatus disabled_reason was echoed verbatim ("HD seed origin is not known-recoverable; back the seed up and pass -autoshield=1") and drawn INSIDE the Wallet OPTIONS checkbox grid, wedging a full-width line between the checkboxes. Move it to a full-width note BELOW the grid, and replace the raw daemon text with friendly, actionable wording keyed on the seed_recoverable flag (back up your seed to enable it); the raw daemon reason is kept on hover. Adds App::daemonAutoShieldSeedRecoverable(). - FAQ: add a Chat & Contacts entry ("How do I hide, delete, or block a conversation?") covering the hide / delete-revive / delete-&-block actions and the local-only caveat — data + i18n only, no UI code change. Co-Authored-By: Claude Opus 4.8 (1M context) --- src/app.h | 1 + src/ui/pages/settings_page.cpp | 47 +++++++++++++++++----------------- src/ui/windows/faq_content.cpp | 1 + src/util/i18n.cpp | 6 ++++- 4 files changed, 31 insertions(+), 24 deletions(-) diff --git a/src/app.h b/src/app.h index 610e0b3..dbb6794 100644 --- a/src/app.h +++ b/src/app.h @@ -169,6 +169,7 @@ public: bool daemonAutoShieldActive() const { return daemon_autoshield_active_; } const std::string& daemonAutoShieldAddress() const { return daemon_autoshield_address_; } const std::string& daemonAutoShieldDisabledReason() const { return daemon_autoshield_disabled_reason_; } + bool daemonAutoShieldSeedRecoverable() const { return daemon_autoshield_seed_recoverable_; } // W7 QoL: a plaintext support-diagnostics snapshot (version, variant, daemon/RPC/wallet/log state) // for the "Copy diagnostics" action. Contains no secrets. diff --git a/src/ui/pages/settings_page.cpp b/src/ui/pages/settings_page.cpp index 70e8f5d..6a53da9 100644 --- a/src/ui/pages/settings_page.cpp +++ b/src/ui/pages/settings_page.cpp @@ -1193,29 +1193,6 @@ void RenderSettingsPage(App* app) { if (ImGui::IsItemHovered()) material::Tooltip("%s", TR("tt_save_ztx")); CB(TrId("auto_shield", "auto_shld"), &s_settingsState.auto_shield); if (ImGui::IsItemHovered()) material::Tooltip("%s", TR("tt_auto_shield")); - // O1: when a v1.3.0+ node auto-shields coinbase itself, show its real state — the checkbox - // above only governs the wallet's own fallback shielder (which defers to the node). Nothing - // renders on pre-1.3.0 daemons (never probed), so their behaviour is unchanged. - // This status must NOT flow with ImGui's cursor: the checkbox grid is absolutely positioned - // (SetCursorScreenPos at rowY), so a normal-flow Text would land under the auto-shield checkbox - // and the next grid row (Use Tor / Keep daemon) would draw on top of it. Instead, draw it on its - // own full-width row at the grid's current rowY, wrapped to the card, then advance rowY past it. - if (app && app->daemonAutoShieldProbed() && - (app->daemonAutoShieldActive() || !app->daemonAutoShieldDisabledReason().empty())) { - ImGui::SetCursorScreenPos(ImVec2(cx, rowY)); - ImGui::PushTextWrapPos((cx + cw) - ImGui::GetWindowPos().x); // wrap to the card content width - if (app->daemonAutoShieldActive()) { - ImGui::TextColored(ImVec4(0.40f, 0.78f, 0.40f, 1.0f), " %s", TR("autoshield_by_node")); - if (!app->daemonAutoShieldAddress().empty()) - ImGui::TextDisabled(" %s", app->daemonAutoShieldAddress().c_str()); - } else { - ImGui::TextDisabled(" %s", app->daemonAutoShieldDisabledReason().c_str()); - } - ImGui::PopTextWrapPos(); - last = ImGui::GetCursorScreenPos().y; // cursor is now below the status text - rowY = last + gp; // next grid row starts below it - c = 0; - } CB(TrId("use_tor", "tor"), &s_settingsState.use_tor); if (ImGui::IsItemHovered()) material::Tooltip("%s", TR("tt_tor")); if (showDaemonOptions) { @@ -1232,6 +1209,30 @@ void RenderSettingsPage(App* app) { saveSettingsPageState(app->settings()); } if (ImGui::IsItemHovered()) material::Tooltip("%s", TR("tt_verbose")); + + // O1: node coinbase auto-shield status (v1.3.0+). Rendered as a full-width note BELOW the + // checkbox grid (not wedged between checkboxes) with friendly wording — the daemon's raw + // technical reason is available on hover. Nothing renders on pre-1.3.0 daemons (never probed). + if (app && app->daemonAutoShieldProbed() && + (app->daemonAutoShieldActive() || !app->daemonAutoShieldDisabledReason().empty())) { + ImGui::SetCursorScreenPos(ImVec2(cx, last + gp)); + ImGui::PushTextWrapPos((cx + cw) - ImGui::GetWindowPos().x); // wrap to the card content width + if (app->daemonAutoShieldActive()) { + ImGui::TextColored(ImVec4(0.40f, 0.78f, 0.40f, 1.0f), "%s", TR("autoshield_by_node")); + if (!app->daemonAutoShieldAddress().empty()) + ImGui::TextDisabled(" %s", app->daemonAutoShieldAddress().c_str()); + } else { + // Friendly, actionable wording. The seed-not-recoverable case is the common one and has a + // clear fix (back up the seed); anything else gets a generic line. Raw daemon text on hover. + ImGui::TextDisabled("%s", app->daemonAutoShieldSeedRecoverable() + ? TR("autoshield_off_generic") + : TR("autoshield_off_backup_seed")); + if (ImGui::IsItemHovered()) + material::Tooltip("%s", app->daemonAutoShieldDisabledReason().c_str()); + } + ImGui::PopTextWrapPos(); + last = ImGui::GetCursorScreenPos().y; // grow the card to include the note + } cardClose(0, last); } diff --git a/src/ui/windows/faq_content.cpp b/src/ui/windows/faq_content.cpp index d67a979..e47d20a 100644 --- a/src/ui/windows/faq_content.cpp +++ b/src/ui/windows/faq_content.cpp @@ -50,6 +50,7 @@ const std::vector& walletFaq() { "faq_w_chat_1_q", "faq_w_chat_1_a" }, { "faq_w_chat_2_q", "faq_w_chat_2_a" }, { "faq_w_chat_3_q", "faq_w_chat_3_a" }, + { "faq_w_chat_4_q", "faq_w_chat_4_a" }, }}, { "faq_w_set_title", { { "faq_w_set_1_q", "faq_w_set_1_a" }, diff --git a/src/util/i18n.cpp b/src/util/i18n.cpp index e2657c4..7a52056 100644 --- a/src/util/i18n.cpp +++ b/src/util/i18n.cpp @@ -1274,7 +1274,9 @@ void I18n::loadBuiltinEnglish() 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."; strings_["wallet_degraded_notify"] = "Your wallet opened in reduced-function mode: existing funds are safe and spendable, but creating new addresses and shielding are disabled. Back up your seed phrase and restore it to fully repair the wallet."; - strings_["autoshield_by_node"] = "Auto-shield is handled by your node"; + strings_["autoshield_by_node"] = "Your node auto-shields mined coinbase for you."; + strings_["autoshield_off_backup_seed"] = "Mined coinbase isn't being auto-shielded yet. Back up your seed phrase (Settings \xE2\x86\x92 Backup & Data) so your node can safely turn it on."; + strings_["autoshield_off_generic"] = "Your node isn't auto-shielding mined coinbase right now."; // In-dialog recovery lifecycle (Offer → Working → Done/Failed) + disclosures. strings_["wallet_recovery_working_label"] = "Working"; strings_["wallet_recovery_done"] = "Done"; @@ -1650,6 +1652,8 @@ void I18n::loadBuiltinEnglish() strings_["faq_w_chat_2_a"] = "Your chat identity is derived from your wallet's recovery phrase, so it travels with your wallet \xE2\x80\x94 restore the wallet and your identity comes back. You don't create a separate account or password."; strings_["faq_w_chat_3_q"] = "How do contacts work?"; strings_["faq_w_chat_3_a"] = "Add a contact by their address in the Contacts tab, optionally with a name and avatar. Contacts can be kept private to the current wallet or shared across all wallets you open on this computer."; + strings_["faq_w_chat_4_q"] = "How do I hide, delete, or block a conversation?"; + strings_["faq_w_chat_4_a"] = "Open a conversation and use the icons in its header. Hide (the eye) drops it from the list but keeps every message \xE2\x80\x94 a new message un-hides it. Delete (the trash) opens a dialog: 'Delete' clears the history on this device (if that person messages you again, the conversation comes back), while 'Delete & block' also stops their future messages until you unblock them from the 'Blocked' list above the conversation list. Everything here is local to this device \xE2\x80\x94 the messages stay on the blockchain and the other person keeps their own copy, so it isn't an 'unsend'."; // Wallet > Settings & Appearance strings_["faq_w_set_1_q"] = "How do I change the theme?"; From 4ee0f524d46e25b00b67615be58be44ea9e95abc Mon Sep 17 00:00:00 2001 From: DanS Date: Wed, 2 Sep 2026 01:12:08 -0500 Subject: [PATCH 88/89] build(release): strip the Windows app exe MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit The Linux and macOS release paths already strip the main binary (and the Windows path even stripped the dragonx-wallet-rebuild helper), but the Windows app exe was shipping unstripped — ~5 MB of symbols on the full node, ~19 MB on the params-heavy lite build. Strip it right after the Windows build, best-effort with a warning fallback. Co-Authored-By: Claude Opus 4.8 (1M context) --- build.sh | 5 +++++ 1 file changed, 5 insertions(+) diff --git a/build.sh b/build.sh index e54ff98..e76cc82 100755 --- a/build.sh +++ b/build.sh @@ -842,6 +842,11 @@ HDR cmake --build . -j "$JOBS" [[ -f "bin/${APP_BASENAME}.exe" ]] || { err "Windows build failed"; exit 1; } + # Strip the app exe — the Linux and macOS release paths already strip theirs, and even the Windows + # helper (dragonx-wallet-rebuild.exe) is stripped, but the main app exe was shipping unstripped + # (~5MB of symbols on the full node, ~19MB on the params-heavy lite build). Best-effort. + x86_64-w64-mingw32-strip --strip-all "bin/${APP_BASENAME}.exe" 2>/dev/null \ + || warn " strip unavailable — shipping unstripped ${APP_BASENAME}.exe" 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. From c7e48c16f89c34d705af8c316a85c0eb442c31c3 Mon Sep 17 00:00:00 2001 From: DanS Date: Wed, 2 Sep 2026 01:12:08 -0500 Subject: [PATCH 89/89] feat(lite): version 1.1.0 + variant-aware FAQ MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Bump DRAGONX_LITE_VERSION 1.0.0 -> 1.1.0: since lite-1.0.0 the Lite variant gained the whole 2.0.x shared UI/UX + diagnostics + i18n + perf work and this session's chat delete/block — a minor bump (new features, no breaking change). Make the FAQ variant-aware (walletFaq(fullNode)) so the Lite build reads correctly: "What is ObsidianDragonLite?", encryption in the Wallet tab (not Node & Security), migrate-to-seed hidden, node-specific answers reworded neutrally ("the wallet syncs"), a new "Lite Wallet" subcategory (server model + privacy tradeoff) standing in for the hidden Daemon group, and the redundant single "Wallet" group tab dropped when there's no Daemon group to switch to. Co-Authored-By: Claude Opus 4.8 (1M context) --- CMakeLists.txt | 2 +- src/ui/windows/faq_content.cpp | 119 +++++++++++++++++++-------------- src/ui/windows/faq_content.h | 5 +- src/ui/windows/faq_dialog.cpp | 16 +++-- src/util/i18n.cpp | 26 +++++-- 5 files changed, 102 insertions(+), 66 deletions(-) diff --git a/CMakeLists.txt b/CMakeLists.txt index f48d852..70df660 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -26,7 +26,7 @@ set(DRAGONX_VERSION_SUFFIX "") # ObsidianDragonLite is versioned INDEPENDENTLY of the full-node app above. The active variant's # version flows to the generated header, the Windows .rc/manifest, and build.sh's release names via # DRAGONX_APP_VERSION* (resolved in the lite/full block below). -set(DRAGONX_LITE_VERSION "1.0.0") +set(DRAGONX_LITE_VERSION "1.1.0") set(DRAGONX_LITE_VERSION_SUFFIX "") # C++17 standard diff --git a/src/ui/windows/faq_content.cpp b/src/ui/windows/faq_content.cpp index e47d20a..b2f4661 100644 --- a/src/ui/windows/faq_content.cpp +++ b/src/ui/windows/faq_content.cpp @@ -9,57 +9,76 @@ namespace ui { namespace faq { // ── Wallet group ─────────────────────────────────────────────────────────── -const std::vector& walletFaq() +// Variant-aware: gs_1 (what the app IS) and sec_1 (where encryption lives) differ between the +// full-node and Lite builds; migrate-to-seed (seed_2) is full-node only; and the Lite build gets a +// trailing "Lite Wallet" subcategory that stands in for the (hidden) Daemon group. The remaining +// answers are worded neutrally so one string serves both variants. +static std::vector buildWalletFaq(bool fullNode) { - static const std::vector kWallet = { - { "faq_w_gs_title", { - { "faq_w_gs_1_q", "faq_w_gs_1_a" }, - { "faq_w_gs_2_q", "faq_w_gs_2_a" }, - { "faq_w_gs_3_q", "faq_w_gs_3_a" }, - { "faq_w_gs_4_q", "faq_w_gs_4_a" }, - }}, - { "faq_w_addr_title", { - { "faq_w_addr_1_q", "faq_w_addr_1_a" }, - { "faq_w_addr_2_q", "faq_w_addr_2_a" }, - { "faq_w_addr_3_q", "faq_w_addr_3_a" }, - { "faq_w_addr_4_q", "faq_w_addr_4_a" }, - }}, - { "faq_w_send_title", { - { "faq_w_send_1_q", "faq_w_send_1_a" }, - { "faq_w_send_2_q", "faq_w_send_2_a" }, - { "faq_w_send_3_q", "faq_w_send_3_a" }, - { "faq_w_send_4_q", "faq_w_send_4_a" }, - }}, - { "faq_w_bal_title", { - { "faq_w_bal_1_q", "faq_w_bal_1_a" }, - { "faq_w_bal_2_q", "faq_w_bal_2_a" }, - { "faq_w_bal_3_q", "faq_w_bal_3_a" }, - }}, - { "faq_w_sec_title", { - { "faq_w_sec_1_q", "faq_w_sec_1_a" }, - { "faq_w_sec_2_q", "faq_w_sec_2_a" }, - { "faq_w_sec_3_q", "faq_w_sec_3_a" }, - }}, - { "faq_w_seed_title", { - { "faq_w_seed_1_q", "faq_w_seed_1_a" }, - { "faq_w_seed_2_q", "faq_w_seed_2_a" }, - { "faq_w_seed_3_q", "faq_w_seed_3_a" }, - { "faq_w_seed_4_q", "faq_w_seed_4_a" }, - }}, - { "faq_w_chat_title", { - { "faq_w_chat_1_q", "faq_w_chat_1_a" }, - { "faq_w_chat_2_q", "faq_w_chat_2_a" }, - { "faq_w_chat_3_q", "faq_w_chat_3_a" }, - { "faq_w_chat_4_q", "faq_w_chat_4_a" }, - }}, - { "faq_w_set_title", { - { "faq_w_set_1_q", "faq_w_set_1_a" }, - { "faq_w_set_2_q", "faq_w_set_2_a" }, - { "faq_w_set_3_q", "faq_w_set_3_a" }, - { "faq_w_set_4_q", "faq_w_set_4_a" }, - }}, - }; - return kWallet; + std::vector w; + w.push_back({ "faq_w_gs_title", { + { fullNode ? "faq_w_gs_1_q" : "faq_l_gs_1_q", fullNode ? "faq_w_gs_1_a" : "faq_l_gs_1_a" }, + { "faq_w_gs_2_q", "faq_w_gs_2_a" }, + { "faq_w_gs_3_q", "faq_w_gs_3_a" }, + { "faq_w_gs_4_q", "faq_w_gs_4_a" }, + }}); + w.push_back({ "faq_w_addr_title", { + { "faq_w_addr_1_q", "faq_w_addr_1_a" }, + { "faq_w_addr_2_q", "faq_w_addr_2_a" }, + { "faq_w_addr_3_q", "faq_w_addr_3_a" }, + { "faq_w_addr_4_q", "faq_w_addr_4_a" }, + }}); + w.push_back({ "faq_w_send_title", { + { "faq_w_send_1_q", "faq_w_send_1_a" }, + { "faq_w_send_2_q", "faq_w_send_2_a" }, + { "faq_w_send_3_q", "faq_w_send_3_a" }, + { "faq_w_send_4_q", "faq_w_send_4_a" }, + }}); + w.push_back({ "faq_w_bal_title", { + { "faq_w_bal_1_q", "faq_w_bal_1_a" }, + { "faq_w_bal_2_q", "faq_w_bal_2_a" }, + { "faq_w_bal_3_q", "faq_w_bal_3_a" }, + }}); + w.push_back({ "faq_w_sec_title", { + { "faq_w_sec_1_q", fullNode ? "faq_w_sec_1_a" : "faq_l_sec_1_a" }, + { "faq_w_sec_2_q", "faq_w_sec_2_a" }, + { "faq_w_sec_3_q", "faq_w_sec_3_a" }, + }}); + { + std::vector seed = { { "faq_w_seed_1_q", "faq_w_seed_1_a" } }; + if (fullNode) seed.push_back({ "faq_w_seed_2_q", "faq_w_seed_2_a" }); // migrate-to-seed is full-node only + seed.push_back({ "faq_w_seed_3_q", "faq_w_seed_3_a" }); + seed.push_back({ "faq_w_seed_4_q", "faq_w_seed_4_a" }); + w.push_back({ "faq_w_seed_title", std::move(seed) }); + } + w.push_back({ "faq_w_chat_title", { + { "faq_w_chat_1_q", "faq_w_chat_1_a" }, + { "faq_w_chat_2_q", "faq_w_chat_2_a" }, + { "faq_w_chat_3_q", "faq_w_chat_3_a" }, + { "faq_w_chat_4_q", "faq_w_chat_4_a" }, + }}); + w.push_back({ "faq_w_set_title", { + { "faq_w_set_1_q", "faq_w_set_1_a" }, + { "faq_w_set_2_q", "faq_w_set_2_a" }, + { "faq_w_set_3_q", "faq_w_set_3_a" }, + { "faq_w_set_4_q", "faq_w_set_4_a" }, + }}); + // Lite-only: explain the server model (stands in for the hidden Daemon group). + if (!fullNode) { + w.push_back({ "faq_l_lite_title", { + { "faq_l_lite_1_q", "faq_l_lite_1_a" }, + { "faq_l_lite_2_q", "faq_l_lite_2_a" }, + { "faq_l_lite_3_q", "faq_l_lite_3_a" }, + }}); + } + return w; +} + +const std::vector& walletFaq(bool fullNode) +{ + static const std::vector kFull = buildWalletFaq(true); + static const std::vector kLite = buildWalletFaq(false); + return fullNode ? kFull : kLite; } // ── Daemon group (full-node only) ────────────────────────────────────────── diff --git a/src/ui/windows/faq_content.h b/src/ui/windows/faq_content.h index 274d674..81499d8 100644 --- a/src/ui/windows/faq_content.h +++ b/src/ui/windows/faq_content.h @@ -33,7 +33,10 @@ struct FaqSubcategory { // The two top-level groups. daemonFaq() is full-node material and is only shown when // the build supports full-node lifecycle actions (see App::supportsFullNodeLifecycleActions()). -const std::vector& walletFaq(); +// walletFaq() is variant-aware: pass fullNode=false for the Lite variant, which swaps in +// lite-appropriate answers (no local node / daemon), drops full-node-only entries +// (e.g. migrate-to-seed), and appends a "Lite Wallet" subcategory explaining the server model. +const std::vector& walletFaq(bool fullNode); const std::vector& daemonFaq(); } // namespace faq diff --git a/src/ui/windows/faq_dialog.cpp b/src/ui/windows/faq_dialog.cpp index aafb2b7..aa916ca 100644 --- a/src/ui/windows/faq_dialog.cpp +++ b/src/ui/windows/faq_dialog.cpp @@ -84,16 +84,17 @@ void RenderFaqDialog(App* app, bool* p_open) if (ImGui::IsKeyPressed(ImGuiKey_Escape)) *p_open = false; // Subtitle under the plain heading, matching the Wallets dialog's intro caption. - material::Type().textColored(material::TypeStyle::Caption, material::OnSurfaceMedium(), TR("faq_intro")); + material::Type().textColored(material::TypeStyle::Caption, material::OnSurfaceMedium(), + TR(daemonAvailable ? "faq_intro" : "faq_intro_lite")); ImGui::Dummy(ImVec2(0, Layout::spacingSm())); const float contentW = ImGui::GetContentRegionAvail().x; - // ── Group tabs: Wallet | Daemon ── - { - const int nTabs = daemonAvailable ? 2 : 1; + // ── Group tabs: Wallet | Daemon — only when there's a choice. Lite has just the Wallet group, so a + // lone "Wallet" selector is redundant; skip it entirely (the group is already pinned to 0 above). + if (daemonAvailable) { const float gap = ImGui::GetStyle().ItemSpacing.x; - const float tabW = (contentW - gap * (nTabs - 1)) / static_cast(nTabs); + const float tabW = (contentW - gap) / 2.0f; auto tab = [&](const char* label, int idx) { const bool active = (s_faq.group == idx); if (active) { @@ -104,7 +105,8 @@ void RenderFaqDialog(App* app, bool* p_open) if (active) ImGui::PopStyleColor(2); }; tab(TR("faq_group_wallet"), 0); - if (daemonAvailable) { ImGui::SameLine(); tab(TR("faq_group_daemon"), 1); } + ImGui::SameLine(); + tab(TR("faq_group_daemon"), 1); } ImGui::Dummy(ImVec2(0, Layout::spacingXs())); @@ -131,7 +133,7 @@ void RenderFaqDialog(App* app, bool* p_open) material::ApplySmoothScroll(); ImDrawList* dl = ImGui::GetWindowDrawList(); - const auto& groups = (s_faq.group == 1 && daemonAvailable) ? faq::daemonFaq() : faq::walletFaq(); + const auto& groups = (s_faq.group == 1 && daemonAvailable) ? faq::daemonFaq() : faq::walletFaq(daemonAvailable); bool anyShown = false; bool firstSection = true; diff --git a/src/util/i18n.cpp b/src/util/i18n.cpp index 7a52056..8780f1d 100644 --- a/src/util/i18n.cpp +++ b/src/util/i18n.cpp @@ -1564,6 +1564,7 @@ void I18n::loadBuiltinEnglish() strings_["faq"] = "FAQ"; strings_["faq_title"] = "Help & FAQ"; strings_["faq_intro"] = "Answers about your wallet and the DragonX node. Search, or browse by topic below."; + strings_["faq_intro_lite"] = "Answers about your Lite wallet. Search, or browse by topic below."; strings_["faq_search_hint"] = "Search the FAQ\xE2\x80\xA6"; strings_["faq_open_tooltip"] = "Help & FAQ"; strings_["faq_no_results"] = "No results. Try a different search term."; @@ -1595,9 +1596,9 @@ void I18n::loadBuiltinEnglish() strings_["faq_w_gs_2_q"] = "How do I create a new wallet?"; strings_["faq_w_gs_2_a"] = "On first launch the setup wizard creates a wallet for you automatically. New wallets are backed by a secret recovery phrase (a list of words). Write that phrase down and keep it offline \xE2\x80\x94 it is the only way to restore your funds if this computer is lost.\n\nYou can review or back up the phrase any time from Settings > Backup & Data > Seed phrase."; strings_["faq_w_gs_3_q"] = "How do I restore a wallet I already have?"; - strings_["faq_w_gs_3_a"] = "Use the seed-phrase restore flow if you have a recovery phrase, or copy an existing wallet.dat file into the wallet's data directory before launch.\n\nAfter restoring, the node re-scans the blockchain to find your past transactions, so your balance and history may take a while to appear the first time."; + strings_["faq_w_gs_3_a"] = "Use the seed-phrase restore flow if you have a recovery phrase. (On the full-node build you can also copy an existing wallet.dat file into the wallet's data directory before launch.)\n\nAfter restoring, the wallet re-scans to find your past transactions, so your balance and history may take a while to appear the first time."; strings_["faq_w_gs_4_q"] = "What does the first-run setup do?"; - strings_["faq_w_gs_4_a"] = "The wizard lets you pick an appearance/theme, optionally download a bootstrap to speed up the initial blockchain sync, and set up encryption and a PIN. You can skip any step and change all of these later in Settings."; + strings_["faq_w_gs_4_a"] = "The wizard lets you pick an appearance/theme, set up encryption and a PIN, and \xE2\x80\x94 on the full-node build \xE2\x80\x94 optionally download a bootstrap to speed up the first sync. You can skip any step and change all of these later in Settings."; // Wallet > Addresses & Privacy strings_["faq_w_addr_1_q"] = "What's the difference between transparent and shielded addresses?"; @@ -1617,11 +1618,11 @@ void I18n::loadBuiltinEnglish() strings_["faq_w_send_3_q"] = "Can I attach a message to a payment?"; strings_["faq_w_send_3_a"] = "Yes \xE2\x80\x94 when sending to a shielded (z) address you can include an encrypted memo. Only the recipient can read it. Transparent addresses do not support memos."; strings_["faq_w_send_4_q"] = "I sent a payment but it says pending \xE2\x80\x94 why?"; - strings_["faq_w_send_4_a"] = "A transaction is 'pending' until it is mined into a block and gains confirmations. This usually takes a minute or two. Shielded transactions also need the node to be synced to build the proof.\n\nIf a send stays pending unusually long, check that the node is connected and synced (see the status bar at the bottom of the window)."; + strings_["faq_w_send_4_a"] = "A transaction is 'pending' until it is mined into a block and gains confirmations. This usually takes a minute or two. Shielded transactions also need your wallet to be synced to build the proof.\n\nIf a send stays pending unusually long, check that your wallet is connected and synced (see the status bar at the bottom of the window)."; // Wallet > Balance & Sync strings_["faq_w_bal_1_q"] = "Why is my balance 0 or not updating?"; - strings_["faq_w_bal_1_a"] = "While the node is still syncing the blockchain, your balance is incomplete and may read 0 \xE2\x80\x94 the wallet hasn't scanned all of your transactions yet. It fills in once syncing finishes.\n\nWatch the status bar at the bottom: it shows the connection state and block height. Once the node is synced, your balance is accurate."; + strings_["faq_w_bal_1_a"] = "While your wallet is still syncing, your balance is incomplete and may read 0 \xE2\x80\x94 it hasn't scanned all of your transactions yet. It fills in once syncing finishes.\n\nWatch the status bar at the bottom: it shows the connection state and block height. Once syncing is complete, your balance is accurate."; strings_["faq_w_bal_2_q"] = "What are confirmations?"; strings_["faq_w_bal_2_a"] = "Each new block mined on top of the block containing your transaction adds one confirmation. More confirmations mean the payment is more firmly settled. Received funds become spendable after the first confirmation."; strings_["faq_w_bal_3_q"] = "What's the difference between total and spendable balance?"; @@ -1631,7 +1632,7 @@ void I18n::loadBuiltinEnglish() strings_["faq_w_sec_1_q"] = "How do I encrypt my wallet?"; strings_["faq_w_sec_1_a"] = "Open Settings > Node & Security and set a passphrase (the SECURITY section). Encryption protects your private keys on disk, so someone with access to the files still cannot spend your coins.\n\nChoose a strong passphrase and don't lose it \xE2\x80\x94 there is no way to recover an encrypted wallet without it."; strings_["faq_w_sec_2_q"] = "What is the PIN / lock screen?"; - strings_["faq_w_sec_2_a"] = "The PIN locks the app's screen so balances and actions are hidden when you step away. It's a convenience lock on top of encryption; you set it up during the wizard or in Settings > Node & Security (encrypt the wallet first)."; + strings_["faq_w_sec_2_a"] = "The PIN locks the app's screen so balances and actions are hidden when you step away. It's a convenience lock on top of encryption; you set it up during the wizard or in Settings, after encrypting the wallet."; strings_["faq_w_sec_3_q"] = "I forgot my passphrase \xE2\x80\x94 can it be recovered?"; strings_["faq_w_sec_3_a"] = "No. Wallet encryption cannot be bypassed. If you still have your seed recovery phrase, you can restore the wallet from it into a fresh wallet and set a new passphrase. Without either the passphrase or the seed phrase, the funds cannot be recovered."; @@ -1641,9 +1642,9 @@ void I18n::loadBuiltinEnglish() strings_["faq_w_seed_2_q"] = "My wallet has no recovery phrase \xE2\x80\x94 can I add one?"; strings_["faq_w_seed_2_a"] = "Older (legacy) wallets weren't seed-based. The wallet can migrate a legacy wallet into a modern seed-backed one: it creates a new seed wallet and sweeps your funds into it. Look for 'Migrate to seed\xE2\x80\xA6' in Settings > Backup & Data. This feature needs the current daemon version."; strings_["faq_w_seed_3_q"] = "How do I restore from my recovery phrase?"; - strings_["faq_w_seed_3_a"] = "Use the seed-restore flow when setting up a wallet and enter your words in order. The node then re-scans the chain to rebuild your balance and history, which can take a while the first time."; + strings_["faq_w_seed_3_a"] = "Use the seed-restore flow when setting up a wallet and enter your words in order. Your wallet then re-scans to rebuild your balance and history, which can take a while the first time."; strings_["faq_w_seed_4_q"] = "Should I also back up wallet.dat?"; - strings_["faq_w_seed_4_a"] = "Your seed phrase is the primary backup and is enough to restore everything. A copy of the wallet.dat file is a convenient secondary backup that also preserves labels and settings. Keep any backup offline and private."; + strings_["faq_w_seed_4_a"] = "Your seed phrase is the primary backup and is enough to restore everything. A copy of your wallet file is a convenient secondary backup that also preserves labels and settings. Keep any backup offline and private."; // Wallet > Chat & Contacts strings_["faq_w_chat_1_q"] = "What is the Chat feature?"; @@ -1654,6 +1655,17 @@ void I18n::loadBuiltinEnglish() strings_["faq_w_chat_3_a"] = "Add a contact by their address in the Contacts tab, optionally with a name and avatar. Contacts can be kept private to the current wallet or shared across all wallets you open on this computer."; strings_["faq_w_chat_4_q"] = "How do I hide, delete, or block a conversation?"; strings_["faq_w_chat_4_a"] = "Open a conversation and use the icons in its header. Hide (the eye) drops it from the list but keeps every message \xE2\x80\x94 a new message un-hides it. Delete (the trash) opens a dialog: 'Delete' clears the history on this device (if that person messages you again, the conversation comes back), while 'Delete & block' also stops their future messages until you unblock them from the 'Blocked' list above the conversation list. Everything here is local to this device \xE2\x80\x94 the messages stay on the blockchain and the other person keeps their own copy, so it isn't an 'unsend'."; + // ---- Lite-variant FAQ (ObsidianDragonLite): swapped-in answers + a Lite Wallet subcategory ---- + strings_["faq_l_gs_1_q"] = "What is ObsidianDragonLite?"; + strings_["faq_l_gs_1_a"] = "ObsidianDragonLite is the lightweight DragonX wallet. Instead of running a full node, it connects to a DragonX lite server, so it starts fast and doesn't download the whole blockchain.\n\nIt manages your keys, balances, and sending just like the full wallet \xE2\x80\x94 see the 'Lite Wallet' section below for how the server connection works and the privacy tradeoff."; + strings_["faq_l_sec_1_a"] = "Open Settings > Wallet and set a passphrase in the security section. Encryption protects your private keys on disk, so someone with access to the files still cannot spend your coins.\n\nChoose a strong passphrase and don't lose it \xE2\x80\x94 there is no way to recover an encrypted wallet without it."; + strings_["faq_l_lite_title"] = "Lite Wallet"; + strings_["faq_l_lite_1_q"] = "How is the Lite wallet different from the full wallet?"; + strings_["faq_l_lite_1_a"] = "The Lite wallet talks to a DragonX lite server instead of running its own full node. That makes it fast to start and light on disk and bandwidth, because it doesn't download or verify the entire blockchain itself. Your private keys always stay on your device \xE2\x80\x94 they are never sent to the server."; + strings_["faq_l_lite_2_q"] = "How do I choose or change the server?"; + strings_["faq_l_lite_2_a"] = "Open Settings and pick a server. You can switch servers at any time and the wallet re-syncs from the new one. If a server is slow or unreachable, try another."; + strings_["faq_l_lite_3_q"] = "Is the Lite wallet as private as the full node?"; + strings_["faq_l_lite_3_a"] = "Your keys never leave your device, and shielded amounts stay encrypted. But the lite server does see which addresses your wallet asks about and your IP address, so it can link your addresses together \xE2\x80\x94 a convenience-for-privacy tradeoff. For the most privacy, use the full-node wallet, which verifies the chain itself and doesn't reveal your addresses to a server."; // Wallet > Settings & Appearance strings_["faq_w_set_1_q"] = "How do I change the theme?";