Merge #7146: feat(qt): introduce framework for sourcing and applying data, use for {Masternode,Proposal}Lists

3d64056 move-only: move definitions to clientfeeds.{cpp,h} to deal with circulars (Kittywhiskers Van Gogh)
4f56a5e lint: update circular dependencies allowlist (Kittywhiskers Van Gogh)
77a99ee qt: register masternode information as a feed, replace per-wallet thread (Kittywhiskers Van Gogh)
722ec6a refactor(qt): pull out proposal data sourcing to `MasternodeFeed` (Kittywhiskers Van Gogh)
a6c7ba3 qt: register proposal information as a feed, replace per-wallet thread (Kittywhiskers Van Gogh)
35eb3d2 feat(qt): introduce framework for sourcing and applying data (Kittywhiskers Van Gogh)
4e951df refactor(qt): pull out proposal data sourcing to `ProposalFeed` (Kittywhiskers Van Gogh)
7827ae1 move-only: src/qt/governancelist.{cpp,h} -> src/qt/proposallist.{cpp,h} (Kittywhiskers Van Gogh)
342f785 refactor: s/ProposalList/Proposals/g (Kittywhiskers Van Gogh)

Pull request description:

  ## Additional Information

  * Dependency for #7118

  * The redesigned "Masternode" and "Governance" tabs (see [dash#7110](#7110) and [dash#7116](#7116)) were migrated to a worker-based update mechanism with a773635 and others, this proved to deal with main thread contention and the debounce mechanism prevented frequent refreshes of infrequently updated data and was a step towards throttled event-driven updates.
    * This implementation though had a problematic side effect, a worker thread is spawned **per tab per wallet** and while per tab threads were by design, per wallet threads meant redundant work happening all at once fighting over the same locks, which cause noticeable performance degradation.

    * This pull request therefore introduces the concept of "feeds", that perform the expensive fetch operation that are either triggered by events (and debounced) or user feedback (and executed immediately) to ensure snappiness. The IBD throttling logic is respected.

  * The result is having a central worker thread fetching (`fetch()`) and dispatching refresh signals (`dataReady()`) which are then used by the consumer (e.g. `updateMasternodeList()`) to fetch wallet-specific information (which is relatively inexpensive) and then *apply* those changes (e.g. `setMasternodeList()`).

    * Note that wallet-specific fetching is done on the main thread, to prevent thread explosion (even if they are doing now non-redundant work) as they'd still be per tab per wallet.

  * Note that masternodes and proposal views use different refresh intervals, masternode data uses 3 seconds and proposal data uses 10 seconds, scaled up to 30s and 60s respectively during IBD.

  ## Breaking Changes

  None expected.

  ## Checklist

  - [x] I have performed a self-review of my own code
  - [x] I have commented my code, particularly in hard-to-understand areas
  - [x] I have added or updated relevant unit/integration/functional/e2e tests **(note: N/A)**
  - [x] I have made corresponding changes to the documentation **(note: N/A)**
  - [x] I have assigned this pull request to a milestone _(for repository code-owners and collaborators only)_

ACKs for top commit:
  UdjinM6:
    utACK 3d64056

Tree-SHA512: 2bd89418e9de80c10269fc723468141970a41e492baadf839824eb4c58cea43f65ab8b8cbeac1867e0dffd3c3bc5785ec59fab97bd1c3659fe46f7bf797eddcc

Author: PastaPastaPasta

src/Makefile.qt.include

@@ -23,7 +23,6 @@ QT_FORMS_UI = \
   qt/forms/debugwindow.ui \
   qt/forms/descriptiondialog.ui \
   qt/forms/editaddressdialog.ui \
-  qt/forms/governancelist.ui \
   qt/forms/helpmessagedialog.ui \
   qt/forms/intro.ui \
   qt/forms/masternodelist.ui \
@@ -33,6 +32,7 @@ QT_FORMS_UI = \
   qt/forms/optionsdialog.ui \
   qt/forms/overviewpage.ui \
   qt/forms/proposalcreate.ui \
+  qt/forms/proposallist.ui \
   qt/forms/proposalresume.ui \
   qt/forms/psbtoperationsdialog.ui \
   qt/forms/qrdialog.ui \
@@ -53,14 +53,14 @@ QT_MOC_CPP = \
   qt/moc_bitcoinamountfield.cpp \
   qt/moc_bitcoingui.cpp \
   qt/moc_bitcoinunits.cpp \
+  qt/moc_clientfeeds.cpp \
   qt/moc_clientmodel.cpp \
   qt/moc_coincontroldialog.cpp \
   qt/moc_coincontroltreewidget.cpp \
   qt/moc_createwalletdialog.cpp \
   qt/moc_csvmodelwriter.cpp \
   qt/moc_descriptiondialog.cpp \
   qt/moc_editaddressdialog.cpp \
-  qt/moc_governancelist.cpp \
   qt/moc_guiutil.cpp \
   qt/moc_initexecutor.cpp \
   qt/moc_intro.cpp \
@@ -78,8 +78,9 @@ QT_MOC_CPP = \
   qt/moc_paymentserver.cpp \
   qt/moc_peertablemodel.cpp \
   qt/moc_peertablesortproxy.cpp \
-  qt/moc_proposalmodel.cpp \
   qt/moc_proposalcreate.cpp \
+  qt/moc_proposallist.cpp \
+  qt/moc_proposalmodel.cpp \
   qt/moc_proposalresume.cpp \
   qt/moc_psbtoperationsdialog.cpp \
   qt/moc_qrdialog.cpp \
@@ -133,17 +134,17 @@ BITCOIN_QT_H = \
   qt/bitcoinamountfield.h \
   qt/bitcoingui.h \
   qt/bitcoinunits.h \
+  qt/clientfeeds.h \
   qt/clientmodel.h \
   qt/coincontroldialog.h \
   qt/coincontroltreewidget.h \
   qt/createwalletdialog.h \
   qt/csvmodelwriter.h \
   qt/descriptiondialog.h \
   qt/editaddressdialog.h \
-  qt/governancelist.h \
   qt/guiconstants.h \
-  qt/guiutil.h \
   qt/guiutil_font.h \
+  qt/guiutil.h \
   qt/initexecutor.h \
   qt/intro.h \
   qt/macdockiconhandler.h \
@@ -163,6 +164,7 @@ BITCOIN_QT_H = \
   qt/peertablemodel.h \
   qt/peertablesortproxy.h \
   qt/proposalcreate.h \
+  qt/proposallist.h \
   qt/proposalmodel.h \
   qt/proposalresume.h \
   qt/psbtoperationsdialog.h \
@@ -242,9 +244,12 @@ BITCOIN_QT_BASE_CPP = \
   qt/bantablemodel.cpp \
   qt/bitcoin.cpp \
   qt/bitcoinaddressvalidator.cpp \
+  qt/masternodemodel.cpp \
+  qt/proposalmodel.cpp \
   qt/bitcoinamountfield.cpp \
   qt/bitcoingui.cpp \
   qt/bitcoinunits.cpp \
+  qt/clientfeeds.cpp \
   qt/clientmodel.cpp \
   qt/csvmodelwriter.cpp \
   qt/guiutil.cpp \
@@ -277,15 +282,13 @@ BITCOIN_QT_WALLET_CPP = \
   qt/createwalletdialog.cpp \
   qt/descriptiondialog.cpp \
   qt/editaddressdialog.cpp \
-  qt/governancelist.cpp \
   qt/masternodelist.cpp \
-  qt/masternodemodel.cpp \
   qt/mnemonicverificationdialog.cpp \
   qt/openuridialog.cpp \
   qt/overviewpage.cpp \
   qt/paymentserver.cpp \
   qt/proposalcreate.cpp \
-  qt/proposalmodel.cpp \
+  qt/proposallist.cpp \
   qt/proposalresume.cpp \
   qt/psbtoperationsdialog.cpp \
   qt/qrdialog.cpp \

src/qt/bitcoingui.cpp

@@ -5,18 +5,31 @@
 
 #include <qt/bitcoingui.h>
 
+#include <chain.h>
+#include <chainparams.h>
+#include <interfaces/coinjoin.h>
+#include <interfaces/handler.h>
+#include <interfaces/node.h>
+#include <node/interface_ui.h>
+#include <util/system.h>
+#include <util/translation.h>
+#include <util/underlying.h>
+#include <validation.h>
+
 #include <qt/bitcoinunits.h>
 #include <qt/clientmodel.h>
 #include <qt/createwalletdialog.h>
 #include <qt/guiconstants.h>
-#include <qt/guiutil.h>
 #include <qt/guiutil_font.h>
+#include <qt/guiutil.h>
+#include <qt/masternodelist.h>
 #include <qt/modaloverlay.h>
 #include <qt/networkstyle.h>
 #include <qt/notificator.h>
 #include <qt/openuridialog.h>
 #include <qt/optionsdialog.h>
 #include <qt/optionsmodel.h>
+#include <qt/proposallist.h>
 #include <qt/rpcconsole.h>
 #include <qt/utilitydialog.h>
 
@@ -31,20 +44,6 @@
 #include <qt/macdockiconhandler.h>
 #endif
 
-#include <functional>
-#include <chain.h>
-#include <chainparams.h>
-#include <interfaces/coinjoin.h>
-#include <interfaces/handler.h>
-#include <interfaces/node.h>
-#include <node/interface_ui.h>
-#include <qt/governancelist.h>
-#include <qt/masternodelist.h>
-#include <util/system.h>
-#include <util/translation.h>
-#include <util/underlying.h>
-#include <validation.h>
-
 #include <QAction>
 #include <QActionGroup>
 #include <QApplication>
@@ -72,6 +71,8 @@
 #include <QVBoxLayout>
 #include <QWindow>
 
+#include <functional>
+
 namespace {
 // Total governance clock frames. Frame 0 is reserved for the superblock
 // maturity window; frames 1 through GOV_CYCLE_FRAME_COUNT-1 are used for the

src/qt/clientfeeds.cpp

@@ -0,0 +1,235 @@
+// Copyright (c) 2026 The Dash Core developers
+// Distributed under the MIT software license, see the accompanying
+// file COPYING or http://www.opensource.org/licenses/mit-license.php.
+
+#include <qt/clientfeeds.h>
+
+#include <coins.h>
+#include <key_io.h>
+#include <script/standard.h>
+#include <util/threadnames.h>
+#include <util/time.h>
+
+#include <qt/clientmodel.h>
+#include <qt/masternodemodel.h>
+#include <qt/proposalmodel.h>
+
+#include <QDebug>
+#include <QThread>
+
+namespace {
+constexpr auto MASTERNODE_UPDATE_INTERVAL{3s};
+constexpr auto PROPOSAL_UPDATE_INTERVAL{10s};
+} // anonymous namespace
+
+FeedBase::FeedBase(QObject* parent, const FeedBase::Config& config) :
+    QObject{parent},
+    m_config{config}
+{
+}
+
+FeedBase::~FeedBase() = default;
+
+void FeedBase::requestForceRefresh()
+{
+    if (m_timer) {
+        m_timer->start(0);
+    }
+}
+
+void FeedBase::requestRefresh()
+{
+    if (m_timer && !m_timer->isActive()) {
+        m_timer->start(m_syncing.load() ? m_config.m_throttle : m_config.m_baseline);
+    }
+}
+
+MasternodeFeed::MasternodeFeed(QObject* parent, ClientModel& client_model) :
+    Feed<MasternodeData>{parent, {/*m_baseline=*/MASTERNODE_UPDATE_INTERVAL, /*m_throttle=*/MASTERNODE_UPDATE_INTERVAL*10}},
+    m_client_model{client_model}
+{
+}
+
+MasternodeFeed::~MasternodeFeed() = default;
+
+void MasternodeFeed::fetch()
+{
+    if (m_client_model.node().shutdownRequested()) {
+        return;
+    }
+
+    const auto [dmn, pindex] = m_client_model.getMasternodeList();
+    if (!dmn || !pindex) {
+        return;
+    }
+
+    auto projectedPayees = dmn->getProjectedMNPayees(pindex);
+    if (projectedPayees.empty() && dmn->getValidMNsCount() > 0) {
+        // GetProjectedMNPayees failed to provide results for a list with valid mns.
+        // Keep current list and let it try again later.
+        return;
+    }
+
+    auto ret = std::make_shared<Data>();
+    ret->m_list_height = dmn->getHeight();
+
+    Uint256HashMap<int> nextPayments;
+    for (size_t i = 0; i < projectedPayees.size(); i++) {
+        const auto& dmn = projectedPayees[i];
+        nextPayments.emplace(dmn->getProTxHash(), ret->m_list_height + (int)i + 1);
+    }
+
+    dmn->forEachMN(/*only_valid=*/false, [&](const auto& dmn) {
+        CTxDestination collateralDest;
+        Coin coin;
+        QString collateralStr = QObject::tr("UNKNOWN");
+        if (m_client_model.node().getUnspentOutput(dmn.getCollateralOutpoint(), coin) &&
+            ExtractDestination(coin.out.scriptPubKey, collateralDest)) {
+            collateralStr = QString::fromStdString(EncodeDestination(collateralDest));
+        }
+        int nNextPayment{0};
+        if (auto nextPaymentIt = nextPayments.find(dmn.getProTxHash()); nextPaymentIt != nextPayments.end()) {
+            nNextPayment = nextPaymentIt->second;
+        }
+        ret->m_entries.push_back(std::make_unique<MasternodeEntry>(dmn, collateralStr, nNextPayment));
+    });
+
+    ret->m_valid = true;
+    setData(std::move(ret));
+}
+
+ProposalFeed::ProposalFeed(QObject* parent, ClientModel& client_model) :
+    Feed<ProposalData>{parent, {/*m_baseline=*/PROPOSAL_UPDATE_INTERVAL, /*m_throttle=*/PROPOSAL_UPDATE_INTERVAL*6}},
+    m_client_model{client_model}
+{
+}
+
+ProposalFeed::~ProposalFeed() = default;
+
+void ProposalFeed::fetch()
+{
+    if (m_client_model.node().shutdownRequested()) {
+        return;
+    }
+
+    const auto [dmn, pindex] = m_client_model.getMasternodeList();
+    if (!dmn || !pindex) {
+        return;
+    }
+
+    auto ret = std::make_shared<Data>();
+    // A proposal is considered passing if (YES votes - NO votes) >= (Total Weight of Masternodes / 10),
+    // count total valid (ENABLED) masternodes to determine passing threshold.
+    // Need to query number of masternodes here with access to client model.
+    const int nWeightedMnCount = dmn->getValidWeightedMNsCount();
+    ret->m_abs_vote_req = std::max(Params().GetConsensus().nGovernanceMinQuorum, nWeightedMnCount / 10);
+    ret->m_gov_info = m_client_model.node().gov().getGovernanceInfo();
+    std::vector<CGovernanceObject> govObjList;
+    m_client_model.getAllGovernanceObjects(govObjList);
+    for (const auto& govObj : govObjList) {
+        if (govObj.GetObjectType() != GovernanceObject::PROPOSAL) {
+            continue; // Skip triggers.
+        }
+        ret->m_proposals.emplace_back(std::make_shared<Proposal>(m_client_model, govObj, ret->m_gov_info, ret->m_gov_info.requiredConfs,
+                                                                 /*is_broadcast=*/true));
+    }
+
+    auto fundable{m_client_model.node().gov().getFundableProposalHashes()};
+    ret->m_fundable_hashes = std::move(fundable.hashes);
+
+    setData(std::move(ret));
+}
+
+ClientFeeds::ClientFeeds(QObject* parent) :
+    QObject{parent},
+    m_thread{new QThread(this)}
+{
+}
+
+ClientFeeds::~ClientFeeds()
+{
+    stop();
+}
+
+void ClientFeeds::registerFeed(FeedBase* raw)
+{
+    auto* timer = new QTimer(this);
+    timer->setSingleShot(true);
+    raw->m_timer = timer;
+
+    connect(timer, &QTimer::timeout, this, [this, raw] {
+        if (raw->m_in_progress.exchange(true)) {
+            raw->m_retry_pending.store(true);
+            return;
+        }
+        QMetaObject::invokeMethod(m_worker, [this, raw] {
+            try {
+                raw->fetch();
+            } catch (const std::exception& e) {
+                qWarning() << "ClientFeeds::fetch() exception: " << e.what();
+            } catch (...) {
+                qWarning() << "ClientFeeds::fetch() unknown exception";
+            }
+            QTimer::singleShot(0, raw, [this, raw] {
+                raw->m_in_progress.store(false);
+                if (m_stopped) return;
+                Q_EMIT raw->dataReady();
+                if (raw->m_retry_pending.exchange(false)) {
+                    raw->requestRefresh();
+                }
+            });
+        });
+    });
+}
+
+void ClientFeeds::start()
+{
+    m_worker = new QObject();
+    m_worker->moveToThread(m_thread);
+    m_thread->start();
+    QMetaObject::invokeMethod(m_worker, [] { util::ThreadRename("qt-clientfeed"); });
+
+    for (const auto& source : m_sources) {
+        if (source->m_timer) {
+            source->m_timer->start(0);
+        }
+    }
+}
+
+void ClientFeeds::stop()
+{
+    if (m_stopped) {
+        return;
+    }
+
+    m_stopped = true;
+    for (const auto& source : m_sources) {
+        if (source->m_timer) {
+            source->m_timer->stop();
+            source->m_timer = nullptr;
+        }
+    }
+    if (m_thread->isRunning()) {
+        m_thread->quit();
+        m_thread->wait();
+    }
+    delete m_worker;
+    m_worker = nullptr;
+}
+
+void ClientFeeds::setSyncing(bool syncing)
+{
+    if (m_stopped) {
+        return;
+    }
+
+    for (const auto& source : m_sources) {
+        if (source->m_syncing.load() == syncing) {
+            continue;
+        }
+        source->setSyncing(syncing);
+        if (source->m_timer && source->m_timer->isActive()) {
+            source->m_timer->start(syncing ? source->m_config.m_throttle : source->m_config.m_baseline);
+        }
+    }
+}