From cebae5a445567f045517c495691243cd8bebf943 Mon Sep 17 00:00:00 2001
From: pasta <pasta@dashboost.org>
Date: Wed, 19 Aug 2026 05:26:36 -0500
Subject: [PATCH 1/2] feat(qt): add masternode registration and maintenance UI

---
 src/Makefile.qt.include                    |   12 +
 src/Makefile.qttest.include                |    6 +
 src/interfaces/providertx.h                |    2 +
 src/qt/forms/masternodelist.ui             |   10 +
 src/qt/masternodedialogs.cpp               |  721 ++++++++
 src/qt/masternodedialogs.h                 |  222 +++
 src/qt/masternodelist.cpp                  |  100 +-
 src/qt/masternodelist.h                    |    9 +
 src/qt/masternodemodel.cpp                 |   54 +-
 src/qt/masternodemodel.h                   |   25 +-
 src/qt/masternodeoperationrunner.cpp       |  165 ++
 src/qt/masternodeoperationrunner.h         |   70 +
 src/qt/masternodewidgets.cpp               |  347 ++++
 src/qt/masternodewidgets.h                 |  158 ++
 src/qt/masternodewizard.cpp                | 1788 ++++++++++++++++++++
 src/qt/masternodewizard.h                  |  235 +++
 src/qt/res/css/dark.css                    |    8 +-
 src/qt/res/css/general.css                 |   11 +-
 src/qt/res/css/light.css                   |    8 +-
 src/qt/res/css/traditional.css             |   13 +-
 src/qt/test/masternodemaintenancetests.cpp |  529 ++++++
 src/qt/test/masternodemaintenancetests.h   |   40 +
 src/qt/test/masternodewidgettests.cpp      | 1055 ++++++++++++
 src/qt/test/masternodewidgettests.h        |   46 +
 src/qt/test/test_main.cpp                  |    8 +
 test/util/data/non-backported.txt          |    6 +
 26 files changed, 5627 insertions(+), 21 deletions(-)
 create mode 100644 src/qt/masternodedialogs.cpp
 create mode 100644 src/qt/masternodedialogs.h
 create mode 100644 src/qt/masternodeoperationrunner.cpp
 create mode 100644 src/qt/masternodeoperationrunner.h
 create mode 100644 src/qt/masternodewidgets.cpp
 create mode 100644 src/qt/masternodewidgets.h
 create mode 100644 src/qt/masternodewizard.cpp
 create mode 100644 src/qt/masternodewizard.h
 create mode 100644 src/qt/test/masternodemaintenancetests.cpp
 create mode 100644 src/qt/test/masternodemaintenancetests.h
 create mode 100644 src/qt/test/masternodewidgettests.cpp
 create mode 100644 src/qt/test/masternodewidgettests.h

diff --git a/src/Makefile.qt.include b/src/Makefile.qt.include
index 16296207eca1..56ddd8a12156 100644
--- a/src/Makefile.qt.include
+++ b/src/Makefile.qt.include
@@ -71,8 +71,12 @@ QT_MOC_CPP = \
   qt/moc_intro.cpp \
   qt/moc_macdockiconhandler.cpp \
   qt/moc_macnotificationhandler.cpp \
+  qt/moc_masternodedialogs.cpp \
   qt/moc_masternodelist.cpp \
   qt/moc_masternodemodel.cpp \
+  qt/moc_masternodeoperationrunner.cpp \
+  qt/moc_masternodewidgets.cpp \
+  qt/moc_masternodewizard.cpp \
   qt/moc_mnemonicverificationdialog.cpp \
   qt/moc_modaloverlay.cpp \
   qt/moc_networkwidget.cpp \
@@ -158,8 +162,12 @@ BITCOIN_QT_H = \
   qt/macdockiconhandler.h \
   qt/macnotificationhandler.h \
   qt/macos_appnap.h \
+  qt/masternodedialogs.h \
   qt/masternodelist.h \
   qt/masternodemodel.h \
+  qt/masternodeoperationrunner.h \
+  qt/masternodewidgets.h \
+  qt/masternodewizard.h \
   qt/mnemonicverificationdialog.h \
   qt/modaloverlay.h \
   qt/networkstyle.h \
@@ -302,7 +310,11 @@ BITCOIN_QT_WALLET_CPP = \
   qt/createwalletdialog.cpp \
   qt/descriptiondialog.cpp \
   qt/editaddressdialog.cpp \
+  qt/masternodedialogs.cpp \
   qt/masternodelist.cpp \
+  qt/masternodeoperationrunner.cpp \
+  qt/masternodewidgets.cpp \
+  qt/masternodewizard.cpp \
   qt/mnemonicverificationdialog.cpp \
   qt/openuridialog.cpp \
   qt/overviewpage.cpp \
diff --git a/src/Makefile.qttest.include b/src/Makefile.qttest.include
index bcea59d339d8..00401c6340d7 100644
--- a/src/Makefile.qttest.include
+++ b/src/Makefile.qttest.include
@@ -17,12 +17,16 @@ if ENABLE_WALLET
 TEST_QT_MOC_CPP += \
   qt/test/moc_addressbooktests.cpp \
   qt/test/moc_providertransactiontests.cpp \
+  qt/test/moc_masternodewidgettests.cpp \
+  qt/test/moc_masternodemaintenancetests.cpp \
   qt/test/moc_wallettests.cpp
 endif # ENABLE_WALLET
 
 TEST_QT_H = \
   qt/test/addressbooktests.h \
   qt/test/apptests.h \
+  qt/test/masternodemaintenancetests.h \
+  qt/test/masternodewidgettests.h \
   qt/test/optiontests.h \
   qt/test/providertransactiontests.h \
   qt/test/rpcnestedtests.h \
@@ -48,6 +52,8 @@ if ENABLE_WALLET
 qt_test_test_dash_qt_SOURCES += \
   qt/test/addressbooktests.cpp \
   qt/test/providertransactiontests.cpp \
+  qt/test/masternodewidgettests.cpp \
+  qt/test/masternodemaintenancetests.cpp \
   qt/test/wallettests.cpp \
   wallet/test/wallet_test_fixture.cpp
 endif # ENABLE_WALLET
diff --git a/src/interfaces/providertx.h b/src/interfaces/providertx.h
index c9f048efe31d..0561d84a095a 100644
--- a/src/interfaces/providertx.h
+++ b/src/interfaces/providertx.h
@@ -75,6 +75,8 @@ struct ProviderNetInfo {
 };
 
 struct ProviderPayout {
+    static constexpr uint16_t MAX_REWARD{10000};
+
     CTxDestination destination;
     uint16_t reward{0};
 };
diff --git a/src/qt/forms/masternodelist.ui b/src/qt/forms/masternodelist.ui
index 41d519b2095a..ab3c7cdd7b59 100644
--- a/src/qt/forms/masternodelist.ui
+++ b/src/qt/forms/masternodelist.ui
@@ -93,6 +93,16 @@
            </property>
           </widget>
          </item>
+         <item>
+          <widget class="QPushButton" name="btnRegisterMasternode">
+           <property name="toolTip">
+            <string>Register a new masternode or evonode using this wallet</string>
+           </property>
+           <property name="text">
+            <string>Register Masternode…</string>
+           </property>
+          </widget>
+         </item>
         </layout>
        </item>
        <item row="1" column="0">
diff --git a/src/qt/masternodedialogs.cpp b/src/qt/masternodedialogs.cpp
new file mode 100644
index 000000000000..214b23cc6d4a
--- /dev/null
+++ b/src/qt/masternodedialogs.cpp
@@ -0,0 +1,721 @@
+// 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/masternodedialogs.h>
+
+#include <bls/bls.h>
+#include <chainparams.h>
+#include <evo/providertx.h>
+#include <evo/types.h>
+#include <interfaces/node.h>
+#include <interfaces/wallet.h>
+#include <key_io.h>
+#include <script/standard.h>
+#include <support/cleanse.h>
+#include <uint256.h>
+#include <util/strencodings.h>
+
+#include <qt/guiutil.h>
+#include <qt/masternodemodel.h>
+#include <qt/masternodewidgets.h>
+#include <qt/qvalidatedlineedit.h>
+#include <qt/walletmodel.h>
+
+#include <QApplication>
+#include <QComboBox>
+#include <QDialogButtonBox>
+#include <QFormLayout>
+#include <QLabel>
+#include <QLineEdit>
+#include <QMessageBox>
+#include <QPushButton>
+#include <QSizePolicy>
+#include <QSpinBox>
+#include <QStringList>
+#include <QVBoxLayout>
+
+#include <limits>
+#include <optional>
+#include <string>
+#include <utility>
+
+namespace {
+
+bool IsHexString(const QString& text, int length) { return text.size() == length && IsHex(text.toStdString()); }
+
+bool IsValidPlatformNodeId(const QString& text)
+{
+    if (!IsHexString(text, 40)) return false;
+    uint160 platform_node_id;
+    platform_node_id.SetHex(text.toStdString());
+    return !platform_node_id.IsNull();
+}
+
+bool IsNonNullP2PKHAddress(const QString& text)
+{
+    const CTxDestination destination{DecodeDestination(text.trimmed().toStdString())};
+    const auto* key_id{std::get_if<PKHash>(&destination)};
+    return key_id != nullptr && !ToKeyID(*key_id).IsNull();
+}
+
+uint16_t PortOrDefault(const QStringList& endpoints, uint16_t default_port)
+{
+    if (endpoints.isEmpty()) return default_port;
+    uint16_t port{0};
+    std::string host;
+    if (SplitHostPort(endpoints.first().trimmed().toStdString(), port, host) && !host.empty() && port != 0) return port;
+    return default_port;
+}
+
+std::optional<CTxDestination> ParseDestination(const QString& text, QString& error)
+{
+    const CTxDestination destination{DecodeDestination(text.trimmed().toStdString())};
+    if (!IsValidDestination(destination)) {
+        error = QObject::tr("Invalid Dash address: %1").arg(text);
+        return std::nullopt;
+    }
+    return destination;
+}
+
+std::vector<std::string> ToStringVector(const QStringList& entries)
+{
+    std::vector<std::string> result;
+    result.reserve(entries.size());
+    for (const QString& entry : entries)
+        result.push_back(entry.toStdString());
+    return result;
+}
+
+QString ProviderTxErrorText(const interfaces::ProviderTxError& error)
+{
+    QString text{QString::fromStdString(error.message.translated)};
+    if (error.code == interfaces::ProviderTxErrorCode::FUNDING_ERROR) {
+        text = text.isEmpty() ? QObject::tr("The transaction could not be funded.")
+                              : QObject::tr("The transaction could not be funded: %1").arg(text);
+    }
+    const QString reject_reason{QString::fromStdString(error.reject_reason)};
+    if (!reject_reason.isEmpty() && !text.contains(reject_reason)) {
+        text += QObject::tr("\n\nNetwork rejection: %1").arg(reject_reason);
+    }
+    return text;
+}
+
+bool OperatorKeyMatches(const CBLSSecretKey& secret_key, const std::vector<unsigned char>& public_key)
+{
+    return secret_key.IsValid() && !public_key.empty() &&
+           secret_key.GetPublicKey().ToByteVector(/*specificLegacyScheme=*/false) == public_key;
+}
+
+} // anonymous namespace
+
+namespace MasternodeMaintenance {
+
+ActionAvailability actionAvailability(bool can_sign, bool owns_owner_key)
+{
+    return {
+        /*update_service=*/can_sign,
+        /*update_registrar=*/can_sign && owns_owner_key,
+        /*revoke=*/can_sign,
+    };
+}
+
+} // namespace MasternodeMaintenance
+
+OperatorSecretWidget::OperatorSecretWidget(QWidget* parent) :
+    QWidget(parent)
+{
+    m_manual_edit = new QLineEdit(this);
+    m_manual_edit->setEchoMode(QLineEdit::Password);
+    m_manual_edit->setPlaceholderText(tr("Operator BLS secret key (64 hexadecimal characters)"));
+
+    auto* layout{new QVBoxLayout(this)};
+    layout->setContentsMargins(0, 0, 0, 0);
+    layout->addWidget(m_manual_edit);
+    connect(m_manual_edit, &QLineEdit::textChanged, this, &OperatorSecretWidget::changed);
+}
+
+bool OperatorSecretWidget::isValid() const
+{
+    std::string encoded{m_manual_edit->text().trimmed().toStdString()};
+    CBLSSecretKey key;
+    const bool valid{key.SetHexStr(encoded, /*specificLegacyScheme=*/false)};
+    if (!encoded.empty()) memory_cleanse(encoded.data(), encoded.size());
+    return valid;
+}
+
+std::optional<CBLSSecretKey> OperatorSecretWidget::takeSecret()
+{
+    std::string encoded{m_manual_edit->text().trimmed().toStdString()};
+    // QLineEdit does not offer secure storage. Overwrite its visible backing
+    // value before clearing it, and cleanse the explicit byte copy below.
+    m_manual_edit->setText(QString(m_manual_edit->text().size(), QLatin1Char('0')));
+    m_manual_edit->clear();
+
+    CBLSSecretKey key;
+    const bool valid{key.SetHexStr(encoded, /*specificLegacyScheme=*/false)};
+    if (!encoded.empty()) memory_cleanse(encoded.data(), encoded.size());
+    if (!valid) return std::nullopt;
+    return key;
+}
+
+struct MasternodeActionDialog::UnlockHolder {
+    WalletModel::UnlockContext ctx;
+    explicit UnlockHolder(WalletModel& wallet_model) :
+        ctx(wallet_model.requestUnlock())
+    {
+    }
+};
+
+MasternodeActionDialog::MasternodeActionDialog(interfaces::Node& node, WalletModel* wallet_model,
+                                               const MasternodeEntry& entry, QWidget* parent) :
+    QDialog(parent),
+    m_node{node},
+    m_wallet_model{wallet_model},
+    m_protx_hash{entry.proTxHashRaw()},
+    m_operator_pubkey{entry.operatorPubKeyBytes()},
+    m_runner{wallet_model ? new MasternodeOperationRunner(node.evo(), wallet_model->wallet(), this) : nullptr}
+{
+}
+
+MasternodeActionDialog::~MasternodeActionDialog()
+{
+    m_destroying = true;
+    if (m_runner) m_runner->shutdown();
+}
+
+void MasternodeActionDialog::setupUi(const QString& title, const QString& intro, QLayout* form, const QString& ok_text)
+{
+    setWindowTitle(title);
+    setMinimumWidth(650);
+
+    auto* layout{new QVBoxLayout(this)};
+    auto* intro_label{new QLabel(intro, this)};
+    intro_label->setWordWrap(true);
+    layout->addWidget(intro_label);
+
+    auto* protx_label{new QLabel(tr("Masternode: %1").arg(QString::fromStdString(m_protx_hash.ToString())), this)};
+    protx_label->setWordWrap(true);
+    protx_label->setTextInteractionFlags(Qt::TextSelectableByMouse);
+    layout->addWidget(protx_label);
+    layout->addLayout(form);
+
+    m_status_label = new QLabel(this);
+    m_status_label->setWordWrap(true);
+    m_status_label->setStyleSheet(GUIUtil::getThemedStyleQString(GUIUtil::ThemedStyle::TS_ERROR));
+    m_status_label->setVisible(false);
+    layout->addWidget(m_status_label);
+
+    m_button_box = new QDialogButtonBox(QDialogButtonBox::Ok | QDialogButtonBox::Cancel, this);
+    m_ok_button = m_button_box->button(QDialogButtonBox::Ok);
+    m_ok_button->setText(ok_text);
+    if (m_wallet_model == nullptr) {
+        m_ok_button->setToolTip(tr("No wallet is available."));
+    } else if (m_wallet_model->wallet().privateKeysDisabled()) {
+        m_ok_button->setToolTip(tr("This wallet is watch-only and cannot sign transactions."));
+    }
+    connect(m_button_box, &QDialogButtonBox::accepted, this, &MasternodeActionDialog::submit);
+    connect(m_button_box, &QDialogButtonBox::rejected, this, &MasternodeActionDialog::reject);
+    layout->addWidget(m_button_box);
+
+    GUIUtil::updateFonts();
+    validate();
+}
+
+FeeSourcePicker* MasternodeActionDialog::addFeeSourceRow(QFormLayout* form, const QString& automatic_note)
+{
+    auto* picker{new FeeSourcePicker(this)};
+    picker->setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Fixed);
+    picker->setAutomaticOption(tr("Automatic (recommended)"));
+    picker->setWalletModel(m_wallet_model);
+    auto* note{new QLabel(automatic_note, this)};
+    note->setWordWrap(true);
+    auto* box{new QVBoxLayout()};
+    box->addWidget(picker);
+    box->addWidget(note);
+    form->addRow(tr("Fee source:"), box);
+    return picker;
+}
+
+bool MasternodeActionDialog::canSign() const
+{
+    return m_wallet_model != nullptr && !m_wallet_model->wallet().privateKeysDisabled();
+}
+
+void MasternodeActionDialog::setOkValid(bool valid)
+{
+    m_valid = valid;
+    if (m_ok_button) m_ok_button->setEnabled(valid && canSign() && !m_busy);
+}
+
+void MasternodeActionDialog::showError(const QString& message)
+{
+    m_status_label->setText(message);
+    m_status_label->setVisible(true);
+}
+
+void MasternodeActionDialog::clearError()
+{
+    m_status_label->clear();
+    m_status_label->setVisible(false);
+}
+
+void MasternodeActionDialog::abortOperation(const QString& message)
+{
+    m_unlock.reset();
+    setBusy(false);
+    showError(message);
+}
+
+void MasternodeActionDialog::reject()
+{
+    if (m_busy) return;
+    QDialog::reject();
+}
+
+bool MasternodeActionDialog::ensureUnlocked()
+{
+    if (!canSign()) return false;
+    if (!m_unlock) m_unlock = std::make_unique<UnlockHolder>(*m_wallet_model);
+    if (m_unlock->ctx.isValid()) return true;
+    m_unlock.reset();
+    showError(tr("The wallet must be unlocked to create and sign this transaction."));
+    return false;
+}
+
+void MasternodeActionDialog::setBusy(bool busy)
+{
+    if (m_busy == busy) return;
+    m_busy = busy;
+    if (busy) {
+        QApplication::setOverrideCursor(Qt::WaitCursor);
+    } else {
+        QApplication::restoreOverrideCursor();
+    }
+    if (m_button_box) m_button_box->setEnabled(!busy);
+    setOkValid(m_valid);
+}
+
+void MasternodeActionDialog::resolveOperatorKey(OperatorSecretWidget& widget, SecretCallback callback)
+{
+    if (!ensureUnlocked()) return;
+    clearError();
+    setBusy(true);
+
+    auto key{widget.takeSecret()};
+    if (!key) {
+        abortOperation(tr("Enter a valid basic-scheme BLS operator secret key."));
+        return;
+    }
+    if (!OperatorKeyMatches(*key, m_operator_pubkey)) {
+        abortOperation(tr("The operator secret key does not match this masternode's registered public key."));
+        return;
+    }
+    callback(*key);
+}
+
+void MasternodeActionDialog::startSubmission(std::function<bool(MasternodeOperationRunner::SubmissionCallback)> start)
+{
+    if (!m_busy) {
+        if (!ensureUnlocked()) return;
+        clearError();
+        setBusy(true);
+    }
+    if (!start([this](auto result) { finishSubmission(std::move(result)); })) {
+        abortOperation(tr("Another masternode operation is already in progress."));
+    }
+}
+
+void MasternodeActionDialog::finishSubmission(MasternodeOperationRunner::SubmissionResult result)
+{
+    m_unlock.reset();
+    if (m_destroying) {
+        setBusy(false);
+        return;
+    }
+    setBusy(false);
+    if (const auto* error{std::get_if<interfaces::ProviderTxError>(&result)}) {
+        showError(ProviderTxErrorText(*error));
+        return;
+    }
+    const auto& submission{std::get<interfaces::ProviderTxSubmission>(result)};
+    if (!submission.tx) {
+        showError(tr("The operation completed without returning a transaction."));
+        return;
+    }
+    if (!submission.submitted) {
+        showError(tr("The transaction was created but was not sent to the network."));
+        return;
+    }
+    QMessageBox::information(this, windowTitle(),
+                             tr("The transaction was sent successfully.") + "\n\n" +
+                                 tr("Transaction ID: %1").arg(QString::fromStdString(submission.tx->GetHash().ToString())));
+    accept();
+}
+
+UpdateServiceDialog::UpdateServiceDialog(interfaces::Node& node, WalletModel* wallet_model,
+                                         const MasternodeEntry& entry, QWidget* parent) :
+    UpdateServiceDialog(node, wallet_model, entry, node.evo().getProviderTxCapabilities(), parent)
+{
+}
+
+UpdateServiceDialog::UpdateServiceDialog(interfaces::Node& node, WalletModel* wallet_model, const MasternodeEntry& entry,
+                                         interfaces::ProviderTxCapabilities capabilities, QWidget* parent) :
+    MasternodeActionDialog(node, wallet_model, entry, parent),
+    m_type{entry.type()},
+    m_operator_reward_pct{entry.operatorRewardPct()},
+    m_capabilities{capabilities}
+{
+    auto* form{new QFormLayout()};
+    form->setFieldGrowthPolicy(QFormLayout::AllNonFixedFieldsGrow);
+
+    m_addrs_edit = new QLineEdit(this);
+    m_addrs_edit->setText(entry.coreP2PAddresses());
+    m_addrs_edit->setPlaceholderText(tr("IP:PORT, comma-separated for multiple entries"));
+    if (!m_capabilities.extended_addresses) {
+        m_addrs_edit->setToolTip(tr("Multiple addresses require extended provider transactions."));
+    }
+    connect(m_addrs_edit, &QLineEdit::textChanged, this, &UpdateServiceDialog::validate);
+    form->addRow(m_capabilities.extended_addresses ? tr("Service addresses:") : tr("Service address:"), m_addrs_edit);
+
+    m_operator_key = new OperatorSecretWidget(this);
+    m_operator_key->setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Fixed);
+    connect(m_operator_key, &OperatorSecretWidget::changed, this, &UpdateServiceDialog::validate);
+    form->addRow(tr("Operator key:"), m_operator_key);
+
+    if (m_type == MnType::Evo) {
+        m_platform_node_id_edit = new QLineEdit(this);
+        m_platform_node_id_edit->setText(entry.platformNodeID());
+        m_platform_node_id_edit->setPlaceholderText(tr("Platform node ID (40 hexadecimal characters)"));
+        connect(m_platform_node_id_edit, &QLineEdit::textChanged, this, &UpdateServiceDialog::validate);
+        form->addRow(tr("Platform node ID:"), m_platform_node_id_edit);
+
+        if (m_capabilities.extended_addresses) {
+            m_platform_p2p_edit = new QLineEdit(this);
+            m_platform_p2p_edit->setText(entry.platformP2PAddresses());
+            m_platform_p2p_edit->setPlaceholderText(tr("IP:PORT, comma-separated for multiple entries"));
+            connect(m_platform_p2p_edit, &QLineEdit::textChanged, this, &UpdateServiceDialog::validate);
+            form->addRow(tr("Platform P2P addresses:"), m_platform_p2p_edit);
+
+            m_platform_https_edit = new QLineEdit(this);
+            m_platform_https_edit->setText(entry.platformHTTPSAddresses());
+            m_platform_https_edit->setPlaceholderText(tr("IP:PORT or domain:port, comma-separated"));
+            connect(m_platform_https_edit, &QLineEdit::textChanged, this, &UpdateServiceDialog::validate);
+            form->addRow(tr("Platform HTTPS addresses:"), m_platform_https_edit);
+        } else {
+            const QStringList p2p{entry.platformP2PAddresses().split(',', Qt::SkipEmptyParts)};
+            const QStringList https{entry.platformHTTPSAddresses().split(',', Qt::SkipEmptyParts)};
+            m_platform_p2p_port_edit = new QSpinBox(this);
+            m_platform_p2p_port_edit->setRange(1, std::numeric_limits<uint16_t>::max());
+            m_platform_p2p_port_edit->setValue(PortOrDefault(p2p, Params().GetDefaultPlatformP2PPort()));
+            form->addRow(tr("Platform P2P port:"), m_platform_p2p_port_edit);
+
+            m_platform_https_port_edit = new QSpinBox(this);
+            m_platform_https_port_edit->setRange(1, std::numeric_limits<uint16_t>::max());
+            m_platform_https_port_edit->setValue(PortOrDefault(https, Params().GetDefaultPlatformHTTPPort()));
+            form->addRow(tr("Platform HTTPS port:"), m_platform_https_port_edit);
+        }
+    }
+
+    if (m_operator_reward_pct > 0) {
+        m_operator_payout_edit = new QValidatedLineEdit(this);
+        GUIUtil::setupAddressWidget(m_operator_payout_edit, this);
+        m_operator_payout_edit->setText(entry.operatorPayoutAddress());
+        connect(m_operator_payout_edit, &QLineEdit::textChanged, this, &UpdateServiceDialog::validate);
+        form->addRow(tr("Operator payout address:"), m_operator_payout_edit);
+    }
+
+    m_fee_source = addFeeSourceRow(form, tr("Automatic uses the current operator payout, then the masternode payout. "
+                                            "Select an address only "
+                                            "to override that choice."));
+
+    setupUi(m_type == MnType::Evo ? tr("Update EvoNode Service") : tr("Update Masternode Service"),
+            tr("Update the registered service endpoints. A successful update also revives a PoSe-banned "
+               "masternode. Every current value is prefilled so unchanged fields are preserved."),
+            form, tr("Send Update"));
+}
+
+void UpdateServiceDialog::validate()
+{
+    QString error;
+    bool ok{buildNetInfo(error).has_value()};
+    ok &= m_operator_key->isValid();
+    if (m_operator_payout_edit) {
+        ok &= m_operator_payout_edit->text().trimmed().isEmpty() || m_operator_payout_edit->isValid();
+    }
+    if (m_type == MnType::Evo) {
+        ok &= IsValidPlatformNodeId(m_platform_node_id_edit->text().trimmed());
+    }
+    setOkValid(ok);
+}
+
+std::optional<interfaces::ProviderNetInfo> UpdateServiceDialog::buildNetInfo(QString& error) const
+{
+    interfaces::ProviderNetInfo net_info;
+    net_info.core_p2p = ToStringVector(MasternodeWidgetUtil::tokenizeEndpointList(m_addrs_edit->text()));
+    if (m_type == MnType::Evo) {
+        if (m_capabilities.extended_addresses) {
+            net_info.platform_p2p = ToStringVector(MasternodeWidgetUtil::tokenizeEndpointList(m_platform_p2p_edit->text()));
+            net_info.platform_https = ToStringVector(
+                MasternodeWidgetUtil::tokenizeEndpointList(m_platform_https_edit->text()));
+        } else {
+            net_info.platform_p2p = static_cast<uint16_t>(m_platform_p2p_port_edit->value());
+            net_info.platform_https = static_cast<uint16_t>(m_platform_https_port_edit->value());
+        }
+    }
+    if (const auto validation_error{
+            m_node.evo().validateProviderNetInfo(net_info, m_type, m_capabilities.version, /*optional=*/false)}) {
+        error = ProviderTxErrorText(*validation_error);
+        return std::nullopt;
+    }
+    return net_info;
+}
+
+std::optional<interfaces::ProviderUpdateServiceRequest> UpdateServiceDialog::buildRequest(const CBLSSecretKey& operator_key,
+                                                                                          QString& error) const
+{
+    interfaces::ProviderUpdateServiceRequest request;
+    request.type = m_type;
+    request.pro_tx_hash = m_protx_hash;
+    request.operator_key = operator_key;
+    request.submit = true;
+
+    auto net_info{buildNetInfo(error)};
+    if (!net_info) return std::nullopt;
+    request.net_info = std::move(*net_info);
+
+    if (m_type == MnType::Evo) {
+        const QString platform_node_id_text{m_platform_node_id_edit->text().trimmed()};
+        if (!IsValidPlatformNodeId(platform_node_id_text)) {
+            error = tr("Enter a valid Platform node ID (40 hexadecimal characters).");
+            return std::nullopt;
+        }
+        uint160 platform_node_id;
+        platform_node_id.SetHex(platform_node_id_text.toStdString());
+        request.platform_node_id = platform_node_id;
+    }
+
+    if (m_operator_payout_edit && !m_operator_payout_edit->text().trimmed().isEmpty()) {
+        auto payout{ParseDestination(m_operator_payout_edit->text(), error)};
+        if (!payout) return std::nullopt;
+        request.operator_payout = *payout;
+    }
+    if (const QString fee_source{m_fee_source->selectedAddress()}; !fee_source.isEmpty()) {
+        auto fee{ParseDestination(fee_source, error)};
+        if (!fee) return std::nullopt;
+        request.fee_source = *fee;
+    }
+    return request;
+}
+
+void UpdateServiceDialog::submit()
+{
+    resolveOperatorKey(*m_operator_key, [this](CBLSSecretKey operator_key) {
+        QString error;
+        auto request{buildRequest(operator_key, error)};
+        if (!request) {
+            abortOperation(error);
+            return;
+        }
+        startSubmission([this, request = std::move(*request)](auto callback) mutable {
+            return m_runner->updateMasternodeService(std::move(request), std::move(callback));
+        });
+    });
+}
+
+UpdateRegistrarDialog::UpdateRegistrarDialog(interfaces::Node& node, WalletModel* wallet_model,
+                                             const MasternodeEntry& entry, QWidget* parent) :
+    UpdateRegistrarDialog(node, wallet_model, entry, node.evo().getProviderTxCapabilities(), parent)
+{
+}
+
+UpdateRegistrarDialog::UpdateRegistrarDialog(interfaces::Node& node, WalletModel* wallet_model,
+                                             const MasternodeEntry& entry,
+                                             interfaces::ProviderTxCapabilities capabilities, QWidget* parent) :
+    MasternodeActionDialog(node, wallet_model, entry, parent),
+    m_capabilities{capabilities},
+    m_initial_operator_pubkey{entry.operatorPubKey(m_capabilities.version == ProTxVersion::LegacyBLS)},
+    m_initial_voting{entry.votingAddress()},
+    m_initial_payout{entry.payoutAddresses().size() == 1 ? entry.payoutAddresses().front() : QString{}}
+{
+    auto* form{new QFormLayout()};
+    form->setFieldGrowthPolicy(QFormLayout::AllNonFixedFieldsGrow);
+
+    m_operator_pubkey_edit = new QLineEdit(this);
+    m_operator_pubkey_edit->setText(m_initial_operator_pubkey);
+    m_operator_pubkey_edit->setPlaceholderText(tr("Operator BLS public key (96 hexadecimal characters)"));
+    connect(m_operator_pubkey_edit, &QLineEdit::textChanged, this, &UpdateRegistrarDialog::validate);
+    form->addRow(tr("Operator public key:"), m_operator_pubkey_edit);
+
+    auto* warning{new QLabel(tr("Changing the operator key immediately PoSe-bans the masternode. The new operator must "
+                                "send an Update "
+                                "Service transaction to revive it."),
+                             this)};
+    warning->setWordWrap(true);
+    warning->setStyleSheet(GUIUtil::getThemedStyleQString(GUIUtil::ThemedStyle::TS_WARNING));
+    form->addRow(warning);
+
+    m_voting_edit = new QValidatedLineEdit(this);
+    GUIUtil::setupAddressWidget(m_voting_edit, this);
+    m_voting_edit->setText(m_initial_voting);
+    connect(m_voting_edit, &QLineEdit::textChanged, this, &UpdateRegistrarDialog::validate);
+    form->addRow(tr("Voting address:"), m_voting_edit);
+
+    m_payout_edit = new QValidatedLineEdit(this);
+    GUIUtil::setupAddressWidget(m_payout_edit, this);
+    m_payout_edit->setText(m_initial_payout);
+    connect(m_payout_edit, &QLineEdit::textChanged, this, &UpdateRegistrarDialog::validate);
+    form->addRow(tr("Payout address:"), m_payout_edit);
+    if (entry.payoutAddresses().size() != 1) {
+        m_payout_edit->setEnabled(false);
+        m_payout_edit->setPlaceholderText(tr("Multiple payout shares are preserved; use the RPC to change them"));
+        m_payout_edit->setToolTip(tr("This dialog cannot safely flatten a multi-payout masternode into one address."));
+    }
+
+    m_fee_source = addFeeSourceRow(form, tr("Automatic uses the masternode's current primary payout address. Select an "
+                                            "address only to "
+                                            "override that choice."));
+
+    setupUi(tr("Update Masternode Registrar"),
+            tr("Update the operator key, voting address, or payout address. All current values are prefilled; "
+               "only changed fields are sent. The owner key must be present in this wallet."),
+            form, tr("Send Update"));
+}
+
+bool UpdateRegistrarDialog::operatorChanged() const
+{
+    return m_operator_pubkey_edit->text().trimmed() != m_initial_operator_pubkey;
+}
+
+bool UpdateRegistrarDialog::votingChanged() const { return m_voting_edit->text().trimmed() != m_initial_voting; }
+
+bool UpdateRegistrarDialog::payoutChanged() const
+{
+    return m_payout_edit->isEnabled() && m_payout_edit->text().trimmed() != m_initial_payout;
+}
+
+void UpdateRegistrarDialog::validate()
+{
+    const QString operator_pubkey{m_operator_pubkey_edit->text().trimmed()};
+    const bool any_change{operatorChanged() || votingChanged() || payoutChanged()};
+    CBLSPublicKey parsed_operator;
+    const bool operator_valid{
+        parsed_operator.SetHexStr(operator_pubkey.toStdString(), m_capabilities.version == ProTxVersion::LegacyBLS)};
+    const bool ok{any_change && operator_valid && IsNonNullP2PKHAddress(m_voting_edit->text()) &&
+                  (!m_payout_edit->isEnabled() || MasternodeWidgetUtil::isP2PKHorP2SHAddress(m_payout_edit->text()))};
+    setOkValid(ok);
+}
+
+std::optional<interfaces::ProviderUpdateRegistrarRequest> UpdateRegistrarDialog::buildRequest(QString& error) const
+{
+    interfaces::ProviderUpdateRegistrarRequest request;
+    request.pro_tx_hash = m_protx_hash;
+    request.use_legacy_bls_scheme = m_capabilities.version == ProTxVersion::LegacyBLS;
+    request.submit = true;
+
+    if (operatorChanged()) {
+        CBLSPublicKey key;
+        const bool legacy{m_capabilities.version == ProTxVersion::LegacyBLS};
+        if (!key.SetHexStr(m_operator_pubkey_edit->text().trimmed().toStdString(), legacy)) {
+            error = tr("Enter a valid operator public key for the current provider-transaction version.");
+            return std::nullopt;
+        }
+        request.operator_key = key;
+    }
+    if (votingChanged()) {
+        const auto destination{ParseDestination(m_voting_edit->text(), error)};
+        const auto* key_id{destination ? std::get_if<PKHash>(&*destination) : nullptr};
+        if (!key_id || ToKeyID(*key_id).IsNull()) {
+            if (error.isEmpty()) error = tr("The voting address must be a key address.");
+            return std::nullopt;
+        }
+        request.voting_key = ToKeyID(*key_id);
+    }
+    if (payoutChanged()) {
+        auto payout{ParseDestination(m_payout_edit->text(), error)};
+        if (!payout) return std::nullopt;
+        request.payouts = std::vector<interfaces::ProviderPayout>{{*payout, interfaces::ProviderPayout::MAX_REWARD}};
+        request.uses_extended_payouts = m_capabilities.version >= ProTxVersion::ExtAddr;
+    }
+    if (const QString fee_source{m_fee_source->selectedAddress()}; !fee_source.isEmpty()) {
+        auto fee{ParseDestination(fee_source, error)};
+        if (!fee) return std::nullopt;
+        request.fee_source = *fee;
+    }
+    return request;
+}
+
+void UpdateRegistrarDialog::submit()
+{
+    QString error;
+    auto request{buildRequest(error)};
+    if (!request) {
+        showError(error);
+        return;
+    }
+    startSubmission([this, request = std::move(*request)](auto callback) mutable {
+        return m_runner->updateMasternodeRegistrar(std::move(request), std::move(callback));
+    });
+}
+
+RevokeDialog::RevokeDialog(interfaces::Node& node, WalletModel* wallet_model, const MasternodeEntry& entry,
+                           QWidget* parent) :
+    MasternodeActionDialog(node, wallet_model, entry, parent)
+{
+    auto* form{new QFormLayout()};
+    form->setFieldGrowthPolicy(QFormLayout::AllNonFixedFieldsGrow);
+
+    m_reason_combo = new QComboBox(this);
+    m_reason_combo->setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Fixed);
+    m_reason_combo->addItem(tr("Not specified"), CProUpRevTx::REASON_NOT_SPECIFIED);
+    m_reason_combo->addItem(tr("Termination of service"), CProUpRevTx::REASON_TERMINATION_OF_SERVICE);
+    m_reason_combo->addItem(tr("Compromised keys"), CProUpRevTx::REASON_COMPROMISED_KEYS);
+    m_reason_combo->addItem(tr("Change of keys"), CProUpRevTx::REASON_CHANGE_OF_KEYS);
+    form->addRow(tr("Reason:"), m_reason_combo);
+
+    m_operator_key = new OperatorSecretWidget(this);
+    m_operator_key->setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Fixed);
+    connect(m_operator_key, &OperatorSecretWidget::changed, this, &RevokeDialog::validate);
+    form->addRow(tr("Operator key:"), m_operator_key);
+
+    m_fee_source = addFeeSourceRow(form, tr("Automatic uses the current operator payout, then the masternode payout. "
+                                            "Select an address only "
+                                            "to override that choice."));
+
+    setupUi(tr("Revoke Masternode Service"),
+            tr("Revoking clears the service address and PoSe-bans the masternode until its owner changes the "
+               "operator key. The collateral is not affected."),
+            form, tr("Revoke"));
+}
+
+void RevokeDialog::validate() { setOkValid(m_operator_key->isValid()); }
+
+std::optional<interfaces::ProviderRevokeRequest> RevokeDialog::buildRequest(CBLSSecretKey operator_key, QString& error) const
+{
+    interfaces::ProviderRevokeRequest request;
+    request.pro_tx_hash = m_protx_hash;
+    request.operator_key = operator_key;
+    request.reason = static_cast<uint16_t>(m_reason_combo->currentData().toUInt());
+    request.submit = true;
+    if (const QString fee_source{m_fee_source->selectedAddress()}; !fee_source.isEmpty()) {
+        auto fee{ParseDestination(fee_source, error)};
+        if (!fee) return std::nullopt;
+        request.fee_source = *fee;
+    }
+    return request;
+}
+
+void RevokeDialog::submit()
+{
+    resolveOperatorKey(*m_operator_key, [this](CBLSSecretKey operator_key) {
+        QString error;
+        auto request{buildRequest(operator_key, error)};
+        if (!request) {
+            abortOperation(error);
+            return;
+        }
+        startSubmission([this, request = std::move(*request)](auto callback) mutable {
+            return m_runner->revokeMasternode(std::move(request), std::move(callback));
+        });
+    });
+}
diff --git a/src/qt/masternodedialogs.h b/src/qt/masternodedialogs.h
new file mode 100644
index 000000000000..0375d5d9bbd5
--- /dev/null
+++ b/src/qt/masternodedialogs.h
@@ -0,0 +1,222 @@
+// 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_MASTERNODEDIALOGS_H
+#define BITCOIN_QT_MASTERNODEDIALOGS_H
+
+#include <evo/dmn_types.h>
+#include <interfaces/providertx.h>
+#include <qt/masternodeoperationrunner.h>
+
+#include <QDialog>
+#include <QString>
+#include <QWidget>
+
+#include <functional>
+#include <memory>
+#include <optional>
+#include <vector>
+
+class FeeSourcePicker;
+class MasternodeEntry;
+class MasternodeMaintenanceTests;
+class QValidatedLineEdit;
+class WalletModel;
+
+namespace interfaces {
+class Node;
+} // namespace interfaces
+
+QT_BEGIN_NAMESPACE
+class QComboBox;
+class QDialogButtonBox;
+class QFormLayout;
+class QLabel;
+class QLayout;
+class QLineEdit;
+class QPushButton;
+class QSpinBox;
+QT_END_NAMESPACE
+
+namespace MasternodeMaintenance {
+
+struct ActionAvailability {
+    bool update_service{false};
+    bool update_registrar{false};
+    bool revoke{false};
+};
+
+//! Centralized context-menu role policy. Operator transactions require manual
+//! secret entry; registrar updates require the owner key.
+ActionAvailability actionAvailability(bool can_sign, bool owns_owner_key);
+
+} // namespace MasternodeMaintenance
+
+//! Manual entry for the registered operator secret. The secret is validated as
+//! a basic-scheme BLS key and matched against the selected masternode before use.
+class OperatorSecretWidget : public QWidget
+{
+    Q_OBJECT
+
+public:
+    explicit OperatorSecretWidget(QWidget* parent = nullptr);
+
+    bool isValid() const;
+    //! Parse the entered key and immediately clear the password field and the
+    //! temporary encoded buffer. Returns nullopt for malformed input.
+    std::optional<CBLSSecretKey> takeSecret();
+
+Q_SIGNALS:
+    void changed();
+
+private:
+    QLineEdit* m_manual_edit;
+};
+
+//! Shared asynchronous scaffolding for typed provider-maintenance operations.
+class MasternodeActionDialog : public QDialog
+{
+    Q_OBJECT
+
+    friend class MasternodeMaintenanceTests;
+
+public Q_SLOTS:
+    void reject() override;
+
+protected:
+    using SecretCallback = std::function<void(CBLSSecretKey)>;
+
+    MasternodeActionDialog(interfaces::Node& node, WalletModel* wallet_model, const MasternodeEntry& entry,
+                           QWidget* parent);
+    ~MasternodeActionDialog() override;
+
+    void setupUi(const QString& title, const QString& intro, QLayout* form, const QString& ok_text);
+    FeeSourcePicker* addFeeSourceRow(QFormLayout* form, const QString& automatic_note);
+
+    bool canSign() const;
+    void setOkValid(bool valid);
+    void showError(const QString& message);
+    void clearError();
+    void abortOperation(const QString& message);
+    void resolveOperatorKey(OperatorSecretWidget& widget, SecretCallback callback);
+    void startSubmission(std::function<bool(MasternodeOperationRunner::SubmissionCallback)> start);
+
+    interfaces::Node& m_node;
+    WalletModel* const m_wallet_model;
+    const uint256 m_protx_hash;
+    const std::vector<unsigned char> m_operator_pubkey;
+    MasternodeOperationRunner* const m_runner;
+
+protected Q_SLOTS:
+    virtual void validate() = 0;
+    virtual void submit() = 0;
+
+private:
+    struct UnlockHolder;
+
+    bool ensureUnlocked();
+    void finishSubmission(MasternodeOperationRunner::SubmissionResult result);
+    void setBusy(bool busy);
+
+    std::unique_ptr<UnlockHolder> m_unlock;
+    QDialogButtonBox* m_button_box{nullptr};
+    QPushButton* m_ok_button{nullptr};
+    QLabel* m_status_label{nullptr};
+    bool m_busy{false};
+    bool m_valid{false};
+    bool m_destroying{false};
+};
+
+class UpdateServiceDialog : public MasternodeActionDialog
+{
+    Q_OBJECT
+
+    friend class MasternodeMaintenanceTests;
+
+public:
+    UpdateServiceDialog(interfaces::Node& node, WalletModel* wallet_model, const MasternodeEntry& entry,
+                        QWidget* parent = nullptr);
+
+protected:
+    void validate() override;
+    void submit() override;
+
+private:
+    UpdateServiceDialog(interfaces::Node& node, WalletModel* wallet_model, const MasternodeEntry& entry,
+                        interfaces::ProviderTxCapabilities capabilities, QWidget* parent);
+    std::optional<interfaces::ProviderNetInfo> buildNetInfo(QString& error) const;
+    std::optional<interfaces::ProviderUpdateServiceRequest> buildRequest(const CBLSSecretKey& operator_key,
+                                                                         QString& error) const;
+
+    const MnType m_type;
+    const uint16_t m_operator_reward_pct;
+    const interfaces::ProviderTxCapabilities m_capabilities;
+
+    QLineEdit* m_addrs_edit{nullptr};
+    OperatorSecretWidget* m_operator_key{nullptr};
+    QLineEdit* m_platform_node_id_edit{nullptr};
+    QLineEdit* m_platform_p2p_edit{nullptr};
+    QLineEdit* m_platform_https_edit{nullptr};
+    QSpinBox* m_platform_p2p_port_edit{nullptr};
+    QSpinBox* m_platform_https_port_edit{nullptr};
+    QValidatedLineEdit* m_operator_payout_edit{nullptr};
+    FeeSourcePicker* m_fee_source{nullptr};
+};
+
+class UpdateRegistrarDialog : public MasternodeActionDialog
+{
+    Q_OBJECT
+
+    friend class MasternodeMaintenanceTests;
+
+public:
+    UpdateRegistrarDialog(interfaces::Node& node, WalletModel* wallet_model, const MasternodeEntry& entry,
+                          QWidget* parent = nullptr);
+
+protected:
+    void validate() override;
+    void submit() override;
+
+private:
+    UpdateRegistrarDialog(interfaces::Node& node, WalletModel* wallet_model, const MasternodeEntry& entry,
+                          interfaces::ProviderTxCapabilities capabilities, QWidget* parent);
+    std::optional<interfaces::ProviderUpdateRegistrarRequest> buildRequest(QString& error) const;
+    bool operatorChanged() const;
+    bool votingChanged() const;
+    bool payoutChanged() const;
+
+    const interfaces::ProviderTxCapabilities m_capabilities;
+    const QString m_initial_operator_pubkey;
+    const QString m_initial_voting;
+    const QString m_initial_payout;
+
+    QLineEdit* m_operator_pubkey_edit{nullptr};
+    QValidatedLineEdit* m_voting_edit{nullptr};
+    QValidatedLineEdit* m_payout_edit{nullptr};
+    FeeSourcePicker* m_fee_source{nullptr};
+};
+
+class RevokeDialog : public MasternodeActionDialog
+{
+    Q_OBJECT
+
+    friend class MasternodeMaintenanceTests;
+
+public:
+    RevokeDialog(interfaces::Node& node, WalletModel* wallet_model, const MasternodeEntry& entry,
+                 QWidget* parent = nullptr);
+
+protected:
+    void validate() override;
+    void submit() override;
+
+private:
+    std::optional<interfaces::ProviderRevokeRequest> buildRequest(CBLSSecretKey operator_key, QString& error) const;
+
+    QComboBox* m_reason_combo{nullptr};
+    OperatorSecretWidget* m_operator_key{nullptr};
+    FeeSourcePicker* m_fee_source{nullptr};
+};
+
+#endif // BITCOIN_QT_MASTERNODEDIALOGS_H
diff --git a/src/qt/masternodelist.cpp b/src/qt/masternodelist.cpp
index fd5d1fa9dbf9..d99c52b4bd4e 100644
--- a/src/qt/masternodelist.cpp
+++ b/src/qt/masternodelist.cpp
@@ -11,6 +11,8 @@
 #include <qt/clientmodel.h>
 #include <qt/descriptiondialog.h>
 #include <qt/guiutil.h>
+#include <qt/masternodedialogs.h>
+#include <qt/masternodewizard.h>
 #include <qt/walletmodel.h>
 
 #include <QApplication>
@@ -19,6 +21,7 @@
 #include <QHeaderView>
 #include <QMetaObject>
 #include <QSettings>
+#include <QSignalBlocker>
 #include <QThread>
 
 #include <set>
@@ -116,8 +119,15 @@ MasternodeList::MasternodeList(QWidget* parent) :
     ui->checkBoxOwned->setEnabled(false);
 
     contextMenuDIP3 = new QMenu(this);
+    contextMenuDIP3->setToolTipsVisible(true);
     contextMenuDIP3->addAction(tr("Copy ProTx Hash"), this, &MasternodeList::copyProTxHash_clicked);
     contextMenuDIP3->addAction(tr("Copy Collateral Outpoint"), this, &MasternodeList::copyCollateralOutpoint_clicked);
+    contextMenuDIP3->addSeparator();
+    m_action_update_service = contextMenuDIP3->addAction(tr("Update Service…"), this, &MasternodeList::onUpdateService);
+    m_action_update_registrar = contextMenuDIP3->addAction(tr("Update Registrar…"), this,
+                                                           &MasternodeList::onUpdateRegistrar);
+    m_action_revoke = contextMenuDIP3->addAction(tr("Revoke…"), this, &MasternodeList::onRevoke);
+    contextMenuDIP3->addSeparator();
 
     QMenu* filterMenu = contextMenuDIP3->addMenu(tr("Filter by"));
     filterMenu->addAction(tr("Collateral Address"), this, &MasternodeList::filterByCollateralAddress);
@@ -125,6 +135,10 @@ MasternodeList::MasternodeList(QWidget* parent) :
     filterMenu->addAction(tr("Owner Address"), this, &MasternodeList::filterByOwnerAddress);
     filterMenu->addAction(tr("Voting Address"), this, &MasternodeList::filterByVotingAddress);
 
+    ui->btnRegisterMasternode->setEnabled(false);
+    ui->btnRegisterMasternode->setToolTip(tr("Registering a masternode requires a wallet."));
+    connect(ui->btnRegisterMasternode, &QPushButton::clicked, this, &MasternodeList::showRegisterWizard);
+
     connect(ui->tableViewMasternodes, &QTableView::customContextMenuRequested, this, &MasternodeList::showContextMenuDIP3);
     connect(ui->tableViewMasternodes, &QTableView::doubleClicked, this, &MasternodeList::extraInfoDIP3_clicked);
     connect(m_proxy_model, &QSortFilterProxyModel::rowsInserted, this, &MasternodeList::updateFilteredCount);
@@ -157,6 +171,7 @@ void MasternodeList::changeEvent(QEvent* event)
 void MasternodeList::setClientModel(ClientModel* model)
 {
     this->clientModel = model;
+    updateRegistrationAvailability();
     if (!clientModel) {
         return;
     }
@@ -171,17 +186,98 @@ void MasternodeList::setWalletModel(WalletModel* model)
 {
     this->walletModel = model;
     ui->checkBoxOwned->setEnabled(walletModel != nullptr);
+    updateRegistrationAvailability();
     if (walletModel) {
         QSettings settings;
         ui->checkBoxOwned->setChecked(settings.value("mnListOwnedOnly", false).toBool());
+    } else {
+        const QSignalBlocker blocker{ui->checkBoxOwned};
+        ui->checkBoxOwned->setChecked(false);
+        m_proxy_model->setShowOwnedOnly(false);
+        m_proxy_model->setMyMasternodeHashes({});
+        m_proxy_model->forceInvalidateFilter();
+        updateFilteredCount();
+    }
+}
+
+void MasternodeList::updateRegistrationAvailability()
+{
+    const bool can_register{clientModel != nullptr && walletModel != nullptr &&
+                            !walletModel->wallet().privateKeysDisabled()};
+    ui->btnRegisterMasternode->setEnabled(can_register);
+    if (walletModel == nullptr) {
+        ui->btnRegisterMasternode->setToolTip(tr("Registering a masternode requires a wallet."));
+    } else if (walletModel->wallet().privateKeysDisabled()) {
+        ui->btnRegisterMasternode->setToolTip(
+            walletModel->wallet().hasExternalSigner() ?
+                tr("Masternode registration does not yet support external-signer wallets.") :
+                tr("Masternode registration requires a wallet with private keys."));
+    } else if (clientModel == nullptr) {
+        ui->btnRegisterMasternode->setToolTip(tr("Masternode registration is unavailable until the node is ready."));
+    } else {
+        ui->btnRegisterMasternode->setToolTip(tr("Register a new masternode or EvoNode using this wallet"));
     }
 }
 
+void MasternodeList::showRegisterWizard()
+{
+    if (!clientModel || !walletModel || walletModel->wallet().privateKeysDisabled()) return;
+    RegisterMasternodeWizard dlg(clientModel->node(), walletModel, this);
+    dlg.exec();
+}
+
 void MasternodeList::showContextMenuDIP3(const QPoint& point)
 {
     QModelIndex index = ui->tableViewMasternodes->indexAt(point);
-    if (index.isValid()) {
-        contextMenuDIP3->exec(QCursor::pos());
+    if (!index.isValid()) return;
+    ui->tableViewMasternodes->setCurrentIndex(index);
+    ui->tableViewMasternodes->selectRow(index.row());
+
+    const auto* entry{GetSelectedEntry()};
+    const bool can_sign{walletModel != nullptr && !walletModel->wallet().privateKeysDisabled()};
+    const bool owns_owner_key{entry != nullptr && can_sign &&
+                              walletModel->wallet().isSpendable(PKHash(entry->keyIdOwnerRaw()))};
+    const auto availability{MasternodeMaintenance::actionAvailability(can_sign, owns_owner_key)};
+
+    m_action_update_service->setEnabled(availability.update_service);
+    m_action_update_service->setToolTip(
+        availability.update_service ? QString{} : tr("Requires a wallet capable of signing transactions"));
+    m_action_update_registrar->setEnabled(availability.update_registrar);
+    m_action_update_registrar->setToolTip(
+        availability.update_registrar ? QString{} : tr("Requires this masternode's owner key in the wallet"));
+    m_action_revoke->setEnabled(availability.revoke);
+    m_action_revoke->setToolTip(availability.revoke ? QString{} : tr("Requires a wallet capable of signing transactions"));
+    contextMenuDIP3->exec(QCursor::pos());
+}
+
+const MasternodeEntry* MasternodeList::selectedEntryForDialog()
+{
+    const auto* entry{GetSelectedEntry()};
+    return entry != nullptr && clientModel != nullptr && walletModel != nullptr ? entry : nullptr;
+}
+
+void MasternodeList::onUpdateService()
+{
+    if (const auto* entry{selectedEntryForDialog()}) {
+        UpdateServiceDialog dialog(clientModel->node(), walletModel, *entry, this);
+        dialog.exec();
+    }
+}
+
+void MasternodeList::onUpdateRegistrar()
+{
+    if (const auto* entry{selectedEntryForDialog()};
+        entry != nullptr && walletModel->wallet().isSpendable(PKHash(entry->keyIdOwnerRaw()))) {
+        UpdateRegistrarDialog dialog(clientModel->node(), walletModel, *entry, this);
+        dialog.exec();
+    }
+}
+
+void MasternodeList::onRevoke()
+{
+    if (const auto* entry{selectedEntryForDialog()}) {
+        RevokeDialog dialog(clientModel->node(), walletModel, *entry, this);
+        dialog.exec();
     }
 }
 
diff --git a/src/qt/masternodelist.h b/src/qt/masternodelist.h
index ffbd4fb8fe09..4ce40115e091 100644
--- a/src/qt/masternodelist.h
+++ b/src/qt/masternodelist.h
@@ -89,11 +89,16 @@ class MasternodeList : public QWidget
     MasternodeListSortFilterProxyModel* m_proxy_model{nullptr};
     MasternodeModel* m_model{nullptr};
     QMenu* contextMenuDIP3{nullptr};
+    QAction* m_action_update_service{nullptr};
+    QAction* m_action_update_registrar{nullptr};
+    QAction* m_action_revoke{nullptr};
     WalletModel* walletModel{nullptr};
 
     void setMasternodeList(MasternodeData&& data, QSet<QString>&& owned_mns);
+    void updateRegistrationAvailability();
 
     const MasternodeEntry* GetSelectedEntry();
+    const MasternodeEntry* selectedEntryForDialog();
 
 Q_SIGNALS:
     void doubleClicked(const QModelIndex&);
@@ -101,6 +106,7 @@ class MasternodeList : public QWidget
 private Q_SLOTS:
     void copyCollateralOutpoint_clicked();
     void copyProTxHash_clicked();
+    void showRegisterWizard();
     void extraInfoDIP3_clicked();
     void filterByCollateralAddress();
     void filterByOwnerAddress();
@@ -110,6 +116,9 @@ private Q_SLOTS:
     void on_checkBoxOwned_stateChanged(int state);
     void on_comboBoxType_currentIndexChanged(int index);
     void on_filterText_textChanged(const QString& strFilterIn);
+    void onRevoke();
+    void onUpdateRegistrar();
+    void onUpdateService();
     void showContextMenuDIP3(const QPoint&);
     void updateFilteredCount();
     void updateMasternodeList();
diff --git a/src/qt/masternodemodel.cpp b/src/qt/masternodemodel.cpp
index a99e754a0dc8..a5db721ba113 100644
--- a/src/qt/masternodemodel.cpp
+++ b/src/qt/masternodemodel.cpp
@@ -4,7 +4,9 @@
 
 #include <qt/masternodemodel.h>
 
+#include <bls/bls.h>
 #include <chainparams.h>
+#include <evo/types.h>
 #include <interfaces/node.h>
 #include <key_io.h>
 #include <pubkey.h>
@@ -25,14 +27,14 @@
 namespace {
 std::optional<QString> JoinArray(const UniValue& arr)
 {
-    if (!arr.isArray() || arr.empty()) return std::nullopt;
+    if (!arr.isArray()) return std::nullopt;
     QStringList list;
     for (size_t i = 0; i < arr.size(); ++i) {
         if (arr[i].isStr()) {
             list << QString::fromStdString(arr[i].get_str());
         }
     }
-    return list.isEmpty() ? std::nullopt : std::optional<QString>(list.join(", "));
+    return list.join(", ");
 }
 } // anonymous namespace
 
@@ -48,13 +50,16 @@ MasternodeEntry::MasternodeEntry(const interfaces::MnEntryCPtr& dmn, const QStri
     m_collateral_outpoint{QString::fromStdString(dmn->getCollateralOutpoint().ToStringShort())},
     m_owner_address{QString::fromStdString(EncodeDestination(PKHash(dmn->getKeyIdOwner())))},
     m_protx_hash{QString::fromStdString(dmn->getProTxHash().ToString())},
-    m_service{QString::fromStdString(dmn->getNetInfoPrimary().ToStringAddrPort())},
     m_type_description{QString::fromStdString(std::string(GetMnType(dmn->getType()).description))},
     m_voting_address{QString::fromStdString(EncodeDestination(PKHash(dmn->getKeyIdVoting())))},
     m_operator_reward_pct{dmn->getOperatorReward()}
 {
-    auto addr_key = dmn->getNetInfoPrimary().GetKey();
-    m_service_key = QByteArray(reinterpret_cast<const char*>(addr_key.data()), addr_key.size());
+    const CService primary_service{dmn->getNetInfoPrimary()};
+    if (primary_service.IsValid()) {
+        m_service = QString::fromStdString(primary_service.ToStringAddrPort());
+        const auto addr_key{primary_service.GetKey()};
+        m_service_key = QByteArray(reinterpret_cast<const char*>(addr_key.data()), addr_key.size());
+    }
 
     QStringList payout_addresses;
     for (const auto& script_payout : dmn->getScriptPayouts()) {
@@ -62,14 +67,18 @@ MasternodeEntry::MasternodeEntry(const interfaces::MnEntryCPtr& dmn, const QStri
             payout_addresses << QString::fromStdString(EncodeDestination(dest));
         }
     }
+    m_payout_addresses = payout_addresses;
     m_payout_address = payout_addresses.isEmpty() ? QObject::tr("UNKNOWN") : payout_addresses.join(", ");
 
+    if (CTxDestination operator_destination; ExtractDestination(dmn->getScriptOperatorPayout(), operator_destination)) {
+        m_operator_payout_address = QString::fromStdString(EncodeDestination(operator_destination));
+    }
+
     if (m_operator_reward_pct) {
         m_operator_reward = QString::number(m_operator_reward_pct / 100.0, 'f', 2) + "%";
         if (dmn->getScriptOperatorPayout() != CScript()) {
-            CTxDestination operatorDest;
-            if (ExtractDestination(dmn->getScriptOperatorPayout(), operatorDest)) {
-                m_operator_reward += " " + QObject::tr("to %1").arg(QString::fromStdString(EncodeDestination(operatorDest)));
+            if (!m_operator_payout_address.isEmpty()) {
+                m_operator_reward += " " + QObject::tr("to %1").arg(m_operator_payout_address);
             } else {
                 m_operator_reward += " " + QObject::tr("to UNKNOWN");
             }
@@ -90,6 +99,9 @@ MasternodeEntry::MasternodeEntry(const interfaces::MnEntryCPtr& dmn, const QStri
         m_collateral_index = val.getInt<int32_t>();
     }
     if (const auto& state = json.find_value("state"); state.isObject()) {
+        if (const auto& val = state.find_value("version"); val.isNum()) {
+            m_operator_legacy_scheme = val.getInt<int>() == ProTxVersion::LegacyBLS;
+        }
         if (const auto& val = state.find_value("consecutivePayments"); val.isNum()) {
             m_consecutive_payments = val.getInt<int32_t>();
         }
@@ -115,6 +127,26 @@ MasternodeEntry::MasternodeEntry(const interfaces::MnEntryCPtr& dmn, const QStri
 
 MasternodeEntry::~MasternodeEntry() = default;
 
+QString MasternodeEntry::operatorPubKey(bool legacy_scheme) const
+{
+    CBLSPublicKey key;
+    if (!m_pub_key_operator ||
+        !key.SetHexStr(m_pub_key_operator->toStdString(), /*specificLegacyScheme=*/m_operator_legacy_scheme)) {
+        return {};
+    }
+    return key.IsValid() ? QString::fromStdString(key.ToString(legacy_scheme)) : QString{};
+}
+
+std::vector<unsigned char> MasternodeEntry::operatorPubKeyBytes() const
+{
+    CBLSPublicKey key;
+    if (!m_pub_key_operator ||
+        !key.SetHexStr(m_pub_key_operator->toStdString(), /*specificLegacyScheme=*/m_operator_legacy_scheme)) {
+        return {};
+    }
+    return key.ToByteVector(/*specificLegacyScheme=*/false);
+}
+
 QString MasternodeEntry::toHtml() const
 {
     QString ret;
@@ -144,14 +176,14 @@ QString MasternodeEntry::toHtml() const
         ret += "<b>" + QObject::tr("Consecutive Payments") + ":</b> " + QString::number(*m_consecutive_payments) + "<br>";
     }
     ret += "<b>" + QObject::tr("Operator Reward") + ":</b> " + QString::number(m_operator_reward_pct / 100.0, 'f', 2) + "%<br>";
-    if (m_network_addresses) {
+    if (m_network_addresses && !m_network_addresses->isEmpty()) {
         ret += "<b>" + QObject::tr("Network Addresses") + ":</b> " + m_network_addresses->toHtmlEscaped() + "<br>";
     }
 
-    if (m_platform_https_addresses) {
+    if (m_platform_https_addresses && !m_platform_https_addresses->isEmpty()) {
         ret += "<b>" + QObject::tr("Platform HTTPS Addresses") + ":</b> " + m_platform_https_addresses->toHtmlEscaped() + "<br>";
     }
-    if (m_platform_p2p_addresses) {
+    if (m_platform_p2p_addresses && !m_platform_p2p_addresses->isEmpty()) {
         ret += "<b>" + QObject::tr("Platform P2P Addresses") + ":</b> " + m_platform_p2p_addresses->toHtmlEscaped() + "<br>";
     }
     if (m_platform_node_id) {
diff --git a/src/qt/masternodemodel.h b/src/qt/masternodemodel.h
index 9db5bcf2741d..56eb716640c6 100644
--- a/src/qt/masternodemodel.h
+++ b/src/qt/masternodemodel.h
@@ -12,6 +12,7 @@
 #include <QByteArray>
 #include <QIcon>
 #include <QString>
+#include <QStringList>
 
 #include <memory>
 #include <optional>
@@ -33,8 +34,10 @@ class MasternodeEntry
     QString m_collateral_outpoint{};
     QString m_json{};
     QString m_operator_reward{};
+    QString m_operator_payout_address{};
     QString m_owner_address{};
     QString m_payout_address{};
+    QStringList m_payout_addresses{};
     QString m_protx_hash{};
     QString m_service{};
     QString m_type_description{};
@@ -49,10 +52,12 @@ class MasternodeEntry
     std::optional<QString> m_platform_node_id{};
     std::optional<QString> m_platform_p2p_addresses{};
     std::optional<QString> m_pub_key_operator{};
+    bool m_operator_legacy_scheme{false};
     uint16_t m_operator_reward_pct{0};
 
 public:
-    explicit MasternodeEntry(const interfaces::MnEntryCPtr& dmn, const QString& collateral_address, int next_payment_height);
+    explicit MasternodeEntry(const interfaces::MnEntryCPtr& dmn, const QString& collateral_address,
+                             int next_payment_height);
     ~MasternodeEntry();
 
     bool isBanned() const { return m_banned; }
@@ -75,18 +80,34 @@ class MasternodeEntry
     const QString& collateralAddress() const { return m_collateral_address; }
     const QString& collateralOutpoint() const { return m_collateral_outpoint; }
     const QString& operatorReward() const { return m_operator_reward; }
+    const QString& operatorPayoutAddress() const { return m_operator_payout_address; }
     const QString& ownerAddress() const { return m_owner_address; }
     const QString& payoutAddress() const { return m_payout_address; }
+    const QStringList& payoutAddresses() const { return m_payout_addresses; }
     const QString& proTxHash() const { return m_protx_hash; }
     const QString& service() const { return m_service; }
     const QString& toJson() const { return m_json; }
     const QString& typeDescription() const { return m_type_description; }
     const QString& votingAddress() const { return m_voting_address; }
     const uint256& proTxHashRaw() const { return m_dmn->getProTxHash(); }
+    std::vector<unsigned char> operatorPubKeyBytes() const;
+    QString operatorPubKey(bool legacy_scheme = false) const;
+    QString coreP2PAddresses() const { return m_network_addresses.value_or(m_service); }
+    QString platformP2PAddresses() const { return m_platform_p2p_addresses.value_or(QString{}); }
+    QString platformHTTPSAddresses() const { return m_platform_https_addresses.value_or(QString{}); }
+    QString platformNodeID() const { return m_platform_node_id.value_or(QString{}); }
 
     auto toTie() const
     {
-        return std::tie(m_banned, m_last_paid_height, m_next_payment_height, m_pose_penalty, m_service, m_operator_reward_pct);
+        // Cover every mutable field rendered by the table/details dialogs or
+        // consumed by an action dialog. Otherwise reconcile() retains an old
+        // MnEntry after a provider update and subsequent edits can overwrite
+        // newer network, payout, voting, or Platform state.
+        return std::tie(m_banned, m_last_paid_height, m_next_payment_height, m_pose_penalty, m_consecutive_payments,
+                        m_pose_ban_height, m_pose_revived_height, m_service_key, m_service, m_operator_reward_pct,
+                        m_operator_reward, m_operator_payout_address, m_payout_address, m_payout_addresses,
+                        m_voting_address, m_pub_key_operator, m_operator_legacy_scheme, m_network_addresses,
+                        m_platform_node_id, m_platform_p2p_addresses, m_platform_https_addresses);
     }
     QString toHtml() const;
 };
diff --git a/src/qt/masternodeoperationrunner.cpp b/src/qt/masternodeoperationrunner.cpp
new file mode 100644
index 000000000000..2b3a37c44df8
--- /dev/null
+++ b/src/qt/masternodeoperationrunner.cpp
@@ -0,0 +1,165 @@
+// 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/masternodeoperationrunner.h>
+
+#include <interfaces/node.h>
+#include <interfaces/wallet.h>
+#include <util/threadnames.h>
+#include <util/translation.h>
+
+#include <QMetaObject>
+#include <QThread>
+
+#include <exception>
+#include <mutex>
+#include <optional>
+#include <utility>
+
+MasternodeOperationRunner::MasternodeOperationRunner(interfaces::EVO& evo, interfaces::Wallet& wallet,
+                                                     QObject* parent) :
+    QObject(parent),
+    m_evo(evo),
+    m_wallet(wallet),
+    m_thread(new QThread(this)),
+    m_worker(new QObject())
+{
+    m_worker->moveToThread(m_thread);
+    connect(m_thread, &QThread::finished, m_worker, &QObject::deleteLater);
+    m_thread->start();
+    QMetaObject::invokeMethod(m_worker, [] { util::ThreadRename("qt-providertx"); });
+}
+
+MasternodeOperationRunner::~MasternodeOperationRunner()
+{
+    shutdown();
+}
+
+template <typename Result, typename Operation, typename Callback>
+bool MasternodeOperationRunner::run(Operation operation, Callback callback)
+{
+    Q_ASSERT(QThread::currentThread() == thread());
+    if (m_busy || m_shutdown || !m_thread->isRunning()) return false;
+    m_busy = true;
+    struct SharedResult {
+        std::mutex mutex;
+        std::optional<Result> value;
+    };
+    auto result{std::make_shared<SharedResult>()};
+    m_pending_delivery = [this, result, callback = std::move(callback)]() mutable {
+        std::optional<Result> completed;
+        {
+            const std::lock_guard<std::mutex> lock{result->mutex};
+            if (!result->value) return;
+            completed.emplace(std::move(*result->value));
+            result->value.reset();
+        }
+        m_busy = false;
+        callback(std::move(*completed));
+    };
+    const bool dispatched{QMetaObject::invokeMethod(
+        m_worker, [this, operation = std::move(operation), result]() mutable {
+            std::optional<Result> completed;
+            try {
+                completed.emplace(operation());
+            } catch (const std::exception& e) {
+                completed.emplace(interfaces::ProviderTxError{interfaces::ProviderTxErrorCode::INTERNAL_ERROR,
+                                                              Untranslated(e.what()), {}, std::nullopt});
+            } catch (...) {
+                completed.emplace(interfaces::ProviderTxError{interfaces::ProviderTxErrorCode::INTERNAL_ERROR,
+                                                              Untranslated("provider transaction operation failed"),
+                                                              {}, std::nullopt});
+            }
+            {
+                const std::lock_guard<std::mutex> lock{result->mutex};
+                result->value.emplace(std::move(*completed));
+            }
+            const bool queued{QMetaObject::invokeMethod(this, [this] {
+                auto delivery{std::move(m_pending_delivery)};
+                if (delivery) delivery();
+            })};
+            Q_ASSERT(queued);
+            Q_UNUSED(queued);
+        })};
+    if (!dispatched) {
+        m_pending_delivery = {};
+        m_busy = false;
+        return false;
+    }
+    return true;
+}
+
+void MasternodeOperationRunner::shutdown()
+{
+    Q_ASSERT(QThread::currentThread() == thread());
+    if (m_shutdown) return;
+    m_shutdown = true;
+
+    if (m_thread->isRunning()) {
+        // This blocking call is queued after any pending operation. It keeps
+        // the worker event loop alive until that operation has produced its
+        // result, including when shutdown starts immediately after dispatch.
+        const bool drained{QMetaObject::invokeMethod(m_worker, [] {}, Qt::BlockingQueuedConnection)};
+        Q_ASSERT(drained);
+        Q_UNUSED(drained);
+        m_thread->quit();
+        m_thread->wait();
+    }
+
+    // Move before invocation: the callback may destroy the runner, and the
+    // function object must not erase itself while it is executing.
+    auto delivery{std::move(m_pending_delivery)};
+    if (delivery) delivery();
+}
+
+bool MasternodeOperationRunner::registerMasternode(interfaces::ProviderRegistrationRequest request,
+                                                   SubmissionCallback callback)
+{
+    return run<SubmissionResult>(
+        [this, request = std::move(request)] { return m_evo.registerMasternode(m_wallet, request); },
+        std::move(callback));
+}
+
+bool MasternodeOperationRunner::prepareMasternodeRegistration(interfaces::ProviderRegistrationRequest request,
+                                                              PrepareCallback callback)
+{
+    return run<PrepareResult>(
+        [this, request = std::move(request)] { return m_evo.prepareMasternodeRegistration(m_wallet, request); },
+        std::move(callback));
+}
+
+bool MasternodeOperationRunner::submitMasternodeRegistration(CTransactionRef transaction,
+                                                             std::vector<unsigned char> signature,
+                                                             SubmissionCallback callback)
+{
+    return run<SubmissionResult>(
+        [this, transaction = std::move(transaction), signature = std::move(signature)] {
+            return m_evo.submitMasternodeRegistration(m_wallet, transaction, signature);
+        },
+        std::move(callback));
+}
+
+bool MasternodeOperationRunner::updateMasternodeService(interfaces::ProviderUpdateServiceRequest request,
+                                                        SubmissionCallback callback)
+{
+    return run<SubmissionResult>(
+        [this, request = std::move(request)] { return m_evo.updateMasternodeService(m_wallet, request); },
+        std::move(callback));
+}
+
+bool MasternodeOperationRunner::updateMasternodeRegistrar(interfaces::ProviderUpdateRegistrarRequest request,
+                                                          SubmissionCallback callback)
+{
+    return run<SubmissionResult>(
+        [this, request = std::move(request)] { return m_evo.updateMasternodeRegistrar(m_wallet, request); },
+        std::move(callback));
+}
+
+bool MasternodeOperationRunner::revokeMasternode(interfaces::ProviderRevokeRequest request,
+                                                 SubmissionCallback callback)
+{
+    return run<SubmissionResult>(
+        [this, request = std::move(request)] { return m_evo.revokeMasternode(m_wallet, request); },
+        std::move(callback));
+}
diff --git a/src/qt/masternodeoperationrunner.h b/src/qt/masternodeoperationrunner.h
new file mode 100644
index 000000000000..9fbd9879a57a
--- /dev/null
+++ b/src/qt/masternodeoperationrunner.h
@@ -0,0 +1,70 @@
+// 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_MASTERNODEOPERATIONRUNNER_H
+#define BITCOIN_QT_MASTERNODEOPERATIONRUNNER_H
+
+#include <interfaces/providertx.h>
+
+#include <QObject>
+
+#include <functional>
+#include <memory>
+#include <vector>
+
+namespace interfaces {
+class EVO;
+class Wallet;
+} // namespace interfaces
+
+QT_BEGIN_NAMESPACE
+class QThread;
+QT_END_NAMESPACE
+
+/**
+ * Runs synchronous typed provider-transaction operations away from the GUI
+ * thread. Parsing and presentation remain in the dialog; this class transports
+ * domain requests and results without RPC method names, JSON, or wallet URIs.
+ */
+class MasternodeOperationRunner : public QObject
+{
+    Q_OBJECT
+
+public:
+    using SubmissionResult = interfaces::ProviderTxResult<interfaces::ProviderTxSubmission>;
+    using PrepareResult = interfaces::ProviderTxResult<interfaces::PreparedProviderRegistration>;
+    using SubmissionCallback = std::function<void(SubmissionResult)>;
+    using PrepareCallback = std::function<void(PrepareResult)>;
+
+    MasternodeOperationRunner(interfaces::EVO& evo, interfaces::Wallet& wallet, QObject* parent = nullptr);
+    ~MasternodeOperationRunner() override;
+
+    bool registerMasternode(interfaces::ProviderRegistrationRequest request, SubmissionCallback callback);
+    bool prepareMasternodeRegistration(interfaces::ProviderRegistrationRequest request, PrepareCallback callback);
+    bool submitMasternodeRegistration(CTransactionRef transaction, std::vector<unsigned char> signature,
+                                      SubmissionCallback callback);
+    bool updateMasternodeService(interfaces::ProviderUpdateServiceRequest request, SubmissionCallback callback);
+    bool updateMasternodeRegistrar(interfaces::ProviderUpdateRegistrarRequest request, SubmissionCallback callback);
+    bool revokeMasternode(interfaces::ProviderRevokeRequest request, SubmissionCallback callback);
+
+    bool isBusy() const { return m_busy; }
+    //! Wait for a running operation and synchronously deliver its result on the
+    //! caller thread. Used during owner/app teardown so completion and resource
+    //! ownership cannot disappear with a queued Qt callback.
+    void shutdown();
+
+private:
+    template <typename Result, typename Operation, typename Callback>
+    bool run(Operation operation, Callback callback);
+
+    interfaces::EVO& m_evo;
+    interfaces::Wallet& m_wallet;
+    QThread* const m_thread;
+    QObject* const m_worker;
+    bool m_busy{false};
+    bool m_shutdown{false};
+    std::function<void()> m_pending_delivery;
+};
+
+#endif // BITCOIN_QT_MASTERNODEOPERATIONRUNNER_H
diff --git a/src/qt/masternodewidgets.cpp b/src/qt/masternodewidgets.cpp
new file mode 100644
index 000000000000..069e29976db3
--- /dev/null
+++ b/src/qt/masternodewidgets.cpp
@@ -0,0 +1,347 @@
+// 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/masternodewidgets.h>
+
+#include <bls/bls.h>
+#include <interfaces/wallet.h>
+#include <key_io.h>
+#include <script/standard.h>
+#include <support/cleanse.h>
+#include <util/strencodings.h>
+
+#include <qt/bitcoinunits.h>
+#include <qt/guiutil.h>
+#include <qt/optionsmodel.h>
+#include <qt/qvalidatedlineedit.h>
+#include <qt/walletmodel.h>
+
+#include <QButtonGroup>
+#include <QFrame>
+#include <QHBoxLayout>
+#include <QLabel>
+#include <QPushButton>
+#include <QRadioButton>
+#include <QRegularExpression>
+#include <QVBoxLayout>
+#include <QVariant>
+
+#include <algorithm>
+#include <map>
+#include <string>
+#include <utility>
+#include <variant>
+#include <vector>
+
+namespace MasternodeWidgetUtil {
+
+QStringList tokenizeEndpointList(const QString& input)
+{
+    static const QRegularExpression separator{"[,\\s]+"};
+    return input.split(separator, Qt::SkipEmptyParts);
+}
+
+bool isP2PKHAddress(const QString& address)
+{
+    const CTxDestination dest{DecodeDestination(address.trimmed().toStdString())};
+    return std::holds_alternative<PKHash>(dest);
+}
+
+bool isP2PKHorP2SHAddress(const QString& address)
+{
+    const CTxDestination dest{DecodeDestination(address.trimmed().toStdString())};
+    return std::holds_alternative<PKHash>(dest) || std::holds_alternative<ScriptHash>(dest);
+}
+
+QLabel* makeTitle(const QString& text, QWidget* parent, double point_size)
+{
+    auto* label{new QLabel(text, parent)};
+    label->setWordWrap(true);
+    GUIUtil::setFont({label}, GUIUtil::FontWeight::Bold, point_size);
+    return label;
+}
+
+QLabel* makeHint(const QString& text, QWidget* parent)
+{
+    auto* label{new QLabel(text, parent)};
+    label->setWordWrap(true);
+    label->setStyleSheet(GUIUtil::getThemedStyleQString(GUIUtil::ThemedStyle::TS_SECONDARY));
+    return label;
+}
+
+QLabel* makeValue(const QString& text, QWidget* parent, bool monospace)
+{
+    auto* label{new QLabel(text, parent)};
+    label->setTextFormat(Qt::PlainText);
+    label->setWordWrap(true);
+    label->setTextInteractionFlags(Qt::TextSelectableByMouse);
+    if (monospace) label->setFont(GUIUtil::fixedPitchFont());
+    return label;
+}
+
+QString chunked(const QString& text, int chunk_size)
+{
+    if (chunk_size <= 0) return text;
+    QString ret;
+    ret.reserve(text.size() + text.size() / chunk_size);
+    for (int pos = 0; pos < text.size(); pos += chunk_size) {
+        if (pos > 0) ret += QLatin1Char(' ');
+        ret += text.mid(pos, chunk_size);
+    }
+    return ret;
+}
+
+QWidget* makeCopyableValue(const QString& display, const QString& copy_text, QWidget* parent)
+{
+    auto* row_widget{new QWidget(parent)};
+    auto* row{new QHBoxLayout(row_widget)};
+    row->setContentsMargins(0, 0, 0, 0);
+    row->setSpacing(TITLE_SPACING);
+    auto* value{makeValue(display, row_widget, /*monospace=*/true)};
+    value->setToolTip(copy_text);
+    row->addWidget(value, /*stretch=*/1);
+    auto* copy{new QPushButton(QObject::tr("Copy"), row_widget)};
+    copy->setToolTip(QObject::tr("Copy to clipboard"));
+    QObject::connect(copy, &QPushButton::clicked, copy, [copy_text] { GUIUtil::setClipboard(copy_text); });
+    row->addWidget(copy, /*stretch=*/0, Qt::AlignTop);
+    return row_widget;
+}
+
+QFrame* makeCard(QWidget* parent)
+{
+    auto* card{new QFrame(parent)};
+    card->setObjectName("mnCard");
+    return card;
+}
+
+OptionCard makeOptionCard(QWidget* parent, QWidget* header, const QString& hint)
+{
+    OptionCard ret;
+    ret.card = makeCard(parent);
+    auto* card_layout{new QVBoxLayout(ret.card)};
+    card_layout->setContentsMargins(CARD_PADDING, CARD_PADDING, CARD_PADDING, CARD_PADDING);
+    card_layout->setSpacing(TITLE_SPACING);
+    card_layout->addWidget(header);
+    if (!hint.isEmpty()) {
+        auto* hint_row{new QHBoxLayout()};
+        hint_row->setContentsMargins(BODY_INDENT, 0, 0, 0);
+        hint_row->addWidget(makeHint(hint, ret.card), /*stretch=*/1);
+        card_layout->addLayout(hint_row);
+    }
+    ret.body = new QWidget(ret.card);
+    ret.body_layout = new QVBoxLayout(ret.body);
+    ret.body_layout->setContentsMargins(BODY_INDENT, 0, 0, 0);
+    ret.body_layout->setSpacing(ROW_SPACING);
+    card_layout->addWidget(ret.body);
+    return ret;
+}
+
+} // namespace MasternodeWidgetUtil
+
+FeeSourcePicker::FeeSourcePicker(QWidget* parent) :
+    QComboBox(parent)
+{
+    setSizeAdjustPolicy(QComboBox::AdjustToMinimumContentsLengthWithIcon);
+    setMinimumContentsLength(40);
+}
+
+void FeeSourcePicker::setWalletModel(WalletModel* wallet_model)
+{
+    m_wallet_model = wallet_model;
+    refresh();
+}
+
+void FeeSourcePicker::setAutomaticOption(const QString& label)
+{
+    if (m_automatic_label == label) return;
+    m_automatic_label = label;
+    refresh();
+}
+
+void FeeSourcePicker::setMinimumBalance(CAmount minimum)
+{
+    if (m_minimum_balance == minimum) return;
+    m_minimum_balance = minimum;
+    refresh();
+}
+
+void FeeSourcePicker::setExcludedOutpoint(std::optional<COutPoint> outpoint)
+{
+    if (m_excluded_outpoint == outpoint) return;
+    m_excluded_outpoint = std::move(outpoint);
+    refresh();
+}
+
+void FeeSourcePicker::refresh()
+{
+    clear();
+    if (!m_automatic_label.isEmpty()) addItem(m_automatic_label, QVariant{});
+    if (m_wallet_model == nullptr) return;
+
+    // Group each coin under its own scriptPubKey destination: the RPCs'
+    // FundSpecialTx only selects coins paying exactly the chosen address, while
+    // listCoins() groups change outputs under their parent non-change address,
+    // which would overstate what a protx call can actually spend.
+    std::map<CTxDestination, CAmount> balances;
+    for (const auto& [dest, coins] : m_wallet_model->wallet().listCoins()) {
+        for (const auto& [outpoint, txout] : coins) {
+            if (m_excluded_outpoint && outpoint == *m_excluded_outpoint) continue;
+            if (txout.is_spent || txout.depth_in_main_chain < 0) continue;
+            if (m_wallet_model->wallet().isLockedCoin(outpoint)) continue;
+            if (!m_wallet_model->wallet().isSpendable(txout.txout.scriptPubKey)) continue;
+            CTxDestination coin_dest;
+            if (!ExtractDestination(txout.txout.scriptPubKey, coin_dest)) continue;
+            balances[coin_dest] += txout.txout.nValue;
+        }
+    }
+
+    std::vector<std::pair<QString, CAmount>> entries;
+    for (const auto& [dest, total] : balances) {
+        if (total <= 0 || total < m_minimum_balance) continue;
+        entries.emplace_back(QString::fromStdString(EncodeDestination(dest)), total);
+    }
+    std::sort(entries.begin(), entries.end(),
+              [](const auto& lhs, const auto& rhs) { return lhs.second > rhs.second; });
+
+    const auto unit{m_wallet_model->getOptionsModel()->getDisplayUnit()};
+    for (const auto& [address, balance] : entries) {
+        addItem(QString("%1 (%2)").arg(address, BitcoinUnits::formatWithUnit(unit, balance, /*plussign=*/false,
+                                                                             BitcoinUnits::SeparatorStyle::ALWAYS)),
+                address);
+    }
+    if (count() > 0) setCurrentIndex(0);
+}
+
+QString FeeSourcePicker::selectedAddress() const
+{
+    return currentData().toString();
+}
+
+OperatorKeyWidget::OperatorKeyWidget(QWidget* parent) :
+    QWidget(parent)
+{
+    using namespace MasternodeWidgetUtil;
+
+    // Generate the key pair up front so toggling the radios never discards a
+    // key the user may already have seen.
+    CBLSSecretKey secret_key;
+    secret_key.MakeNewKey();
+    auto generated_secret{secret_key.ToByteVector(/*specificLegacyScheme=*/false)};
+    m_generated_secret.assign(generated_secret.begin(), generated_secret.end());
+    if (!generated_secret.empty()) memory_cleanse(generated_secret.data(), generated_secret.size());
+    m_generated_public = QString::fromStdString(secret_key.GetPublicKey().ToString(/*specificLegacyScheme=*/false));
+
+    m_generate_radio = new QRadioButton(tr("Generate a new operator key"), this);
+    m_generate_radio->setChecked(true);
+    auto generate_card{makeOptionCard(this, m_generate_radio,
+                                      tr("The secret key is shown and confirmed before registering, then kept "
+                                         "nowhere else."))};
+    m_generate_body = generate_card.body;
+    // The key is 96 hex characters: it gets its own full-width line, otherwise it
+    // wraps against the edge of whatever sits beside it
+    generate_card.body_layout->addWidget(makeHint(tr("Public key"), m_generate_body));
+    generate_card.body_layout->addWidget(makeValue(chunked(m_generated_public), m_generate_body,
+                                                   /*monospace=*/true));
+
+    m_existing_radio = new QRadioButton(tr("Use an existing operator public key"), this);
+    auto existing_card{makeOptionCard(this, m_existing_radio,
+                                      tr("For a hosted node: the operator keeps the secret key and gives you the "
+                                         "public key."))};
+    m_existing_body = existing_card.body;
+    m_existing_edit = new QValidatedLineEdit(m_existing_body);
+    m_existing_edit->setPlaceholderText(tr("Operator BLS public key (96 hexadecimal characters, basic scheme)"));
+    m_existing_edit->setEnabled(false);
+    existing_card.body_layout->addWidget(m_existing_edit);
+
+    // The radios live in separate cards, so auto-exclusivity by parent no
+    // longer applies and a button group has to keep them exclusive.
+    auto* group{new QButtonGroup(this)};
+    group->addButton(m_generate_radio);
+    group->addButton(m_existing_radio);
+
+    auto* layout{new QVBoxLayout(this)};
+    layout->setContentsMargins(0, 0, 0, 0);
+    layout->setSpacing(TITLE_SPACING);
+    layout->addWidget(generate_card.card);
+    layout->addWidget(existing_card.card);
+
+    connect(m_generate_radio, &QRadioButton::toggled, this, &OperatorKeyWidget::updateState);
+    connect(m_existing_radio, &QRadioButton::toggled, this, &OperatorKeyWidget::updateState);
+    connect(m_existing_edit, &QLineEdit::textChanged, this, &OperatorKeyWidget::updateState);
+    updateState();
+}
+
+OperatorKeyWidget::~OperatorKeyWidget()
+{
+    clearSecret(m_generated_secret);
+}
+
+void OperatorKeyWidget::updateState()
+{
+    const Mode current{mode()};
+    m_generate_body->setVisible(current == Mode::GenerateOnly);
+    m_existing_body->setVisible(current == Mode::Existing);
+    m_existing_edit->setEnabled(current == Mode::Existing);
+    if (current == Mode::Existing) {
+        const QString text{m_existing_edit->text().trimmed()};
+        // Leave the neutral style while empty; only flag actual invalid input
+        m_existing_edit->setValid(text.isEmpty() || isValid());
+    }
+    Q_EMIT changed();
+}
+
+OperatorKeyWidget::Mode OperatorKeyWidget::mode() const
+{
+    if (m_existing_radio->isChecked()) return Mode::Existing;
+    return Mode::GenerateOnly;
+}
+
+QString OperatorKeyWidget::publicKeyHex() const
+{
+    switch (mode()) {
+    case Mode::GenerateOnly:
+        return m_generated_public;
+    case Mode::Existing:
+        return isValid() ? m_existing_edit->text().trimmed() : QString();
+    }
+    return {};
+}
+
+QString OperatorKeyWidget::secretHex() const
+{
+    switch (mode()) {
+    case Mode::GenerateOnly:
+        return secretDisplay(m_generated_secret);
+    case Mode::Existing:
+        return {};
+    }
+    return {};
+}
+
+QString OperatorKeyWidget::secretDisplay(Span<const unsigned char> secret)
+{
+    std::string encoded{HexStr(secret)};
+    QString display{QString::fromStdString(encoded)};
+    if (!encoded.empty()) memory_cleanse(encoded.data(), encoded.size());
+    return display;
+}
+
+void OperatorKeyWidget::clearSecret(SecureVector& secret)
+{
+    if (!secret.empty()) memory_cleanse(secret.data(), secret.size());
+    secret.clear();
+    secret.shrink_to_fit();
+}
+
+bool OperatorKeyWidget::hasGeneratedSecret() const
+{
+    return mode() == Mode::GenerateOnly;
+}
+
+bool OperatorKeyWidget::isValid() const
+{
+    if (hasGeneratedSecret()) return !m_generated_public.isEmpty();
+    CBLSPublicKey pubkey;
+    return pubkey.SetHexStr(m_existing_edit->text().trimmed().toStdString(), /*specificLegacyScheme=*/false);
+}
diff --git a/src/qt/masternodewidgets.h b/src/qt/masternodewidgets.h
new file mode 100644
index 000000000000..6517a9b37191
--- /dev/null
+++ b/src/qt/masternodewidgets.h
@@ -0,0 +1,158 @@
+// 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_MASTERNODEWIDGETS_H
+#define BITCOIN_QT_MASTERNODEWIDGETS_H
+
+#include <consensus/amount.h>
+#include <primitives/transaction.h>
+#include <support/allocators/secure.h>
+#include <span.h>
+
+#include <QComboBox>
+#include <QString>
+#include <QStringList>
+#include <QWidget>
+
+#include <optional>
+#include <vector>
+
+class QValidatedLineEdit;
+class WalletModel;
+
+QT_BEGIN_NAMESPACE
+class QFrame;
+class QLabel;
+class QRadioButton;
+class QVBoxLayout;
+QT_END_NAMESPACE
+
+//! Free validation and layout helpers shared by the masternode management dialogs
+namespace MasternodeWidgetUtil {
+//! Tokenize a comma/whitespace-separated endpoint list. Syntax, purpose,
+//! routability, port, duplicate and cardinality validation belongs to the
+//! typed provider service so the GUI and transaction builder use one ruleset.
+QStringList tokenizeEndpointList(const QString& input);
+//! True when `address` decodes to a P2PKH destination on the current network
+bool isP2PKHAddress(const QString& address);
+//! True when `address` decodes to a P2PKH or P2SH destination on the current network
+bool isP2PKHorP2SHAddress(const QString& address);
+
+//! Spacing tokens (px) keeping one vertical rhythm across the dialogs' pages
+constexpr int GROUP_SPACING{16}; //!< between top-level groups of a page
+constexpr int TITLE_SPACING{8};  //!< between a group's title and its body
+constexpr int ROW_SPACING{10};   //!< between rows inside a group
+constexpr int BODY_INDENT{26};   //!< indent of a body under its radio header
+constexpr int CARD_PADDING{12};  //!< a card's internal padding
+
+//! Bold label. A negative `point_size` keeps the theme's own size.
+QLabel* makeTitle(const QString& text, QWidget* parent, double point_size = -1);
+//! Dim, word-wrapped explanation
+QLabel* makeHint(const QString& text, QWidget* parent);
+//! Word-wrapped, selectable plain-text value; `monospace` for addresses, hashes and keys
+QLabel* makeValue(const QString& text, QWidget* parent, bool monospace = false);
+//! Group `text` into blocks of `chunk_size` characters separated by spaces. A BLS
+//! key is one 96-character word that a wrapping label refuses to break; grouped,
+//! it wraps between blocks and stays readable.
+QString chunked(const QString& text, int chunk_size = 12);
+//! Monospace value with a Copy button beside it. `display` is shown as given,
+//! `copy_text` is what the button puts on the clipboard, so a key can be shown
+//! in chunks and still be copied unbroken.
+QWidget* makeCopyableValue(const QString& display, const QString& copy_text, QWidget* parent);
+//! Frame grouping one choice or one section, named "mnCard" for theming
+QFrame* makeCard(QWidget* parent);
+
+//! A card presenting one choice: `header` (the radio button) sits on top, the
+//! optional `hint` below it, and `body` holds the controls that only matter
+//! while the choice is selected, so it can be hidden to collapse the card.
+struct OptionCard {
+    QFrame* card;
+    QWidget* body;
+    QVBoxLayout* body_layout;
+};
+//! Build an option card. `header` is re-parented into the card, so radio
+//! buttons of one page need a QButtonGroup to stay mutually exclusive.
+OptionCard makeOptionCard(QWidget* parent, QWidget* header, const QString& hint = QString());
+} // namespace MasternodeWidgetUtil
+
+//! Combo box listing the wallet's addresses with their spendable balance,
+//! largest first. Used to pick the fee source (or funding source) of a protx
+//! operation, defaulting to the address most likely able to pay.
+class FeeSourcePicker : public QComboBox
+{
+    Q_OBJECT
+
+public:
+    explicit FeeSourcePicker(QWidget* parent = nullptr);
+
+    void setWalletModel(WalletModel* wallet_model);
+    //! Add an explicit first option which leaves fee-source selection to Core.
+    //! An empty label removes it. Registration flows do not enable this option.
+    void setAutomaticOption(const QString& label);
+    //! Hide addresses whose spendable balance is below `minimum` (default 0 = show all)
+    void setMinimumBalance(CAmount minimum);
+    //! Omit a collateral outpoint that the registration operation will lock
+    //! before funding its fee transaction.
+    void setExcludedOutpoint(std::optional<COutPoint> outpoint);
+    //! Re-scan the wallet's coins and rebuild the list
+    void refresh();
+
+    QString selectedAddress() const;
+
+private:
+    WalletModel* m_wallet_model{nullptr};
+    CAmount m_minimum_balance{0};
+    QString m_automatic_label;
+    std::optional<COutPoint> m_excluded_outpoint;
+};
+
+//! Operator key selection: generate a fresh basic-scheme BLS key pair or paste
+//! an existing operator public key. A generated secret is kept only in memory
+//! here; the owning dialog is responsible for showing it to the user once.
+class OperatorKeyWidget : public QWidget
+{
+    Q_OBJECT
+
+public:
+    //! Where the operator key comes from and what happens to its secret
+    enum class Mode {
+        GenerateOnly, //!< generated here; the secret exists only in this dialog
+        Existing,     //!< an operator public key supplied by the user
+    };
+
+    explicit OperatorKeyWidget(QWidget* parent = nullptr);
+    ~OperatorKeyWidget() override;
+
+    //! Currently selected mode
+    Mode mode() const;
+    //! Selected operator public key in basic-scheme hex (empty when invalid)
+    QString publicKeyHex() const;
+    //! Generated secret key hex; empty when an existing public key is used. The
+    //! returned QString is a transient display copy; callers must not retain it.
+    QString secretHex() const;
+    //! True when this widget holds the generated operator secret rather than
+    //! only the public key of a secret somebody else keeps
+    bool hasGeneratedSecret() const;
+    //! True when publicKeyHex() returns a usable key
+    bool isValid() const;
+
+Q_SIGNALS:
+    void changed();
+
+private Q_SLOTS:
+    void updateState();
+
+private:
+    static QString secretDisplay(Span<const unsigned char> secret);
+    static void clearSecret(SecureVector& secret);
+    QRadioButton* m_generate_radio{nullptr};
+    QRadioButton* m_existing_radio{nullptr};
+    QWidget* m_generate_body{nullptr};
+    QWidget* m_existing_body{nullptr};
+    QValidatedLineEdit* m_existing_edit{nullptr};
+    SecureVector m_generated_secret;
+    QString m_generated_public;
+};
+
+#endif // BITCOIN_QT_MASTERNODEWIDGETS_H
diff --git a/src/qt/masternodewizard.cpp b/src/qt/masternodewizard.cpp
new file mode 100644
index 000000000000..290282e1ab8e
--- /dev/null
+++ b/src/qt/masternodewizard.cpp
@@ -0,0 +1,1788 @@
+// 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/masternodewizard.h>
+
+#include <chainparams.h>
+#include <evo/dmn_types.h>
+#include <interfaces/node.h>
+#include <interfaces/wallet.h>
+#include <key_io.h>
+#include <primitives/transaction.h>
+#include <script/standard.h>
+#include <util/strencodings.h>
+
+#include <qt/bitcoinunits.h>
+#include <qt/guiutil.h>
+#include <qt/masternodeoperationrunner.h>
+#include <qt/masternodewidgets.h>
+#include <qt/optionsmodel.h>
+#include <qt/qvalidatedlineedit.h>
+#include <qt/sendcoinsdialog.h>
+#include <qt/walletmodel.h>
+
+#include <QButtonGroup>
+#include <QComboBox>
+#include <QDoubleSpinBox>
+#include <QFormLayout>
+#include <QFrame>
+#include <QGridLayout>
+#include <QHBoxLayout>
+#include <QLabel>
+#include <QLayoutItem>
+#include <QLineEdit>
+#include <QMessageBox>
+#include <QPlainTextEdit>
+#include <QProgressBar>
+#include <QPushButton>
+#include <QRadioButton>
+#include <QScrollArea>
+#include <QSpinBox>
+#include <QStackedWidget>
+#include <QVBoxLayout>
+#include <QtMath>
+
+#include <limits>
+#include <set>
+#include <string>
+#include <variant>
+#include <vector>
+
+namespace {
+using MasternodeWidgetUtil::CARD_PADDING;
+using MasternodeWidgetUtil::GROUP_SPACING;
+using MasternodeWidgetUtil::ROW_SPACING;
+using MasternodeWidgetUtil::TITLE_SPACING;
+using MasternodeWidgetUtil::makeCard;
+using MasternodeWidgetUtil::makeOptionCard;
+using MasternodeWidgetUtil::makeValue;
+
+//! Point size of a page heading
+constexpr double PAGE_TITLE_SIZE{14};
+
+std::set<COutPoint> RegisteredCollaterals(interfaces::Wallet& wallet)
+{
+    const auto registered{wallet.listProTxCoins()};
+    return {registered.begin(), registered.end()};
+}
+
+QLabel* MakeTitle(const QString& text, QWidget* parent)
+{
+    return MasternodeWidgetUtil::makeTitle(text, parent, PAGE_TITLE_SIZE);
+}
+
+//! Heading of one block inside a page, in the page's own text size
+QLabel* MakeLabel(const QString& text, QWidget* parent)
+{
+    return MasternodeWidgetUtil::makeTitle(text, parent);
+}
+
+QLabel* MakeHint(const QString& text, QWidget* parent)
+{
+    return MasternodeWidgetUtil::makeHint(text, parent);
+}
+
+//! Vertical layout of a wizard page: the dialog supplies the margins, the page
+//! only keeps the rhythm between its groups.
+QVBoxLayout* MakePageLayout(QWidget* page)
+{
+    auto* layout{new QVBoxLayout(page)};
+    layout->setContentsMargins(0, 0, 0, 0);
+    layout->setSpacing(GROUP_SPACING);
+    return layout;
+}
+
+//! One group inside a page: label, hint and controls sit closer together than
+//! the groups themselves do.
+QVBoxLayout* MakeBlock(QVBoxLayout* page_layout)
+{
+    auto* block{new QVBoxLayout()};
+    block->setSpacing(TITLE_SPACING);
+    page_layout->addLayout(block);
+    return block;
+}
+
+QString FormatAmount(const WalletModel* wallet_model, CAmount amount)
+{
+    const auto unit{wallet_model && wallet_model->getOptionsModel() ?
+                        wallet_model->getOptionsModel()->getDisplayUnit() :
+                        BitcoinUnits::Unit::DASH};
+    return BitcoinUnits::formatWithUnit(unit, amount, /*plussign=*/false, BitcoinUnits::SeparatorStyle::ALWAYS);
+}
+} // anonymous namespace
+
+//! Keeps the wallet unlocked on the GUI thread while a typed provider operation is in
+//! flight. UnlockContext is neither copyable nor movable, so it is constructed
+//! in place from requestUnlock()'s prvalue.
+struct RegisterMasternodeWizard::UnlockHolder
+{
+    WalletModel::UnlockContext ctx;
+    explicit UnlockHolder(WalletModel& wallet_model) :
+        ctx(wallet_model.requestUnlock()) {}
+};
+
+RegisterMasternodeWizard::RegisterMasternodeWizard(interfaces::Node& node, WalletModel* walletModel, QWidget* parent) :
+    QDialog(parent),
+    m_node(node),
+    m_walletModel(walletModel)
+{
+    setWindowTitle(tr("Register Masternode"));
+
+    m_pages = new QStackedWidget(this);
+    // Insertion order must match the Page enum: the enum value doubles as the
+    // stack index.
+    m_pages->insertWidget(PageType, createTypePage());
+    m_pages->insertWidget(PageCollateral, createCollateralPage());
+    m_pages->insertWidget(PageService, createServicePage());
+    m_pages->insertWidget(PageKeys, createKeysPage());
+    m_pages->insertWidget(PagePayout, createPayoutPage());
+    m_pages->insertWidget(PagePlatform, createPlatformPage());
+    m_pages->insertWidget(PageFee, createFeePage());
+    m_pages->insertWidget(PageReview, createReviewPage());
+    m_pages->insertWidget(PageSecret, createSecretPage());
+    m_pages->insertWidget(PageSign, createSignPage());
+    m_pages->insertWidget(PageResult, createResultPage());
+
+    m_progress_label = MakeHint(QString(), this);
+    m_error_label = new QLabel(this);
+    m_error_label->setWordWrap(true);
+    m_error_label->setStyleSheet(GUIUtil::getThemedStyleQString(GUIUtil::ThemedStyle::TS_ERROR));
+    m_error_label->setMinimumHeight(m_error_label->fontMetrics().lineSpacing() * 2);
+
+    m_busy_bar = new QProgressBar(this);
+    m_busy_bar->setRange(0, 0);
+    m_busy_bar->setTextVisible(false);
+    m_busy_bar->setMaximumHeight(4);
+    m_busy_bar->setVisible(false);
+
+    m_back_button = new QPushButton(tr("Back"), this);
+    m_next_button = new QPushButton(tr("Next"), this);
+    m_next_button->setDefault(true);
+    m_cancel_button = new QPushButton(tr("Cancel"), this);
+
+    auto* buttons{new QHBoxLayout()};
+    buttons->addWidget(m_back_button);
+    buttons->addStretch();
+    buttons->addWidget(m_cancel_button);
+    buttons->addWidget(m_next_button);
+
+    // The dialog owns the page margins; the pages themselves use none so the
+    // two do not add up.
+    auto* layout{new QVBoxLayout(this)};
+    layout->setContentsMargins(24, 12, 24, 12);
+    layout->setSpacing(GROUP_SPACING);
+    layout->addWidget(m_progress_label);
+    layout->addWidget(m_pages, /*stretch=*/1);
+    layout->addWidget(m_busy_bar);
+    layout->addWidget(m_error_label);
+    layout->addLayout(buttons);
+
+    connect(m_back_button, &QPushButton::clicked, this, &RegisterMasternodeWizard::onBack);
+    connect(m_next_button, &QPushButton::clicked, this, &RegisterMasternodeWizard::onNext);
+    connect(m_cancel_button, &QPushButton::clicked, this, &RegisterMasternodeWizard::reject);
+
+    const auto edited = [this] { onPageEdited(); };
+    for (QLineEdit* const edit :
+         {static_cast<QLineEdit*>(m_col_address), m_col_txid, m_service_edit, static_cast<QLineEdit*>(m_owner_edit),
+          static_cast<QLineEdit*>(m_voting_edit), static_cast<QLineEdit*>(m_payout_edit), m_platform_nodeid,
+          m_platform_p2p, m_platform_https, m_confirm_edit}) {
+        connect(edit, &QLineEdit::textChanged, this, edited);
+    }
+    connect(m_sig_edit, &QPlainTextEdit::textChanged, this, edited);
+    connect(m_col_utxo_combo, QOverload<int>::of(&QComboBox::currentIndexChanged), this, edited);
+    connect(m_col_vout, QOverload<int>::of(&QSpinBox::valueChanged), this, edited);
+    connect(m_platform_p2p_port, QOverload<int>::of(&QSpinBox::valueChanged), this, edited);
+    connect(m_platform_https_port, QOverload<int>::of(&QSpinBox::valueChanged), this, edited);
+    connect(m_fee_picker, QOverload<int>::of(&QComboBox::currentIndexChanged), this, edited);
+    connect(m_operator_widget, &OperatorKeyWidget::changed, this, [this] {
+        rebuildOrder();
+        onPageEdited();
+    });
+    if (m_walletModel != nullptr) {
+        m_runner = std::make_unique<MasternodeOperationRunner>(m_node.evo(), m_walletModel->wallet(), this);
+    }
+
+    rebuildOrder();
+    enterPage(PageType);
+
+    GUIUtil::disableMacFocusRect(this);
+    GUIUtil::updateFonts();
+    setMinimumSize(700, 560);
+    resize(760, 680);
+}
+
+RegisterMasternodeWizard::~RegisterMasternodeWizard()
+{
+    // Finish and synchronously deliver any backend result before releasing
+    // session-owned state. A prepare may have acquired a coin lock.
+    m_destroying = true;
+    if (m_runner) m_runner->shutdown();
+    m_runner.reset();
+    if (m_prepared_collateral_lock_acquired && m_walletModel != nullptr) {
+        m_walletModel->wallet().unlockCoin(m_prepared_collateral_outpoint);
+    }
+    for (QLineEdit* const edit : {m_secret_edit, m_conf_line_edit, m_confirm_edit}) {
+        edit->setText(QString(edit->text().size(), QLatin1Char('0')));
+        edit->clear();
+    }
+}
+
+QWidget* RegisterMasternodeWizard::createTypePage()
+{
+    auto* page{new QWidget(this)};
+    auto* layout{MakePageLayout(page)};
+    layout->addWidget(MakeTitle(tr("Masternode type"), page));
+
+    m_type_regular = new QRadioButton(
+        tr("Masternode — %1 collateral").arg(FormatAmount(m_walletModel, GetMnType(MnType::Regular).collat_amount)),
+        page);
+    m_type_regular->setChecked(true);
+    auto regular_card{makeOptionCard(page, m_type_regular,
+                                     tr("Provides Core network services and earns regular masternode rewards."))};
+    regular_card.body->setVisible(false);
+    layout->addWidget(regular_card.card);
+
+    m_type_evo = new QRadioButton(
+        tr("EvoNode — %1 collateral").arg(FormatAmount(m_walletModel, GetMnType(MnType::Evo).collat_amount)), page);
+    auto evo_card{makeOptionCard(page, m_type_evo,
+                                 tr("Additionally hosts Dash Platform, has four times the voting weight and earns a "
+                                    "larger share of rewards. Requires a Platform node ID and extra services."))};
+    evo_card.body->setVisible(false);
+    layout->addWidget(evo_card.card);
+    layout->addStretch();
+
+    auto* group{new QButtonGroup(page)};
+    group->addButton(m_type_regular);
+    group->addButton(m_type_evo);
+
+    connect(m_type_regular, &QRadioButton::toggled, this, [this] {
+        setWindowTitle(isEvo() ? tr("Register EvoNode") : tr("Register Masternode"));
+        rebuildOrder();
+        refreshCollateralCandidates();
+        updateProgress();
+    });
+    return page;
+}
+
+QWidget* RegisterMasternodeWizard::createCollateralPage()
+{
+    auto* page{new QWidget(this)};
+    auto* layout{MakePageLayout(page)};
+    layout->addWidget(MakeTitle(tr("Collateral"), page));
+
+    m_col_fund = new QRadioButton(tr("Send collateral from this wallet to a new address"), page);
+    m_col_fund->setChecked(true);
+    auto fund_card{makeOptionCard(page, m_col_fund,
+                                  tr("A single transaction funds the collateral and registers the masternode."))};
+    m_col_fund_box = fund_card.body;
+    {
+        auto* row{new QHBoxLayout()};
+        m_col_address = new QValidatedLineEdit(m_col_fund_box);
+        GUIUtil::setupAddressWidget(m_col_address, this);
+        row->addWidget(m_col_address, /*stretch=*/1);
+        auto* fresh{new QPushButton(tr("Use new address"), m_col_fund_box)};
+        connect(fresh, &QPushButton::clicked, this, [this] {
+            QString err;
+            const QString addr{freshAddress(err)};
+            if (addr.isEmpty()) {
+                showError(err);
+            } else {
+                m_col_address->setText(addr);
+            }
+        });
+        row->addWidget(fresh);
+        fund_card.body_layout->addLayout(row);
+    }
+    layout->addWidget(fund_card.card);
+
+    m_col_wallet = new QRadioButton(tr("Use an existing collateral output of this wallet"), page);
+    auto wallet_card{makeOptionCard(page, m_col_wallet,
+                                    tr("An unspent P2PKH output of exactly the collateral amount, confirmed and not "
+                                       "used by another masternode."))};
+    m_col_wallet_box = wallet_card.body;
+    {
+        m_col_utxo_combo = new QComboBox(m_col_wallet_box);
+        m_col_utxo_combo->setSizeAdjustPolicy(QComboBox::AdjustToMinimumContentsLengthWithIcon);
+        m_col_utxo_combo->setMinimumContentsLength(40);
+        wallet_card.body_layout->addWidget(m_col_utxo_combo);
+        // Empty state of the card: the exact requirement, filled in with the
+        // type's collateral amount by refreshCollateralCandidates().
+        m_col_utxo_none = MakeHint(QString(), m_col_wallet_box);
+        m_col_utxo_none->setVisible(false);
+        wallet_card.body_layout->addWidget(m_col_utxo_none);
+    }
+    layout->addWidget(wallet_card.card);
+
+    m_col_external = new QRadioButton(tr("Reference an external collateral (e.g. hardware wallet)"), page);
+    auto external_card{makeOptionCard(page, m_col_external,
+                                      tr("A confirmed P2PKH output of exactly the collateral amount, held outside "
+                                         "this wallet."))};
+    m_col_external_box = external_card.body;
+    {
+        external_card.body_layout->addWidget(
+            MakeHint(tr("After review you will be asked to sign a message with the collateral key outside this "
+                        "wallet."),
+                     m_col_external_box));
+        auto* outpoint_form{new QFormLayout()};
+        outpoint_form->setFieldGrowthPolicy(QFormLayout::AllNonFixedFieldsGrow);
+        m_col_txid = new QLineEdit(m_col_external_box);
+        m_col_txid->setPlaceholderText(tr("Collateral transaction id (64 hexadecimal characters)"));
+        m_col_txid->setMaxLength(64);
+        outpoint_form->addRow(tr("Transaction ID:"), m_col_txid);
+        m_col_vout = new QSpinBox(m_col_external_box);
+        m_col_vout->setRange(0, 99999);
+        m_col_vout->setToolTip(tr("Output index"));
+        m_col_vout->setMaximumWidth(140);
+        outpoint_form->addRow(tr("Output index:"), m_col_vout);
+        external_card.body_layout->addLayout(outpoint_form);
+    }
+    layout->addWidget(external_card.card);
+    layout->addStretch();
+
+    auto* group{new QButtonGroup(page)};
+    group->addButton(m_col_fund);
+    group->addButton(m_col_wallet);
+    group->addButton(m_col_external);
+
+    const auto update_boxes = [this] {
+        m_col_fund_box->setVisible(m_col_fund->isChecked());
+        m_col_wallet_box->setVisible(m_col_wallet->isChecked());
+        m_col_external_box->setVisible(m_col_external->isChecked());
+        if (m_col_wallet->isChecked()) refreshCollateralCandidates();
+        rebuildOrder();
+    };
+    connect(m_col_fund, &QRadioButton::toggled, this, update_boxes);
+    connect(m_col_wallet, &QRadioButton::toggled, this, update_boxes);
+    connect(m_col_external, &QRadioButton::toggled, this, update_boxes);
+    update_boxes();
+    return page;
+}
+
+QWidget* RegisterMasternodeWizard::createServicePage()
+{
+    auto* page{new QWidget(this)};
+    auto* layout{MakePageLayout(page)};
+    layout->addWidget(MakeTitle(tr("Service addresses"), page));
+    auto* block{MakeBlock(layout)};
+    block->addWidget(MakeHint(tr("Public addresses your masternode will serve the Core P2P network on, separated "
+                                 "by commas or spaces. Each entry must be unique on the network."),
+                              page));
+    m_service_edit = new QLineEdit(page);
+    m_service_edit->setPlaceholderText(QString("1.2.3.4:%1").arg(Params().GetDefaultPort()));
+    block->addWidget(m_service_edit);
+    block->addWidget(MakeHint(tr("May be left empty; the masternode then stays inactive until you send a service "
+                                 "update with an address."),
+                              page));
+    layout->addStretch();
+    return page;
+}
+
+QWidget* RegisterMasternodeWizard::createKeysPage()
+{
+    auto* page{new QWidget(this)};
+    auto* layout{MakePageLayout(page)};
+    layout->addWidget(MakeTitle(tr("Keys"), page));
+
+    auto* scroll{new QScrollArea(page)};
+    scroll->setObjectName("mnWizardScroll");
+    scroll->setWidgetResizable(true);
+    scroll->setFrameShape(QFrame::NoFrame);
+    scroll->setHorizontalScrollBarPolicy(Qt::ScrollBarAlwaysOff);
+    scroll->viewport()->setAutoFillBackground(false);
+    auto* key_container{new QWidget(scroll)};
+    auto* key_layout{MakePageLayout(key_container)};
+    key_layout->setContentsMargins(0, 0, ROW_SPACING, 0);
+
+    // Owner and voting address rows share the "fill in a fresh wallet address"
+    // button, differing only in the field they write to.
+    const auto address_row = [this, key_container](QValidatedLineEdit*& edit) {
+        auto* row{new QHBoxLayout()};
+        edit = new QValidatedLineEdit(key_container);
+        GUIUtil::setupAddressWidget(edit, this);
+        row->addWidget(edit, /*stretch=*/1);
+        auto* fresh{new QPushButton(tr("Use new address"), key_container)};
+        QValidatedLineEdit* const target{edit};
+        connect(fresh, &QPushButton::clicked, this, [this, target] {
+            QString err;
+            const QString addr{freshAddress(err)};
+            if (addr.isEmpty()) {
+                showError(err);
+            } else {
+                target->setText(addr);
+            }
+        });
+        row->addWidget(fresh);
+        return row;
+    };
+
+    auto* owner_block{MakeBlock(key_layout)};
+    owner_block->addWidget(MakeLabel(tr("Owner address"), key_container));
+    owner_block->addWidget(MakeHint(tr("Controls this masternode (P2PKH): its key signs registrar updates. Use "
+                                       "a new address to keep that key in this wallet, or enter an address "
+                                       "controlled by the owner."),
+                                    key_container));
+    owner_block->addLayout(address_row(m_owner_edit));
+
+    auto* voting_block{MakeBlock(key_layout)};
+    voting_block->addWidget(MakeLabel(tr("Voting address"), key_container));
+    voting_block->addWidget(MakeHint(tr("May be delegated (P2PKH). Leave empty to vote with the owner key; use "
+                                        "a new address to keep a separate voting key in this wallet."),
+                                     key_container));
+    voting_block->addLayout(address_row(m_voting_edit));
+    m_voting_edit->setPlaceholderText(tr("Leave empty to use the owner address"));
+
+    auto* operator_block{MakeBlock(key_layout)};
+    operator_block->addWidget(MakeLabel(tr("Operator key"), key_container));
+    operator_block->addWidget(MakeHint(tr("The operator runs the masternode server (BLS); only the public key is "
+                                          "registered on-chain."),
+                                       key_container));
+    m_operator_widget = new OperatorKeyWidget(key_container);
+    operator_block->addWidget(MakeHint(tr("A generated secret key is shown and must be confirmed before registering. "
+                                          "It is not stored in this wallet."),
+                                       key_container));
+    operator_block->addWidget(m_operator_widget);
+    key_layout->addStretch();
+    scroll->setWidget(key_container);
+    layout->addWidget(scroll, /*stretch=*/1);
+    return page;
+}
+
+QWidget* RegisterMasternodeWizard::createPayoutPage()
+{
+    auto* page{new QWidget(this)};
+    auto* layout{MakePageLayout(page)};
+    layout->addWidget(MakeTitle(tr("Payout"), page));
+
+    auto* payout_block{MakeBlock(layout)};
+    payout_block->addWidget(MakeLabel(tr("Payout address"), page));
+    payout_block->addWidget(MakeHint(tr("Receives this masternode's block rewards (P2PKH or P2SH)."), page));
+    auto* payout_row{new QHBoxLayout()};
+    m_payout_edit = new QValidatedLineEdit(page);
+    GUIUtil::setupAddressWidget(m_payout_edit, this);
+    payout_row->addWidget(m_payout_edit, /*stretch=*/1);
+    auto* payout_fresh{new QPushButton(tr("Use new address"), page)};
+    connect(payout_fresh, &QPushButton::clicked, this, [this] {
+        QString err;
+        const QString addr{freshAddress(err)};
+        if (addr.isEmpty()) {
+            showError(err);
+        } else {
+            m_payout_edit->setText(addr);
+        }
+    });
+    payout_row->addWidget(payout_fresh);
+    payout_block->addLayout(payout_row);
+
+    auto* reward_block{MakeBlock(layout)};
+    reward_block->addWidget(MakeLabel(tr("Operator reward"), page));
+    reward_block->addWidget(MakeHint(tr("Share of the reward promised to the operator."), page));
+    m_operator_reward = new QDoubleSpinBox(page);
+    m_operator_reward->setRange(0.0, 100.0);
+    m_operator_reward->setDecimals(2);
+    m_operator_reward->setSuffix(QString::fromUtf8(" %"));
+    m_operator_reward->setMinimumWidth(120);
+    m_operator_reward->setMaximumWidth(160);
+    auto* reward_row{new QHBoxLayout()};
+    reward_row->addWidget(m_operator_reward);
+    reward_row->addStretch();
+    reward_block->addLayout(reward_row);
+    m_reward_warning = MakeHint(tr("The operator will permanently receive this share of all rewards of this "
+                                   "masternode. Leave it at 0 unless you have an agreement with your operator."),
+                                page);
+    m_reward_warning->setStyleSheet(GUIUtil::getThemedStyleQString(GUIUtil::ThemedStyle::TS_WARNING));
+    m_reward_warning->setVisible(false);
+    reward_block->addWidget(m_reward_warning);
+    connect(m_operator_reward, QOverload<double>::of(&QDoubleSpinBox::valueChanged), this,
+            [this](double value) { m_reward_warning->setVisible(value > 0.0); });
+    layout->addStretch();
+    return page;
+}
+
+QWidget* RegisterMasternodeWizard::createPlatformPage()
+{
+    auto* page{new QWidget(this)};
+    auto* layout{MakePageLayout(page)};
+    layout->addWidget(MakeTitle(tr("Platform services"), page));
+
+    auto* nodeid_block{MakeBlock(layout)};
+    nodeid_block->addWidget(MakeLabel(tr("Platform node ID"), page));
+    nodeid_block->addWidget(MakeHint(tr("Derived from the Platform P2P public key (40 hexadecimal characters)."),
+                                     page));
+    m_platform_nodeid = new QLineEdit(page);
+    m_platform_nodeid->setMaxLength(40);
+    m_platform_nodeid->setPlaceholderText(QString("f2dbd9b0a1f541a7c44d34a58674d0262f5feca5"));
+    nodeid_block->addWidget(m_platform_nodeid);
+
+    // Only one of the two cards is ever shown: which one depends on whether v24
+    // is active, and with it on the ProTx version the node will build.
+    {
+        auto card{makeOptionCard(page, MakeLabel(tr("Platform addresses"), page),
+                                 tr("ADDR:PORT entries, separated by commas or spaces."))};
+        m_platform_addr_box = card.card;
+        card.body_layout->addWidget(MakeHint(tr("Platform P2P"), m_platform_addr_box));
+        m_platform_p2p = new QLineEdit(card.body);
+        m_platform_p2p->setPlaceholderText(QString("1.2.3.4:26656"));
+        card.body_layout->addWidget(m_platform_p2p);
+        card.body_layout->addWidget(MakeHint(tr("Platform HTTPS API"), m_platform_addr_box));
+        m_platform_https = new QLineEdit(card.body);
+        m_platform_https->setPlaceholderText(QString("platform.example.org:443"));
+        card.body_layout->addWidget(m_platform_https);
+        layout->addWidget(m_platform_addr_box);
+    }
+
+    {
+        auto card{makeOptionCard(page, MakeLabel(tr("Platform ports"), page),
+                                 tr("Before v24 activation only the Platform ports can be registered; they apply "
+                                    "to the first service address."))};
+        m_platform_port_box = card.card;
+        auto* row{new QHBoxLayout()};
+        row->addWidget(new QLabel(tr("Platform P2P port:"), card.body));
+        m_platform_p2p_port = new QSpinBox(card.body);
+        m_platform_p2p_port->setRange(1, 65535);
+        m_platform_p2p_port->setValue(Params().GetDefaultPlatformP2PPort());
+        row->addWidget(m_platform_p2p_port);
+        row->addSpacing(GROUP_SPACING);
+        row->addWidget(new QLabel(tr("Platform HTTPS port:"), card.body));
+        m_platform_https_port = new QSpinBox(card.body);
+        m_platform_https_port->setRange(1, 65535);
+        m_platform_https_port->setValue(Params().GetDefaultPlatformHTTPPort());
+        row->addWidget(m_platform_https_port);
+        row->addStretch();
+        card.body_layout->addLayout(row);
+        layout->addWidget(m_platform_port_box);
+    }
+    layout->addStretch();
+    return page;
+}
+
+QWidget* RegisterMasternodeWizard::createFeePage()
+{
+    auto* page{new QWidget(this)};
+    auto* layout{MakePageLayout(page)};
+    layout->addWidget(MakeTitle(tr("Fee source"), page));
+    auto* block{MakeBlock(layout)};
+    m_fee_explain = MakeHint(QString(), page);
+    block->addWidget(m_fee_explain);
+    m_fee_picker = new FeeSourcePicker(page);
+    m_fee_picker->setWalletModel(m_walletModel);
+    block->addWidget(m_fee_picker);
+    layout->addStretch();
+    return page;
+}
+
+QWidget* RegisterMasternodeWizard::createReviewPage()
+{
+    auto* page{new QWidget(this)};
+    auto* layout{MakePageLayout(page)};
+    layout->addWidget(MakeTitle(tr("Review"), page));
+    // An EvoNode summary is a third longer than a masternode one, so the review
+    // scrolls instead of squeezing its cards
+    auto* scroll{new QScrollArea(page)};
+    scroll->setObjectName("mnWizardScroll");
+    scroll->setWidgetResizable(true);
+    scroll->setFrameShape(QFrame::NoFrame);
+    scroll->setHorizontalScrollBarPolicy(Qt::ScrollBarAlwaysOff);
+    scroll->viewport()->setAutoFillBackground(false);
+    m_review_container = new QWidget(scroll);
+    m_review_layout = new QVBoxLayout(m_review_container);
+    m_review_layout->setContentsMargins(0, 0, ROW_SPACING, 0);
+    m_review_layout->setSpacing(GROUP_SPACING);
+    m_review_layout->addStretch();
+    scroll->setWidget(m_review_container);
+    layout->addWidget(scroll, /*stretch=*/1);
+    return page;
+}
+
+QWidget* RegisterMasternodeWizard::createSignPage()
+{
+    auto* page{new QWidget(this)};
+    auto* layout{MakePageLayout(page)};
+    layout->addWidget(MakeTitle(tr("Prove collateral ownership"), page));
+    auto* message_block{MakeBlock(layout)};
+    m_sign_address_label = MakeHint(QString(), page);
+    message_block->addWidget(m_sign_address_label);
+    message_block->addWidget(MakeHint(tr("Sign the following message with the collateral key (for example with "
+                                         "your hardware wallet's sign-message feature), then paste the base64 "
+                                         "signature below."),
+                                      page));
+    m_sign_message = new QPlainTextEdit(page);
+    m_sign_message->setReadOnly(true);
+    m_sign_message->setMaximumHeight(90);
+    message_block->addWidget(m_sign_message);
+    auto* copy_row{new QHBoxLayout()};
+    auto* copy_button{new QPushButton(tr("Copy message"), page)};
+    connect(copy_button, &QPushButton::clicked, this,
+            [this] { GUIUtil::setClipboard(m_sign_message->toPlainText()); });
+    copy_row->addWidget(copy_button);
+    copy_row->addStretch();
+    message_block->addLayout(copy_row);
+
+    auto* signature_block{MakeBlock(layout)};
+    signature_block->addWidget(MakeLabel(tr("Signature"), page));
+    m_sig_edit = new QPlainTextEdit(page);
+    m_sig_edit->setPlaceholderText(tr("Paste the base64 signature here"));
+    m_sig_edit->setMaximumHeight(90);
+    signature_block->addWidget(m_sig_edit);
+    layout->addStretch();
+    return page;
+}
+
+QWidget* RegisterMasternodeWizard::createSecretPage()
+{
+    auto* page{new QWidget(this)};
+    auto* layout{MakePageLayout(page)};
+    layout->addWidget(MakeTitle(tr("Save operator key"), page));
+    layout->addWidget(MakeHint(tr("Save this generated key before registering. It is kept nowhere else and cannot "
+                                  "be recovered from the wallet."),
+                               page));
+
+    auto* scroll{new QScrollArea(page)};
+    scroll->setObjectName("mnWizardScroll");
+    scroll->setWidgetResizable(true);
+    scroll->setFrameShape(QFrame::NoFrame);
+    scroll->setHorizontalScrollBarPolicy(Qt::ScrollBarAlwaysOff);
+    scroll->viewport()->setAutoFillBackground(false);
+    auto* secret_container{new QWidget(scroll)};
+    auto* secret_layout{new QVBoxLayout(secret_container)};
+    secret_layout->setContentsMargins(0, 0, ROW_SPACING, 0);
+    secret_layout->setSpacing(GROUP_SPACING);
+
+    auto* secret_box{makeCard(secret_container)};
+    auto* box{new QVBoxLayout(secret_box)};
+    box->setContentsMargins(CARD_PADDING, CARD_PADDING, CARD_PADDING, CARD_PADDING);
+    box->setSpacing(TITLE_SPACING);
+    box->addWidget(MakeLabel(tr("Operator secret key"), secret_box));
+    m_secret_note = MakeHint(tr("Save it now — registration cannot start until you confirm it."), secret_box);
+    m_secret_note->setStyleSheet(GUIUtil::getThemedStyleQString(GUIUtil::ThemedStyle::TS_WARNING));
+    box->addWidget(m_secret_note);
+    m_secret_edit = new QLineEdit(secret_box);
+    m_secret_edit->setReadOnly(true);
+    m_secret_edit->setFont(GUIUtil::fixedPitchFont());
+    box->addWidget(m_secret_edit);
+    box->addWidget(MakeHint(tr("Add this line to dash.conf on your masternode server:"), secret_box));
+    auto* conf_row{new QHBoxLayout()};
+    m_conf_line_edit = new QLineEdit(secret_box);
+    m_conf_line_edit->setReadOnly(true);
+    m_conf_line_edit->setFont(GUIUtil::fixedPitchFont());
+    conf_row->addWidget(m_conf_line_edit, /*stretch=*/1);
+    auto* copy_conf{new QPushButton(tr("Copy"), secret_box)};
+    connect(copy_conf, &QPushButton::clicked, this, [this] { GUIUtil::setClipboard(m_conf_line_edit->text()); });
+    conf_row->addWidget(copy_conf);
+    box->addLayout(conf_row);
+
+    auto* confirm_box{new QWidget(secret_box)};
+    auto* confirm_layout{new QVBoxLayout(confirm_box)};
+    confirm_layout->setContentsMargins(0, 0, 0, 0);
+    confirm_layout->setSpacing(TITLE_SPACING);
+    confirm_layout->addWidget(MakeHint(tr("Type the last 4 characters of the secret key to confirm you saved it "
+                                          "before registering:"),
+                                       confirm_box));
+    m_confirm_edit = new QLineEdit(confirm_box);
+    m_confirm_edit->setMaxLength(4);
+    m_confirm_edit->setMaximumWidth(120);
+    confirm_layout->addWidget(m_confirm_edit);
+    box->addWidget(confirm_box);
+    secret_layout->addWidget(secret_box);
+    secret_layout->addStretch();
+    scroll->setWidget(secret_container);
+    layout->addWidget(scroll, /*stretch=*/1);
+    return page;
+}
+
+QWidget* RegisterMasternodeWizard::createResultPage()
+{
+    auto* page{new QWidget(this)};
+    auto* layout{MakePageLayout(page)};
+    layout->addWidget(MakeTitle(tr("Masternode registered"), page));
+
+    auto* scroll{new QScrollArea(page)};
+    scroll->setObjectName("mnWizardScroll");
+    scroll->setWidgetResizable(true);
+    scroll->setFrameShape(QFrame::NoFrame);
+    scroll->setHorizontalScrollBarPolicy(Qt::ScrollBarAlwaysOff);
+    scroll->viewport()->setAutoFillBackground(false);
+    auto* result_container{new QWidget(scroll)};
+    auto* result_layout{new QVBoxLayout(result_container)};
+    result_layout->setContentsMargins(0, 0, ROW_SPACING, 0);
+    result_layout->setSpacing(GROUP_SPACING);
+
+    // What happened
+    {
+        auto* card{makeCard(result_container)};
+        auto* box{new QVBoxLayout(card)};
+        box->setContentsMargins(CARD_PADDING, CARD_PADDING, CARD_PADDING, CARD_PADDING);
+        box->setSpacing(TITLE_SPACING);
+        m_result_label = MakeHint(QString(), card);
+        box->addWidget(m_result_label);
+        box->addWidget(MakeLabel(tr("Provider transaction hash"), card));
+        m_result_hash = makeValue(QString(), card, /*monospace=*/true);
+        box->addWidget(m_result_hash);
+        m_result_tx_note = MakeHint(QString(), card);
+        box->addWidget(m_result_tx_note);
+        result_layout->addWidget(card);
+    }
+
+    // What to do next
+    {
+        auto* card{makeCard(result_container)};
+        auto* box{new QVBoxLayout(card)};
+        box->setContentsMargins(CARD_PADDING, CARD_PADDING, CARD_PADDING, CARD_PADDING);
+        box->setSpacing(TITLE_SPACING);
+        box->addWidget(MakeLabel(tr("Next steps"), card));
+        m_next_steps = new QLabel(card);
+        m_next_steps->setWordWrap(true);
+        m_next_steps->setTextInteractionFlags(Qt::TextSelectableByMouse);
+        box->addWidget(m_next_steps);
+        result_layout->addWidget(card);
+    }
+    result_layout->addStretch();
+    scroll->setWidget(result_container);
+    layout->addWidget(scroll, /*stretch=*/1);
+    return page;
+}
+
+bool RegisterMasternodeWizard::isEvo() const
+{
+    return m_type_evo->isChecked();
+}
+
+bool RegisterMasternodeWizard::usesExtendedAddresses() const
+{
+    return m_node.evo().getProviderTxCapabilities().extended_addresses;
+}
+
+bool RegisterMasternodeWizard::isExternalCollateral() const
+{
+    return m_col_external->isChecked();
+}
+
+bool RegisterMasternodeWizard::isFundCollateral() const
+{
+    return m_col_fund->isChecked();
+}
+
+std::optional<CTxDestination> RegisterMasternodeWizard::knownCollateralDestination() const
+{
+    if (isFundCollateral()) {
+        const CTxDestination destination{DecodeDestination(collateralAddress().toStdString())};
+        if (IsValidDestination(destination)) return destination;
+        return std::nullopt;
+    }
+    if (!m_col_wallet->isChecked() || m_col_utxo_combo->currentIndex() < 0) {
+        return std::nullopt;
+    }
+    const CTxDestination destination{DecodeDestination(
+        m_col_utxo_combo->itemData(m_col_utxo_combo->currentIndex(), COLLATERAL_ADDRESS_ROLE).toString().toStdString())};
+    return IsValidDestination(destination) ? std::optional{destination} : std::nullopt;
+}
+
+QString RegisterMasternodeWizard::collateralAddress() const
+{
+    return isFundCollateral() ? m_col_address->text().trimmed() : QString();
+}
+
+QString RegisterMasternodeWizard::ownerAddress() const
+{
+    return m_owner_edit->text().trimmed();
+}
+
+QString RegisterMasternodeWizard::votingAddress() const
+{
+    return m_voting_edit->text().trimmed();
+}
+
+QString RegisterMasternodeWizard::freshAddress(QString& err) const
+{
+    err.clear();
+    if (m_walletModel == nullptr) {
+        err = tr("No wallet is available.");
+        return {};
+    }
+    auto dest{m_walletModel->wallet().getNewDestination(/*label=*/"")};
+    if (!dest) {
+        err = tr("Could not generate a new address: %1")
+                  .arg(QString::fromStdString(util::ErrorString(dest).translated));
+        return {};
+    }
+    return QString::fromStdString(EncodeDestination(*dest));
+}
+
+CAmount RegisterMasternodeWizard::collateralAmount() const
+{
+    return GetMnType(isEvo() ? MnType::Evo : MnType::Regular).collat_amount;
+}
+
+bool RegisterMasternodeWizard::secretGateRequired() const
+{
+    return m_operator_widget->hasGeneratedSecret();
+}
+
+bool RegisterMasternodeWizard::secretConfirmed() const
+{
+    return m_confirm_edit->text().trimmed().compare(m_operator_widget->secretHex().right(4),
+                                                    Qt::CaseInsensitive) == 0;
+}
+
+void RegisterMasternodeWizard::rebuildOrder()
+{
+    const std::optional<Page> current{m_order.isEmpty() ? std::nullopt : std::optional<Page>{currentPage()}};
+    m_order = {PageType, PageCollateral, PageService, PageKeys, PagePayout};
+    if (isEvo()) m_order << PagePlatform;
+    m_order << PageFee << PageReview;
+    if (m_operator_widget != nullptr && secretGateRequired()) m_order << PageSecret;
+    if (isExternalCollateral()) m_order << PageSign;
+    m_order << PageResult;
+    if (current && m_order.contains(*current)) {
+        m_pos = m_order.indexOf(*current);
+    } else if (m_pos >= m_order.size()) {
+        m_pos = m_order.size() - 1;
+    }
+    updateProgress();
+}
+
+RegisterMasternodeWizard::Page RegisterMasternodeWizard::currentPage() const
+{
+    return m_order.isEmpty() ? PageType : m_order.at(m_pos);
+}
+
+QString RegisterMasternodeWizard::pageTitle(Page page) const
+{
+    switch (page) {
+    case PageType:
+        return tr("Masternode type");
+    case PageCollateral:
+        return tr("Collateral");
+    case PageService:
+        return tr("Service addresses");
+    case PageKeys:
+        return tr("Keys");
+    case PagePayout:
+        return tr("Payout");
+    case PagePlatform:
+        return tr("Platform services");
+    case PageFee:
+        return tr("Fee source");
+    case PageReview:
+        return tr("Review");
+    case PageSecret:
+        return tr("Save operator key");
+    case PageSign:
+        return tr("Prove collateral ownership");
+    case PageResult:
+        return tr("Complete");
+    }
+    return {};
+}
+
+void RegisterMasternodeWizard::updateProgress()
+{
+    if (m_progress_label == nullptr || m_order.isEmpty()) return;
+    if (currentPage() == PageResult) {
+        m_progress_label->setText(tr("Complete"));
+        return;
+    }
+    const int total{m_order.size() - 1};
+    m_progress_label->setText(tr("Step %1 of %2 · %3").arg(m_pos + 1).arg(total).arg(pageTitle(currentPage())));
+}
+
+void RegisterMasternodeWizard::goToPage(Page page)
+{
+    const int pos{m_order.indexOf(page)};
+    if (pos < 0) return;
+    m_pos = pos;
+    enterPage(page);
+}
+
+void RegisterMasternodeWizard::enterPage(Page page)
+{
+    m_pages->setCurrentIndex(page);
+    m_validation_page.reset();
+    showError(QString());
+    if (page != PageReview) m_unlock.reset();
+    switch (page) {
+    case PageCollateral:
+        if (m_col_address->text().isEmpty() && m_walletModel != nullptr) {
+            QString err;
+            const QString addr{freshAddress(err)};
+            if (!addr.isEmpty()) m_col_address->setText(addr);
+        }
+        refreshCollateralCandidates();
+        break;
+    case PageKeys: {
+        if (m_owner_edit->text().isEmpty() && m_walletModel != nullptr) {
+            QString err;
+            const QString addr{freshAddress(err)};
+            if (!addr.isEmpty()) m_owner_edit->setText(addr);
+        }
+        break;
+    }
+    case PagePayout:
+        if (m_payout_edit->text().isEmpty() && m_walletModel != nullptr) {
+            QString err;
+            const QString addr{freshAddress(err)};
+            if (!addr.isEmpty()) m_payout_edit->setText(addr);
+        }
+        break;
+    case PagePlatform: {
+        const auto capabilities{m_node.evo().getProviderTxCapabilities()};
+        const bool v3{capabilities.extended_addresses};
+        m_platform_provider_version = capabilities.version;
+        m_platform_extended_addresses = v3;
+        m_platform_addr_box->setVisible(v3);
+        m_platform_port_box->setVisible(!v3);
+        break;
+    }
+    case PageFee: {
+        // The exact fee depends on selected coins and current wallet fee
+        // settings. Do not reject a viable source using a fixed estimate; the
+        // typed funding operation remains the authority.
+        const CAmount required{isFundCollateral() ? collateralAmount() : 0};
+        std::optional<COutPoint> excluded_outpoint;
+        if (m_col_wallet->isChecked() && m_col_utxo_combo->currentIndex() >= 0) {
+            uint256 hash;
+            hash.SetHex(m_col_utxo_combo->currentData().toString().toStdString());
+            excluded_outpoint.emplace(
+                hash, static_cast<uint32_t>(m_col_utxo_combo->itemData(m_col_utxo_combo->currentIndex(), VOUT_ROLE).toInt()));
+        }
+        m_fee_picker->setExcludedOutpoint(std::move(excluded_outpoint));
+        m_fee_picker->setMinimumBalance(required);
+        m_fee_picker->refresh();
+        if (isFundCollateral()) {
+            m_fee_explain->setText(
+                tr("The selected address funds the %1 collateral plus the transaction fee. The exact fee is "
+                   "calculated from your wallet settings when you register, and change returns to this address.")
+                    .arg(FormatAmount(m_walletModel, collateralAmount())));
+        } else {
+            m_fee_explain->setText(tr("The selected address pays the transaction fee."));
+        }
+        break;
+    }
+    case PageReview:
+        populateReview();
+        break;
+    case PageSecret:
+        populateSecret();
+        break;
+    default:
+        break;
+    }
+    updateProgress();
+    updateButtons();
+}
+
+bool RegisterMasternodeWizard::validatePage(Page page, QString& err)
+{
+    err.clear();
+    switch (page) {
+    case PageCollateral:
+        if (isFundCollateral()) {
+            if (!MasternodeWidgetUtil::isP2PKHorP2SHAddress(collateralAddress())) {
+                err = tr("Enter a valid collateral address (P2PKH or P2SH).");
+            }
+        } else if (m_col_wallet->isChecked()) {
+            if (m_col_utxo_combo->currentIndex() < 0) {
+                err = tr("This wallet has no unspent output of exactly %1. Fund the collateral from the wallet "
+                         "instead.")
+                          .arg(FormatAmount(m_walletModel, collateralAmount()));
+            }
+        } else {
+            const QString txid{m_col_txid->text().trimmed()};
+            uint256 hash;
+            hash.SetHex(txid.toStdString());
+            if (txid.length() != 64 || !IsHex(txid.toStdString()) || hash.IsNull()) {
+                err = tr("Enter the collateral transaction id as 64 hexadecimal characters.");
+            }
+        }
+        break;
+    case PageService: {
+        const QStringList list{MasternodeWidgetUtil::tokenizeEndpointList(m_service_edit->text())};
+        if (list.isEmpty() && isEvo() && !usesExtendedAddresses()) {
+            err = tr("EvoNodes need at least one service address to carry the Platform ports before v24 "
+                     "activation.");
+        } else if (!isEvo()) {
+            validateProviderNetInfo(/*optional=*/true, err);
+        } else if (!list.isEmpty()) {
+            interfaces::ProviderNetInfo core_only;
+            for (const QString& entry : list) core_only.core_p2p.push_back(entry.toStdString());
+            const uint16_t version{m_node.evo().getProviderTxCapabilities().version};
+            if (const auto error{m_node.evo().validateProviderNetInfo(
+                    core_only, MnType::Regular, version, /*optional=*/true)}) {
+                err = QString::fromStdString(error->message.translated);
+            }
+        }
+        break;
+    }
+    case PageKeys: {
+        const CTxDestination owner_destination{DecodeDestination(ownerAddress().toStdString())};
+        const auto* owner{std::get_if<PKHash>(&owner_destination)};
+        const QString voting_text{votingAddress()};
+        const CTxDestination voting_destination{
+            DecodeDestination((voting_text.isEmpty() ? ownerAddress() : voting_text).toStdString())};
+        const auto* voting{std::get_if<PKHash>(&voting_destination)};
+        const auto collateral_destination{knownCollateralDestination()};
+        if (!owner || ToKeyID(*owner).IsNull()) {
+            err = tr("Enter a valid owner address (P2PKH).");
+        } else if (!voting || ToKeyID(*voting).IsNull()) {
+            err = tr("Enter a valid voting address (P2PKH), or leave it empty to use the owner address.");
+        } else if (collateral_destination &&
+                   (*collateral_destination == owner_destination || *collateral_destination == voting_destination)) {
+            err = tr("The owner and voting addresses must differ from the collateral address.");
+        } else if (!m_operator_widget->isValid()) {
+            err = tr("Enter a valid operator BLS public key (96 hexadecimal characters, basic scheme).");
+        }
+        break;
+    }
+    case PagePayout: {
+        const QString payout{m_payout_edit->text().trimmed()};
+        const CTxDestination payout_destination{DecodeDestination(payout.toStdString())};
+        const CTxDestination owner_destination{DecodeDestination(ownerAddress().toStdString())};
+        const CTxDestination voting_destination{
+            DecodeDestination((votingAddress().isEmpty() ? ownerAddress() : votingAddress()).toStdString())};
+        if (!MasternodeWidgetUtil::isP2PKHorP2SHAddress(payout)) {
+            err = tr("Enter a valid payout address (P2PKH or P2SH).");
+        } else if (payout_destination == owner_destination || payout_destination == voting_destination) {
+            err = tr("The payout address must differ from the owner and voting addresses.");
+        } else if (const auto collateral_destination{knownCollateralDestination()};
+                   collateral_destination && payout_destination == *collateral_destination) {
+            err = tr("The payout address must differ from the collateral address.");
+        }
+        break;
+    }
+    case PagePlatform: {
+        const QString nodeid{m_platform_nodeid->text().trimmed()};
+        uint160 platform_node_id;
+        platform_node_id.SetHex(nodeid.toStdString());
+        if (nodeid.length() != 40 || !IsHex(nodeid.toStdString()) || platform_node_id.IsNull()) {
+            err = tr("Enter the Platform node ID as 40 hexadecimal characters.");
+            break;
+        }
+        if (m_platform_extended_addresses) {
+            const QStringList p2p{MasternodeWidgetUtil::tokenizeEndpointList(m_platform_p2p->text())};
+            const QStringList https{MasternodeWidgetUtil::tokenizeEndpointList(m_platform_https->text())};
+            const bool has_service{!MasternodeWidgetUtil::tokenizeEndpointList(m_service_edit->text()).isEmpty()};
+            if (p2p.isEmpty() != https.isEmpty()) {
+                err = tr("Enter both a Platform P2P and a Platform HTTPS address; one cannot be registered "
+                         "without the other.");
+            } else if (has_service && p2p.isEmpty()) {
+                err = tr("Enter at least one Platform P2P and one Platform HTTPS address, or clear the service "
+                         "addresses to set everything later with a service update.");
+            } else if (!has_service && !p2p.isEmpty()) {
+                err = tr("Enter at least one Core service address when Platform endpoints are set, or clear all "
+                         "service endpoints to set them later with a service update.");
+            }
+        }
+        if (err.isEmpty()) validateProviderNetInfo(/*optional=*/true, err);
+        break;
+    }
+    case PageFee:
+        if (m_fee_picker->currentIndex() < 0) {
+            err = isFundCollateral() ?
+                      tr("No spendable wallet address holds the %1 collateral amount. The selected address must "
+                         "also have enough for the fee calculated when you register.")
+                          .arg(FormatAmount(m_walletModel, collateralAmount())) :
+                      tr("No spendable wallet address has a positive balance available to pay the transaction "
+                         "fee.");
+        }
+        break;
+    case PageSign: {
+        const QString sig{m_sig_edit->toPlainText().simplified().remove(' ')};
+        if (sig.isEmpty() || !DecodeBase64(sig.toStdString()).has_value()) {
+            err = tr("Paste the base64-encoded signature of the message above, made with the collateral key.");
+        }
+        break;
+    }
+    default:
+        break;
+    }
+    return err.isEmpty();
+}
+
+interfaces::ProviderNetInfo RegisterMasternodeWizard::providerNetInfo() const
+{
+    interfaces::ProviderNetInfo net_info;
+    for (const QString& entry : MasternodeWidgetUtil::tokenizeEndpointList(m_service_edit->text())) {
+        net_info.core_p2p.push_back(entry.toStdString());
+    }
+    if (!isEvo()) return net_info;
+
+    if (m_platform_extended_addresses) {
+        std::vector<std::string> p2p;
+        for (const QString& entry : MasternodeWidgetUtil::tokenizeEndpointList(m_platform_p2p->text())) {
+            p2p.push_back(entry.toStdString());
+        }
+        std::vector<std::string> https;
+        for (const QString& entry : MasternodeWidgetUtil::tokenizeEndpointList(m_platform_https->text())) {
+            https.push_back(entry.toStdString());
+        }
+        net_info.platform_p2p = std::move(p2p);
+        net_info.platform_https = std::move(https);
+    } else {
+        net_info.platform_p2p = static_cast<uint16_t>(m_platform_p2p_port->value());
+        net_info.platform_https = static_cast<uint16_t>(m_platform_https_port->value());
+    }
+    return net_info;
+}
+
+bool RegisterMasternodeWizard::validateProviderNetInfo(bool optional, QString& err) const
+{
+    const uint16_t version{isEvo() && m_platform_provider_version != 0 ?
+                               m_platform_provider_version :
+                               m_node.evo().getProviderTxCapabilities().version};
+    if (const auto error{m_node.evo().validateProviderNetInfo(
+            providerNetInfo(), isEvo() ? MnType::Evo : MnType::Regular, version, optional)}) {
+        err = QString::fromStdString(error->message.translated);
+        return false;
+    }
+    return true;
+}
+
+void RegisterMasternodeWizard::onNext()
+{
+    if (m_busy) return;
+    const Page current{currentPage()};
+    QString err;
+    if (!validatePage(current, err)) {
+        m_validation_page = current;
+        showError(err);
+        updateButtons();
+        return;
+    }
+    m_validation_page.reset();
+    showError(QString());
+    if (current == PageReview) {
+        if (secretGateRequired()) {
+            goToPage(PageSecret);
+        } else {
+            startRegistration();
+        }
+    } else if (current == PageSecret) {
+        startRegistration();
+    } else if (current == PageSign) {
+        startSubmit();
+    } else if (current == PageResult) {
+        accept();
+    } else {
+        ++m_pos;
+        enterPage(m_order[m_pos]);
+    }
+}
+
+void RegisterMasternodeWizard::onBack()
+{
+    if (m_busy || m_pos == 0) return;
+    --m_pos;
+    enterPage(m_order[m_pos]);
+}
+
+void RegisterMasternodeWizard::updateButtons()
+{
+    const Page current{currentPage()};
+    m_back_button->setVisible(current != PageType && current != PageResult);
+    // After register_prepare the transaction is fixed; going back would
+    // silently invalidate the message being signed.
+    m_back_button->setEnabled(!m_busy && current != PageSign);
+    m_back_button->setToolTip(current == PageSign ? tr("Back is unavailable after preparation because changing the "
+                                                       "registration would invalidate the message being signed.")
+                                                  : QString{});
+    m_cancel_button->setVisible(current != PageResult);
+    m_cancel_button->setEnabled(!m_busy);
+
+    if (!m_busy) {
+        QString next_text{tr("Next")};
+        if (current == PageReview) {
+            next_text = secretGateRequired() ? tr("Continue") : (isExternalCollateral() ? tr("Prepare") : tr("Register"));
+        } else if (current == PageSecret) {
+            next_text = isExternalCollateral() ? tr("Prepare") : tr("Register");
+        } else if (current == PageSign) {
+            next_text = tr("Submit");
+        } else if (current == PageResult) {
+            next_text = tr("Finish");
+        }
+        m_next_button->setText(next_text);
+    }
+
+    bool enabled{!m_busy};
+    QString tooltip;
+    if (m_walletModel == nullptr) {
+        enabled = false;
+        tooltip = tr("No wallet is available. Masternode registration requires a wallet.");
+    } else if (m_walletModel->wallet().privateKeysDisabled()) {
+        enabled = false;
+        tooltip = tr("This wallet is watch-only. Masternode registration requires a wallet that can sign "
+                     "transactions.");
+    } else if (current == PageSecret && !secretConfirmed()) {
+        enabled = false;
+        tooltip = tr("Confirm you saved the operator secret key by typing its last 4 characters.");
+    } else if (m_validation_page && *m_validation_page == current) {
+        QString error;
+        if (!validatePage(current, error)) {
+            enabled = false;
+            tooltip = error;
+        }
+    }
+    m_next_button->setEnabled(enabled);
+    m_next_button->setToolTip(tooltip);
+}
+
+void RegisterMasternodeWizard::onPageEdited()
+{
+    if (m_validation_page && *m_validation_page == currentPage()) {
+        QString error;
+        validatePage(currentPage(), error);
+        showError(error);
+        if (error.isEmpty()) m_validation_page.reset();
+    } else if (!m_error_label->text().isEmpty()) {
+        showError(QString());
+    }
+    updateButtons();
+}
+
+void RegisterMasternodeWizard::setBusy(bool busy, const QString& busy_text)
+{
+    m_busy = busy;
+    m_busy_bar->setVisible(busy);
+    if (busy) {
+        m_next_button->setText(busy_text);
+    }
+    updateButtons();
+}
+
+void RegisterMasternodeWizard::showError(const QString& message)
+{
+    m_error_label->setText(message);
+}
+
+void RegisterMasternodeWizard::refreshCollateralCandidates()
+{
+    if (m_walletModel == nullptr) {
+        m_col_utxo_combo->clear();
+        m_col_utxo_none->setVisible(true);
+        return;
+    }
+    refreshCollateralCandidates(RegisteredCollaterals(m_walletModel->wallet()));
+}
+
+void RegisterMasternodeWizard::refreshCollateralCandidates(const std::set<COutPoint>& registered_collaterals)
+{
+    m_col_utxo_combo->clear();
+    if (m_walletModel == nullptr) return;
+    const CAmount collateral{collateralAmount()};
+    for (const auto& [dest, coins] : m_walletModel->wallet().listCoins()) {
+        for (const auto& [outpoint, txout] : coins) {
+            if (txout.txout.nValue != collateral || txout.is_spent || txout.depth_in_main_chain < 1) continue;
+            if (registered_collaterals.count(outpoint) != 0) continue;
+            if (m_walletModel->wallet().isLockedCoin(outpoint)) continue;
+            if (!m_walletModel->wallet().isSpendable(txout.txout.scriptPubKey)) continue;
+            // protx register only accepts P2PKH collaterals; check the coin's own
+            // script, as listCoins() groups change under the parent's address
+            CTxDestination coin_dest;
+            if (!ExtractDestination(txout.txout.scriptPubKey, coin_dest) ||
+                !std::holds_alternative<PKHash>(coin_dest)) {
+                continue;
+            }
+            const QString address{QString::fromStdString(EncodeDestination(coin_dest))};
+            const QString txid{QString::fromStdString(outpoint.hash.ToString())};
+            m_col_utxo_combo->addItem(QString("%1:%2 (%3)").arg(txid).arg(outpoint.n).arg(address), txid);
+            m_col_utxo_combo->setItemData(m_col_utxo_combo->count() - 1, static_cast<int>(outpoint.n), VOUT_ROLE);
+            m_col_utxo_combo->setItemData(m_col_utxo_combo->count() - 1, address, COLLATERAL_ADDRESS_ROLE);
+        }
+    }
+    // An empty combo box says nothing; show the reason instead
+    const bool have_candidates{m_col_utxo_combo->count() > 0};
+    m_col_utxo_combo->setVisible(have_candidates);
+    m_col_utxo_none->setVisible(!have_candidates);
+    m_col_utxo_none->setText(tr("This wallet has no unspent output of exactly %1 with a confirmation. Send the "
+                                "collateral from this wallet instead, or reference one held elsewhere.")
+                                 .arg(FormatAmount(m_walletModel, collateralAmount())));
+}
+
+int RegisterMasternodeWizard::reviewLabelWidth(const QWidget* card) const
+{
+    // The widest label decides the column, so every card shares one alignment
+    static const QStringList labels{tr("Type"),         tr("Service"),        tr("Platform node ID"),
+                                    tr("Platform P2P"), tr("Platform HTTPS"), tr("Platform ports"),
+                                    tr("Amount"),       tr("Destination"),    tr("Output"),
+                                    tr("Source"),       tr("Owner"),          tr("Voting"),
+                                    tr("Operator"),     tr("Address"),        tr("Operator share"),
+                                    tr("Fee source"),   tr("Network fee")};
+    const QFontMetrics metrics{card->font()};
+    int width{0};
+    for (const QString& label : labels) {
+        width = std::max(width, metrics.horizontalAdvance(label));
+    }
+    return width;
+}
+
+void RegisterMasternodeWizard::populateReview()
+{
+    // The sections mirror the wizard's own pages, so a wrong value can be traced
+    // back to the page that set it
+    // Two columns: a label column just wide enough for its text, and the value
+    // column taking the rest, so every row lines up down the card
+    QGridLayout* section{nullptr};
+    QWidget* section_card{nullptr};
+    const auto begin_section = [this, &section, &section_card](const QString& title) {
+        // makeCard() hands back a bare frame; the card owns the layout we build here
+        auto* card{makeCard(m_review_container)};
+        section_card = card;
+        auto* card_layout{new QVBoxLayout(card)};
+        card_layout->setContentsMargins(CARD_PADDING, CARD_PADDING, CARD_PADDING, CARD_PADDING);
+        card_layout->setSpacing(TITLE_SPACING);
+        card_layout->addWidget(MakeLabel(title, card));
+        section = new QGridLayout();
+        section->setContentsMargins(0, 0, 0, 0);
+        section->setHorizontalSpacing(GROUP_SPACING);
+        section->setVerticalSpacing(ROW_SPACING);
+        section->setColumnStretch(1, 1);
+        // One label width for every card, so the values line up down the page
+        section->setColumnMinimumWidth(0, reviewLabelWidth(card));
+        card_layout->addLayout(section);
+        m_review_layout->insertWidget(m_review_layout->count() - 1, card);
+    };
+    const auto row = [&section, &section_card](const QString& key, const QString& value, bool monospace = false) {
+        const int r{section->rowCount()};
+        section->addWidget(MakeHint(key, section_card), r, 0, Qt::AlignLeft | Qt::AlignTop);
+        section->addWidget(makeValue(value, section_card, monospace), r, 1);
+    };
+    // A BLS key is one 96-character word, which a wrapping label refuses to break.
+    // Shown in chunks it wraps like the other values, and the Copy button hands
+    // out the unbroken key.
+    const auto key_row = [&section, &section_card](const QString& key, const QString& value) {
+        const int r{section->rowCount()};
+        section->addWidget(MakeHint(key, section_card), r, 0, Qt::AlignLeft | Qt::AlignTop);
+        section->addWidget(MasternodeWidgetUtil::makeCopyableValue(MasternodeWidgetUtil::chunked(value), value,
+                                                                   section_card),
+                           r, 1);
+    };
+
+    // Rebuilt on every entry to the page: the user may have gone back and edited.
+    // The trailing stretch stays; only the cards are replaced.
+    while (m_review_layout->count() > 1) {
+        QLayoutItem* item{m_review_layout->takeAt(0)};
+        delete item->widget();
+        delete item;
+    }
+
+    begin_section(tr("Node"));
+    row(tr("Type"), isEvo() ? tr("EvoNode") : tr("Masternode"));
+    const QStringList services{MasternodeWidgetUtil::tokenizeEndpointList(m_service_edit->text())};
+    row(tr("Service"), services.isEmpty() ? tr("Not set — the node stays inactive until you send a service update") :
+                                            services.join(", "),
+        !services.isEmpty());
+    if (isEvo()) {
+        row(tr("Platform node ID"), m_platform_nodeid->text().trimmed(), /*monospace=*/true);
+        if (m_platform_extended_addresses) {
+            row(tr("Platform P2P"),
+                MasternodeWidgetUtil::tokenizeEndpointList(m_platform_p2p->text()).join(", "),
+                /*monospace=*/true);
+            row(tr("Platform HTTPS"),
+                MasternodeWidgetUtil::tokenizeEndpointList(m_platform_https->text()).join(", "),
+                /*monospace=*/true);
+        } else {
+            row(tr("Platform ports"), tr("%1 peer-to-peer, %2 HTTPS")
+                                          .arg(m_platform_p2p_port->value())
+                                          .arg(m_platform_https_port->value()));
+        }
+    }
+
+    begin_section(tr("Collateral"));
+    row(tr("Amount"), FormatAmount(m_walletModel, collateralAmount()));
+    if (isFundCollateral()) {
+        row(tr("Destination"), collateralAddress(), /*monospace=*/true);
+        row(tr("Source"), tr("This wallet sends it as part of the registration"));
+    } else if (m_col_wallet->isChecked()) {
+        row(tr("Output"), m_col_utxo_combo->currentText(), /*monospace=*/true);
+        row(tr("Source"), tr("An output this wallet already holds"));
+    } else {
+        row(tr("Output"), QString("%1:%2").arg(m_col_txid->text().trimmed()).arg(m_col_vout->value()),
+            /*monospace=*/true);
+        row(tr("Source"), tr("Held outside this wallet — you will sign a message with its key"));
+    }
+
+    begin_section(tr("Keys"));
+    row(tr("Owner"), ownerAddress(), /*monospace=*/true);
+    row(tr("Voting"), votingAddress().isEmpty() ? tr("Same as owner") : votingAddress(),
+        !votingAddress().isEmpty());
+    const QString operator_key{m_operator_widget->publicKeyHex()};
+    key_row(tr("Operator"), operator_key);
+    row(QString(), operatorKeyProvenance());
+
+    begin_section(tr("Payout"));
+    row(tr("Address"), m_payout_edit->text().trimmed(), /*monospace=*/true);
+    row(tr("Operator share"), QString("%1%").arg(QString::number(m_operator_reward->value(), 'f', 2)));
+
+    begin_section(tr("Funding"));
+    const QString fee_source{m_fee_picker->selectedAddress()};
+    row(tr("Fee source"), fee_source.isEmpty() ? tr("Not selected") : fee_source,
+        /*monospace=*/!fee_source.isEmpty());
+    row(tr("Network fee"), tr("Calculated at submission using the wallet's current fee settings"));
+
+    m_review_layout->insertWidget(
+        m_review_layout->count() - 1,
+        MakeHint(isExternalCollateral() ?
+                     tr("Preparing creates the unsigned transaction and the message to sign with the collateral "
+                        "key. Nothing is broadcast yet.") :
+                     tr("Registering broadcasts a transaction from this wallet. You may be asked to unlock it."),
+                 m_review_container));
+}
+
+QString RegisterMasternodeWizard::operatorKeyProvenance() const
+{
+    switch (m_operator_widget->mode()) {
+    case OperatorKeyWidget::Mode::GenerateOnly:
+        return tr("Newly generated, shown and confirmed before registration, and kept nowhere else");
+    case OperatorKeyWidget::Mode::Existing:
+        return tr("Supplied by whoever runs the node");
+    }
+    return {};
+}
+
+void RegisterMasternodeWizard::populateSecret()
+{
+    m_secret_edit->setText(m_operator_widget->secretHex());
+    m_conf_line_edit->setText(QString("masternodeblsprivkey=%1").arg(m_operator_widget->secretHex()));
+    m_secret_edit->setCursorPosition(0);
+    m_conf_line_edit->setCursorPosition(0);
+}
+
+std::optional<interfaces::ProviderRegistrationRequest> RegisterMasternodeWizard::buildRegistrationRequest(
+    QString& error) const
+{
+    error.clear();
+    interfaces::ProviderRegistrationRequest request;
+    request.type = isEvo() ? MnType::Evo : MnType::Regular;
+    if (isFundCollateral()) {
+        const CTxDestination destination{DecodeDestination(collateralAddress().toStdString())};
+        if (!IsValidDestination(destination)) {
+            error = tr("The collateral destination is no longer valid.");
+            return std::nullopt;
+        }
+        request.collateral = interfaces::FundProviderCollateral{destination};
+    } else if (m_col_wallet->isChecked()) {
+        uint256 hash;
+        hash.SetHex(m_col_utxo_combo->currentData().toString().toStdString());
+        const COutPoint outpoint{hash,
+                                 static_cast<uint32_t>(
+                                     m_col_utxo_combo->itemData(m_col_utxo_combo->currentIndex(), VOUT_ROLE).toInt())};
+        if (RegisteredCollaterals(m_walletModel->wallet()).count(outpoint) != 0) {
+            error = tr("The selected collateral output is already used by another masternode.");
+            return std::nullopt;
+        }
+        request.collateral = interfaces::ExistingProviderCollateral{outpoint};
+    } else {
+        uint256 hash;
+        hash.SetHex(m_col_txid->text().trimmed().toStdString());
+        request.collateral = interfaces::ExistingProviderCollateral{
+            COutPoint{hash, static_cast<uint32_t>(m_col_vout->value())}};
+    }
+
+    request.net_info = providerNetInfo();
+
+    const CTxDestination owner_destination{DecodeDestination(ownerAddress().toStdString())};
+    const auto* owner{std::get_if<PKHash>(&owner_destination)};
+    if (!owner) {
+        error = tr("The owner address is no longer valid.");
+        return std::nullopt;
+    }
+    request.owner_key = ToKeyID(*owner);
+
+    if (votingAddress().isEmpty()) {
+        request.voting_key = request.owner_key;
+    } else {
+        const CTxDestination voting_destination{DecodeDestination(votingAddress().toStdString())};
+        const auto* voting{std::get_if<PKHash>(&voting_destination)};
+        if (!voting) {
+            error = tr("The voting address is no longer valid.");
+            return std::nullopt;
+        }
+        request.voting_key = ToKeyID(*voting);
+    }
+
+    if (!request.operator_key.SetHexStr(m_operator_widget->publicKeyHex().toStdString(),
+                                        /*specificLegacyScheme=*/false)) {
+        error = tr("The operator public key is no longer valid.");
+        return std::nullopt;
+    }
+    request.operator_reward = static_cast<uint16_t>(qRound(m_operator_reward->value() * 100.0));
+
+    const CTxDestination payout{DecodeDestination(m_payout_edit->text().trimmed().toStdString())};
+    if (!IsValidDestination(payout)) {
+        error = tr("The payout address is no longer valid.");
+        return std::nullopt;
+    }
+    request.payouts.push_back({payout, interfaces::ProviderPayout::MAX_REWARD});
+
+    if (isEvo()) {
+        uint160 platform_node_id;
+        platform_node_id.SetHex(m_platform_nodeid->text().trimmed().toStdString());
+        request.platform_node_id = platform_node_id;
+    }
+
+    const CTxDestination fee_source{DecodeDestination(m_fee_picker->selectedAddress().toStdString())};
+    if (!IsValidDestination(fee_source)) {
+        error = tr("The selected fee source is no longer valid.");
+        return std::nullopt;
+    }
+    request.fee_source = fee_source;
+    request.submit = true;
+    return request;
+}
+
+void RegisterMasternodeWizard::completeRegistration(const CTransactionRef& transaction)
+{
+    if (m_destroying) return;
+    populateResult(QString::fromStdString(transaction->GetHash().ToString()));
+    goToPage(PageResult);
+}
+
+bool RegisterMasternodeWizard::confirmBroadcast()
+{
+    const QString node_type{isEvo() ? tr("EvoNode") : tr("masternode")};
+    QString consequence;
+    if (isFundCollateral()) {
+        consequence = tr("This transaction creates %1 of collateral from this wallet and registers the %2.")
+                          .arg(FormatAmount(m_walletModel, collateralAmount()), node_type);
+    } else if (isExternalCollateral()) {
+        consequence = tr("This transaction registers the external %1 collateral and makes it the collateral for this "
+                         "%2.")
+                          .arg(FormatAmount(m_walletModel, collateralAmount()), node_type);
+    } else {
+        consequence = tr("This transaction registers and locks the wallet's %1 collateral output for this %2.")
+                          .arg(FormatAmount(m_walletModel, collateralAmount()), node_type);
+    }
+    consequence += tr(
+        " The network fee is calculated from the selected fee source using the wallet's current fee settings.");
+
+    SendConfirmationDialog confirmation{tr("Confirm %1 registration").arg(node_type),
+                                        tr("Do you want to broadcast this %1 registration?").arg(node_type),
+                                        consequence,
+                                        tr("Fee source: %1").arg(m_fee_picker->selectedAddress()),
+                                        SEND_CONFIRM_DELAY,
+                                        /*enable_send=*/true,
+                                        /*always_show_unsigned=*/false,
+                                        this};
+    confirmation.setWindowModality(Qt::WindowModal);
+    return confirmation.exec() == QMessageBox::Yes;
+}
+
+void RegisterMasternodeWizard::startRegistration(bool skip_confirmation)
+{
+    if (m_walletModel == nullptr || !m_runner) return;
+    if (secretGateRequired() && !secretConfirmed()) {
+        goToPage(PageSecret);
+        return;
+    }
+    if (isEvo() && m_node.evo().getProviderTxCapabilities().version != m_platform_provider_version) {
+        goToPage(PagePlatform);
+        showError(tr("The network's provider-transaction rules changed while this wizard was open. Review the "
+                     "Platform services page again before registering."));
+        return;
+    }
+    if (!isExternalCollateral() && !skip_confirmation && !confirmBroadcast()) return;
+    if (!m_unlock) m_unlock = std::make_unique<UnlockHolder>(*m_walletModel);
+    if (!m_unlock->ctx.isValid()) {
+        m_unlock.reset();
+        return;
+    }
+
+    QString error;
+    auto request{buildRegistrationRequest(error)};
+    if (!request) {
+        m_unlock.reset();
+        showError(error);
+        return;
+    }
+    if (isExternalCollateral()) {
+        m_prepared_collateral_outpoint =
+            std::get<interfaces::ExistingProviderCollateral>(request->collateral).outpoint;
+    }
+
+    m_stage = isExternalCollateral() ? Stage::Prepare : Stage::Register;
+    setBusy(true, isExternalCollateral() ? tr("Preparing…") : tr("Registering…"));
+    const bool started{
+        isExternalCollateral()
+            ? m_runner->prepareMasternodeRegistration(std::move(*request),
+                                                      [this](auto result) { finishPrepare(std::move(result)); })
+            : m_runner->registerMasternode(
+                  std::move(*request), [this](auto result) { finishSubmission(std::move(result)); })};
+    if (!started) {
+        m_stage = Stage::None;
+        m_unlock.reset();
+        setBusy(false);
+    }
+}
+
+void RegisterMasternodeWizard::startSubmit(bool skip_confirmation)
+{
+    if (m_walletModel == nullptr || !m_runner || !m_prepared_tx) return;
+    if (isEvo() && m_node.evo().getProviderTxCapabilities().version != m_platform_provider_version) {
+        showError(tr("The network's provider-transaction rules changed while the collateral signature was being "
+                     "collected. Discard this prepared registration and review the Platform services page again."));
+        return;
+    }
+    const auto signature{DecodeBase64(m_sig_edit->toPlainText().simplified().remove(' ').toStdString())};
+    if (!signature) {
+        showError(tr("The collateral signature is not valid base64."));
+        return;
+    }
+    if (!skip_confirmation && !confirmBroadcast()) return;
+    m_unlock = std::make_unique<UnlockHolder>(*m_walletModel);
+    if (!m_unlock->ctx.isValid()) {
+        m_unlock.reset();
+        return;
+    }
+    m_stage = Stage::Submit;
+    setBusy(true, tr("Submitting…"));
+    if (!m_runner->submitMasternodeRegistration(
+            m_prepared_tx, *signature, [this](auto result) { finishSubmission(std::move(result)); })) {
+        m_stage = Stage::None;
+        m_unlock.reset();
+        setBusy(false);
+    }
+}
+
+namespace {
+QString ProviderTxErrorText(const interfaces::ProviderTxError& error)
+{
+    QString text{QString::fromStdString(error.message.translated)};
+    const QString reject_reason{QString::fromStdString(error.reject_reason)};
+    if (!reject_reason.isEmpty() && !text.contains(reject_reason)) {
+        text += QObject::tr("\n\nNetwork rejection: %1").arg(reject_reason);
+    }
+    return text;
+}
+} // namespace
+
+void RegisterMasternodeWizard::finishSubmission(MasternodeOperationRunner::SubmissionResult result)
+{
+    const Stage completed_stage{m_stage};
+    m_stage = Stage::None;
+    if (!m_destroying) setBusy(false);
+
+    if (const auto* error{std::get_if<interfaces::ProviderTxError>(&result)}) {
+        m_unlock.reset();
+        if (!m_destroying) {
+            QMessageBox::critical(this, tr("Registration failed"), ProviderTxErrorText(*error));
+        }
+        return;
+    }
+
+    const auto& submission{std::get<interfaces::ProviderTxSubmission>(result)};
+    if (!submission.tx) {
+        if (completed_stage == Stage::Submit && submission.submitted) {
+            // A broadcast submit owns the registered collateral lock even if
+            // its malformed result omitted the transaction object.
+            m_prepared_collateral_lock_acquired = false;
+        }
+        m_unlock.reset();
+        if (!m_destroying) showError(tr("The registration completed without returning a transaction."));
+        return;
+    }
+    if (!submission.submitted) {
+        m_unlock.reset();
+        if (!m_destroying) showError(tr("The registration transaction was created but was not sent to the network."));
+        return;
+    }
+    if (completed_stage == Stage::Submit) m_prepared_collateral_lock_acquired = false;
+    m_unlock.reset();
+    completeRegistration(submission.tx);
+}
+
+void RegisterMasternodeWizard::finishPrepare(
+    interfaces::ProviderTxResult<interfaces::PreparedProviderRegistration> result)
+{
+    m_stage = Stage::None;
+    m_unlock.reset();
+    if (!m_destroying) setBusy(false);
+
+    if (const auto* error{std::get_if<interfaces::ProviderTxError>(&result)}) {
+        if (!m_destroying) {
+            QMessageBox::critical(this, tr("Registration failed"), ProviderTxErrorText(*error));
+        }
+        return;
+    }
+
+    auto prepared{std::get<interfaces::PreparedProviderRegistration>(std::move(result))};
+    if (!prepared.tx) {
+        if (prepared.collateral_lock_acquired && m_walletModel != nullptr) {
+            m_walletModel->wallet().unlockCoin(m_prepared_collateral_outpoint);
+        }
+        if (!m_destroying) showError(tr("The prepare operation completed without returning a transaction."));
+        return;
+    }
+    m_prepared_tx = std::move(prepared.tx);
+    m_prepared_collateral_lock_acquired = prepared.collateral_lock_acquired;
+    m_sign_address_label->setText(
+        tr("Collateral address holding the key: %1")
+            .arg(QString::fromStdString(EncodeDestination(prepared.collateral_address))));
+    m_sign_message->setPlainText(QString::fromStdString(prepared.sign_message));
+    if (!m_destroying) goToPage(PageSign);
+}
+
+void RegisterMasternodeWizard::populateResult(const QString& pro_tx_hash)
+{
+    m_registered = true;
+    m_result_label->setText(tr("The registration transaction was sent to the network."));
+    m_result_hash->setText(pro_tx_hash);
+    m_result_tx_note->setText(
+        isExternalCollateral() ?
+            tr("It is recorded in this wallet and appears under Transactions. The external collateral remains "
+               "at the outpoint you registered and is not controlled by this wallet.") :
+            tr("It is recorded in this wallet and appears under Transactions. The collateral stays in the wallet "
+               "but is locked while the masternode is registered."));
+
+    // The card already carries the "Next steps" heading. Keep numbering in
+    // markup so conditional steps never force translators to renumber strings.
+    QStringList steps;
+    if (m_operator_widget->hasGeneratedSecret()) {
+        steps << tr(
+            "Configure your masternode server with the operator secret key you saved, then restart dashd there.");
+    } else {
+        steps << tr(
+            "Configure your masternode server with the BLS secret key matching the operator public key you provided.");
+    }
+    const bool has_service{!MasternodeWidgetUtil::tokenizeEndpointList(m_service_edit->text()).isEmpty()};
+    if (has_service) {
+        steps << tr("Make sure every registered service address and port is reachable from the internet.");
+    } else {
+        steps << tr("Send an Update Service transaction after the node's service endpoints are ready; it stays "
+                    "inactive until then.");
+    }
+    if (isEvo()) {
+        steps << tr("Provision the Dash Platform services (Tenderdash and Drive) with the Platform node key matching "
+                    "the node ID you registered.");
+        steps << tr("The EvoNode becomes active once the registration is confirmed and the first update is signed by "
+                    "the operator.");
+    } else {
+        steps << tr("The masternode becomes active once the registration is confirmed on the network.");
+    }
+    QString html{"<ol>"};
+    for (const QString& step : steps)
+        html += QString("<li>%1</li>").arg(step.toHtmlEscaped());
+    html += "</ol>";
+    m_next_steps->setText(html);
+}
+
+void RegisterMasternodeWizard::reject()
+{
+    if (m_busy) return;
+    if (m_registered) {
+        QDialog::accept();
+        return;
+    }
+    if (m_prepared_tx) {
+        if (QMessageBox::warning(this, tr("Discard prepared registration?"),
+                                 tr("The prepared registration will be discarded. Any collateral lock acquired "
+                                    "by this wizard will be released."),
+                                 QMessageBox::Yes | QMessageBox::No, QMessageBox::No) != QMessageBox::Yes) {
+            return;
+        }
+        if (m_prepared_collateral_lock_acquired && m_walletModel != nullptr) {
+            m_walletModel->wallet().unlockCoin(m_prepared_collateral_outpoint);
+            m_prepared_collateral_lock_acquired = false;
+        }
+        m_prepared_tx.reset();
+    }
+    QDialog::reject();
+}
diff --git a/src/qt/masternodewizard.h b/src/qt/masternodewizard.h
new file mode 100644
index 000000000000..eb77c315e6bc
--- /dev/null
+++ b/src/qt/masternodewizard.h
@@ -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.
+
+#ifndef BITCOIN_QT_MASTERNODEWIZARD_H
+#define BITCOIN_QT_MASTERNODEWIZARD_H
+
+#include <consensus/amount.h>
+#include <interfaces/providertx.h>
+#include <qt/masternodeoperationrunner.h>
+
+#include <QDialog>
+#include <QString>
+#include <QVector>
+
+#include <memory>
+#include <optional>
+#include <set>
+
+class FeeSourcePicker;
+class MasternodeWidgetTests;
+class OperatorKeyWidget;
+class QValidatedLineEdit;
+class WalletModel;
+
+namespace interfaces {
+class Node;
+} // namespace interfaces
+
+QT_BEGIN_NAMESPACE
+class QComboBox;
+class QDoubleSpinBox;
+class QLabel;
+class QLineEdit;
+class QPlainTextEdit;
+class QProgressBar;
+class QPushButton;
+class QRadioButton;
+class QSpinBox;
+class QStackedWidget;
+class QVBoxLayout;
+QT_END_NAMESPACE
+
+//! Multi-page dialog registering a masternode or EvoNode: collects collateral,
+//! service, key, payout and fee-source details, then invokes the typed provider
+//! transaction interface on a worker thread. Supports funding the collateral
+//! from the wallet, referencing an exact-denomination UTXO already in the
+//! wallet, and external collateral signed out of band.
+class RegisterMasternodeWizard : public QDialog
+{
+    Q_OBJECT
+
+public:
+    explicit RegisterMasternodeWizard(interfaces::Node& node, WalletModel* walletModel, QWidget* parent = nullptr);
+    ~RegisterMasternodeWizard() override;
+
+public Q_SLOTS:
+    void reject() override;
+
+private Q_SLOTS:
+    void onNext();
+    void onBack();
+
+private:
+    friend class MasternodeWidgetTests;
+
+    static constexpr int VOUT_ROLE{Qt::UserRole + 1};
+    static constexpr int COLLATERAL_ADDRESS_ROLE{Qt::UserRole + 2};
+
+    enum Page : int {
+        PageType = 0,
+        PageCollateral,
+        PageService,
+        PageKeys,
+        PagePayout,
+        PagePlatform,
+        PageFee,
+        PageReview,
+        PageSecret,
+        PageSign,
+        PageResult,
+    };
+    //! Which typed operation is in flight
+    enum class Stage {
+        None,
+        Register,
+        Prepare,
+        Submit,
+    };
+
+    QWidget* createTypePage();
+    QWidget* createCollateralPage();
+    QWidget* createServicePage();
+    QWidget* createKeysPage();
+    QWidget* createPayoutPage();
+    QWidget* createPlatformPage();
+    QWidget* createFeePage();
+    QWidget* createReviewPage();
+    QWidget* createSecretPage();
+    QWidget* createSignPage();
+    QWidget* createResultPage();
+
+    bool isEvo() const;
+    bool usesExtendedAddresses() const;
+    bool isExternalCollateral() const;
+    bool isFundCollateral() const;
+    std::optional<CTxDestination> knownCollateralDestination() const;
+    QString collateralAddress() const;
+    QString ownerAddress() const;
+    QString votingAddress() const;
+    QString freshAddress(QString& err) const;
+    CAmount collateralAmount() const;
+    //! True when the user typed the generated operator secret's last 4 characters
+    bool secretConfirmed() const;
+    //! True while the generated operator secret exists nowhere but this dialog.
+    bool secretGateRequired() const;
+
+    void rebuildOrder();
+    Page currentPage() const;
+    QString pageTitle(Page page) const;
+    void updateProgress();
+    void goToPage(Page page);
+    void enterPage(Page page);
+    bool validatePage(Page page, QString& err);
+    interfaces::ProviderNetInfo providerNetInfo() const;
+    bool validateProviderNetInfo(bool optional, QString& err) const;
+    void updateButtons();
+    void onPageEdited();
+    void setBusy(bool busy, const QString& busy_text = QString());
+    void showError(const QString& message);
+    bool confirmBroadcast();
+
+    void refreshCollateralCandidates();
+    void refreshCollateralCandidates(const std::set<COutPoint>& registered_collaterals);
+    void completeRegistration(const CTransactionRef& transaction);
+    void populateReview();
+    //! Width of the review's label column, shared by every section
+    int reviewLabelWidth(const QWidget* card) const;
+    //! One line saying where the operator key comes from and whether it can be
+    //! seen again
+    QString operatorKeyProvenance() const;
+    void populateSecret();
+    void populateResult(const QString& pro_tx_hash);
+    std::optional<interfaces::ProviderRegistrationRequest> buildRegistrationRequest(QString& error) const;
+    void startRegistration(bool skip_confirmation = false);
+    void startSubmit(bool skip_confirmation = false);
+    void finishSubmission(MasternodeOperationRunner::SubmissionResult result);
+    void finishPrepare(interfaces::ProviderTxResult<interfaces::PreparedProviderRegistration> result);
+
+    interfaces::Node& m_node;
+    WalletModel* const m_walletModel;
+    std::unique_ptr<MasternodeOperationRunner> m_runner;
+    Stage m_stage{Stage::None};
+    struct UnlockHolder;
+    std::unique_ptr<UnlockHolder> m_unlock;
+
+    QVector<Page> m_order;
+    int m_pos{0};
+    bool m_busy{false};
+    bool m_destroying{false};
+    bool m_registered{false};
+    bool m_platform_extended_addresses{false};
+    uint16_t m_platform_provider_version{0};
+    std::optional<Page> m_validation_page;
+
+    QStackedWidget* m_pages;
+    QLabel* m_progress_label{nullptr};
+    QLabel* m_error_label;
+    QProgressBar* m_busy_bar;
+    QPushButton* m_back_button;
+    QPushButton* m_next_button;
+    QPushButton* m_cancel_button;
+
+    // Type page
+    QRadioButton* m_type_regular;
+    QRadioButton* m_type_evo;
+    // Collateral page
+    QRadioButton* m_col_fund;
+    QRadioButton* m_col_wallet;
+    QRadioButton* m_col_external;
+    QWidget* m_col_fund_box;
+    QWidget* m_col_wallet_box;
+    QWidget* m_col_external_box;
+    QValidatedLineEdit* m_col_address;
+    QComboBox* m_col_utxo_combo;
+    QLabel* m_col_utxo_none;
+    QLineEdit* m_col_txid;
+    QSpinBox* m_col_vout;
+    // Service page
+    QLineEdit* m_service_edit;
+    // Keys page
+    QValidatedLineEdit* m_owner_edit;
+    QValidatedLineEdit* m_voting_edit;
+    OperatorKeyWidget* m_operator_widget{nullptr};
+    // Payout page
+    QValidatedLineEdit* m_payout_edit;
+    QDoubleSpinBox* m_operator_reward;
+    QLabel* m_reward_warning;
+    // Platform page. Pre-v24 ProTxs only store bare platform ports; the
+    // ADDR:PORT list form requires a version 3 ProTx (v24 active).
+    QLineEdit* m_platform_nodeid;
+    QWidget* m_platform_addr_box;
+    QLineEdit* m_platform_p2p;
+    QLineEdit* m_platform_https;
+    QWidget* m_platform_port_box;
+    QSpinBox* m_platform_p2p_port;
+    QSpinBox* m_platform_https_port;
+    // Fee page
+    FeeSourcePicker* m_fee_picker;
+    QLabel* m_fee_explain;
+    // Review page. The sections are rebuilt on every entry, so the layout owns
+    // the rows rather than a single rich-text label.
+    QWidget* m_review_container;
+    QVBoxLayout* m_review_layout;
+    // Generated-secret page. Confirmation is required before any operation
+    // can broadcast a registration using the generated key.
+    QLabel* m_secret_note;
+    QLineEdit* m_secret_edit;
+    QLineEdit* m_conf_line_edit;
+    QLineEdit* m_confirm_edit;
+    // Sign page (external collateral)
+    QLabel* m_sign_address_label;
+    QPlainTextEdit* m_sign_message;
+    QPlainTextEdit* m_sig_edit;
+    CTransactionRef m_prepared_tx;
+    COutPoint m_prepared_collateral_outpoint;
+    bool m_prepared_collateral_lock_acquired{false};
+    // Result page
+    QLabel* m_result_label;
+    QLabel* m_result_hash;
+    QLabel* m_result_tx_note;
+    QLabel* m_next_steps;
+};
+
+#endif // BITCOIN_QT_MASTERNODEWIZARD_H
diff --git a/src/qt/res/css/dark.css b/src/qt/res/css/dark.css
index 1f1ab164f185..04bbfd71562a 100644
--- a/src/qt/res/css/dark.css
+++ b/src/qt/res/css/dark.css
@@ -17,7 +17,7 @@ Loaded in GUIUtil::loadStyleSheet() in guitil.cpp.
 /* do not modify! section updated by update-css-files.py
 <colors>
 
-# Used colors in dark.css for commit 44de8a93f2
+# Used colors in dark.css for commit f645c6e71615
 
 #00000000
 #333
@@ -27,6 +27,7 @@ Loaded in GUIUtil::loadStyleSheet() in guitil.cpp.
 #323233
 #363637
 #39393b
+#3c3c3c
 #4a4a4b
 #585858
 #818181
@@ -53,6 +54,11 @@ QWidget { /* override text selection background color for all text widgets */
     selection-background-color: #c7c7c7;
 }
 
+QFrame#mnCard {
+    border: 1px solid #4a4a4b;
+    border-radius: 3px;
+}
+
 QCheckBox,
 QLabel,
 QListView,
diff --git a/src/qt/res/css/general.css b/src/qt/res/css/general.css
index f166061a1f2f..48cb8e037d10 100644
--- a/src/qt/res/css/general.css
+++ b/src/qt/res/css/general.css
@@ -30,7 +30,7 @@ in the <theme.css> file.
 /* do not modify! section updated by update-css-files.py
 <colors>
 
-# Used colors in general.css for commit 44de8a93f2
+# Used colors in general.css for commit f645c6e71615
 
 #00000000
 #222222
@@ -58,6 +58,11 @@ QDialog {
     border: 0px;
 }
 
+QFrame#mnCard {
+    background-color: #00000000;
+    border-radius: 3px;
+}
+
 QMessageBox {
 }
 
@@ -806,7 +811,9 @@ QRadioButton::indicator:unchecked:disabled {
 QScrollArea
 ******************************************************/
 
-.QScrollArea {
+QScrollArea#mnWizardScroll,
+QScrollArea#mnWizardScroll > QWidget,
+QScrollArea#mnWizardScroll > QWidget > QWidget {
     background-color: #00000000;
     border: 0px;
 }
diff --git a/src/qt/res/css/light.css b/src/qt/res/css/light.css
index 7c2bc7e9513d..574d72017cec 100644
--- a/src/qt/res/css/light.css
+++ b/src/qt/res/css/light.css
@@ -17,7 +17,7 @@ Loaded in GUIUtil::loadStyleSheet() in guitil.cpp.
 /* do not modify! section updated by update-css-files.py
 <colors>
 
-# Used colors in light.css for commit 44de8a93f2
+# Used colors in light.css for commit f645c6e71615
 
 #00000000
 #555
@@ -30,6 +30,7 @@ Loaded in GUIUtil::loadStyleSheet() in guitil.cpp.
 #e0e0e0
 #eaeaec
 #f2f2f4
+#ffffff
 #ccfafafa
 
 </colors>
@@ -51,6 +52,11 @@ QWidget { /* override text selection background color for all text widgets */
     selection-background-color: #555;
 }
 
+QFrame#mnCard {
+    border: 1px solid #dcdcdc;
+    border-radius: 3px;
+}
+
 QCheckBox,
 QLabel,
 QListView,
diff --git a/src/qt/res/css/traditional.css b/src/qt/res/css/traditional.css
index b1b9870710f3..cfce68c83f3d 100644
--- a/src/qt/res/css/traditional.css
+++ b/src/qt/res/css/traditional.css
@@ -17,20 +17,29 @@ Loaded in GUIUtil::loadStyleSheet() in guitil.cpp.
 /* do not modify! section updated by update-css-files.py
 <colors>
 
-# Used colors in traditional.css for commit 44de8a93f2
+# Used colors in traditional.css for commit f645c6e71615
 
 #00000000
-#222222
 #333
 #fff
 #008de4
 #047ac2
+#222222
+#808080
+#a7a7a7
 #a84832
+#c79304
+#ffffff
 #ccfafafa
 
 </colors>
 */
 
+QFrame#mnCard {
+    border: 1px solid #808080;
+    border-radius: 3px;
+}
+
 /******************************************************
 QToolBar / QToolButton
 ******************************************************/
diff --git a/src/qt/test/masternodemaintenancetests.cpp b/src/qt/test/masternodemaintenancetests.cpp
new file mode 100644
index 000000000000..8b183a7e1935
--- /dev/null
+++ b/src/qt/test/masternodemaintenancetests.cpp
@@ -0,0 +1,529 @@
+// 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/masternodemaintenancetests.h>
+
+#include <bls/bls.h>
+#include <chainparams.h>
+#include <interfaces/node.h>
+#include <key_io.h>
+#include <netaddress.h>
+#include <netbase.h>
+#include <qt/masternodedialogs.h>
+#include <qt/masternodemodel.h>
+#include <qt/masternodewidgets.h>
+#include <qt/qvalidatedlineedit.h>
+#include <script/standard.h>
+#include <test/util/setup_common.h>
+#include <tinyformat.h>
+#include <univalue.h>
+#include <util/translation.h>
+
+#include <QApplication>
+#include <QLabel>
+#include <QLineEdit>
+#include <QMessageBox>
+#include <QSignalSpy>
+#include <QSpinBox>
+#include <QTest>
+#include <QTimer>
+
+#include <limits>
+#include <memory>
+#include <string>
+#include <utility>
+
+namespace {
+
+class TestMnEntry final : public interfaces::MnEntry
+{
+public:
+    explicit TestMnEntry(MnType type = MnType::Evo, bool legacy_operator_display = false, uint16_t operator_reward = 0) :
+        interfaces::MnEntry(CDeterministicMNCPtr{}),
+        m_type{type},
+        m_owner{NewKeyID()},
+        m_voting{NewKeyID()},
+        m_payout{GetScriptForDestination(PKHash{NewKeyID()})},
+        m_operator_payout{operator_reward ? GetScriptForDestination(PKHash{NewKeyID()}) : CScript{}},
+        m_operator_reward{operator_reward},
+        m_core_endpoint{strprintf("127.0.0.1:%d", Params().GetDefaultPort())}
+    {
+        m_hash.SetHex("01");
+        m_primary_service = LookupNumeric("127.0.0.1", 19999);
+        setOperatorKey(legacy_operator_display);
+    }
+
+    bool isBanned() const override { return m_banned; }
+    CService getNetInfoPrimary() const override { return m_primary_service; }
+    std::vector<CService> getPlatformHTTPSAddrs() const override { return {}; }
+    MnType getType() const override { return m_type; }
+    UniValue toJson() const override
+    {
+        UniValue result(UniValue::VOBJ);
+        result.pushKV("collateralHash", uint256::ONE.ToString());
+        result.pushKV("collateralIndex", 0);
+        UniValue state(UniValue::VOBJ);
+        state.pushKV("version", m_operator_version);
+        state.pushKV("consecutivePayments", 1);
+        state.pushKV("PoSeBanHeight", -1);
+        state.pushKV("PoSeRevivedHeight", -1);
+        state.pushKV("pubKeyOperator", m_operator_display);
+        state.pushKV("platformNodeID", m_platform_node_id);
+        if (!m_core_endpoint.empty() || !m_platform_p2p.empty() || !m_platform_https.empty()) {
+            UniValue addresses(UniValue::VOBJ);
+            addresses.pushKV("core_p2p", StringArray(m_core_endpoint));
+            addresses.pushKV("platform_p2p", StringArray(m_platform_p2p));
+            addresses.pushKV("platform_https", StringArray(m_platform_https));
+            state.pushKV("addresses", addresses);
+        }
+        result.pushKV("state", state);
+        return result;
+    }
+    const CKeyID& getKeyIdOwner() const override { return m_owner; }
+    const CKeyID& getKeyIdVoting() const override { return m_voting; }
+    const COutPoint& getCollateralOutpoint() const override { return m_collateral; }
+    const CScript& getScriptPayout() const override { return m_payout; }
+    std::vector<CScript> getScriptPayouts() const override { return {m_payout}; }
+    const CScript& getScriptOperatorPayout() const override { return m_operator_payout; }
+    const int32_t& getLastPaidHeight() const override { return m_last_paid; }
+    const int32_t& getPoSePenalty() const override { return m_penalty; }
+    const int32_t& getRegisteredHeight() const override { return m_registered; }
+    const uint16_t& getOperatorReward() const override { return m_operator_reward; }
+    const uint256& getProTxHash() const override { return m_hash; }
+    const CBLSSecretKey& operatorSecret() const { return m_operator_secret; }
+
+    void mutate()
+    {
+        m_voting = NewKeyID();
+        m_payout = GetScriptForDestination(PKHash{NewKeyID()});
+        m_operator_payout = GetScriptForDestination(PKHash{NewKeyID()});
+        m_operator_reward = 500;
+        m_core_endpoint = "127.0.0.2:20001";
+        m_platform_p2p = "127.0.0.2:26657";
+        m_platform_https = "api.example.org:8443";
+        m_platform_node_id = "2222222222222222222222222222222222222222";
+        setOperatorKey(/*legacy_display=*/false);
+    }
+
+    void clearEndpoints()
+    {
+        m_primary_service = {};
+        m_core_endpoint.clear();
+        m_platform_p2p.clear();
+        m_platform_https.clear();
+    }
+
+    void setPlatformEndpoints(std::string p2p, std::string https)
+    {
+        m_platform_p2p = std::move(p2p);
+        m_platform_https = std::move(https);
+    }
+
+private:
+    static CKeyID NewKeyID()
+    {
+        static unsigned int counter{1};
+        CKeyID key_id;
+        key_id.SetHex(strprintf("%040u", counter++));
+        return key_id;
+    }
+
+    static UniValue StringArray(const std::string& value)
+    {
+        UniValue result(UniValue::VARR);
+        if (!value.empty()) result.push_back(value);
+        return result;
+    }
+
+    void setOperatorKey(bool legacy_display)
+    {
+        CBLSSecretKey key;
+        key.MakeNewKey();
+        m_operator_secret = key;
+        const auto public_key{key.GetPublicKey()};
+        m_operator_display = public_key.ToString(legacy_display);
+        m_operator_version = legacy_display ? ProTxVersion::LegacyBLS : ProTxVersion::BasicBLS;
+    }
+
+    bool m_banned{false};
+    MnType m_type;
+    CKeyID m_owner;
+    CKeyID m_voting;
+    COutPoint m_collateral{uint256::ONE, 0};
+    CScript m_payout;
+    CScript m_operator_payout;
+    int32_t m_last_paid{10};
+    int32_t m_penalty{0};
+    int32_t m_registered{1};
+    uint16_t m_operator_reward{0};
+    uint256 m_hash;
+    uint16_t m_operator_version{ProTxVersion::BasicBLS};
+    CBLSSecretKey m_operator_secret;
+    CService m_primary_service;
+    std::string m_operator_display;
+    std::string m_core_endpoint;
+    std::string m_platform_p2p{"127.0.0.1:26656"};
+    std::string m_platform_https{"api.example.com:443"};
+    std::string m_platform_node_id{"1111111111111111111111111111111111111111"};
+};
+
+} // anonymous namespace
+
+void MasternodeMaintenanceTests::automaticFeeSource()
+{
+    FeeSourcePicker picker;
+    picker.setAutomaticOption("Automatic (recommended)");
+    QCOMPARE(picker.count(), 1);
+    QCOMPARE(picker.currentText(), QString("Automatic (recommended)"));
+    QVERIFY(picker.selectedAddress().isEmpty());
+}
+
+void MasternodeMaintenanceTests::operatorSecretValidation()
+{
+    OperatorSecretWidget widget;
+    QVERIFY(!widget.isValid());
+
+    CBLSSecretKey key;
+    key.MakeNewKey();
+    auto* edit{widget.findChild<QLineEdit*>()};
+    QVERIFY(edit != nullptr);
+    edit->setText(QString::fromStdString(key.ToString(/*specificLegacyScheme=*/false)));
+    QVERIFY(widget.isValid());
+    const auto parsed{widget.takeSecret()};
+    QVERIFY(parsed.has_value());
+    QCOMPARE(parsed->GetPublicKey().ToByteVector(false), key.GetPublicKey().ToByteVector(false));
+    QVERIFY(edit->text().isEmpty());
+    QVERIFY(!widget.isValid());
+
+    edit->setText("not-a-secret");
+    QVERIFY(!widget.takeSecret().has_value());
+    QVERIFY(edit->text().isEmpty());
+}
+
+void MasternodeMaintenanceTests::operatorPublicKeyEncoding()
+{
+    auto source{std::make_shared<TestMnEntry>(MnType::Evo, /*legacy_operator_display=*/true)};
+    MasternodeEntry entry{source, "collateral", 50};
+
+    const auto raw{entry.operatorPubKeyBytes()};
+    CBLSPublicKey public_key;
+    public_key.SetBytes(raw, /*specificLegacyScheme=*/false);
+    QVERIFY(public_key.IsValid());
+    QCOMPARE(entry.operatorPubKey(/*legacy_scheme=*/false),
+             QString::fromStdString(public_key.ToString(/*specificLegacyScheme=*/false)));
+    QCOMPARE(entry.operatorPubKey(/*legacy_scheme=*/true),
+             QString::fromStdString(public_key.ToString(/*specificLegacyScheme=*/true)));
+    QVERIFY(entry.operatorPubKey(/*legacy_scheme=*/false) != entry.operatorPubKey(/*legacy_scheme=*/true));
+}
+
+void MasternodeMaintenanceTests::actionRoleGating()
+{
+    using MasternodeMaintenance::actionAvailability;
+
+    const auto no_wallet{actionAvailability(false, false)};
+    QVERIFY(!no_wallet.update_service);
+    QVERIFY(!no_wallet.update_registrar);
+    QVERIFY(!no_wallet.revoke);
+
+    const auto operator_only{actionAvailability(true, false)};
+    QVERIFY(operator_only.update_service);
+    QVERIFY(!operator_only.update_registrar);
+    QVERIFY(operator_only.revoke);
+
+    const auto owner{actionAvailability(true, true)};
+    QVERIFY(owner.update_service);
+    QVERIFY(owner.update_registrar);
+    QVERIFY(owner.revoke);
+}
+
+void MasternodeMaintenanceTests::reconcileMutableFields()
+{
+    auto initial{std::make_shared<TestMnEntry>()};
+    MasternodeEntryList first;
+    first.push_back(std::make_shared<MasternodeEntry>(initial, "collateral", 50));
+
+    MasternodeModel model;
+    model.reconcile(std::move(first));
+    const MasternodeEntry* entry{model.getEntryAt(model.index(0, 0))};
+    QVERIFY(entry != nullptr);
+    const QString initial_operator{entry->operatorPubKey()};
+    const QString initial_voting{entry->votingAddress()};
+    const QString initial_payout{entry->payoutAddress()};
+    QCOMPARE(entry->coreP2PAddresses(), QString("127.0.0.1:%1").arg(Params().GetDefaultPort()));
+    QCOMPARE(entry->platformNodeID(), QString("1111111111111111111111111111111111111111"));
+
+    auto updated{std::make_shared<TestMnEntry>()};
+    updated->mutate();
+    MasternodeEntryList second;
+    second.push_back(std::make_shared<MasternodeEntry>(updated, "collateral", 50));
+    model.reconcile(std::move(second));
+
+    entry = model.getEntryAt(model.index(0, 0));
+    QVERIFY(entry != nullptr);
+    QCOMPARE(entry->coreP2PAddresses(), QString("127.0.0.2:20001"));
+    QCOMPARE(entry->platformP2PAddresses(), QString("127.0.0.2:26657"));
+    QCOMPARE(entry->platformHTTPSAddresses(), QString("api.example.org:8443"));
+    QCOMPARE(entry->platformNodeID(), QString("2222222222222222222222222222222222222222"));
+    QVERIFY(entry->operatorPubKey() != initial_operator);
+    QVERIFY(entry->votingAddress() != initial_voting);
+    QVERIFY(entry->payoutAddress() != initial_payout);
+    QVERIFY(!entry->operatorPayoutAddress().isEmpty());
+    QCOMPARE(entry->operatorRewardPct(), uint16_t{500});
+
+    auto inactive{std::make_shared<TestMnEntry>()};
+    inactive->clearEndpoints();
+    const MasternodeEntry inactive_entry{inactive, "collateral", 50};
+    QVERIFY(inactive_entry.coreP2PAddresses().isEmpty());
+    QVERIFY(inactive_entry.platformP2PAddresses().isEmpty());
+    QVERIFY(inactive_entry.platformHTTPSAddresses().isEmpty());
+    const QString inactive_html{inactive_entry.toHtml()};
+    QVERIFY(!inactive_html.contains("Network Addresses"));
+    QVERIFY(!inactive_html.contains("Platform P2P Addresses"));
+    QVERIFY(!inactive_html.contains("Platform HTTPS Addresses"));
+}
+
+void MasternodeMaintenanceTests::serviceRequestConstruction()
+{
+    TestChain100Setup test;
+    m_node.setContext(&test.m_node);
+
+    const auto check_request = [this](MnType type, interfaces::ProviderTxCapabilities capabilities) {
+        auto source{std::make_shared<TestMnEntry>(type, capabilities.version == ProTxVersion::LegacyBLS,
+                                                  /*operator_reward=*/500)};
+        MasternodeEntry entry{source, "collateral", 50};
+        UpdateServiceDialog dialog(m_node, /*wallet_model=*/nullptr, entry, capabilities, /*parent=*/nullptr);
+        QString error;
+        const auto request{dialog.buildRequest(source->operatorSecret(), error)};
+        QVERIFY2(request.has_value(), qPrintable(error));
+        QCOMPARE(request->type, type);
+        QCOMPARE(request->pro_tx_hash, source->getProTxHash());
+        QCOMPARE(request->operator_key.GetPublicKey().ToByteVector(false),
+                 source->operatorSecret().GetPublicKey().ToByteVector(false));
+        QCOMPARE(request->net_info.core_p2p, std::vector<std::string>{entry.coreP2PAddresses().toStdString()});
+        QVERIFY(request->operator_payout.has_value());
+        QVERIFY(!request->fee_source.has_value());
+        QVERIFY(request->submit);
+
+        if (type == MnType::Regular) {
+            QVERIFY(std::holds_alternative<std::monostate>(request->net_info.platform_p2p));
+            QVERIFY(std::holds_alternative<std::monostate>(request->net_info.platform_https));
+            QVERIFY(!request->platform_node_id.has_value());
+        } else if (capabilities.extended_addresses) {
+            QCOMPARE(std::get<std::vector<std::string>>(request->net_info.platform_p2p),
+                     std::vector<std::string>{"127.0.0.1:26656"});
+            QCOMPARE(std::get<std::vector<std::string>>(request->net_info.platform_https),
+                     std::vector<std::string>{"api.example.com:443"});
+            QVERIFY(request->platform_node_id.has_value());
+        } else {
+            QCOMPARE(std::get<uint16_t>(request->net_info.platform_p2p), uint16_t{26656});
+            QCOMPARE(std::get<uint16_t>(request->net_info.platform_https), uint16_t{443});
+            QVERIFY(request->platform_node_id.has_value());
+        }
+
+        if (type == MnType::Evo) {
+            auto* const secret_edit{dialog.m_operator_key->findChild<QLineEdit*>()};
+            QVERIFY(secret_edit != nullptr);
+            secret_edit->setText(QString::fromStdString(source->operatorSecret().ToString(/*specificLegacyScheme=*/false)));
+            QVERIFY(dialog.m_valid);
+
+            dialog.m_platform_node_id_edit->setText(QString(40, QLatin1Char('0')));
+            QVERIFY(!dialog.m_valid);
+            error.clear();
+            QVERIFY(!dialog.buildRequest(source->operatorSecret(), error).has_value());
+            QVERIFY(error.contains("Platform node ID"));
+        }
+    };
+
+    check_request(MnType::Regular, {ProTxVersion::BasicBLS, false});
+    check_request(MnType::Evo, {ProTxVersion::BasicBLS, false});
+    check_request(MnType::Evo, {ProTxVersion::ExtAddr, true});
+
+    auto malformed_source{std::make_shared<TestMnEntry>(MnType::Evo)};
+    malformed_source->setPlatformEndpoints("missing-port", "api.example.com:not-a-port");
+    MasternodeEntry malformed_entry{malformed_source, "collateral", 50};
+    UpdateServiceDialog fallback_dialog(m_node, /*wallet_model=*/nullptr, malformed_entry,
+                                        interfaces::ProviderTxCapabilities{ProTxVersion::BasicBLS, false},
+                                        /*parent=*/nullptr);
+    QCOMPARE(fallback_dialog.m_platform_p2p_port_edit->value(), Params().GetDefaultPlatformP2PPort());
+    QCOMPARE(fallback_dialog.m_platform_https_port_edit->value(), Params().GetDefaultPlatformHTTPPort());
+
+    QString error;
+    const auto fallback_request{fallback_dialog.buildRequest(malformed_source->operatorSecret(), error)};
+    QVERIFY2(fallback_request.has_value(), qPrintable(error));
+    QCOMPARE(std::get<uint16_t>(fallback_request->net_info.platform_p2p), Params().GetDefaultPlatformP2PPort());
+    QCOMPARE(std::get<uint16_t>(fallback_request->net_info.platform_https), Params().GetDefaultPlatformHTTPPort());
+}
+
+void MasternodeMaintenanceTests::registrarRequestConstruction()
+{
+    TestChain100Setup test;
+    m_node.setContext(&test.m_node);
+
+    for (const interfaces::ProviderTxCapabilities capabilities :
+         {interfaces::ProviderTxCapabilities{ProTxVersion::LegacyBLS, false},
+          interfaces::ProviderTxCapabilities{ProTxVersion::ExtAddr, true}}) {
+        auto source{std::make_shared<TestMnEntry>(MnType::Regular, capabilities.version == ProTxVersion::LegacyBLS)};
+        MasternodeEntry entry{source, "collateral", 50};
+        UpdateRegistrarDialog dialog(m_node, /*wallet_model=*/nullptr, entry, capabilities, /*parent=*/nullptr);
+        QString error;
+
+        const auto unchanged{dialog.buildRequest(error)};
+        QVERIFY2(unchanged.has_value(), qPrintable(error));
+        QVERIFY(!unchanged->operator_key.has_value());
+        QVERIFY(!unchanged->voting_key.has_value());
+        QVERIFY(!unchanged->payouts.has_value());
+        QVERIFY(unchanged->submit);
+
+        dialog.m_voting_edit->setText(QString::fromStdString(EncodeDestination(PKHash{uint160{}})));
+        QVERIFY(!dialog.m_valid);
+        error.clear();
+        QVERIFY(!dialog.buildRequest(error).has_value());
+        QVERIFY(error.contains("voting address"));
+
+        CBLSSecretKey replacement;
+        replacement.MakeNewKey();
+        dialog.m_operator_pubkey_edit->setText(
+            QString::fromStdString(replacement.GetPublicKey().ToString(capabilities.version == ProTxVersion::LegacyBLS)));
+        CKeyID voting;
+        voting.SetHex("42");
+        dialog.m_voting_edit->setText(QString::fromStdString(EncodeDestination(PKHash{voting})));
+        CKeyID payout;
+        payout.SetHex("43");
+        dialog.m_payout_edit->setText(QString::fromStdString(EncodeDestination(PKHash{payout})));
+
+        error.clear();
+        const auto changed{dialog.buildRequest(error)};
+        QVERIFY2(changed.has_value(), qPrintable(error));
+        QVERIFY(changed->operator_key.has_value());
+        QCOMPARE(changed->operator_key->ToByteVector(false), replacement.GetPublicKey().ToByteVector(false));
+        QCOMPARE(changed->voting_key, std::optional<CKeyID>{voting});
+        QVERIFY(changed->payouts.has_value());
+        QCOMPARE(changed->payouts->size(), size_t{1});
+        QCOMPARE(changed->payouts->front().destination, CTxDestination{PKHash{payout}});
+        QCOMPARE(changed->payouts->front().reward, interfaces::ProviderPayout::MAX_REWARD);
+        QCOMPARE(changed->uses_extended_payouts, capabilities.version >= ProTxVersion::ExtAddr);
+        QCOMPARE(changed->use_legacy_bls_scheme, capabilities.version == ProTxVersion::LegacyBLS);
+    }
+}
+
+void MasternodeMaintenanceTests::revokeRequestConstruction()
+{
+    TestChain100Setup test;
+    m_node.setContext(&test.m_node);
+    auto source{std::make_shared<TestMnEntry>(MnType::Regular)};
+    MasternodeEntry entry{source, "collateral", 50};
+    RevokeDialog dialog(m_node, /*wallet_model=*/nullptr, entry, /*parent=*/nullptr);
+
+    for (int reason = 0; reason <= 3; ++reason) {
+        dialog.m_reason_combo->setCurrentIndex(reason);
+        QString error;
+        const auto request{dialog.buildRequest(source->operatorSecret(), error)};
+        QVERIFY2(request.has_value(), qPrintable(error));
+        QCOMPARE(request->pro_tx_hash, source->getProTxHash());
+        QCOMPARE(request->reason, static_cast<uint16_t>(reason));
+        QVERIFY(!request->fee_source.has_value());
+        QVERIFY(request->submit);
+    }
+}
+
+void MasternodeMaintenanceTests::dialogFieldGeometry()
+{
+#if defined(Q_OS_MACOS)
+    if (QApplication::platformName() == "minimal") {
+        QWARN("Skipping dialogFieldGeometry on macOS with the minimal platform due to QTBUG-49686");
+        return;
+    }
+#endif
+    TestChain100Setup test;
+    m_node.setContext(&test.m_node);
+    auto source{std::make_shared<TestMnEntry>(MnType::Regular)};
+    MasternodeEntry entry{source, "collateral", 50};
+
+    RevokeDialog revoke(m_node, /*wallet_model=*/nullptr, entry, /*parent=*/nullptr);
+    revoke.show();
+    QApplication::processEvents();
+    const auto field_rect = [](QWidget* field, QWidget* dialog) {
+        return QRect{field->mapTo(dialog, QPoint{}), field->size()};
+    };
+    const QRect reason_rect{field_rect(revoke.m_reason_combo, &revoke)};
+    const QRect operator_rect{field_rect(revoke.m_operator_key, &revoke)};
+    const QRect fee_rect{field_rect(revoke.m_fee_source, &revoke)};
+    const auto fields_align = [](const QRect& expected, const QRect& actual) {
+        // Native controls can extend a few pixels outside their layout item.
+        return qAbs(expected.left() - actual.left()) <= 12 && qAbs(expected.right() - actual.right()) <= 12;
+    };
+    QVERIFY(reason_rect.width() > 400);
+    QVERIFY(fields_align(reason_rect, operator_rect));
+    QVERIFY(fields_align(reason_rect, fee_rect));
+
+    UpdateRegistrarDialog registrar(m_node, /*wallet_model=*/nullptr, entry,
+                                    interfaces::ProviderTxCapabilities{ProTxVersion::BasicBLS, false},
+                                    /*parent=*/nullptr);
+    registrar.show();
+    QApplication::processEvents();
+    const QRect public_key_rect{field_rect(registrar.m_operator_pubkey_edit, &registrar)};
+    for (QWidget* field : {static_cast<QWidget*>(registrar.m_voting_edit), static_cast<QWidget*>(registrar.m_payout_edit),
+                           static_cast<QWidget*>(registrar.m_fee_source)}) {
+        const QRect rect{field_rect(field, &registrar)};
+        QVERIFY(fields_align(public_key_rect, rect));
+    }
+}
+
+void MasternodeMaintenanceTests::dialogLifecycleAndSubmissionStates()
+{
+#if defined(Q_OS_MACOS)
+    if (QApplication::platformName() == "minimal") {
+        QWARN("Skipping dialogLifecycleAndSubmissionStates on macOS with the minimal platform due to QTBUG-49686");
+        return;
+    }
+#endif
+    TestChain100Setup test;
+    m_node.setContext(&test.m_node);
+    auto source{std::make_shared<TestMnEntry>(MnType::Regular)};
+    MasternodeEntry entry{source, "collateral", 50};
+    UpdateRegistrarDialog dialog(m_node, /*wallet_model=*/nullptr, entry,
+                                 interfaces::ProviderTxCapabilities{ProTxVersion::BasicBLS, false},
+                                 /*parent=*/nullptr);
+    QSignalSpy rejected_spy(&dialog, &QDialog::rejected);
+    dialog.show();
+
+    dialog.setBusy(true);
+    dialog.reject();
+    QCOMPARE(rejected_spy.count(), 0);
+    QVERIFY(dialog.isVisible());
+    dialog.setBusy(false);
+
+    dialog.finishSubmission(interfaces::ProviderTxSubmission{MakeTransactionRef(CMutableTransaction{}), false});
+    QVERIFY(dialog.m_status_label->isVisible());
+    QVERIFY(dialog.m_status_label->text().contains("not sent", Qt::CaseInsensitive));
+    QCOMPARE(rejected_spy.count(), 0);
+
+    dialog.finishSubmission(interfaces::ProviderTxError{interfaces::ProviderTxErrorCode::INTERNAL_ERROR,
+                                                        Untranslated("maintenance failed"),
+                                                        {},
+                                                        std::nullopt});
+    QVERIFY(dialog.m_status_label->text().contains("maintenance failed", Qt::CaseInsensitive));
+
+    // shutdown() can synchronously deliver a completed operation from the
+    // destructor. It must release busy/unlock state without opening modal UI
+    // or changing the dialog result during teardown.
+    bool message_box_seen{false};
+    QTimer::singleShot(0, [&message_box_seen] {
+        for (QWidget* const widget : QApplication::topLevelWidgets()) {
+            auto* const message_box{qobject_cast<QMessageBox*>(widget)};
+            if (message_box == nullptr) continue;
+            message_box_seen = true;
+            message_box->accept();
+        }
+    });
+    QSignalSpy accepted_spy(&dialog, &QDialog::accepted);
+    dialog.m_destroying = true;
+    dialog.setBusy(true);
+    dialog.finishSubmission(interfaces::ProviderTxSubmission{MakeTransactionRef(CMutableTransaction{}), /*submitted=*/true});
+    QApplication::processEvents();
+    QVERIFY(!message_box_seen);
+    QCOMPARE(accepted_spy.count(), 0);
+    QVERIFY(!dialog.m_busy);
+    QVERIFY(QApplication::overrideCursor() == nullptr);
+}
diff --git a/src/qt/test/masternodemaintenancetests.h b/src/qt/test/masternodemaintenancetests.h
new file mode 100644
index 000000000000..e52f37494c94
--- /dev/null
+++ b/src/qt/test/masternodemaintenancetests.h
@@ -0,0 +1,40 @@
+// 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_MASTERNODEMAINTENANCETESTS_H
+#define BITCOIN_QT_TEST_MASTERNODEMAINTENANCETESTS_H
+
+#include <QObject>
+
+namespace interfaces {
+class Node;
+}
+
+class MasternodeMaintenanceTests : public QObject
+{
+    Q_OBJECT
+
+public:
+    explicit MasternodeMaintenanceTests(interfaces::Node& node) :
+        m_node(node)
+    {
+    }
+
+private Q_SLOTS:
+    void automaticFeeSource();
+    void operatorSecretValidation();
+    void operatorPublicKeyEncoding();
+    void actionRoleGating();
+    void reconcileMutableFields();
+    void serviceRequestConstruction();
+    void registrarRequestConstruction();
+    void revokeRequestConstruction();
+    void dialogFieldGeometry();
+    void dialogLifecycleAndSubmissionStates();
+
+private:
+    interfaces::Node& m_node;
+};
+
+#endif // BITCOIN_QT_TEST_MASTERNODEMAINTENANCETESTS_H
diff --git a/src/qt/test/masternodewidgettests.cpp b/src/qt/test/masternodewidgettests.cpp
new file mode 100644
index 000000000000..77787d8c9428
--- /dev/null
+++ b/src/qt/test/masternodewidgettests.cpp
@@ -0,0 +1,1055 @@
+// 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/masternodewidgettests.h>
+
+#include <bls/bls.h>
+#include <chainparams.h>
+#include <evo/types.h>
+#include <interfaces/node.h>
+#include <interfaces/providertx.h>
+#include <interfaces/wallet.h>
+#include <key_io.h>
+#include <qt/clientmodel.h>
+#include <qt/masternodelist.h>
+#include <qt/masternodeoperationrunner.h>
+#include <qt/masternodewidgets.h>
+#include <qt/masternodewizard.h>
+#include <qt/optionsmodel.h>
+#include <qt/qvalidatedlineedit.h>
+#include <qt/walletmodel.h>
+#include <random.h>
+#include <script/script.h>
+#include <script/standard.h>
+#include <test/util/setup_common.h>
+#include <util/system.h>
+#include <util/translation.h>
+#include <wallet/wallet.h>
+
+#include <QAbstractButton>
+#include <QApplication>
+#include <QCheckBox>
+#include <QComboBox>
+#include <QDoubleSpinBox>
+#include <QLabel>
+#include <QLineEdit>
+#include <QMenu>
+#include <QMessageBox>
+#include <QPlainTextEdit>
+#include <QProgressBar>
+#include <QPushButton>
+#include <QRadioButton>
+#include <QScrollArea>
+#include <QSemaphore>
+#include <QSignalSpy>
+#include <QSpinBox>
+#include <QStackedWidget>
+#include <QTest>
+#include <QThread>
+#include <QTimer>
+
+#include <algorithm>
+#include <atomic>
+#include <cstdint>
+#include <memory>
+#include <optional>
+#include <stdexcept>
+#include <string>
+#include <utility>
+#include <vector>
+
+using wallet::CreateMockWalletDatabase;
+using wallet::CWallet;
+using wallet::WalletContext;
+
+namespace {
+interfaces::ProviderTxError TestProviderError()
+{
+    return {interfaces::ProviderTxErrorCode::INTERNAL_ERROR, Untranslated("fake provider failure"), {}, std::nullopt};
+}
+
+QString TestP2PKHAddress(uint8_t marker)
+{
+    uint160 key_id;
+    key_id.begin()[0] = marker;
+    return QString::fromStdString(EncodeDestination(PKHash{key_id}));
+}
+
+void ClickMessageBox(QMessageBox::StandardButton standard_button, QString* text = nullptr)
+{
+    QTimer::singleShot(0, [standard_button, text] {
+        for (QWidget* const widget : QApplication::topLevelWidgets()) {
+            auto* const message_box{qobject_cast<QMessageBox*>(widget)};
+            if (message_box == nullptr) continue;
+            if (text != nullptr) *text = message_box->text();
+            QAbstractButton* const button{message_box->button(standard_button)};
+            if (button != nullptr) button->click();
+        }
+    });
+}
+
+class BlockingEVO final : public interfaces::EVO
+{
+public:
+    enum class Behavior : uint8_t {
+        BLOCK_AND_ERROR,
+        THROW_STANDARD,
+        THROW_UNKNOWN,
+        RETURN_SUCCESS,
+    };
+
+    std::pair<interfaces::MnListPtr, const CBlockIndex*> getListAtChainTip() override { return {}; }
+    interfaces::ProviderTxCapabilities getProviderTxCapabilities() override { return {}; }
+    std::optional<interfaces::ProviderTxError> validateProviderNetInfo(const interfaces::ProviderNetInfo&, MnType,
+                                                                       uint16_t, bool) override
+    {
+        return std::nullopt;
+    }
+
+    interfaces::ProviderTxResult<interfaces::ProviderTxSubmission> registerMasternode(
+        interfaces::Wallet&, const interfaces::ProviderRegistrationRequest&) override
+    {
+        operation_thread.store(QThread::currentThread());
+        ++operation_count;
+        entered.release();
+        switch (behavior.load()) {
+        case Behavior::BLOCK_AND_ERROR:
+            proceed.acquire();
+            return TestProviderError();
+        case Behavior::THROW_STANDARD:
+            throw std::runtime_error("fake provider exception");
+        case Behavior::THROW_UNKNOWN:
+            throw 42;
+        case Behavior::RETURN_SUCCESS:
+            return interfaces::ProviderTxSubmission{success_tx, submitted.load()};
+        }
+        return TestProviderError();
+    }
+
+    interfaces::ProviderTxResult<interfaces::PreparedProviderRegistration> prepareMasternodeRegistration(
+        interfaces::Wallet&, const interfaces::ProviderRegistrationRequest&) override
+    {
+        return TestProviderError();
+    }
+    interfaces::ProviderTxResult<interfaces::ProviderTxSubmission> submitMasternodeRegistration(
+        interfaces::Wallet&, const CTransactionRef&, const std::vector<unsigned char>&) override
+    {
+        return TestProviderError();
+    }
+    interfaces::ProviderTxResult<interfaces::ProviderTxSubmission> updateMasternodeService(
+        interfaces::Wallet&, const interfaces::ProviderUpdateServiceRequest&) override
+    {
+        return TestProviderError();
+    }
+    interfaces::ProviderTxResult<interfaces::ProviderTxSubmission> updateMasternodeRegistrar(
+        interfaces::Wallet&, const interfaces::ProviderUpdateRegistrarRequest&) override
+    {
+        return TestProviderError();
+    }
+    interfaces::ProviderTxResult<interfaces::ProviderTxSubmission> revokeMasternode(
+        interfaces::Wallet&, const interfaces::ProviderRevokeRequest&) override
+    {
+        return TestProviderError();
+    }
+
+    QSemaphore entered;
+    QSemaphore proceed;
+    std::atomic<Behavior> behavior{Behavior::BLOCK_AND_ERROR};
+    std::atomic<QThread*> operation_thread{nullptr};
+    std::atomic<int> operation_count{0};
+    std::atomic<bool> submitted{true};
+    CTransactionRef success_tx{MakeTransactionRef(CMutableTransaction{})};
+};
+} // namespace
+
+void MasternodeWidgetTests::endpointTokenization()
+{
+    QCOMPARE(MasternodeWidgetUtil::tokenizeEndpointList(QString()), QStringList{});
+    QCOMPARE(MasternodeWidgetUtil::tokenizeEndpointList("  1.2.3.4:19999,\n[2001:db8::1]:443\texample.com:443  "),
+             (QStringList{"1.2.3.4:19999", "[2001:db8::1]:443", "example.com:443"}));
+    // Tokenization deliberately preserves duplicates and syntax. The typed
+    // provider validator below owns those rules.
+    QCOMPARE(MasternodeWidgetUtil::tokenizeEndpointList("1.2.3.4:19999, 1.2.3.4:19999"),
+             (QStringList{"1.2.3.4:19999", "1.2.3.4:19999"}));
+}
+
+void MasternodeWidgetTests::providerNetInfoValidation_data()
+{
+    QTest::addColumn<int>("mn_type");
+    QTest::addColumn<int>("version");
+    QTest::addColumn<bool>("optional");
+    QTest::addColumn<QStringList>("core");
+    QTest::addColumn<QStringList>("platform_p2p");
+    QTest::addColumn<QStringList>("platform_https");
+    QTest::addColumn<int>("legacy_p2p_port");
+    QTest::addColumn<int>("legacy_https_port");
+    QTest::addColumn<bool>("valid");
+    QTest::addColumn<QString>("error_fragment");
+
+    const int regular{static_cast<int>(MnType::Regular)};
+    const int evo{static_cast<int>(MnType::Evo)};
+    const int basic{ProTxVersion::BasicBLS};
+    const int extended{ProTxVersion::ExtAddr};
+    const QString core1{QString("1.1.1.1:%1").arg(Params().GetDefaultPort())};
+    const QString core2{QString("1.1.1.2:%1").arg(Params().GetDefaultPort())};
+    const int wrong_network_port{Params().GetDefaultPort() == MainParams().GetDefaultPort()
+                                     ? MainParams().GetDefaultPort() + 1
+                                     : MainParams().GetDefaultPort()};
+
+    const auto add_row = [](const char* name, int type, int version, bool optional, QStringList core, QStringList p2p,
+                            QStringList https, int p2p_port, int https_port, bool valid, QString error = {}) {
+        QTest::newRow(name) << type << version << optional << core << p2p << https << p2p_port << https_port << valid
+                            << error;
+    };
+
+    add_row("regular-basic-empty-optional", regular, basic, true, {}, {}, {}, -1, -1, true);
+    add_row("regular-basic-empty-required", regular, basic, false, {}, {}, {}, -1, -1, false, "cannot be empty");
+    add_row("regular-basic-ipv4", regular, basic, true, {core1}, {}, {}, -1, -1, true);
+    add_row("regular-basic-second-address", regular, basic, true, {core1, core2}, {}, {}, -1, -1, false,
+            "too many entries");
+    add_row("regular-basic-ipv6", regular, basic, true,
+            {QString("[2606:4700:4700::1111]:%1").arg(Params().GetDefaultPort())}, {}, {}, -1, -1, false, "invalid input");
+    add_row("regular-basic-wrong-network-port", regular, basic, true, {QString("1.1.1.1:%1").arg(wrong_network_port)},
+            {}, {}, -1, -1, false, "invalid port");
+    add_row("regular-extended-multiple", regular, extended, true, {core1, core2}, {}, {}, -1, -1, true);
+    add_row("regular-extended-duplicate", regular, extended, true, {core1, core1}, {}, {}, -1, -1, false, "duplicate");
+    add_row("regular-extended-over-limit", regular, extended, true,
+            {core1, core2, QString("1.1.1.3:%1").arg(Params().GetDefaultPort()),
+             QString("1.1.1.4:%1").arg(Params().GetDefaultPort()), QString("1.1.1.5:%1").arg(Params().GetDefaultPort())},
+            {}, {}, -1, -1, false, "too many entries");
+    add_row("regular-extended-core-domain", regular, extended, true, {"example.com:9999"}, {}, {}, -1, -1, false,
+            "invalid input");
+
+    add_row("evo-basic-ports", evo, basic, true, {core1}, {}, {}, 26656, 443, true);
+    add_row("evo-basic-zero-port", evo, basic, true, {core1}, {}, {}, 0, 443, false, "valid port");
+    add_row("evo-extended-all-empty", evo, extended, true, {}, {}, {}, -1, -1, true);
+    add_row("evo-extended-complete", evo, extended, true, {core1}, {"1.1.1.2:26656"}, {"example.com:443"}, -1, -1, true);
+    add_row("evo-extended-platform-only", evo, extended, true, {}, {"1.1.1.2:26656"}, {"example.com:443"}, -1, -1,
+            false, "bad-protx-netinfo-empty");
+    add_row("evo-extended-https-domain", evo, extended, true, {core1}, {"1.1.1.2:26656"}, {"rpc.example.org:443"}, -1,
+            -1, true);
+    add_row("evo-extended-p2p-domain", evo, extended, true, {core1}, {"p2p.example.org:26656"}, {"rpc.example.org:443"},
+            -1, -1, false, "invalid input");
+    add_row("evo-extended-core-only", evo, extended, true, {core1}, {}, {}, -1, -1, false,
+            "cannot be empty if other fields populated");
+    add_row("evo-extended-one-platform-family", evo, extended, true, {core1}, {"1.1.1.2:26656"}, {}, -1, -1, false,
+            "cannot be empty if other fields populated");
+    add_row("evo-extended-cross-purpose-duplicate", evo, extended, true, {core1}, {"1.1.1.2:26656"}, {"1.1.1.2:26656"},
+            -1, -1, false, "duplicate");
+    add_row("invalid-version", regular, 0, true, {}, {}, {}, -1, -1, false, "invalid provider transaction version");
+    add_row("invalid-type", static_cast<int>(MnType::Invalid), basic, true, {}, {}, {}, -1, -1, false,
+            "invalid masternode type");
+}
+
+void MasternodeWidgetTests::providerNetInfoValidation()
+{
+    QFETCH(int, mn_type);
+    QFETCH(int, version);
+    QFETCH(bool, optional);
+    QFETCH(QStringList, core);
+    QFETCH(QStringList, platform_p2p);
+    QFETCH(QStringList, platform_https);
+    QFETCH(int, legacy_p2p_port);
+    QFETCH(int, legacy_https_port);
+    QFETCH(bool, valid);
+    QFETCH(QString, error_fragment);
+
+    interfaces::ProviderNetInfo net_info;
+    for (const QString& entry : core)
+        net_info.core_p2p.push_back(entry.toStdString());
+    if (static_cast<MnType>(mn_type) == MnType::Evo) {
+        if (version >= ProTxVersion::ExtAddr) {
+            std::vector<std::string> p2p;
+            std::vector<std::string> https;
+            for (const QString& entry : platform_p2p)
+                p2p.push_back(entry.toStdString());
+            for (const QString& entry : platform_https)
+                https.push_back(entry.toStdString());
+            net_info.platform_p2p = std::move(p2p);
+            net_info.platform_https = std::move(https);
+        } else {
+            net_info.platform_p2p = static_cast<uint16_t>(legacy_p2p_port);
+            net_info.platform_https = static_cast<uint16_t>(legacy_https_port);
+        }
+    }
+
+    const auto error{m_node.evo().validateProviderNetInfo(net_info, static_cast<MnType>(mn_type),
+                                                          static_cast<uint16_t>(version), optional)};
+    QCOMPARE(!error.has_value(), valid);
+    if (!valid) {
+        QVERIFY(error.has_value());
+        QVERIFY2(QString::fromStdString(error->message.original).contains(error_fragment), error->message.original.c_str());
+    }
+}
+
+void MasternodeWidgetTests::operationRunnerThreading()
+{
+    TestChain100Setup test;
+    m_node.setContext(&test.m_node);
+    WalletContext& context{*m_node.walletLoader().context()};
+    const auto wallet{std::make_shared<CWallet>(m_node.context()->chain.get(), m_node.context()->coinjoin_loader.get(),
+                                                "", gArgs, CreateMockWalletDatabase())};
+    wallet->LoadWallet();
+    auto wallet_interface{interfaces::MakeWallet(context, wallet)};
+    QVERIFY(wallet_interface != nullptr);
+
+    BlockingEVO evo;
+    int callback_count{0};
+    QThread* callback_thread{nullptr};
+    auto callback = [&](MasternodeOperationRunner::SubmissionResult completion) {
+        ++callback_count;
+        callback_thread = QThread::currentThread();
+        QVERIFY(std::holds_alternative<interfaces::ProviderTxError>(completion));
+    };
+    MasternodeOperationRunner runner(evo, *wallet_interface);
+
+    QVERIFY(runner.registerMasternode(interfaces::ProviderRegistrationRequest{}, callback));
+    const bool entered_first{evo.entered.tryAcquire(1, 5000)};
+    const bool busy_first{runner.isBusy()};
+    const bool accepted_second{runner.registerMasternode(interfaces::ProviderRegistrationRequest{}, callback)};
+    const int first_operation_count{evo.operation_count.load()};
+    QThread* const first_operation_thread{evo.operation_thread.load()};
+    // Release before asserting so an assertion failure cannot strand the worker
+    // and deadlock the runner destructor.
+    evo.proceed.release(accepted_second ? 2 : 1);
+    QVERIFY(entered_first);
+    QVERIFY(busy_first);
+    QVERIFY(!accepted_second);
+    QCOMPARE(first_operation_count, 1);
+    QVERIFY(first_operation_thread != QThread::currentThread());
+    QTRY_COMPARE_WITH_TIMEOUT(callback_count, 1, 5000);
+    QCOMPARE(callback_thread, QThread::currentThread());
+    QVERIFY(!runner.isBusy());
+
+    // Completion clears the one-flight guard and allows the runner to be reused.
+    QVERIFY(runner.registerMasternode(interfaces::ProviderRegistrationRequest{}, callback));
+    const bool entered_reuse{evo.entered.tryAcquire(1, 5000)};
+    const int reuse_operation_count{evo.operation_count.load()};
+    evo.proceed.release();
+    QVERIFY(entered_reuse);
+    QCOMPARE(reuse_operation_count, 2);
+    QTRY_COMPARE_WITH_TIMEOUT(callback_count, 2, 5000);
+}
+
+void MasternodeWidgetTests::operationRunnerExceptions()
+{
+    TestChain100Setup test;
+    m_node.setContext(&test.m_node);
+    WalletContext& context{*m_node.walletLoader().context()};
+    const auto wallet{std::make_shared<CWallet>(m_node.context()->chain.get(), m_node.context()->coinjoin_loader.get(),
+                                                "", gArgs, CreateMockWalletDatabase())};
+    wallet->LoadWallet();
+    auto wallet_interface{interfaces::MakeWallet(context, wallet)};
+    QVERIFY(wallet_interface != nullptr);
+
+    BlockingEVO evo;
+    std::optional<MasternodeOperationRunner::SubmissionResult> callback_result;
+    const auto callback = [&callback_result](MasternodeOperationRunner::SubmissionResult completion) {
+        callback_result.emplace(std::move(completion));
+    };
+    MasternodeOperationRunner runner(evo, *wallet_interface);
+
+    evo.behavior.store(BlockingEVO::Behavior::THROW_STANDARD);
+    QVERIFY(runner.registerMasternode(interfaces::ProviderRegistrationRequest{}, callback));
+    QTRY_VERIFY_WITH_TIMEOUT(callback_result.has_value(), 5000);
+    const auto* standard_error{std::get_if<interfaces::ProviderTxError>(&*callback_result)};
+    QVERIFY(standard_error != nullptr);
+    QCOMPARE(standard_error->code, interfaces::ProviderTxErrorCode::INTERNAL_ERROR);
+    QVERIFY(QString::fromStdString(standard_error->message.original).contains("fake provider exception"));
+    QVERIFY(!runner.isBusy());
+
+    callback_result.reset();
+    evo.behavior.store(BlockingEVO::Behavior::THROW_UNKNOWN);
+    QVERIFY(runner.registerMasternode(interfaces::ProviderRegistrationRequest{}, callback));
+    QTRY_VERIFY_WITH_TIMEOUT(callback_result.has_value(), 5000);
+    const auto* unknown_error{std::get_if<interfaces::ProviderTxError>(&*callback_result)};
+    QVERIFY(unknown_error != nullptr);
+    QCOMPARE(unknown_error->code, interfaces::ProviderTxErrorCode::INTERNAL_ERROR);
+    QVERIFY(QString::fromStdString(unknown_error->message.original).contains("operation failed"));
+    QVERIFY(!runner.isBusy());
+}
+
+void MasternodeWidgetTests::operationRunnerShutdownDelivery()
+{
+    TestChain100Setup test;
+    m_node.setContext(&test.m_node);
+    WalletContext& context{*m_node.walletLoader().context()};
+    const auto wallet{std::make_shared<CWallet>(m_node.context()->chain.get(), m_node.context()->coinjoin_loader.get(),
+                                                "", gArgs, CreateMockWalletDatabase())};
+    wallet->LoadWallet();
+    auto wallet_interface{interfaces::MakeWallet(context, wallet)};
+    QVERIFY(wallet_interface != nullptr);
+
+    BlockingEVO evo;
+    int callback_count{0};
+    QThread* callback_thread{nullptr};
+    auto runner{std::make_unique<MasternodeOperationRunner>(evo, *wallet_interface)};
+    QVERIFY(runner->registerMasternode(interfaces::ProviderRegistrationRequest{},
+                                       [&](MasternodeOperationRunner::SubmissionResult completion) {
+                                           ++callback_count;
+                                           callback_thread = QThread::currentThread();
+                                           QVERIFY(std::holds_alternative<interfaces::ProviderTxError>(completion));
+                                           runner.reset();
+                                       }));
+
+    const bool entered{evo.entered.tryAcquire(1, 5000)};
+    evo.proceed.release();
+    QVERIFY(entered);
+    QCOMPARE(callback_count, 0);
+
+    auto* const runner_ptr{runner.get()};
+    runner_ptr->shutdown();
+    QCOMPARE(callback_count, 1);
+    QCOMPARE(callback_thread, QThread::currentThread());
+    QVERIFY(runner == nullptr);
+    QApplication::processEvents();
+    QCOMPARE(callback_count, 1);
+
+    // Shutdown must drain work that was only queued, map its exception, and
+    // deliver it without requiring another GUI event-loop turn. This covers
+    // the owner-destruction path immediately after an operation is launched.
+    BlockingEVO throwing_evo;
+    throwing_evo.behavior.store(BlockingEVO::Behavior::THROW_STANDARD);
+    std::optional<MasternodeOperationRunner::SubmissionResult> throwing_result;
+    QThread* throwing_callback_thread{nullptr};
+    auto throwing_runner{std::make_unique<MasternodeOperationRunner>(throwing_evo, *wallet_interface)};
+    QVERIFY(throwing_runner->registerMasternode(interfaces::ProviderRegistrationRequest{},
+                                                [&](MasternodeOperationRunner::SubmissionResult completion) {
+                                                    throwing_result.emplace(std::move(completion));
+                                                    throwing_callback_thread = QThread::currentThread();
+                                                }));
+    throwing_runner.reset();
+    QVERIFY(throwing_result.has_value());
+    const auto* error{std::get_if<interfaces::ProviderTxError>(&*throwing_result)};
+    QVERIFY(error != nullptr);
+    QVERIFY(QString::fromStdString(error->message.original).contains("fake provider exception"));
+    QCOMPARE(throwing_callback_thread, QThread::currentThread());
+}
+
+void MasternodeWidgetTests::feeSourcePickerEligibility()
+{
+    TestChain100Setup test;
+    m_node.setContext(&test.m_node);
+    WalletContext& context{*m_node.walletLoader().context()};
+    const auto wallet{std::make_shared<CWallet>(m_node.context()->chain.get(), m_node.context()->coinjoin_loader.get(),
+                                                "", gArgs, CreateMockWalletDatabase())};
+    wallet->LoadWallet();
+    wallet->SetWalletFlag(wallet::WALLET_FLAG_DESCRIPTORS);
+
+    CTxDestination first;
+    CTxDestination second;
+    const CBlockIndex* tip{nullptr};
+    {
+        LOCK(wallet->cs_wallet);
+        wallet->SetupDescriptorScriptPubKeyMans("", "");
+        const auto first_result{wallet->GetNewDestination("")};
+        const auto second_result{wallet->GetNewDestination("")};
+        QVERIFY(first_result);
+        QVERIFY(second_result);
+        first = *first_result;
+        second = *second_result;
+        tip = WITH_LOCK(test.m_node.chainman->GetMutex(), return test.m_node.chainman->ActiveChain().Tip());
+        QVERIFY(tip != nullptr);
+        wallet->SetLastBlockProcessed(tip->nHeight, tip->GetBlockHash());
+    }
+
+    CMutableTransaction funding;
+    funding.vin.emplace_back(GetRandHash(), 0);
+    funding.vout.emplace_back(10 * COIN, GetScriptForDestination(first));
+    funding.vout.emplace_back(20 * COIN, GetScriptForDestination(first));
+    funding.vout.emplace_back(5 * COIN, GetScriptForDestination(second));
+    const CTransactionRef funding_tx{MakeTransactionRef(funding)};
+    QVERIFY(wallet->AddToWallet(funding_tx, wallet::TxStateConfirmed{tip->GetBlockHash(), tip->nHeight, /*index=*/0}) !=
+            nullptr);
+
+    OptionsModel options_model(m_node);
+    bilingual_str options_error;
+    QVERIFY(options_model.Init(options_error));
+    ClientModel client_model(m_node, &options_model);
+    WalletModel wallet_model(interfaces::MakeWallet(context, wallet), client_model);
+    FeeSourcePicker picker;
+    picker.setWalletModel(&wallet_model);
+
+    QCOMPARE(picker.count(), 2);
+    QCOMPARE(picker.selectedAddress(), QString::fromStdString(EncodeDestination(first)));
+    picker.setMinimumBalance(30 * COIN);
+    QCOMPARE(picker.count(), 1);
+
+    // Registration excludes its selected existing collateral coin from the
+    // address's available fee balance, but leaves other outputs at that exact
+    // destination eligible.
+    const COutPoint excluded{funding_tx->GetHash(), 0};
+    picker.setMinimumBalance(20 * COIN);
+    picker.setExcludedOutpoint(excluded);
+    QCOMPARE(picker.count(), 1);
+    QCOMPARE(picker.selectedAddress(), QString::fromStdString(EncodeDestination(first)));
+    picker.setMinimumBalance(20 * COIN + 1);
+    QCOMPARE(picker.count(), 0);
+
+    picker.setExcludedOutpoint(std::nullopt);
+    picker.setMinimumBalance(30 * COIN);
+    QVERIFY(wallet_model.wallet().lockCoin(excluded, /*write_to_db=*/false));
+    picker.refresh();
+    QCOMPARE(picker.count(), 0);
+    QVERIFY(wallet_model.wallet().unlockCoin(excluded));
+}
+
+void MasternodeWidgetTests::registeredCollateralExclusion()
+{
+    TestChain100Setup test;
+    m_node.setContext(&test.m_node);
+    WalletContext& context{*m_node.walletLoader().context()};
+    const auto wallet{std::make_shared<CWallet>(m_node.context()->chain.get(), m_node.context()->coinjoin_loader.get(),
+                                                "", gArgs, CreateMockWalletDatabase())};
+    wallet->LoadWallet();
+    wallet->SetWalletFlag(wallet::WALLET_FLAG_DESCRIPTORS);
+
+    CTxDestination destination;
+    const CBlockIndex* tip{nullptr};
+    {
+        LOCK(wallet->cs_wallet);
+        wallet->SetupDescriptorScriptPubKeyMans("", "");
+        const auto destination_result{wallet->GetNewDestination("")};
+        QVERIFY(destination_result);
+        destination = *destination_result;
+        tip = WITH_LOCK(test.m_node.chainman->GetMutex(), return test.m_node.chainman->ActiveChain().Tip());
+        QVERIFY(tip != nullptr);
+        wallet->SetLastBlockProcessed(tip->nHeight, tip->GetBlockHash());
+    }
+
+    CMutableTransaction funding;
+    funding.vin.emplace_back(GetRandHash(), 0);
+    funding.vout.emplace_back(GetMnType(MnType::Regular).collat_amount, GetScriptForDestination(destination));
+    const CTransactionRef funding_tx{MakeTransactionRef(funding)};
+    QVERIFY(wallet->AddToWallet(funding_tx, wallet::TxStateConfirmed{tip->GetBlockHash(), tip->nHeight, /*index=*/0}) !=
+            nullptr);
+
+    OptionsModel options_model(m_node);
+    bilingual_str options_error;
+    QVERIFY(options_model.Init(options_error));
+    ClientModel client_model(m_node, &options_model);
+    WalletModel wallet_model(interfaces::MakeWallet(context, wallet), client_model);
+    RegisterMasternodeWizard wizard(m_node, &wallet_model);
+    wizard.m_col_wallet->setChecked(true);
+
+    wizard.refreshCollateralCandidates({});
+    QCOMPARE(wizard.m_col_utxo_combo->count(), 1);
+    const COutPoint collateral{funding_tx->GetHash(), 0};
+    QCOMPARE(wizard.m_col_utxo_combo->currentData().toString(), QString::fromStdString(collateral.hash.ToString()));
+
+    wizard.refreshCollateralCandidates({collateral});
+    QCOMPARE(wizard.m_col_utxo_combo->count(), 0);
+    QVERIFY(!wizard.m_col_utxo_none->isHidden());
+}
+
+void MasternodeWidgetTests::wizardMinimumGeometry()
+{
+#if defined(Q_OS_MACOS)
+    if (QApplication::platformName() == "minimal") {
+        QWARN("Skipping wizardMinimumGeometry on macOS with the minimal platform due to QTBUG-49686");
+        return;
+    }
+#endif
+    TestChain100Setup test;
+    m_node.setContext(&test.m_node);
+
+    RegisterMasternodeWizard wizard(m_node, /*walletModel=*/nullptr);
+    QCOMPARE(wizard.m_platform_p2p_port->value(), Params().GetDefaultPlatformP2PPort());
+    QCOMPARE(wizard.m_platform_https_port->value(), Params().GetDefaultPlatformHTTPPort());
+    wizard.resize(700, 560);
+    wizard.show();
+    QApplication::processEvents();
+    QCOMPARE(wizard.minimumSize(), QSize(700, 560));
+    QCOMPARE(wizard.size(), QSize(700, 560));
+    QVERIFY(wizard.m_progress_label->text().contains("Step 1"));
+    QVERIFY(wizard.m_progress_label->text().contains("of 8"));
+    QVERIFY(wizard.m_order.contains(RegisterMasternodeWizard::PageSecret));
+
+    const auto operator_modes{wizard.m_operator_widget->findChildren<QRadioButton*>()};
+    const auto existing_mode{std::find_if(operator_modes.begin(), operator_modes.end(), [](const QRadioButton* radio) {
+        return radio->text().contains("existing operator", Qt::CaseInsensitive);
+    })};
+    QVERIFY(existing_mode != operator_modes.end());
+    (*existing_mode)->setChecked(true);
+    QVERIFY(!wizard.m_order.contains(RegisterMasternodeWizard::PageSecret));
+    QVERIFY(wizard.m_progress_label->text().contains("of 7"));
+    wizard.m_type_evo->setChecked(true);
+    QCOMPARE(wizard.windowTitle(), QString("Register EvoNode"));
+    QVERIFY(wizard.m_progress_label->text().contains("of 8"));
+
+    const auto controls_fit = [&wizard](RegisterMasternodeWizard::Page page_id) {
+        wizard.enterPage(page_id);
+        QApplication::processEvents();
+        QWidget* const page{wizard.m_pages->widget(page_id)};
+        QVERIFY(page != nullptr);
+        const QRect available{page->rect()};
+        for (QWidget* const child : page->findChildren<QWidget*>()) {
+            const bool interactive{
+                qobject_cast<QAbstractButton*>(child) != nullptr || qobject_cast<QComboBox*>(child) != nullptr ||
+                qobject_cast<QDoubleSpinBox*>(child) != nullptr || qobject_cast<QLineEdit*>(child) != nullptr ||
+                qobject_cast<QPlainTextEdit*>(child) != nullptr || qobject_cast<QSpinBox*>(child) != nullptr};
+            if (!interactive || !child->isVisibleTo(page)) continue;
+            const QRect child_rect{child->mapTo(page, QPoint{0, 0}), child->size()};
+            const QString available_text{
+                QString("%1,%2 %3x%4").arg(available.x()).arg(available.y()).arg(available.width()).arg(available.height())};
+            const QString child_text{
+                QString("%1,%2 %3x%4").arg(child_rect.x()).arg(child_rect.y()).arg(child_rect.width()).arg(child_rect.height())};
+            QVERIFY2(available.contains(child_rect), qPrintable(QString("%1 on page %2 falls outside %3 (geometry %4)")
+                                                                    .arg(child->metaObject()->className())
+                                                                    .arg(static_cast<int>(page_id))
+                                                                    .arg(available_text)
+                                                                    .arg(child_text)));
+        }
+    };
+
+    for (const auto page : {RegisterMasternodeWizard::PageType, RegisterMasternodeWizard::PageCollateral,
+                            RegisterMasternodeWizard::PageService, RegisterMasternodeWizard::PagePayout,
+                            RegisterMasternodeWizard::PageFee, RegisterMasternodeWizard::PageSign}) {
+        controls_fit(page);
+    }
+    controls_fit(RegisterMasternodeWizard::PagePlatform);
+
+    for (const auto page_id : {RegisterMasternodeWizard::PageKeys, RegisterMasternodeWizard::PageReview,
+                               RegisterMasternodeWizard::PageSecret, RegisterMasternodeWizard::PageResult}) {
+        wizard.enterPage(page_id);
+        QApplication::processEvents();
+        QWidget* const page{wizard.m_pages->widget(page_id)};
+        auto* const scroll{page->findChild<QScrollArea*>()};
+        QVERIFY(scroll != nullptr);
+        QCOMPARE(scroll->objectName(), QString("mnWizardScroll"));
+        QVERIFY(scroll->widgetResizable());
+        QCOMPARE(scroll->horizontalScrollBarPolicy(), Qt::ScrollBarAlwaysOff);
+        QCOMPARE(scroll->verticalScrollBarPolicy(), Qt::ScrollBarAsNeeded);
+        QVERIFY(scroll->widget() != nullptr);
+        QVERIFY(page->rect().contains(QRect{scroll->mapTo(page, QPoint{0, 0}), scroll->size()}));
+    }
+
+    wizard.enterPage(RegisterMasternodeWizard::PageFee);
+    QVERIFY(wizard.m_fee_explain->text().contains("exact fee", Qt::CaseInsensitive));
+    QVERIFY(!wizard.m_fee_explain->text().contains("0.001"));
+
+    wizard.m_col_external->setChecked(true);
+    wizard.goToPage(RegisterMasternodeWizard::PageSign);
+    QVERIFY(!wizard.m_back_button->isEnabled());
+    QVERIFY(wizard.m_back_button->toolTip().contains("invalidate", Qt::CaseInsensitive));
+
+    wizard.setBusy(true, "Testing…");
+    QVERIFY(wizard.m_busy_bar->isVisible());
+    QCOMPARE(wizard.m_next_button->text(), QString("Testing…"));
+    wizard.setBusy(false);
+    QVERIFY(!wizard.m_busy_bar->isVisible());
+}
+
+void MasternodeWidgetTests::wizardPageValidation()
+{
+#if defined(Q_OS_MACOS)
+    if (QApplication::platformName() == "minimal") {
+        QWARN("Skipping wizardPageValidation on macOS with the minimal platform due to QTBUG-49686");
+        return;
+    }
+#endif
+    TestChain100Setup test;
+    m_node.setContext(&test.m_node);
+
+    RegisterMasternodeWizard wizard(m_node, /*walletModel=*/nullptr);
+    const QString null_address{TestP2PKHAddress(0)};
+    const QString collateral{TestP2PKHAddress(1)};
+    const QString owner{TestP2PKHAddress(2)};
+    const QString voting{TestP2PKHAddress(3)};
+    const QString payout{TestP2PKHAddress(4)};
+    QString error;
+
+    const auto expect_invalid = [&wizard, &error](RegisterMasternodeWizard::Page page) {
+        error.clear();
+        QVERIFY(!wizard.validatePage(page, error));
+        QVERIFY2(!error.isEmpty(), "Invalid page value must have an actionable error");
+    };
+
+    // A syntactically valid but null outpoint must not reach the provider
+    // transaction builder.
+    wizard.m_col_external->setChecked(true);
+    wizard.m_col_txid->setText(QString(64, QLatin1Char('0')));
+    expect_invalid(RegisterMasternodeWizard::PageCollateral);
+
+    // Encoded all-zero key identifiers are valid Base58 strings, but are null
+    // owner/voting identities and must be rejected explicitly.
+    wizard.m_col_fund->setChecked(true);
+    wizard.m_col_address->setText(collateral);
+    wizard.m_owner_edit->setText(null_address);
+    wizard.m_voting_edit->clear();
+    expect_invalid(RegisterMasternodeWizard::PageKeys);
+
+    wizard.m_owner_edit->setText(owner);
+    wizard.m_voting_edit->setText(null_address);
+    expect_invalid(RegisterMasternodeWizard::PageKeys);
+
+    wizard.m_voting_edit->setText(collateral);
+    expect_invalid(RegisterMasternodeWizard::PageKeys);
+
+    // The exact-wallet flow stores its collateral destination in the combo's
+    // dedicated role, and applies the same consensus role-separation rules.
+    wizard.m_col_wallet->setChecked(true);
+    wizard.m_col_utxo_combo->addItem("collateral", QString(64, QLatin1Char('1')));
+    wizard.m_col_utxo_combo->setItemData(0, collateral, RegisterMasternodeWizard::COLLATERAL_ADDRESS_ROLE);
+    wizard.m_owner_edit->setText(collateral);
+    wizard.m_voting_edit->setText(voting);
+    expect_invalid(RegisterMasternodeWizard::PageKeys);
+    wizard.m_owner_edit->setText(owner);
+    wizard.m_voting_edit->setText(collateral);
+    expect_invalid(RegisterMasternodeWizard::PageKeys);
+    wizard.m_voting_edit->setText(voting);
+    wizard.m_payout_edit->setText(collateral);
+    expect_invalid(RegisterMasternodeWizard::PagePayout);
+
+    // Role collisions are invalid regardless of which collateral workflow the
+    // user selected. The funded-collateral address is another prohibited role.
+    for (QRadioButton* mode : {wizard.m_col_fund, wizard.m_col_wallet, wizard.m_col_external}) {
+        mode->setChecked(true);
+        wizard.m_owner_edit->setText(owner);
+        wizard.m_voting_edit->setText(voting);
+
+        wizard.m_payout_edit->setText(owner);
+        expect_invalid(RegisterMasternodeWizard::PagePayout);
+
+        wizard.m_payout_edit->setText(voting);
+        expect_invalid(RegisterMasternodeWizard::PagePayout);
+    }
+
+    wizard.m_col_fund->setChecked(true);
+    wizard.m_col_address->setText(collateral);
+    wizard.m_payout_edit->setText(collateral);
+    expect_invalid(RegisterMasternodeWizard::PagePayout);
+
+    // A non-null, unrelated payout remains valid after the collision checks.
+    wizard.m_payout_edit->setText(payout);
+    error.clear();
+    QVERIFY2(wizard.validatePage(RegisterMasternodeWizard::PagePayout, error), qPrintable(error));
+
+    wizard.m_fee_picker->addItem("fee", payout);
+    const auto request{wizard.buildRegistrationRequest(error)};
+    QVERIFY2(request.has_value(), qPrintable(error));
+    QCOMPARE(request->payouts.size(), size_t{1});
+    QCOMPARE(request->payouts.front().reward, interfaces::ProviderPayout::MAX_REWARD);
+
+    wizard.m_type_evo->setChecked(true);
+    wizard.m_platform_nodeid->setText(QString(40, QLatin1Char('0')));
+    error.clear();
+    QVERIFY(!wizard.validatePage(RegisterMasternodeWizard::PagePlatform, error));
+    QVERIFY(error.contains("node ID", Qt::CaseInsensitive));
+
+    // Once validation has failed, edits revalidate immediately and the
+    // reserved error row keeps the button bar from jumping.
+    wizard.m_type_regular->setChecked(true);
+    wizard.m_col_external->setChecked(true);
+    wizard.goToPage(RegisterMasternodeWizard::PageCollateral);
+    wizard.show();
+    QApplication::processEvents();
+    const int button_y{wizard.m_next_button->y()};
+    wizard.m_col_txid->setText("invalid");
+    wizard.onNext();
+    QVERIFY(wizard.m_validation_page == RegisterMasternodeWizard::PageCollateral);
+    QVERIFY(!wizard.m_error_label->text().isEmpty());
+    QApplication::processEvents();
+    QCOMPARE(wizard.m_next_button->y(), button_y);
+    wizard.m_col_txid->setText(QString(64, QLatin1Char('1')));
+    QVERIFY(!wizard.m_validation_page.has_value());
+    QVERIFY(wizard.m_error_label->text().isEmpty());
+    QApplication::processEvents();
+    QCOMPARE(wizard.m_next_button->y(), button_y);
+}
+
+void MasternodeWidgetTests::broadcastConfirmation()
+{
+#if defined(Q_OS_MACOS)
+    if (QApplication::platformName() == "minimal") {
+        QWARN("Skipping broadcastConfirmation on macOS with the minimal platform due to QTBUG-49686");
+        return;
+    }
+#endif
+    TestChain100Setup test;
+    m_node.setContext(&test.m_node);
+
+    RegisterMasternodeWizard wizard(m_node, /*walletModel=*/nullptr);
+    wizard.m_fee_picker->addItem("fee source", TestP2PKHAddress(1));
+
+    bool found{false};
+    bool send_disabled{false};
+    bool unsigned_hidden{false};
+    QString prompt;
+    QString details;
+    QTimer::singleShot(0, [&] {
+        for (QWidget* const widget : QApplication::topLevelWidgets()) {
+            auto* const confirmation{qobject_cast<QMessageBox*>(widget)};
+            if (confirmation == nullptr || !confirmation->isVisible()) continue;
+            found = true;
+            prompt = confirmation->text();
+            details = confirmation->informativeText() + confirmation->detailedText();
+            send_disabled = !confirmation->button(QMessageBox::Yes)->isEnabled();
+            unsigned_hidden = confirmation->button(QMessageBox::Save) == nullptr;
+            confirmation->reject();
+            break;
+        }
+    });
+
+    QVERIFY(!wizard.confirmBroadcast());
+    QVERIFY(found);
+    QVERIFY(send_disabled);
+    QVERIFY(unsigned_hidden);
+    QVERIFY(prompt.contains("registration", Qt::CaseInsensitive));
+    QVERIFY(details.contains("fee source", Qt::CaseInsensitive));
+    QVERIFY(details.contains("wallet", Qt::CaseInsensitive));
+}
+
+void MasternodeWidgetTests::masternodeListRegistrationAvailability()
+{
+    TestChain100Setup test;
+    m_node.setContext(&test.m_node);
+    WalletContext& context{*m_node.walletLoader().context()};
+    const auto wallet{std::make_shared<CWallet>(m_node.context()->chain.get(), m_node.context()->coinjoin_loader.get(),
+                                                "", gArgs, CreateMockWalletDatabase())};
+    wallet->LoadWallet();
+    OptionsModel options_model(m_node);
+    bilingual_str options_error;
+    QVERIFY(options_model.Init(options_error));
+    ClientModel client_model(m_node, &options_model);
+    WalletModel wallet_model(interfaces::MakeWallet(context, wallet), client_model);
+
+    MasternodeList list;
+    auto* const register_button{list.findChild<QPushButton*>("btnRegisterMasternode")};
+    auto* const owned_checkbox{list.findChild<QCheckBox*>("checkBoxOwned")};
+    auto* const context_menu{list.findChild<QMenu*>(QString{}, Qt::FindDirectChildrenOnly)};
+    QVERIFY(register_button != nullptr);
+    QVERIFY(owned_checkbox != nullptr);
+    QVERIFY(context_menu != nullptr);
+    QVERIFY(context_menu->toolTipsVisible());
+    QVERIFY(!register_button->isEnabled());
+    QVERIFY(register_button->toolTip().contains("requires a wallet", Qt::CaseInsensitive));
+
+    list.setWalletModel(&wallet_model);
+    QVERIFY(!register_button->isEnabled());
+    QVERIFY(register_button->toolTip().contains("node is ready", Qt::CaseInsensitive));
+
+    list.setClientModel(&client_model);
+    QVERIFY(register_button->isEnabled());
+
+    owned_checkbox->setChecked(true);
+    list.setWalletModel(nullptr);
+    QVERIFY(!register_button->isEnabled());
+    QVERIFY(register_button->toolTip().contains("requires a wallet", Qt::CaseInsensitive));
+    QVERIFY(!owned_checkbox->isEnabled());
+    QVERIFY(!owned_checkbox->isChecked());
+
+    // Attaching the wallet again restores the user's saved owned-only choice.
+    list.setWalletModel(&wallet_model);
+    QVERIFY(register_button->isEnabled());
+    QVERIFY(owned_checkbox->isEnabled());
+    QVERIFY(owned_checkbox->isChecked());
+    owned_checkbox->setChecked(false);
+
+    list.setClientModel(nullptr);
+    QVERIFY(!register_button->isEnabled());
+    QVERIFY(register_button->toolTip().contains("node is ready", Qt::CaseInsensitive));
+
+    // Reapplying the no-wallet state must preserve both the guard and its
+    // explanation (for example after the last wallet is closed).
+    list.setWalletModel(nullptr);
+    QVERIFY(!register_button->isEnabled());
+    QVERIFY(register_button->toolTip().contains("requires a wallet", Qt::CaseInsensitive));
+}
+
+void MasternodeWidgetTests::wizardInteractionLifecycle()
+{
+#if defined(Q_OS_MACOS)
+    if (QApplication::platformName() == "minimal") {
+        QWARN("Skipping wizardInteractionLifecycle on macOS with the minimal platform due to QTBUG-49686");
+        return;
+    }
+#endif
+    TestChain100Setup test;
+    m_node.setContext(&test.m_node);
+    WalletContext& context{*m_node.walletLoader().context()};
+    const auto wallet{std::make_shared<CWallet>(m_node.context()->chain.get(), m_node.context()->coinjoin_loader.get(),
+                                                "", gArgs, CreateMockWalletDatabase())};
+    wallet->LoadWallet();
+    OptionsModel options_model(m_node);
+    bilingual_str options_error;
+    QVERIFY(options_model.Init(options_error));
+    ClientModel client_model(m_node, &options_model);
+    WalletModel wallet_model(interfaces::MakeWallet(context, wallet), client_model);
+    RegisterMasternodeWizard wizard(m_node, &wallet_model);
+
+    // Cancel, Escape, Back and a window close cannot tear down state owned by
+    // an in-flight typed operation.
+    wizard.goToPage(RegisterMasternodeWizard::PageReview);
+    const int review_position{wizard.m_pos};
+    QSignalSpy rejected_spy(&wizard, &QDialog::rejected);
+    wizard.show();
+    wizard.setBusy(true, "Testing…");
+    wizard.onBack();
+    QCOMPARE(wizard.m_pos, review_position);
+    wizard.reject();
+    QCOMPARE(rejected_spy.count(), 0);
+    QTest::keyClick(&wizard, Qt::Key_Escape);
+    QCOMPARE(rejected_spy.count(), 0);
+    QVERIFY(wizard.isVisible());
+    QVERIFY(!wizard.close());
+    QVERIFY(wizard.isVisible());
+    QCOMPARE(rejected_spy.count(), 0);
+    wizard.setBusy(false);
+
+    // A typed rejection leaves the same dialog editable and presents the
+    // backend's actionable reason.
+    wizard.m_stage = RegisterMasternodeWizard::Stage::Register;
+    wizard.setBusy(true, "Testing…");
+    QString rejection_text;
+    ClickMessageBox(QMessageBox::Ok, &rejection_text);
+    wizard.finishSubmission(TestProviderError());
+    QVERIFY(!wizard.m_busy);
+    QVERIFY(wizard.m_stage == RegisterMasternodeWizard::Stage::None);
+    QVERIFY(wizard.m_next_button->isEnabled());
+    QVERIFY(rejection_text.contains("fake provider failure", Qt::CaseInsensitive));
+
+    // Provider capabilities are sampled again at submission time; a wizard
+    // opened across activation returns to Platform instead of submitting stale
+    // endpoint semantics.
+    wizard.m_type_evo->setChecked(true);
+    wizard.rebuildOrder();
+    const uint16_t current_version{m_node.evo().getProviderTxCapabilities().version};
+    wizard.m_platform_provider_version = current_version == std::numeric_limits<uint16_t>::max()
+                                             ? static_cast<uint16_t>(current_version - 1)
+                                             : static_cast<uint16_t>(current_version + 1);
+    wizard.m_confirm_edit->setText(wizard.m_operator_widget->secretHex().right(4));
+    wizard.goToPage(RegisterMasternodeWizard::PageReview);
+    wizard.startRegistration(/*skip_confirmation=*/true);
+    QCOMPARE(wizard.m_pages->currentIndex(), static_cast<int>(RegisterMasternodeWizard::PagePlatform));
+    QVERIFY(wizard.m_error_label->isVisible());
+    QVERIFY(wizard.m_error_label->text().contains("changed", Qt::CaseInsensitive));
+
+    // Discarding a prepared external registration releases the collateral
+    // lock acquired by this session after explicit confirmation.
+    uint256 collateral_txid;
+    collateral_txid.SetHex("1");
+    const COutPoint collateral_outpoint{collateral_txid, 0};
+    QVERIFY(wallet_model.wallet().lockCoin(collateral_outpoint, /*write_to_db=*/false));
+    wizard.m_col_external->setChecked(true);
+    wizard.m_prepared_tx = MakeTransactionRef(CMutableTransaction{});
+    wizard.m_prepared_collateral_outpoint = collateral_outpoint;
+    wizard.m_prepared_collateral_lock_acquired = true;
+    QString discard_text;
+    ClickMessageBox(QMessageBox::Yes, &discard_text);
+    wizard.reject();
+    QVERIFY(discard_text.contains("released", Qt::CaseInsensitive));
+    QVERIFY(!wallet_model.wallet().isLockedCoin(collateral_outpoint));
+    QCOMPARE(rejected_spy.count(), 1);
+}
+
+void MasternodeWidgetTests::registrationResultStates()
+{
+#if defined(Q_OS_MACOS)
+    if (QApplication::platformName() == "minimal") {
+        QWARN("Skipping registrationResultStates on macOS with the minimal platform due to QTBUG-49686");
+        return;
+    }
+#endif
+    TestChain100Setup test;
+    m_node.setContext(&test.m_node);
+    WalletContext& context{*m_node.walletLoader().context()};
+    const auto wallet{std::make_shared<CWallet>(m_node.context()->chain.get(), m_node.context()->coinjoin_loader.get(),
+                                                "", gArgs, CreateMockWalletDatabase())};
+    wallet->LoadWallet();
+    OptionsModel options_model(m_node);
+    bilingual_str options_error;
+    QVERIFY(options_model.Init(options_error));
+    ClientModel client_model(m_node, &options_model);
+    WalletModel wallet_model(interfaces::MakeWallet(context, wallet), client_model);
+
+    RegisterMasternodeWizard wizard(m_node, &wallet_model);
+    wizard.m_col_external->setChecked(true);
+    wizard.m_service_edit->clear();
+
+    // A generated key is shown and must be confirmed before any provider
+    // operation can start. This guarantees that owner teardown cannot destroy
+    // the only key copy after a successful background broadcast.
+    wizard.goToPage(RegisterMasternodeWizard::PageReview);
+    wizard.onNext();
+    QCOMPARE(wizard.m_pages->currentIndex(), static_cast<int>(RegisterMasternodeWizard::PageSecret));
+    QVERIFY(wizard.m_secret_note->text().contains("cannot start", Qt::CaseInsensitive));
+    QVERIFY(wizard.m_secret_edit->text() == wizard.m_operator_widget->secretHex());
+    QVERIFY(wizard.secretGateRequired());
+    QVERIFY(!wizard.m_next_button->isEnabled());
+
+    wizard.startRegistration(/*skip_confirmation=*/true);
+    QVERIFY(wizard.m_stage == RegisterMasternodeWizard::Stage::None);
+    QCOMPARE(wizard.m_pages->currentIndex(), static_cast<int>(RegisterMasternodeWizard::PageSecret));
+
+    const QString suffix{wizard.m_operator_widget->secretHex().right(4)};
+    wizard.m_confirm_edit->setText(suffix == "0000" ? "1111" : "0000");
+    QVERIFY(!wizard.secretConfirmed());
+    QVERIFY(!wizard.m_next_button->isEnabled());
+    wizard.m_confirm_edit->setText(suffix);
+    QVERIFY(wizard.secretConfirmed());
+    QVERIFY(wizard.m_next_button->isEnabled());
+
+    wizard.populateResult(QString(64, QLatin1Char('1')));
+    wizard.goToPage(RegisterMasternodeWizard::PageResult);
+    wizard.show();
+    QApplication::processEvents();
+
+    QVERIFY(wizard.m_result_tx_note->text().contains("external collateral"));
+    QVERIFY(wizard.m_result_tx_note->text().contains("not controlled by this wallet"));
+    QVERIFY(wizard.m_next_steps->text().contains("Update Service"));
+    QVERIFY(wizard.m_next_button->isEnabled());
+
+    // A malformed non-broadcast submit result must leave a lock acquired by
+    // prepare under this session's ownership so cancel/destruction releases it.
+    wizard.m_stage = RegisterMasternodeWizard::Stage::Submit;
+    wizard.m_prepared_collateral_lock_acquired = true;
+    wizard.finishSubmission(interfaces::ProviderTxSubmission{CTransactionRef{}, /*submitted=*/false});
+    QVERIFY(wizard.m_prepared_collateral_lock_acquired);
+
+    // Once broadcast, the registration owns that lock even if a malformed
+    // backend result omits its transaction object.
+    wizard.m_stage = RegisterMasternodeWizard::Stage::Submit;
+    wizard.finishSubmission(interfaces::ProviderTxSubmission{CTransactionRef{}, /*submitted=*/true});
+    QVERIFY(!wizard.m_prepared_collateral_lock_acquired);
+}
+
+void MasternodeWidgetTests::destinationValidation()
+{
+    const QString p2pkh{QString::fromStdString(EncodeDestination(PKHash{uint160{}}))};
+    const QString p2sh{QString::fromStdString(EncodeDestination(ScriptHash{CScript() << OP_TRUE}))};
+
+    QVERIFY(MasternodeWidgetUtil::isP2PKHAddress(p2pkh));
+    QVERIFY(MasternodeWidgetUtil::isP2PKHorP2SHAddress(p2pkh));
+    QVERIFY(!MasternodeWidgetUtil::isP2PKHAddress(p2sh));
+    QVERIFY(MasternodeWidgetUtil::isP2PKHorP2SHAddress(p2sh));
+    QVERIFY(!MasternodeWidgetUtil::isP2PKHorP2SHAddress("not-an-address"));
+}
+
+void MasternodeWidgetTests::operatorKeyModes()
+{
+    OperatorKeyWidget widget;
+    QVERIFY(widget.mode() == OperatorKeyWidget::Mode::GenerateOnly);
+    QVERIFY(widget.isValid());
+    QVERIFY(!widget.publicKeyHex().isEmpty());
+    QVERIFY(!widget.secretHex().isEmpty());
+
+    CBLSSecretKey secret;
+    secret.MakeNewKey();
+    const auto radios{widget.findChildren<QRadioButton*>()};
+    const auto existing_it{std::find_if(radios.begin(), radios.end(), [](const QRadioButton* radio) {
+        return radio->text().contains("existing operator");
+    })};
+    QVERIFY(existing_it != radios.end());
+    auto* existing_radio{*existing_it};
+    existing_radio->setChecked(true);
+    QVERIFY(widget.mode() == OperatorKeyWidget::Mode::Existing);
+    QVERIFY(!widget.isValid());
+
+    auto* edit{widget.findChild<QValidatedLineEdit*>()};
+    QVERIFY(edit != nullptr);
+    edit->setText(QString::fromStdString(secret.GetPublicKey().ToString(false)));
+    QVERIFY(widget.isValid());
+    QVERIFY(widget.secretHex().isEmpty());
+}
diff --git a/src/qt/test/masternodewidgettests.h b/src/qt/test/masternodewidgettests.h
new file mode 100644
index 000000000000..7e3333697b8a
--- /dev/null
+++ b/src/qt/test/masternodewidgettests.h
@@ -0,0 +1,46 @@
+// 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_MASTERNODEWIDGETTESTS_H
+#define BITCOIN_QT_TEST_MASTERNODEWIDGETTESTS_H
+
+#include <QObject>
+
+namespace interfaces {
+class Node;
+} // namespace interfaces
+
+class MasternodeWidgetTests : public QObject
+{
+    Q_OBJECT
+
+public:
+    explicit MasternodeWidgetTests(interfaces::Node& node) :
+        m_node(node)
+    {
+    }
+
+private Q_SLOTS:
+    void endpointTokenization();
+    void providerNetInfoValidation_data();
+    void providerNetInfoValidation();
+    void operationRunnerThreading();
+    void operationRunnerExceptions();
+    void operationRunnerShutdownDelivery();
+    void feeSourcePickerEligibility();
+    void registeredCollateralExclusion();
+    void wizardMinimumGeometry();
+    void wizardPageValidation();
+    void broadcastConfirmation();
+    void masternodeListRegistrationAvailability();
+    void wizardInteractionLifecycle();
+    void registrationResultStates();
+    void destinationValidation();
+    void operatorKeyModes();
+
+private:
+    interfaces::Node& m_node;
+};
+
+#endif // BITCOIN_QT_TEST_MASTERNODEWIDGETTESTS_H
diff --git a/src/qt/test/test_main.cpp b/src/qt/test/test_main.cpp
index e7ef807a2d51..56e6e3fb306b 100644
--- a/src/qt/test/test_main.cpp
+++ b/src/qt/test/test_main.cpp
@@ -19,6 +19,8 @@
 
 #ifdef ENABLE_WALLET
 #include <qt/test/addressbooktests.h>
+#include <qt/test/masternodemaintenancetests.h>
+#include <qt/test/masternodewidgettests.h>
 #include <qt/test/providertransactiontests.h>
 #include <qt/test/wallettests.h>
 #endif // ENABLE_WALLET
@@ -101,6 +103,9 @@ int main(int argc, char* argv[])
     num_test_failures += QTest::qExec(&test3);
 
 #ifdef ENABLE_WALLET
+    MasternodeWidgetTests masternode_widget_tests(app.node());
+    num_test_failures += QTest::qExec(&masternode_widget_tests);
+
     WalletTests test5(app.node());
     num_test_failures += QTest::qExec(&test5);
 
@@ -109,6 +114,9 @@ int main(int argc, char* argv[])
 
     ProviderTransactionTests provider_transaction_tests(app.node());
     num_test_failures += QTest::qExec(&provider_transaction_tests);
+
+    MasternodeMaintenanceTests masternode_maintenance_tests(app.node());
+    num_test_failures += QTest::qExec(&masternode_maintenance_tests);
 #endif
     TrafficGraphDataTests test7;
     num_test_failures += QTest::qExec(&test7);
diff --git a/test/util/data/non-backported.txt b/test/util/data/non-backported.txt
index 9ef8b5e20873..b27dc1cde71b 100644
--- a/test/util/data/non-backported.txt
+++ b/test/util/data/non-backported.txt
@@ -39,12 +39,18 @@ src/qt/descriptiondialog.*
 src/qt/donutchart.*
 src/qt/guiutil_font.*
 src/qt/informationwidget.*
+src/qt/masternodedialogs.*
 src/qt/masternodelist.*
 src/qt/masternodemodel.*
+src/qt/masternodeoperationrunner.*
+src/qt/masternodewidgets.*
+src/qt/masternodewizard.*
 src/qt/mnemonicverificationdialog.*
 src/qt/networkwidget.*
 src/qt/test/providertransactiontests.cpp
 src/qt/test/providertransactiontests.h
+src/qt/test/masternodemaintenancetests.*
+src/qt/test/masternodewidgettests.*
 src/qt/proposalcreate.*
 src/qt/proposalinfo.*
 src/qt/proposallist.*

From 297c15bbe01862669559ee179753b9088b383a7e Mon Sep 17 00:00:00 2001
From: pasta <pasta@dashboost.org>
Date: Wed, 19 Aug 2026 05:26:36 -0500
Subject: [PATCH 2/2] docs: add masternode management release notes

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

diff --git a/doc/release-notes-7618.md b/doc/release-notes-7618.md
new file mode 100644
index 000000000000..02ea16131a6b
--- /dev/null
+++ b/doc/release-notes-7618.md
@@ -0,0 +1,9 @@
+GUI changes
+-----------
+
+- Dash-Qt can now register and maintain regular masternodes and EvoNodes from
+  the Masternodes tab. The registration wizard supports wallet-funded,
+  wallet-owned, and externally held collateral, while row actions provide
+  Update Service, Update Registrar, and Revoke workflows. Generated operator
+  keys are shown and confirmed before registration; wallet-seed-derived
+  operator keys are not required. (#7618)