From ec3d0ef1ac148d87f43cedc918d4a483d444cf96 Mon Sep 17 00:00:00 2001
From: pasta <pasta@dashboost.org>
Date: Sat, 15 Aug 2026 12:48:04 -0500
Subject: [PATCH 1/2] feat(qt): identify masternode transactions in history

Provider special transactions (ProRegTx, ProUpServTx, ProUpRegTx and
ProUpRevTx) previously appeared in the Qt transaction list as generic
sends/payments split across inputs and outputs. They are now classified
and shown as single summarized Masternode Registration / Masternode
Update records, with provider-specific detail fields (collateral,
service address, owner/voting/payout destinations) in the transaction
description.

New transaction filter entries are appended after the existing ones so
persisted filter indexes keep their meaning across upgrades.

Adds Qt test coverage for provider transaction classification,
live-notification of incoming provider transactions, and transaction
model reconstruction.
---
 src/Makefile.qttest.include              |   3 +
 src/qt/test/providertransactiontests.cpp | 383 +++++++++++++++++++++++
 src/qt/test/providertransactiontests.h   |  33 ++
 src/qt/test/test_main.cpp                |   4 +
 src/qt/transactiondesc.cpp               |  46 +--
 src/qt/transactionfilterproxy.h          |   5 +-
 src/qt/transactionrecord.cpp             |  33 +-
 src/qt/transactionrecord.h               |   7 +-
 src/qt/transactiontablemodel.cpp         |  22 ++
 src/qt/transactionview.cpp               |  14 +-
 test/util/data/non-backported.txt        |   2 +
 11 files changed, 523 insertions(+), 29 deletions(-)
 create mode 100644 src/qt/test/providertransactiontests.cpp
 create mode 100644 src/qt/test/providertransactiontests.h

diff --git a/src/Makefile.qttest.include b/src/Makefile.qttest.include
index 62071d40e5a5..bcea59d339d8 100644
--- a/src/Makefile.qttest.include
+++ b/src/Makefile.qttest.include
@@ -16,6 +16,7 @@ TEST_QT_MOC_CPP = \
 if ENABLE_WALLET
 TEST_QT_MOC_CPP += \
   qt/test/moc_addressbooktests.cpp \
+  qt/test/moc_providertransactiontests.cpp \
   qt/test/moc_wallettests.cpp
 endif # ENABLE_WALLET
 
@@ -23,6 +24,7 @@ TEST_QT_H = \
   qt/test/addressbooktests.h \
   qt/test/apptests.h \
   qt/test/optiontests.h \
+  qt/test/providertransactiontests.h \
   qt/test/rpcnestedtests.h \
   qt/test/uritests.h \
   qt/test/util.h \
@@ -45,6 +47,7 @@ qt_test_test_dash_qt_SOURCES = \
 if ENABLE_WALLET
 qt_test_test_dash_qt_SOURCES += \
   qt/test/addressbooktests.cpp \
+  qt/test/providertransactiontests.cpp \
   qt/test/wallettests.cpp \
   wallet/test/wallet_test_fixture.cpp
 endif # ENABLE_WALLET
diff --git a/src/qt/test/providertransactiontests.cpp b/src/qt/test/providertransactiontests.cpp
new file mode 100644
index 000000000000..5defac08423c
--- /dev/null
+++ b/src/qt/test/providertransactiontests.cpp
@@ -0,0 +1,383 @@
+// 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/test/providertransactiontests.h>
+
+#include <interfaces/chain.h>
+#include <interfaces/node.h>
+#include <key.h>
+#include <key_io.h>
+#include <primitives/transaction.h>
+#include <qt/clientmodel.h>
+#include <qt/optionsmodel.h>
+#include <qt/transactionfilterproxy.h>
+#include <qt/transactionrecord.h>
+#include <qt/transactiontablemodel.h>
+#include <qt/transactionview.h>
+#include <qt/walletmodel.h>
+#include <script/standard.h>
+#include <test/util/setup_common.h>
+#include <validation.h>
+#include <wallet/wallet.h>
+#include <wallet/walletdb.h>
+
+#include <memory>
+#include <optional>
+#include <vector>
+
+#include <QApplication>
+#include <QComboBox>
+#include <QListView>
+#include <QSettings>
+#include <QTableView>
+#include <QTest>
+
+using wallet::AddWallet;
+using wallet::CreateMockWalletDatabase;
+using wallet::CWallet;
+using wallet::RemoveWallet;
+using wallet::TxStateInactive;
+using wallet::WALLET_FLAG_DESCRIPTORS;
+using wallet::WalletContext;
+using wallet::WalletDescriptor;
+using wallet::WalletRescanReserver;
+
+namespace {
+
+struct ExpectedRecord {
+    uint256 txid;
+    TransactionRecord::Type type;
+    CAmount amount;
+    QString label;
+    QString tooltip_text;
+};
+
+CTransactionRef MakeSpecialTransaction(uint16_t type, const COutPoint& input, CAmount output_amount,
+                                       const CScript& output_script)
+{
+    CMutableTransaction tx;
+    tx.nVersion = CTransaction::SPECIAL_VERSION;
+    tx.nType = type;
+    tx.vin.emplace_back(input);
+    tx.vout.emplace_back(output_amount, output_script);
+    return MakeTransactionRef(std::move(tx));
+}
+
+std::vector<int> FindTransactionRows(const QAbstractItemModel& model, const uint256& txid)
+{
+    const QString hash{QString::fromStdString(txid.ToString())};
+    std::vector<int> rows;
+    for (int row = 0; row < model.rowCount(); ++row) {
+        if (model.index(row, 0).data(TransactionTableModel::TxHashRole).toString() == hash) {
+            rows.push_back(row);
+        }
+    }
+    return rows;
+}
+
+QComboBox* FindTransactionTypeWidget(TransactionView& view)
+{
+    for (QComboBox* combo : view.findChildren<QComboBox*>()) {
+        if (combo->findText("Masternode") >= 0) return combo;
+    }
+    return nullptr;
+}
+
+class WalletCleanup
+{
+public:
+    WalletCleanup(WalletContext& context, std::shared_ptr<CWallet> wallet) :
+        m_context(context),
+        m_wallet(std::move(wallet))
+    {
+    }
+    ~WalletCleanup() { RemoveWallet(m_context, m_wallet, /*load_on_start=*/std::nullopt); }
+
+private:
+    WalletContext& m_context;
+    std::shared_ptr<CWallet> m_wallet;
+};
+
+class CoinJoinOptionsRestorer
+{
+public:
+    explicit CoinJoinOptionsRestorer(interfaces::CoinJoin::Options& options) :
+        m_options(options),
+        m_enabled(options.isEnabled())
+    {
+    }
+    ~CoinJoinOptionsRestorer() { m_options.setEnabled(m_enabled); }
+
+private:
+    interfaces::CoinJoin::Options& m_options;
+    const bool m_enabled;
+};
+
+class TransactionTypeSettingRestorer
+{
+public:
+    TransactionTypeSettingRestorer() :
+        m_had_value(m_settings.contains("transactionType")),
+        m_value(m_settings.value("transactionType"))
+    {
+    }
+    ~TransactionTypeSettingRestorer()
+    {
+        if (m_had_value) {
+            m_settings.setValue("transactionType", m_value);
+        } else {
+            m_settings.remove("transactionType");
+        }
+    }
+
+private:
+    QSettings m_settings;
+    const bool m_had_value;
+    const QVariant m_value;
+};
+
+void CheckProviderRecords(const TransactionTableModel& model, const std::vector<ExpectedRecord>& expected)
+{
+    for (const ExpectedRecord& record : expected) {
+        const std::vector<int> rows{FindTransactionRows(model, record.txid)};
+        QCOMPARE(rows.size(), size_t{1});
+
+        const QModelIndex base{model.index(rows.front(), 0)};
+        const QModelIndex type_index{model.index(rows.front(), TransactionTableModel::Type)};
+        const QModelIndex address_index{model.index(rows.front(), TransactionTableModel::ToAddress)};
+
+        QCOMPARE(base.data(TransactionTableModel::TypeRole).toInt(), static_cast<int>(record.type));
+        QCOMPARE(base.data(TransactionTableModel::AmountRole).toLongLong(), record.amount);
+        QCOMPARE(base.data(TransactionTableModel::AddressRole).toString(), QString{});
+        QCOMPARE(base.data(TransactionTableModel::LabelRole).toString(), QString{});
+        QCOMPARE(type_index.data(Qt::DisplayRole).toString(), record.label);
+        QCOMPARE(address_index.data(Qt::DisplayRole).toString(), QString{"(n/a)"});
+
+        const QString tooltip{type_index.data(Qt::ToolTipRole).toString()};
+        QVERIFY(tooltip.contains(record.label));
+        QVERIFY(tooltip.contains(record.tooltip_text));
+        QVERIFY(!tooltip.contains("Payment to yourself"));
+
+        const QString plain_text{base.data(TransactionTableModel::TxPlainTextRole).toString()};
+        QVERIFY(plain_text.contains(record.label));
+        QVERIFY(!plain_text.contains("Payment to yourself"));
+
+        const QString description{base.data(TransactionTableModel::LongDescriptionRole).toString()};
+        QVERIFY(description.contains(record.label));
+        QVERIFY(description.contains(QString::fromStdString(record.txid.ToString())));
+        QVERIFY(description.contains("Net amount"));
+        QVERIFY(description.contains("Transaction total size"));
+        const QString summary{description.section("<hr>", 0, 0)};
+        QVERIFY(!summary.contains("From:"));
+        QVERIFY(!summary.contains("To:"));
+        QVERIFY(!summary.contains("<b>Debit:</b>"));
+        QVERIFY(!summary.contains("<b>Credit:</b>"));
+        QVERIFY(!summary.contains("Output index"));
+    }
+}
+
+} // namespace
+
+void ProviderTransactionTests::transactionTypeSettingCompatibility_data()
+{
+    QTest::addColumn<int>("saved_index");
+    QTest::addColumn<QString>("expected_text");
+    QTest::addColumn<quint32>("expected_filter");
+
+    QTest::newRow("data") << 12 << QString{"Data Transaction"}
+                          << TransactionFilterProxy::TYPE(TransactionRecord::DataTransaction);
+    QTest::newRow("dust") << 13 << QString{"Dust Receive"} << TransactionFilterProxy::TYPE(TransactionRecord::DustReceive);
+    QTest::newRow("other") << 14 << QString{"Other"} << TransactionFilterProxy::TYPE(TransactionRecord::Other);
+}
+
+void ProviderTransactionTests::transactionTypeSettingCompatibility()
+{
+    QFETCH(int, saved_index);
+    QFETCH(QString, expected_text);
+    QFETCH(quint32, expected_filter);
+
+    TransactionTypeSettingRestorer setting_restorer;
+    QSettings{}.setValue("transactionType", saved_index);
+
+    TransactionView transaction_view;
+    QComboBox* const type_widget{FindTransactionTypeWidget(transaction_view)};
+    QVERIFY(type_widget != nullptr);
+    QCOMPARE(type_widget->currentIndex(), saved_index);
+    QCOMPARE(type_widget->currentText(), expected_text);
+    QCOMPARE(type_widget->currentData().toUInt(), expected_filter);
+    QCOMPARE(type_widget->findText("Masternode"), 15);
+}
+
+void ProviderTransactionTests::providerTransactionHistory()
+{
+    TestChain100Setup test;
+    m_node.setContext(&test.m_node);
+
+    WalletContext& context{*m_node.walletLoader().context()};
+    std::shared_ptr<CWallet> wallet{std::make_shared<CWallet>(test.m_node.chain.get(), test.m_node.coinjoin_loader.get(),
+                                                              "", test.m_args, CreateMockWalletDatabase())};
+    wallet->LoadWallet();
+    wallet->SetWalletFlag(WALLET_FLAG_DESCRIPTORS);
+    {
+        LOCK(wallet->cs_wallet);
+        wallet->SetupDescriptorScriptPubKeyMans("", "");
+
+        FlatSigningProvider provider;
+        std::string descriptor_error;
+        std::unique_ptr<Descriptor> descriptor{Parse("combo(" + EncodeSecret(test.coinbaseKey) + ")", provider,
+                                                     descriptor_error, /*require_checksum=*/false)};
+        QVERIFY(descriptor != nullptr);
+        WalletDescriptor wallet_descriptor{std::move(descriptor), 0, 0, 1, 1};
+        QVERIFY(wallet->AddWalletDescriptor(wallet_descriptor, provider, "", /*internal=*/false));
+
+        const CBlockIndex* const tip{
+            WITH_LOCK(Assert(test.m_node.chainman)->GetMutex(), return test.m_node.chainman->ActiveChain().Tip())};
+        wallet->SetLastBlockProcessed(tip->nHeight, tip->GetBlockHash());
+    }
+    {
+        WalletRescanReserver reserver{*wallet};
+        QVERIFY(reserver.reserve());
+        const CWallet::ScanResult result{wallet->ScanForWalletTransactions(Params().GetConsensus().hashGenesisBlock,
+                                                                           /*start_height=*/0, /*max_height=*/{}, reserver,
+                                                                           /*fUpdate=*/false, /*save_progress=*/false)};
+        QCOMPARE(result.status, CWallet::ScanResult::SUCCESS);
+        QVERIFY(result.last_failed_block.IsNull());
+    }
+    QVERIFY(AddWallet(context, wallet));
+    WalletCleanup wallet_cleanup{context, wallet};
+    TransactionTypeSettingRestorer setting_restorer;
+
+    const CScript own_script{GetScriptForRawPubKey(test.coinbaseKey.GetPubKey())};
+    CKey external_key;
+    external_key.MakeNewKey(/*fCompressed=*/true);
+    const CScript external_script{GetScriptForDestination(PKHash(external_key.GetPubKey()))};
+
+    auto make_owned_input = [&test](size_t index) { return COutPoint{test.m_coinbase_txns.at(index)->GetHash(), 0}; };
+    auto input_amount = [&test](size_t index) { return test.m_coinbase_txns.at(index)->vout.at(0).nValue; };
+
+    const CAmount registration_fee{1000};
+    const CAmount service_fee{2000};
+    const CAmount registrar_fee{3000};
+    const CAmount revoke_fee{4000};
+
+    const CTransactionRef registration{MakeSpecialTransaction(TRANSACTION_PROVIDER_REGISTER, make_owned_input(0),
+                                                              input_amount(0) - registration_fee, own_script)};
+    const CTransactionRef update_service{MakeSpecialTransaction(TRANSACTION_PROVIDER_UPDATE_SERVICE, make_owned_input(1),
+                                                                input_amount(1) - service_fee, own_script)};
+    const CTransactionRef update_registrar{MakeSpecialTransaction(TRANSACTION_PROVIDER_UPDATE_REGISTRAR,
+                                                                  make_owned_input(2), input_amount(2) - registrar_fee,
+                                                                  external_script)};
+    const CTransactionRef update_revoke{MakeSpecialTransaction(TRANSACTION_PROVIDER_UPDATE_REVOKE, make_owned_input(3),
+                                                               input_amount(3) - revoke_fee, own_script)};
+    const CTransactionRef other_special_tx{
+        MakeSpecialTransaction(TRANSACTION_ASSET_LOCK, make_owned_input(4), input_amount(4) - 5000, own_script)};
+
+    std::vector<ExpectedRecord> expected{
+        {registration->GetHash(), TransactionRecord::MasternodeRegistration, -registration_fee,
+         QString{"Masternode Registration"}, QString{"Registers a masternode"}},
+        {update_service->GetHash(), TransactionRecord::MasternodeUpdate, -service_fee, QString{"Masternode Update"},
+         QString{"Updates an existing masternode"}},
+        // A provider transaction with an external output reports the complete wallet delta, not
+        // just the fee or an arbitrary output amount.
+        {update_registrar->GetHash(), TransactionRecord::MasternodeUpdate, -input_amount(2),
+         QString{"Masternode Update"}, QString{"Updates an existing masternode"}},
+        {update_revoke->GetHash(), TransactionRecord::MasternodeUpdate, -revoke_fee, QString{"Masternode Update"},
+         QString{"Updates an existing masternode"}},
+    };
+
+    for (const CTransactionRef& tx : {registration, update_service, update_registrar, update_revoke, other_special_tx}) {
+        QVERIFY(wallet->AddToWallet(tx, TxStateInactive{}) != nullptr);
+    }
+
+    OptionsModel options_model{m_node};
+    bilingual_str error;
+    QVERIFY(options_model.Init(error));
+    ClientModel client_model{m_node, &options_model};
+
+    {
+        WalletModel wallet_model{interfaces::MakeWallet(context, wallet), client_model};
+        TransactionTableModel* const model{wallet_model.getTransactionTableModel()};
+
+        // Transactions loaded before the model is constructed exercise the wallet-restart path.
+        CheckProviderRecords(*model, expected);
+        const std::vector<int> registrar_rows{FindTransactionRows(*model, update_registrar->GetHash())};
+        QCOMPARE(registrar_rows.size(), size_t{1});
+        const QString registrar_description{
+            model->index(registrar_rows.front(), 0).data(TransactionTableModel::LongDescriptionRole).toString()};
+        const QString registrar_summary{registrar_description.section("<hr>", 0, 0)};
+        const QString external_address{QString::fromStdString(EncodeDestination(PKHash(external_key.GetPubKey())))};
+        QVERIFY(!registrar_summary.contains(external_address));
+
+        const std::vector<int> other_rows{FindTransactionRows(*model, other_special_tx->GetHash())};
+        QCOMPARE(other_rows.size(), size_t{1});
+        QCOMPARE(model->index(other_rows.front(), 0).data(TransactionTableModel::TypeRole).toInt(),
+                 static_cast<int>(TransactionRecord::SendToSelf));
+        QCOMPARE(model->index(other_rows.front(), TransactionTableModel::Type).data(Qt::DisplayRole).toString(),
+                 QString{"Payment to yourself"});
+
+        // Add an externally funded registration after model construction to exercise live wallet
+        // notification. Its owned output is the wallet's positive net change and still yields one
+        // logical registration record rather than one record per output.
+        const CAmount received_collateral{1000 * COIN};
+        const CTransactionRef received_registration{MakeSpecialTransaction(TRANSACTION_PROVIDER_REGISTER,
+                                                                           COutPoint{uint256::ONE, 7},
+                                                                           received_collateral, own_script)};
+        QVERIFY(wallet->AddToWallet(received_registration, TxStateInactive{}) != nullptr);
+        QTRY_COMPARE_WITH_TIMEOUT(FindTransactionRows(*model, received_registration->GetHash()).size(), size_t{1}, 5000);
+        expected.push_back({received_registration->GetHash(), TransactionRecord::MasternodeRegistration,
+                            received_collateral, QString{"Masternode Registration"}, QString{"Registers a masternode"}});
+        CheckProviderRecords(*model, expected);
+
+        const quint32 masternode_filter{TransactionFilterProxy::TYPE(TransactionRecord::MasternodeRegistration) |
+                                        TransactionFilterProxy::TYPE(TransactionRecord::MasternodeUpdate)};
+        TransactionFilterProxy filter;
+        filter.setSourceModel(model);
+        filter.setTypeFilter(masternode_filter);
+        QCOMPARE(filter.rowCount(), static_cast<int>(expected.size()));
+
+#if defined(Q_OS_MACOS)
+        if (QApplication::platformName() == "minimal") {
+            QWARN("Skipping TransactionView checks on macOS with the minimal platform due to QTBUG-49686");
+        } else
+#endif
+        {
+            CoinJoinOptionsRestorer coinjoin_restorer{m_node.coinJoinOptions()};
+            m_node.coinJoinOptions().setEnabled(false);
+
+            TransactionView transaction_view;
+            transaction_view.setModel(&wallet_model);
+
+            QComboBox* const type_widget{FindTransactionTypeWidget(transaction_view)};
+            QVERIFY(type_widget != nullptr);
+            const int masternode_row{type_widget->findText("Masternode")};
+            QCOMPARE(type_widget->itemData(masternode_row).toUInt(), masternode_filter);
+
+            QListView* const type_list{qobject_cast<QListView*>(type_widget->view())};
+            QVERIFY(type_list != nullptr);
+            for (const quint32 coinjoin_filter :
+                 {TransactionFilterProxy::TYPE(TransactionRecord::CoinJoinSend),
+                  TransactionFilterProxy::TYPE(TransactionRecord::CoinJoinMakeCollaterals),
+                  TransactionFilterProxy::TYPE(TransactionRecord::CoinJoinCreateDenominations),
+                  TransactionFilterProxy::TYPE(TransactionRecord::CoinJoinMixing),
+                  TransactionFilterProxy::TYPE(TransactionRecord::CoinJoinCollateralPayment)}) {
+                const int row{type_widget->findData(coinjoin_filter)};
+                QVERIFY(row >= 0);
+                QVERIFY(type_list->isRowHidden(row));
+            }
+            QVERIFY(!type_list->isRowHidden(masternode_row));
+
+            type_widget->setCurrentIndex(masternode_row);
+            transaction_view.chooseType(masternode_row);
+            QTableView* const table{transaction_view.findChild<QTableView*>("transactionView")};
+            QVERIFY(table != nullptr);
+            QCOMPARE(table->model()->rowCount(), static_cast<int>(expected.size()));
+        }
+    }
+
+    // Reconstructing the model must neither lose the classifications nor duplicate their rows.
+    {
+        WalletModel restarted_wallet_model{interfaces::MakeWallet(context, wallet), client_model};
+        CheckProviderRecords(*restarted_wallet_model.getTransactionTableModel(), expected);
+    }
+}
diff --git a/src/qt/test/providertransactiontests.h b/src/qt/test/providertransactiontests.h
new file mode 100644
index 000000000000..8551c5d34dd3
--- /dev/null
+++ b/src/qt/test/providertransactiontests.h
@@ -0,0 +1,33 @@
+// 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.
+
+#ifndef BITCOIN_QT_TEST_PROVIDERTRANSACTIONTESTS_H
+#define BITCOIN_QT_TEST_PROVIDERTRANSACTIONTESTS_H
+
+#include <QObject>
+
+namespace interfaces {
+class Node;
+} // namespace interfaces
+
+class ProviderTransactionTests : public QObject
+{
+    Q_OBJECT
+
+public:
+    explicit ProviderTransactionTests(interfaces::Node& node) :
+        m_node(node)
+    {
+    }
+
+private Q_SLOTS:
+    void transactionTypeSettingCompatibility_data();
+    void transactionTypeSettingCompatibility();
+    void providerTransactionHistory();
+
+private:
+    interfaces::Node& m_node;
+};
+
+#endif // BITCOIN_QT_TEST_PROVIDERTRANSACTIONTESTS_H
diff --git a/src/qt/test/test_main.cpp b/src/qt/test/test_main.cpp
index 466c347c19fb..e7ef807a2d51 100644
--- a/src/qt/test/test_main.cpp
+++ b/src/qt/test/test_main.cpp
@@ -19,6 +19,7 @@
 
 #ifdef ENABLE_WALLET
 #include <qt/test/addressbooktests.h>
+#include <qt/test/providertransactiontests.h>
 #include <qt/test/wallettests.h>
 #endif // ENABLE_WALLET
 
@@ -105,6 +106,9 @@ int main(int argc, char* argv[])
 
     AddressBookTests test6(app.node());
     num_test_failures += QTest::qExec(&test6);
+
+    ProviderTransactionTests provider_transaction_tests(app.node());
+    num_test_failures += QTest::qExec(&provider_transaction_tests);
 #endif
     TrafficGraphDataTests test7;
     num_test_failures += QTest::qExec(&test7);
diff --git a/src/qt/transactiondesc.cpp b/src/qt/transactiondesc.cpp
index 354bc63f9072..7809c4255619 100644
--- a/src/qt/transactiondesc.cpp
+++ b/src/qt/transactiondesc.cpp
@@ -105,30 +105,36 @@ QString TransactionDesc::toHTML(interfaces::Node& node, interfaces::Wallet& wall
     CAmount nCredit = wtx.credit;
     CAmount nDebit = wtx.debit;
     CAmount nNet = nCredit - nDebit;
+    const bool is_masternode_transaction{rec->type == TransactionRecord::MasternodeRegistration ||
+                                         rec->type == TransactionRecord::MasternodeUpdate};
 
     strHTML += "<b>" + tr("Status") + ":</b> " + FormatTxStatus(status, inMempool);
     strHTML += "<br>";
 
     strHTML += "<b>" + tr("Date") + ":</b> " + (nTime ? GUIUtil::dateTimeStr(nTime) : "") + "<br>";
 
+    switch (rec->type) {
+    case TransactionRecord::MasternodeRegistration:
+        strHTML += "<b>" + tr("Type") + ":</b> " + tr("Masternode Registration") + "<br>";
+        break;
+    case TransactionRecord::MasternodeUpdate:
+        strHTML += "<b>" + tr("Type") + ":</b> " + tr("Masternode Update") + "<br>";
+        break;
+    default:
+        break;
+    }
+
     //
     // From
     //
-    if (wtx.is_coinbase)
-    {
+    if (!is_masternode_transaction && wtx.is_coinbase) {
         strHTML += "<b>" + tr("Source") + ":</b> " + tr("Generated") + "<br>";
-    }
-    else if (wtx.is_platform_transfer)
-    {
+    } else if (!is_masternode_transaction && wtx.is_platform_transfer) {
         strHTML += "<b>" + tr("Source") + ":</b> " + tr("Platform Transfer") + "<br>";
-    }
-    else if (wtx.value_map.count("from") && !wtx.value_map["from"].empty())
-    {
+    } else if (!is_masternode_transaction && wtx.value_map.count("from") && !wtx.value_map["from"].empty()) {
         // Online transaction
         strHTML += "<b>" + tr("From") + ":</b> " + GUIUtil::HtmlEscape(wtx.value_map["from"]) + "<br>";
-    }
-    else
-    {
+    } else if (!is_masternode_transaction) {
         // Offline transaction
         if (nNet > 0)
         {
@@ -156,8 +162,7 @@ QString TransactionDesc::toHTML(interfaces::Node& node, interfaces::Wallet& wall
     //
     // To
     //
-    if (wtx.value_map.count("to") && !wtx.value_map["to"].empty())
-    {
+    if (!is_masternode_transaction && wtx.value_map.count("to") && !wtx.value_map["to"].empty()) {
         // Online transaction
         std::string strAddress = wtx.value_map["to"];
         strHTML += "<b>" + tr("To") + ":</b> ";
@@ -172,8 +177,7 @@ QString TransactionDesc::toHTML(interfaces::Node& node, interfaces::Wallet& wall
     //
     // Amount
     //
-    if (wtx.is_coinbase && nCredit == 0)
-    {
+    if (!is_masternode_transaction && wtx.is_coinbase && nCredit == 0) {
         //
         // Coinbase
         //
@@ -186,16 +190,12 @@ QString TransactionDesc::toHTML(interfaces::Node& node, interfaces::Wallet& wall
         else
             strHTML += "(" + tr("not accepted") + ")";
         strHTML += "<br>";
-    }
-    else if (nNet > 0)
-    {
+    } else if (!is_masternode_transaction && nNet > 0) {
         //
         // Credit
         //
         strHTML += "<b>" + tr("Credit") + ":</b> " + BitcoinUnits::formatHtmlWithUnit(unit, nNet) + "<br>";
-    }
-    else
-    {
+    } else if (!is_masternode_transaction) {
         isminetype fAllFromMe = ISMINE_SPENDABLE;
         for (const isminetype mine : wtx.txin_is_mine)
         {
@@ -293,7 +293,9 @@ QString TransactionDesc::toHTML(interfaces::Node& node, interfaces::Wallet& wall
         strHTML += "<br><b>" + tr("Comment") + ":</b><br>" + GUIUtil::HtmlEscape(wtx.value_map["comment"], true) + "<br>";
 
     strHTML += "<b>" + tr("Transaction ID") + ":</b> " + rec->getTxHash() + "<br>";
-    strHTML += "<b>" + tr("Output index") + ":</b> " + QString::number(rec->getOutputIndex()) + "<br>";
+    if (!is_masternode_transaction) {
+        strHTML += "<b>" + tr("Output index") + ":</b> " + QString::number(rec->getOutputIndex()) + "<br>";
+    }
     strHTML += "<b>" + tr("Transaction total size") + ":</b> " + QString::number(wtx.tx->GetTotalSize()) + " bytes<br>";
 
     // Show OP_RETURN payload for this specific output
diff --git a/src/qt/transactionfilterproxy.h b/src/qt/transactionfilterproxy.h
index 271be2541197..c96914ec78c2 100644
--- a/src/qt/transactionfilterproxy.h
+++ b/src/qt/transactionfilterproxy.h
@@ -24,7 +24,8 @@ class TransactionFilterProxy : public QSortFilterProxyModel
 public:
     explicit TransactionFilterProxy(QObject *parent = nullptr);
 
-    /** Types to exclude from common transaction lists (CoinJoin internal transactions and dust) */
+    /** Types to exclude from common transaction lists (CoinJoin internal transactions and dust).
+     *  Masternode transactions remain visible in the default common-transactions view. */
     static constexpr quint32 EXCLUDED_TYPES =
         TransactionTypeToBit(TransactionRecord::CoinJoinCollateralPayment) |
         TransactionTypeToBit(TransactionRecord::CoinJoinCreateDenominations) |
@@ -36,6 +37,8 @@ class TransactionFilterProxy : public QSortFilterProxyModel
     static constexpr quint32 ALL_TYPES = 0xFFFFFFFF;
     /** Type filter bit field (all types except excluded) */
     static constexpr quint32 COMMON_TYPES = ALL_TYPES & ~EXCLUDED_TYPES;
+    static_assert(TransactionRecord::MasternodeUpdate < 32,
+                  "TransactionRecord::Type no longer fits in the quint32 type filter");
 
     static constexpr quint32 TYPE(int type) { return TransactionTypeToBit(type); }
 
diff --git a/src/qt/transactionrecord.cpp b/src/qt/transactionrecord.cpp
index 224c6273181a..6de7beaf0287 100644
--- a/src/qt/transactionrecord.cpp
+++ b/src/qt/transactionrecord.cpp
@@ -6,12 +6,15 @@
 #include <qt/transactionrecord.h>
 
 #include <chain.h>
-#include <interfaces/wallet.h>
 #include <interfaces/node.h>
+#include <interfaces/wallet.h>
+#include <primitives/transaction.h>
 
 #include <wallet/ismine.h>
 
+#include <algorithm>
 #include <cstdint>
+#include <optional>
 
 using wallet::ISMINE_SPENDABLE;
 using wallet::ISMINE_WATCH_ONLY;
@@ -26,6 +29,22 @@ bool TransactionRecord::showTransaction()
     return true;
 }
 
+static std::optional<TransactionRecord::Type> MasternodeRecordType(const CTransaction& tx)
+{
+    if (!tx.IsSpecialTxVersion()) return std::nullopt;
+
+    switch (tx.nType) {
+    case TRANSACTION_PROVIDER_REGISTER:
+        return TransactionRecord::MasternodeRegistration;
+    case TRANSACTION_PROVIDER_UPDATE_SERVICE:
+    case TRANSACTION_PROVIDER_UPDATE_REGISTRAR:
+    case TRANSACTION_PROVIDER_UPDATE_REVOKE:
+        return TransactionRecord::MasternodeUpdate;
+    default:
+        return std::nullopt;
+    }
+}
+
 /*
  * Decompose CWallet transaction to model transaction records.
  */
@@ -39,6 +58,18 @@ QList<TransactionRecord> TransactionRecord::decomposeTransaction(interfaces::Nod
     CAmount nNet = nCredit - nDebit;
     uint256 hash = wtx.tx->GetHash();
     std::map<std::string, std::string> mapValue = wtx.value_map;
+
+    if (const auto mn_type = MasternodeRecordType(*wtx.tx)) {
+        TransactionRecord record(hash, nTime, *mn_type, /*_strAddress=*/"", std::min<CAmount>(nNet, 0),
+                                 std::max<CAmount>(nNet, 0));
+        record.involvesWatchAddress = std::any_of(wtx.txin_is_mine.begin(), wtx.txin_is_mine.end(),
+                                                  [](const isminetype mine) { return mine & ISMINE_WATCH_ONLY; }) ||
+                                      std::any_of(wtx.txout_is_mine.begin(), wtx.txout_is_mine.end(),
+                                                  [](const isminetype mine) { return mine & ISMINE_WATCH_ONLY; });
+        parts.append(record);
+        return parts;
+    }
+
     auto& coinJoinOptions = node.coinJoinOptions();
 
     // Check if any inputs belong to this wallet (for dust detection)
diff --git a/src/qt/transactionrecord.h b/src/qt/transactionrecord.h
index 0546f60f1597..c526b1ca2b3b 100644
--- a/src/qt/transactionrecord.h
+++ b/src/qt/transactionrecord.h
@@ -70,7 +70,8 @@ struct TransactionStatus {
 class TransactionRecord
 {
 public:
-    // Update EXCLUDED_TYPES in TransactionFilterProxy when adding a new type
+    // Update EXCLUDED_TYPES in TransactionFilterProxy when adding a new type.
+    // Append new types so existing values remain stable as type-filter bit positions.
     enum Type
     {
         Other,
@@ -89,6 +90,10 @@ class TransactionRecord
         PlatformTransfer,
         DustReceive,
         DataTransaction,
+        /// ProRegTx that registers a regular or Evo masternode
+        MasternodeRegistration,
+        /// ProUpServTx, ProUpRegTx, or ProUpRevTx for an existing masternode
+        MasternodeUpdate,
     };
 
     /** Number of confirmation recommended for accepting a transaction */
diff --git a/src/qt/transactiontablemodel.cpp b/src/qt/transactiontablemodel.cpp
index dae027036468..d0b67efa4aac 100644
--- a/src/qt/transactiontablemodel.cpp
+++ b/src/qt/transactiontablemodel.cpp
@@ -437,6 +437,10 @@ QString TransactionTableModel::formatTxType(const TransactionRecord *wtx) const
         return tr("Data Transaction");
     case TransactionRecord::DustReceive:
         return tr("Dust Receive");
+    case TransactionRecord::MasternodeRegistration:
+        return tr("Masternode Registration");
+    case TransactionRecord::MasternodeUpdate:
+        return tr("Masternode Update");
 
     case TransactionRecord::CoinJoinMixing:
         return tr("%1 Mixing").arg(QString::fromStdString(gCoinJoinName));
@@ -492,6 +496,8 @@ QString TransactionTableModel::formatTxToAddress(const TransactionRecord *wtx, b
     case TransactionRecord::CoinJoinMakeCollaterals:
     case TransactionRecord::CoinJoinCreateDenominations:
     case TransactionRecord::DataTransaction:
+    case TransactionRecord::MasternodeRegistration:
+    case TransactionRecord::MasternodeUpdate:
     case TransactionRecord::Other:
         break; // use fail-over here
     } // no default case, so the compiler can warn about missing cases
@@ -521,6 +527,8 @@ QVariant TransactionTableModel::addressColor(const TransactionRecord *wtx) const
     case TransactionRecord::CoinJoinMakeCollaterals:
     case TransactionRecord::CoinJoinCollateralPayment:
     case TransactionRecord::DataTransaction:
+    case TransactionRecord::MasternodeRegistration:
+    case TransactionRecord::MasternodeUpdate:
         return GUIUtil::getThemedQColor(GUIUtil::ThemedColor::BAREADDRESS);
     case TransactionRecord::SendToOther:
     case TransactionRecord::RecvFromOther:
@@ -564,6 +572,8 @@ QVariant TransactionTableModel::amountColor(const TransactionRecord *rec) const
     case TransactionRecord::CoinJoinMakeCollaterals:
     case TransactionRecord::CoinJoinCreateDenominations:
     case TransactionRecord::DustReceive:
+    case TransactionRecord::MasternodeRegistration:
+    case TransactionRecord::MasternodeUpdate:
         return GUIUtil::getThemedQColor(GUIUtil::ThemedColor::ORANGE);
     }
     return GUIUtil::getThemedQColor(GUIUtil::ThemedColor::DEFAULT);
@@ -618,6 +628,18 @@ QString TransactionTableModel::formatTooltip(const TransactionRecord *rec) const
     {
         tooltip += QString(" ") + formatTxToAddress(rec, true);
     }
+    switch (rec->type) {
+    case TransactionRecord::MasternodeRegistration:
+        tooltip += QString("\n") + tr("Registers a masternode. The amount is this wallet's net balance change and is "
+                                      "normally only the network fee when the collateral remains in this wallet.");
+        break;
+    case TransactionRecord::MasternodeUpdate:
+        tooltip += QString("\n") + tr("Updates an existing masternode registration. The amount is this wallet's net "
+                                      "balance change, normally only the network fee.");
+        break;
+    default:
+        break;
+    }
     return tooltip;
 }
 
diff --git a/src/qt/transactionview.cpp b/src/qt/transactionview.cpp
index 19b62418b4f9..bc1d7fe4a8da 100644
--- a/src/qt/transactionview.cpp
+++ b/src/qt/transactionview.cpp
@@ -99,6 +99,8 @@ TransactionView::TransactionView(QWidget* parent) :
     typeWidget->addItem(tr("Data Transaction"), TransactionFilterProxy::TYPE(TransactionRecord::DataTransaction));
     typeWidget->addItem(tr("Dust Receive"), TransactionFilterProxy::TYPE(TransactionRecord::DustReceive));
     typeWidget->addItem(tr("Other"), TransactionFilterProxy::TYPE(TransactionRecord::Other));
+    typeWidget->addItem(tr("Masternode"), TransactionFilterProxy::TYPE(TransactionRecord::MasternodeRegistration) |
+                                              TransactionFilterProxy::TYPE(TransactionRecord::MasternodeUpdate));
     typeWidget->setCurrentIndex(settings.value("transactionType").toInt());
 
     hlayout->addWidget(typeWidget);
@@ -790,10 +792,14 @@ void TransactionView::updateCoinJoinVisibility()
     int idx = fEnabled ? 0 : 1;
     chooseType(idx);
     typeWidget->setCurrentIndex(idx);
-    // Hide all CoinJoin related filters
+    // Hide all CoinJoin related filters by value so this stays correct when entries are reordered.
     QListView* typeList = qobject_cast<QListView*>(typeWidget->view());
-    std::vector<int> vecRows{4, 5, 6, 7, 8};
-    for (auto nRow : vecRows) {
-        typeList->setRowHidden(nRow, !fEnabled);
+    for (const quint32 type_filter : {TransactionFilterProxy::TYPE(TransactionRecord::CoinJoinSend),
+                                      TransactionFilterProxy::TYPE(TransactionRecord::CoinJoinMakeCollaterals),
+                                      TransactionFilterProxy::TYPE(TransactionRecord::CoinJoinCreateDenominations),
+                                      TransactionFilterProxy::TYPE(TransactionRecord::CoinJoinMixing),
+                                      TransactionFilterProxy::TYPE(TransactionRecord::CoinJoinCollateralPayment)}) {
+        const int row = typeWidget->findData(type_filter);
+        if (row >= 0) typeList->setRowHidden(row, !fEnabled);
     }
 }
diff --git a/test/util/data/non-backported.txt b/test/util/data/non-backported.txt
index f759bb01a1e1..0ec9dc549236 100644
--- a/test/util/data/non-backported.txt
+++ b/test/util/data/non-backported.txt
@@ -42,6 +42,8 @@ src/qt/masternodelist.*
 src/qt/masternodemodel.*
 src/qt/mnemonicverificationdialog.*
 src/qt/networkwidget.*
+src/qt/test/providertransactiontests.cpp
+src/qt/test/providertransactiontests.h
 src/qt/proposalcreate.*
 src/qt/proposalinfo.*
 src/qt/proposallist.*

From 314a3d537c93d62687e77a41feca3bd71c287a89 Mon Sep 17 00:00:00 2001
From: pasta <pasta@dashboost.org>
Date: Sat, 15 Aug 2026 12:48:11 -0500
Subject: [PATCH 2/2] docs: add release notes for masternode history

---
 doc/release-notes-7595.md | 9 +++++++++
 1 file changed, 9 insertions(+)
 create mode 100644 doc/release-notes-7595.md

diff --git a/doc/release-notes-7595.md b/doc/release-notes-7595.md
new file mode 100644
index 000000000000..deedec190141
--- /dev/null
+++ b/doc/release-notes-7595.md
@@ -0,0 +1,9 @@
+GUI changes
+-----------
+
+- Dash-Qt now labels masternode registration and update transactions in the
+  transaction history as **Masternode Registration** and **Masternode Update**
+  instead of generic "Payment to yourself" rows. A new **Masternode** filter
+  shows only these operations. The amount shown is the transaction's net effect
+  on your wallet (for example, the network fee on a self-funded registration).
+  (#7595)