perf(mining): memoize the earnings card on tx_revision

The Mining tab's earnings card walked all N wallet transactions on
every frame to total Today / Yesterday / All time and pick the 4 most
recent rows: four string compares per transaction plus a memo search
on receives. It also ran localtime and mktime every frame to find
local midnight.

The pass is now a pure function behind a one-slot cache keyed on
WalletState::tx_revision, the transaction count, the filter pill, the
Solo/Pool mode, solo support and local midnight, with a 2 s maximum
age as a safety net. It reruns only when one of those changes or the
2 s age runs out, instead of every frame. The totals are bit-identical
(same loop, same summation order), and crossing local midnight still
moves Today into Yesterday at once.

Local midnight is recomputed only when the clock second changes,
through the shared util::localTime; a failed localtime now yields a
zeroed struct instead of an uninitialised one. The "x ago" labels and
Est. Daily are still computed per frame.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

src/ui/windows/mining_earnings.cpp

@@ -21,7 +21,9 @@
 #include "imgui_internal.h"
 
 #include <algorithm>
+#include <chrono>
 #include <cmath>
+#include <cstdint>
 #include <cstdio>
 #include <ctime>
 #include <string>
@@ -43,66 +45,28 @@ void RenderMiningEarnings(App* app, const WalletState& state, const MiningInfo&
 {
         const bool s_pool_mode = poolMode;  // alias: keep the moved body's identifier verbatim
         char buf[128];                      // section-local scratch (was shared in the parent)
-        // Gather mining transactions from state
-        double minedToday = 0.0, minedYesterday = 0.0, minedAllTime = 0.0;
-        int minedTodayCount = 0, minedYesterdayCount = 0, minedAllTimeCount = 0;
+        // Mining earnings totals + the 4 most recent rows, memoised (MiningEarningsCache): the O(transactions)
+        // pass reruns only when the tx list (WalletState::tx_revision), the filter pill, the Solo/Pool mode, the
+        // solo capability or the local day changes, or at most every 2 s as a safety net - not every frame.
+        // `now` stays per frame (the "x ago" labels below use it).
         int64_t now = (int64_t)std::time(nullptr);
-
-        // Calendar-day boundaries (local time)
-        time_t nowT = (time_t)now;
-        struct tm local;
-#ifdef _WIN32
-        localtime_s(&local, &nowT);
-#else
-        localtime_r(&nowT, &local);
-#endif
-        local.tm_hour = 0;
-        local.tm_min = 0;
-        local.tm_sec = 0;
-        int64_t todayStart = (int64_t)mktime(&local);
-        int64_t yesterdayStart = todayStart - 86400;
-
-        struct MinedTx {
-            int64_t timestamp;
-            double amount;
-            int confirmations;
-            bool mature;
-            std::string txid;
-            bool isPoolPayout;
-        };
-        std::vector<MinedTx> recentMined;
-
-        for (const auto& tx : state.transactions) {
-            bool isSoloMined = (tx.type == "generate" || tx.type == "immature" || tx.type == "mined");
-            bool isPoolPayout = (tx.type == "receive"
-                                 && !tx.memo.empty()
-                                 && tx.memo.find("Mining Pool payout") != std::string::npos);
-            if (isSoloMined || isPoolPayout) {
-                // Apply earnings filter
-                if (!app->supportsSoloMining()) {
-                    if (s_earnings_filter == 1 && !isPoolPayout) continue;
-                } else {
-                    if (s_earnings_filter == 1 && !isSoloMined) continue;
-                    if (s_earnings_filter == 2 && !isPoolPayout) continue;
-                }
-
-                double amt = std::abs(tx.amount);
-                minedAllTime += amt;
-                minedAllTimeCount++;
-                if (tx.timestamp >= todayStart) {
-                    minedToday += amt;
-                    minedTodayCount++;
-                } else if (tx.timestamp >= yesterdayStart) {
-                    minedYesterday += amt;
-                    minedYesterdayCount++;
-                }
-                // Separate solo blocks from pool payouts based on current mode
-                bool showInCurrentMode = s_pool_mode ? isPoolPayout : isSoloMined;
-                if (showInCurrentMode && recentMined.size() < 4) {
-                    recentMined.push_back({tx.timestamp, amt, tx.confirmations, tx.confirmations >= 100, tx.txid, isPoolPayout});
-                }
-            }
-        }
+        static MiningEarningsCache s_earningsCache;
+        static LocalDayStartMemo s_dayStart;
+        MiningEarningsKey earnKey;
+        earnKey.txRevision = state.tx_revision;
+        earnKey.txCount = state.transactions.size();
+        earnKey.filter = s_earnings_filter;
+        earnKey.soloSupported = app->supportsSoloMining();
+        earnKey.poolMode = s_pool_mode;
+        earnKey.todayStart = s_dayStart.get(now);
+        const int64_t nowMs = (int64_t)std::chrono::duration_cast<std::chrono::milliseconds>(
+            std::chrono::steady_clock::now().time_since_epoch()).count();
+        const MiningEarningsTotals& earn = s_earningsCache.get(earnKey, state.transactions, nowMs);
+        // The names the (unchanged) rendering code below already uses.
+        const double minedToday = earn.today, minedYesterday = earn.yesterday, minedAllTime = earn.allTime;
+        const int minedTodayCount = earn.todayCount, minedYesterdayCount = earn.yesterdayCount,
+                  minedAllTimeCount = earn.allTimeCount;
+        const std::vector<MiningEarningsRecentTx>& recentMined = earn.recent;
 
         // 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

src/ui/windows/mining_tab_helpers.cpp

@@ -1,7 +1,11 @@
 #include "mining_tab_helpers.h"
 
+#include "../../util/local_time.h"
+
 #include <algorithm>
+#include <cmath>
 #include <cstdio>
+#include <ctime>
 #include <thread>
 
 namespace dragonx {
@@ -83,5 +87,74 @@ std::string FormatEstTime(double estimatedHours)
     return std::string(buffer);
 }
 
+MiningEarningsTotals ComputeMiningEarnings(const std::vector<TransactionInfo>& txs, int filter,
+                                           bool soloSupported, bool poolMode,
+                                           std::int64_t todayStart, std::int64_t yesterdayStart)
+{
+    MiningEarningsTotals t;
+    for (const auto& tx : txs) {
+        bool isSoloMined = (tx.type == "generate" || tx.type == "immature" || tx.type == "mined");
+        bool isPoolPayout = (tx.type == "receive"
+                             && !tx.memo.empty()
+                             && tx.memo.find("Mining Pool payout") != std::string::npos);
+        if (!(isSoloMined || isPoolPayout)) continue;
+        // Apply earnings filter
+        if (!soloSupported) {
+            if (filter == 1 && !isPoolPayout) continue;
+        } else {
+            if (filter == 1 && !isSoloMined) continue;
+            if (filter == 2 && !isPoolPayout) continue;
+        }
+        double amt = std::abs(tx.amount);
+        t.allTime += amt;
+        t.allTimeCount++;
+        if (tx.timestamp >= todayStart) {
+            t.today += amt;
+            t.todayCount++;
+        } else if (tx.timestamp >= yesterdayStart) {
+            t.yesterday += amt;
+            t.yesterdayCount++;
+        }
+        // Separate solo blocks from pool payouts based on current mode
+        bool showInCurrentMode = poolMode ? isPoolPayout : isSoloMined;
+        if (showInCurrentMode && t.recent.size() < 4)
+            t.recent.push_back({tx.timestamp, amt, tx.confirmations, tx.confirmations >= 100, tx.txid, isPoolPayout});
+    }
+    return t;
+}
+
+const MiningEarningsTotals& MiningEarningsCache::get(const MiningEarningsKey& key,
+                                                     const std::vector<TransactionInfo>& txs,
+                                                     std::int64_t nowMs)
+{
+    if (!valid_ || !(key == key_) || IntervalElapsed(nowMs, computedAtMs_, kMaxAgeMs)) {
+        totals_ = ComputeMiningEarnings(txs, key.filter, key.soloSupported, key.poolMode,
+                                        key.todayStart, key.todayStart - 86400);   // 86400: as before
+        key_ = key;
+        computedAtMs_ = nowMs;
+        valid_ = true;
+        ++computes_;
+    }
+    return totals_;
+}
+
+bool IntervalElapsed(std::int64_t nowMs, std::int64_t lastMs, std::int64_t minMs)
+{
+    return nowMs < lastMs || nowMs - lastMs >= minMs;
+}
+
+std::int64_t LocalDayStartMemo::get(std::int64_t now)
+{
+    if (now == now_) return start_;
+    std::tm local{};
+    util::localTime(static_cast<std::time_t>(now), local);   // same localtime_r / localtime_s as before
+    local.tm_hour = 0;
+    local.tm_min = 0;
+    local.tm_sec = 0;
+    start_ = (std::int64_t)mktime(&local);
+    now_ = now;
+    return start_;
+}
+
 } // namespace ui
 } // namespace dragonx

src/ui/windows/mining_tab_helpers.h

@@ -1,6 +1,11 @@
 #pragma once
 
+#include <cstddef>
+#include <cstdint>
 #include <string>
+#include <vector>
+
+#include "data/wallet_state.h"   // TransactionInfo
 
 namespace dragonx {
 namespace ui {
@@ -13,5 +18,61 @@ std::string FormatFeePercent(double feePercent);
 double EstimateHoursToBlock(double localHashrate, double networkHashrate, double difficulty);
 std::string FormatEstTime(double estimatedHours);
 
+// ---- Mining earnings card (Today / Yesterday / All time + the 4 most recent rows) ----
+// Stored BY VALUE: never point into WalletState::transactions (a refresh replaces / reallocates it).
+struct MiningEarningsRecentTx {
+    std::int64_t timestamp = 0;
+    double amount = 0.0;
+    int confirmations = 0;
+    bool mature = false;
+    std::string txid;
+    bool isPoolPayout = false;
+};
+struct MiningEarningsTotals {
+    double today = 0.0, yesterday = 0.0, allTime = 0.0;
+    int todayCount = 0, yesterdayCount = 0, allTimeCount = 0;
+    std::vector<MiningEarningsRecentTx> recent;   // <= 4, in tx-list order
+};
+// The earnings card's former inline loop, verbatim. filter: 0 All, 1 Solo, 2 Pool (the card's filter pill).
+MiningEarningsTotals ComputeMiningEarnings(const std::vector<TransactionInfo>& txs, int filter,
+                                           bool soloSupported, bool poolMode,
+                                           std::int64_t todayStart, std::int64_t yesterdayStart);
+// Every input the totals depend on: equal keys => the cached totals are still valid.
+struct MiningEarningsKey {
+    std::uint64_t txRevision = 0;   // WalletState::tx_revision (bumped by every write to `transactions`)
+    std::size_t txCount = 0;        // belt: a future writer that skips the bump but changes the row count
+    int filter = 0;
+    bool soloSupported = false;
+    bool poolMode = false;          // picks the recent-4 rows (solo blocks vs pool payouts)
+    std::int64_t todayStart = 0;    // local midnight; yesterday = todayStart - 86400, as before
+    bool operator==(const MiningEarningsKey& o) const {
+        return txRevision == o.txRevision && txCount == o.txCount && filter == o.filter &&
+               soloSupported == o.soloSupported && poolMode == o.poolMode && todayStart == o.todayStart;
+    }
+};
+class MiningEarningsCache {
+public:
+    static constexpr std::int64_t kMaxAgeMs = 2000;   // bounds staleness if a future writer skips the bump
+    const MiningEarningsTotals& get(const MiningEarningsKey& key, const std::vector<TransactionInfo>& txs,
+                                    std::int64_t nowMs);
+    int computeCount() const { return computes_; }     // tests
+private:
+    bool valid_ = false;
+    MiningEarningsKey key_;
+    std::int64_t computedAtMs_ = 0;
+    MiningEarningsTotals totals_;
+    int computes_ = 0;
+};
+// True when a sample taken at lastMs is at least minMs old (or the clock went backwards).
+bool IntervalElapsed(std::int64_t nowMs, std::int64_t lastMs, std::int64_t minMs);
+// Local midnight for `now` (the same localtime + mktime as before). A pure function of the second, so it is
+// recomputed only when `now` changes instead of on every frame (bit-identical result, DST quirks included).
+class LocalDayStartMemo {
+public:
+    std::int64_t get(std::int64_t now);
+private:
+    std::int64_t now_ = INT64_MIN, start_ = 0;
+};
+
 } // namespace ui
 } // namespace dragonx