From db6c30ffa26c6509c9c7ec94bc4b719da606110f Mon Sep 17 00:00:00 2001
From: Pasta <pasta@dashboost.org>
Date: Thu, 9 Jul 2026 16:34:48 -0500
Subject: [PATCH 01/20] consensus: add shared collateral template script and
 new special tx types

Adds the 7-byte shared masternode collateral template script
(0x04 "DSHC" OP_DROP OP_TRUE, hex 04445348437551) with exact-match helpers,
and reserves special transaction types 10 (ProDisTx), 11 (ProUpShareTx) and
12 (ProUpSharedRegTx) for the decentralized masternode shares DIP. The new
types are whitelisted in ContextualCheckTransaction unconditionally, matching
the asset lock/unlock pattern: pre-activation rejection happens inside the
per-type check functions, which gate on v24.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
---
 src/Makefile.am              |  1 +
 src/evo/sharedcollateral.h   | 33 +++++++++++++++++++++++++++++++++
 src/primitives/transaction.h |  3 +++
 src/validation.cpp           |  5 ++++-
 4 files changed, 41 insertions(+), 1 deletion(-)
 create mode 100644 src/evo/sharedcollateral.h

diff --git a/src/Makefile.am b/src/Makefile.am
index 501a695cf852..f59e6f009c1a 100644
--- a/src/Makefile.am
+++ b/src/Makefile.am
@@ -228,6 +228,7 @@ BITCOIN_CORE_H = \
   evo/mnhftx.h \
   evo/netinfo.h \
   evo/providertx.h \
+  evo/sharedcollateral.h \
   evo/simplifiedmns.h \
   evo/smldiff.h \
   evo/specialtx.h \
diff --git a/src/evo/sharedcollateral.h b/src/evo/sharedcollateral.h
new file mode 100644
index 000000000000..6730fe2de7ec
--- /dev/null
+++ b/src/evo/sharedcollateral.h
@@ -0,0 +1,33 @@
+// Copyright (c) 2026 The Dash Core developers
+// Distributed under the MIT software license, see the accompanying
+// file COPYING or http://www.opensource.org/licenses/mit-license.php.
+
+#ifndef BITCOIN_EVO_SHAREDCOLLATERAL_H
+#define BITCOIN_EVO_SHAREDCOLLATERAL_H
+
+#include <script/script.h>
+
+namespace sharedcollateral {
+
+/**
+ * The shared masternode collateral template script: 0x04 "DSHC" OP_DROP OP_TRUE
+ * (hex 04445348437551). At the script layer this is anyone-can-spend; all
+ * protection comes from consensus rules that restrict both creation (only as
+ * the collateral output of a valid shared ProRegTx) and spending (only via a
+ * valid ProDisTx). Matching is always exact-script comparison, never prefix
+ * matching.
+ */
+inline const CScript& SharedCollateralScript()
+{
+    static const CScript script = CScript() << std::vector<unsigned char>{'D', 'S', 'H', 'C'} << OP_DROP << OP_TRUE;
+    return script;
+}
+
+inline bool IsSharedCollateralScript(const CScript& script)
+{
+    return script == SharedCollateralScript();
+}
+
+} // namespace sharedcollateral
+
+#endif // BITCOIN_EVO_SHAREDCOLLATERAL_H
diff --git a/src/primitives/transaction.h b/src/primitives/transaction.h
index b45e81fa6e88..c03ab9e78d81 100644
--- a/src/primitives/transaction.h
+++ b/src/primitives/transaction.h
@@ -33,6 +33,9 @@ enum {
     TRANSACTION_MNHF_SIGNAL = 7,
     TRANSACTION_ASSET_LOCK = 8,
     TRANSACTION_ASSET_UNLOCK = 9,
+    TRANSACTION_PROVIDER_DISSOLVE = 10,
+    TRANSACTION_PROVIDER_UPDATE_SHARE = 11,
+    TRANSACTION_PROVIDER_UPDATE_SHARED_REGISTRAR = 12,
 };
 
 /** An outpoint - a combination of a transaction hash and an index n into its vout */
diff --git a/src/validation.cpp b/src/validation.cpp
index bd99df8bc8d6..2d57f0739ea5 100644
--- a/src/validation.cpp
+++ b/src/validation.cpp
@@ -363,7 +363,10 @@ static bool ContextualCheckTransaction(const CTransaction& tx, TxValidationState
                 tx.nType != TRANSACTION_QUORUM_COMMITMENT &&
                 tx.nType != TRANSACTION_MNHF_SIGNAL &&
                 tx.nType != TRANSACTION_ASSET_LOCK &&
-                tx.nType != TRANSACTION_ASSET_UNLOCK) {
+                tx.nType != TRANSACTION_ASSET_UNLOCK &&
+                tx.nType != TRANSACTION_PROVIDER_DISSOLVE &&
+                tx.nType != TRANSACTION_PROVIDER_UPDATE_SHARE &&
+                tx.nType != TRANSACTION_PROVIDER_UPDATE_SHARED_REGISTRAR) {
                 return state.Invalid(TxValidationResult::TX_CONSENSUS, "bad-txns-type");
             }
             if (tx.IsCoinBase() && tx.nType != TRANSACTION_COINBASE)

From 8ff0261ef7e3ec68c9ef1e2515a80648ada5c0d5 Mon Sep 17 00:00:00 2001
From: Pasta <pasta@dashboost.org>
Date: Thu, 9 Jul 2026 16:35:34 -0500
Subject: [PATCH 02/20] evo: extend extended-address ProRegTx payload with
 collateral shares

An extended-address (version 3) ProRegTx with a non-zero share count is a
shared masternode registration: 2 to 8 participants each record an immutable
collateral amount, refund script and share owner key, plus an updatable
reward script. The new fields (share table, one 65-byte consent signature
per share, early-period length and penalty) are appended to the extended
payload after the DIP-0026 payouts field; a non-shared extended payload
serializes a zero share count and zeroed penalty fields. The extended
version is unreleased, so this wire change is safe.

Stateless validation (IsShareListTriviallyValid) enforces the DIP rules:
regular masternodes only, internal collateral, null owner key, empty payout
list, per-share minimum of 100 DASH summing exactly to the collateral,
penalty below the smallest share, early period of at most 420480 blocks,
P2PKH/P2SH refund and reward scripts that are not the template and do not pay
any table owner key or the voting key, no duplicate owner keys or refund
scripts, and one join signature per share.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
---
 src/evo/core_write.cpp      |  24 +++++++-
 src/evo/providertx.cpp      | 120 ++++++++++++++++++++++++++++++++++--
 src/evo/providertx.h        |  86 ++++++++++++++++++++++++++
 src/evo/providertx_util.cpp |  36 +++++++++++
 4 files changed, 261 insertions(+), 5 deletions(-)

diff --git a/src/evo/core_write.cpp b/src/evo/core_write.cpp
index c668f65b0dc5..2374b2093592 100644
--- a/src/evo/core_write.cpp
+++ b/src/evo/core_write.cpp
@@ -41,6 +41,8 @@ const std::map<std::string, RPCResult> RPCRESULT_MAP{{
     RESULT_MAP_ENTRY("collateralHash", RPCResult::Type::STR_HEX, "Collateral transaction hash"),
     RESULT_MAP_ENTRY("collateralIndex", RPCResult::Type::NUM, "Collateral transaction output index"),
     RESULT_MAP_ENTRY("consecutivePayments", RPCResult::Type::NUM, "Consecutive payments masternode has received in payment cycle"),
+    RESULT_MAP_ENTRY("earlyPenalty", RPCResult::Type::NUM, "Penalty in duffs for unilateral dissolution during the early period"),
+    RESULT_MAP_ENTRY("earlyPeriodBlocks", RPCResult::Type::NUM, "Length in blocks of the early period during which unilateral dissolution is penalized"),
     RESULT_MAP_ENTRY("height", RPCResult::Type::NUM, "Block height"),
     RESULT_MAP_ENTRY("inputsHash", RPCResult::Type::STR_HEX, "Hash of all the outpoints of the transaction inputs"),
     RESULT_MAP_ENTRY("lastPaidHeight", RPCResult::Type::NUM, "Height masternode was last paid"),
@@ -77,6 +79,19 @@ const std::map<std::string, RPCResult> RPCRESULT_MAP{{
     RESULT_MAP_ENTRY("registeredHeight", RPCResult::Type::NUM, "Height masternode was registered"),
     RESULT_MAP_ENTRY("revocationReason", RPCResult::Type::NUM, "Reason for ProUpRegTx revocation"),
     RESULT_MAP_ENTRY("service", RPCResult::Type::STR, "IP address and port of the masternode (DEPRECATED, returned only if config option -deprecatedrpc=service is passed)"),
+    {"shares",
+        {RPCResult::Type::ARR, "shares", "Collateral shares of a shared masternode",
+    {
+        {RPCResult::Type::OBJ, "", "",
+        {
+            {RPCResult::Type::NUM, "amount", "Collateral contribution in duffs"},
+            {RPCResult::Type::STR, "refundAddress", "Dash address the principal is refunded to at dissolution"},
+            {RPCResult::Type::STR_HEX, "refundScript", "Refund scriptPubKey"},
+            {RPCResult::Type::STR, "rewardAddress", "Dash address this share's owner rewards are paid to"},
+            {RPCResult::Type::STR_HEX, "rewardScript", "Reward scriptPubKey"},
+            {RPCResult::Type::STR, "ownerAddress", "Dash address of the share owner key"},
+        }},
+    }}},
     RESULT_MAP_ENTRY("type", RPCResult::Type::NUM, "Masternode type"),
     RESULT_MAP_ENTRY("type_str", RPCResult::Type::STR, "Masternode type (human-readable string)"),
     RESULT_MAP_ENTRY("version", RPCResult::Type::NUM, "Special transaction version"),
@@ -313,6 +328,9 @@ RPCResult CProRegTx::GetJsonHelp(const std::string& key, bool optional)
         GetRpcResult("votingAddress"),
         GetRpcResult("payoutAddress", /*optional=*/true),
         GetRpcResult("payouts", /*optional=*/true),
+        GetRpcResult("shares", /*optional=*/true),
+        GetRpcResult("earlyPeriodBlocks", /*optional=*/true),
+        GetRpcResult("earlyPenalty", /*optional=*/true),
         GetRpcResult("pubKeyOperator"),
         GetRpcResult("operatorReward"),
         GetRpcResult("platformNodeID", /*optional=*/true),
@@ -335,7 +353,11 @@ UniValue CProRegTx::ToJson() const
     ret.pushKV("addresses", GetNetInfoWithLegacyFields(*this, nType));
     ret.pushKV("ownerAddress", EncodeDestination(PKHash(keyIDOwner)));
     ret.pushKV("votingAddress", EncodeDestination(PKHash(keyIDVoting)));
-    if (nVersion >= ProTxVersion::ExtAddr) {
+    if (IsShared()) {
+        ret.pushKV("shares", ShareListToJson(shares));
+        ret.pushKV("earlyPeriodBlocks", static_cast<int64_t>(nEarlyPeriodBlocks));
+        ret.pushKV("earlyPenalty", nEarlyPenalty);
+    } else if (nVersion >= ProTxVersion::ExtAddr) {
         ret.pushKV("payouts", PayoutListToJson(payouts));
     } else if (CTxDestination dest; ExtractDestination(scriptPayout, dest)) {
         ret.pushKV("payoutAddress", EncodeDestination(dest));
diff --git a/src/evo/providertx.cpp b/src/evo/providertx.cpp
index b0bcc3f7f2b5..4cb49fb365ab 100644
--- a/src/evo/providertx.cpp
+++ b/src/evo/providertx.cpp
@@ -5,6 +5,7 @@
 #include <evo/providertx.h>
 
 #include <evo/dmn_types.h>
+#include <evo/sharedcollateral.h>
 #include <util/std23.h>
 
 #include <chainparams.h>
@@ -59,6 +60,82 @@ bool IsPayoutListTriviallyValid(const MasternodePayoutShares& payouts, const CKe
     return true;
 }
 
+bool IsShareListTriviallyValid(const CollateralShares& shares,
+                               const std::vector<std::vector<unsigned char>>& join_sigs,
+                               uint32_t early_period_blocks, CAmount early_penalty, CAmount required_collateral,
+                               const CKeyID& keyIDVoting, TxValidationState& state)
+{
+    if (shares.size() < CProRegTx::MIN_SHARES || shares.size() > CProRegTx::MAX_SHARES) {
+        return state.Invalid(TxValidationResult::TX_BAD_SPECIAL, "bad-protx-shares-count");
+    }
+    if (join_sigs.size() != shares.size()) {
+        return state.Invalid(TxValidationResult::TX_BAD_SPECIAL, "bad-protx-shares-sig-count");
+    }
+    for (const auto& sig : join_sigs) {
+        if (sig.size() != CPubKey::COMPACT_SIGNATURE_SIZE) {
+            return state.Invalid(TxValidationResult::TX_BAD_SPECIAL, "bad-protx-shares-sig-size");
+        }
+    }
+    if (early_period_blocks > CProRegTx::MAX_EARLY_PERIOD_BLOCKS) {
+        return state.Invalid(TxValidationResult::TX_BAD_SPECIAL, "bad-protx-shares-early-period");
+    }
+
+    CAmount total_amount{0};
+    CAmount min_amount{std::numeric_limits<CAmount>::max()};
+    std::set<CKeyID> seen_owner_keys;
+    std::set<CScript> seen_refund_scripts;
+    for (const auto& share : shares) {
+        // Bounding each amount by the required collateral first makes the sum overflow-safe
+        if (share.amount < CCollateralShare::MIN_AMOUNT || share.amount > required_collateral) {
+            return state.Invalid(TxValidationResult::TX_BAD_SPECIAL, "bad-protx-shares-amount");
+        }
+        total_amount += share.amount;
+        min_amount = std::min(min_amount, share.amount);
+
+        if (share.keyIDOwner.IsNull()) {
+            return state.Invalid(TxValidationResult::TX_BAD_SPECIAL, "bad-protx-shares-key-null");
+        }
+        if (!seen_owner_keys.emplace(share.keyIDOwner).second) {
+            return state.Invalid(TxValidationResult::TX_BAD_SPECIAL, "bad-protx-shares-dup-key");
+        }
+        if (!seen_refund_scripts.emplace(share.scriptRefund).second) {
+            return state.Invalid(TxValidationResult::TX_BAD_SPECIAL, "bad-protx-shares-dup-refund");
+        }
+
+        for (const CScript* script : {&share.scriptRefund, &share.scriptReward}) {
+            if (script == &share.scriptReward && script->empty()) {
+                // An empty reward script means "use the refund script"
+                continue;
+            }
+            if (sharedcollateral::IsSharedCollateralScript(*script)) {
+                return state.Invalid(TxValidationResult::TX_BAD_SPECIAL, "bad-protx-shares-payee-template");
+            }
+            if (!IsValidPayoutScript(*script)) {
+                return state.Invalid(TxValidationResult::TX_BAD_SPECIAL, "bad-protx-shares-payee");
+            }
+            CTxDestination dest;
+            if (!ExtractDestination(*script, dest)) {
+                return state.Invalid(TxValidationResult::TX_BAD_SPECIAL, "bad-protx-shares-payee-dest");
+            }
+            if (dest == CTxDestination(PKHash(keyIDVoting))) {
+                return state.Invalid(TxValidationResult::TX_BAD_SPECIAL, "bad-protx-shares-payee-reuse");
+            }
+            for (const auto& other : shares) {
+                if (dest == CTxDestination(PKHash(other.keyIDOwner))) {
+                    return state.Invalid(TxValidationResult::TX_BAD_SPECIAL, "bad-protx-shares-payee-reuse");
+                }
+            }
+        }
+    }
+    if (total_amount != required_collateral) {
+        return state.Invalid(TxValidationResult::TX_BAD_SPECIAL, "bad-protx-shares-amount-sum");
+    }
+    if (early_penalty < 0 || early_penalty >= min_amount) {
+        return state.Invalid(TxValidationResult::TX_BAD_SPECIAL, "bad-protx-shares-penalty");
+    }
+    return true;
+}
+
 bool IsPayoutListKeySafe(const MasternodePayoutShares& payouts, const CTxDestination& collateral_dest,
                          const CKeyID& keyIDOwner, const CKeyID& keyIDVoting,
                          bool check_payout_collateral_reuse, TxValidationState& state)
@@ -118,14 +195,47 @@ bool CProRegTx::IsTriviallyValid(TxValidationState& state) const
         return state.Invalid(TxValidationResult::TX_CONSENSUS, "bad-protx-mode");
     }
 
-    if (keyIDOwner.IsNull() || !pubKeyOperator.Get().IsValid() || keyIDVoting.IsNull()) {
+    if (IsShared()) {
+        if (nVersion < ProTxVersion::ExtAddr) {
+            return state.Invalid(TxValidationResult::TX_CONSENSUS, "bad-protx-version");
+        }
+        if (nType != MnType::Regular) {
+            return state.Invalid(TxValidationResult::TX_BAD_SPECIAL, "bad-protx-shares-evo");
+        }
+        // The collateral must be internal; the funding inputs and outputs are covered by the consent digest
+        if (!collateralOutpoint.hash.IsNull()) {
+            return state.Invalid(TxValidationResult::TX_BAD_SPECIAL, "bad-protx-shares-external");
+        }
+        // The share owner keys replace the owner key; owner rewards derive from the share table
+        if (!keyIDOwner.IsNull()) {
+            return state.Invalid(TxValidationResult::TX_BAD_SPECIAL, "bad-protx-shares-owner-key");
+        }
+        if (!payouts.empty()) {
+            return state.Invalid(TxValidationResult::TX_BAD_SPECIAL, "bad-protx-shares-payouts");
+        }
+    } else {
+        if (!vchJoinSigs.empty() || nEarlyPeriodBlocks != 0 || nEarlyPenalty != 0) {
+            return state.Invalid(TxValidationResult::TX_BAD_SPECIAL, "bad-protx-shares-empty-fields");
+        }
+        if (keyIDOwner.IsNull()) {
+            return state.Invalid(TxValidationResult::TX_BAD_SPECIAL, "bad-protx-key-null");
+        }
+    }
+    if (!pubKeyOperator.Get().IsValid() || keyIDVoting.IsNull()) {
         return state.Invalid(TxValidationResult::TX_BAD_SPECIAL, "bad-protx-key-null");
     }
     if (pubKeyOperator.IsLegacy() != (nVersion == ProTxVersion::LegacyBLS)) {
         return state.Invalid(TxValidationResult::TX_BAD_SPECIAL, "bad-protx-operator-pubkey");
     }
-    const auto owner_payouts = GetOwnerPayouts(*this);
-    if (!IsPayoutListTriviallyValid(owner_payouts, keyIDOwner, keyIDVoting, state)) return false;
+    if (IsShared()) {
+        if (!IsShareListTriviallyValid(shares, vchJoinSigs, nEarlyPeriodBlocks, nEarlyPenalty,
+                                       GetMnType(nType).collat_amount, keyIDVoting, state)) {
+            return false;
+        }
+    } else {
+        const auto owner_payouts = GetOwnerPayouts(*this);
+        if (!IsPayoutListTriviallyValid(owner_payouts, keyIDOwner, keyIDVoting, state)) return false;
+    }
     if (netInfo->CanStorePlatform() != (nVersion >= ProTxVersion::ExtAddr)) {
         return state.Invalid(TxValidationResult::TX_CONSENSUS, "bad-protx-netinfo-version");
     }
@@ -170,7 +280,9 @@ std::string CProRegTx::MakeSignString() const
 
 std::string CProRegTx::ToString() const
 {
-    const std::string payee = PayoutListToString(GetOwnerPayouts(*this));
+    const std::string payee = IsShared() ? strprintf("shares(%s), earlyPeriodBlocks=%d, earlyPenalty=%d",
+                                                     ShareListToString(shares), nEarlyPeriodBlocks, nEarlyPenalty)
+                                         : PayoutListToString(GetOwnerPayouts(*this));
 
     return strprintf("CProRegTx(nVersion=%d, nType=%d, collateralOutpoint=%s, netInfo=%s, nOperatorReward=%f, "
                      "ownerAddress=%s, pubKeyOperator=%s, votingAddress=%s, scriptPayout=%s, platformNodeID=%s%s)\n",
diff --git a/src/evo/providertx.h b/src/evo/providertx.h
index d27713e74ca7..a6a05f1d32a6 100644
--- a/src/evo/providertx.h
+++ b/src/evo/providertx.h
@@ -46,6 +46,62 @@ class MasternodePayoutShare
 
 using MasternodePayoutShares = std::vector<MasternodePayoutShare>;
 
+/** Serializes a 65-byte compact recoverable ECDSA signature without a length prefix */
+struct CompactSignatureFormatter {
+    template <typename Stream, typename V>
+    void Ser(Stream& s, const V& v)
+    {
+        if (v.size() != CPubKey::COMPACT_SIGNATURE_SIZE) {
+            throw std::ios_base::failure("compact signature size mismatch");
+        }
+        s.write(AsBytes(Span{v}));
+    }
+    template <typename Stream, typename V>
+    void Unser(Stream& s, V& v)
+    {
+        v.resize(CPubKey::COMPACT_SIGNATURE_SIZE);
+        s.read(AsWritableBytes(Span{v}));
+    }
+};
+
+/** One participant's contribution to a shared masternode collateral */
+class CCollateralShare
+{
+public:
+    static constexpr CAmount MIN_AMOUNT{100 * COIN};
+
+    CAmount amount{0};
+    CScript scriptRefund;
+    CScript scriptReward; //!< empty means "use scriptRefund"
+    CKeyID keyIDOwner;
+
+    CCollateralShare() = default;
+    CCollateralShare(CAmount amount, CScript script_refund, CScript script_reward, CKeyID key_id_owner) :
+        amount(amount),
+        scriptRefund(std::move(script_refund)),
+        scriptReward(std::move(script_reward)),
+        keyIDOwner(key_id_owner)
+    {
+    }
+
+    SERIALIZE_METHODS(CCollateralShare, obj)
+    {
+        READWRITE(obj.amount, obj.scriptRefund, obj.scriptReward, obj.keyIDOwner);
+    }
+
+    /** The script this share's portion of owner rewards is paid to */
+    const CScript& RewardScript() const { return scriptReward.empty() ? scriptRefund : scriptReward; }
+
+    friend bool operator==(const CCollateralShare& a, const CCollateralShare& b)
+    {
+        return a.amount == b.amount && a.scriptRefund == b.scriptRefund && a.scriptReward == b.scriptReward &&
+               a.keyIDOwner == b.keyIDOwner;
+    }
+    friend bool operator!=(const CCollateralShare& a, const CCollateralShare& b) { return !(a == b); }
+};
+
+using CollateralShares = std::vector<CCollateralShare>;
+
 [[nodiscard]] MasternodePayoutShares LegacyPayoutAsList(const CScript& script_payout);
 template<class T>
 [[nodiscard]] MasternodePayoutShares GetOwnerPayouts(const T& protx);
@@ -58,11 +114,22 @@ template<class T>
 [[nodiscard]] std::string PayoutListToString(const MasternodePayoutShares& payouts);
 [[nodiscard]] UniValue PayoutListToJson(const MasternodePayoutShares& payouts);
 
+[[nodiscard]] bool IsShareListTriviallyValid(const CollateralShares& shares,
+                                             const std::vector<std::vector<unsigned char>>& join_sigs,
+                                             uint32_t early_period_blocks, CAmount early_penalty,
+                                             CAmount required_collateral, const CKeyID& keyIDVoting,
+                                             TxValidationState& state);
+[[nodiscard]] std::string ShareListToString(const CollateralShares& shares);
+[[nodiscard]] UniValue ShareListToJson(const CollateralShares& shares);
 class CProRegTx
 {
 public:
     static constexpr auto SPECIALTX_TYPE = TRANSACTION_PROVIDER_REGISTER;
 
+    static constexpr uint8_t MIN_SHARES{2};
+    static constexpr uint8_t MAX_SHARES{8};
+    static constexpr uint32_t MAX_EARLY_PERIOD_BLOCKS{420480}; // approx. two years at 2.5-minute blocks
+
     uint16_t nVersion{ProTxVersion::LegacyBLS}; // message version
     MnType nType{MnType::Regular};
     uint16_t nMode{0};                                     // only 0 supported for now
@@ -77,6 +144,10 @@ class CProRegTx
     uint16_t nOperatorReward{0};
     CScript scriptPayout;
     MasternodePayoutShares payouts;
+    CollateralShares shares;                            // non-empty = shared masternode registration
+    std::vector<std::vector<unsigned char>> vchJoinSigs; // one consent signature per share, in share order
+    uint32_t nEarlyPeriodBlocks{0};
+    CAmount nEarlyPenalty{0};
     uint256 inputsHash; // replay protection
     std::vector<unsigned char> vchSig;
 
@@ -110,6 +181,18 @@ class CProRegTx
             for (auto& payout : obj.payouts) {
                 READWRITE(payout);
             }
+            uint8_t shares_count{0};
+            SER_WRITE(obj, shares_count = static_cast<uint8_t>(obj.shares.size()));
+            READWRITE(shares_count);
+            SER_READ(obj, obj.shares.resize(shares_count));
+            for (auto& share : obj.shares) {
+                READWRITE(share);
+            }
+            SER_READ(obj, obj.vchJoinSigs.resize(shares_count));
+            for (auto& sig : obj.vchJoinSigs) {
+                READWRITE(Using<CompactSignatureFormatter>(sig));
+            }
+            READWRITE(obj.nEarlyPeriodBlocks, obj.nEarlyPenalty);
         } else {
             READWRITE(obj.scriptPayout);
         }
@@ -130,6 +213,9 @@ class CProRegTx
         }
     }
 
+    /** Whether this is a shared masternode registration (DIP: decentralized masternode shares) */
+    [[nodiscard]] bool IsShared() const { return !shares.empty(); }
+
     // When signing with the collateral key, we don't sign the hash but a generated message instead
     // This is needed for HW wallet support which can only sign text messages as of now
     std::string MakeSignString() const;
diff --git a/src/evo/providertx_util.cpp b/src/evo/providertx_util.cpp
index 478799ba1da7..834dc4dc4d9a 100644
--- a/src/evo/providertx_util.cpp
+++ b/src/evo/providertx_util.cpp
@@ -59,3 +59,39 @@ UniValue PayoutListToJson(const MasternodePayoutShares& payouts)
     }
     return ret;
 }
+
+std::string ShareListToString(const CollateralShares& shares)
+{
+    std::string ret;
+    for (const auto& share : shares) {
+        CTxDestination dest;
+        const std::string refund_str = ExtractDestination(share.scriptRefund, dest) ? EncodeDestination(dest)
+                                                                                    : HexStr(share.scriptRefund);
+        if (!ret.empty()) ret += ",";
+        ret += strprintf("%s:%d", refund_str, share.amount);
+    }
+    return ret;
+}
+
+UniValue ShareListToJson(const CollateralShares& shares)
+{
+    UniValue ret(UniValue::VARR);
+    for (const auto& share : shares) {
+        UniValue obj(UniValue::VOBJ);
+        obj.pushKV("amount", share.amount);
+        // Refund and reward scripts are required to be P2PKH or P2SH (see IsShareListTriviallyValid),
+        // so a destination can always be extracted and the addresses are always present.
+        CTxDestination refund_dest;
+        ExtractDestination(share.scriptRefund, refund_dest);
+        obj.pushKV("refundAddress", EncodeDestination(refund_dest));
+        obj.pushKV("refundScript", HexStr(share.scriptRefund));
+        CTxDestination reward_dest;
+        ExtractDestination(share.RewardScript(), reward_dest);
+        obj.pushKV("rewardAddress", EncodeDestination(reward_dest));
+        obj.pushKV("rewardScript", HexStr(share.RewardScript()));
+        obj.pushKV("ownerAddress", EncodeDestination(PKHash(share.keyIDOwner)));
+        ret.push_back(obj);
+    }
+    return ret;
+}
+

From ac616bc67c99d5b4923f4d47df150e077271fecc Mon Sep 17 00:00:00 2001
From: Pasta <pasta@dashboost.org>
Date: Thu, 9 Jul 2026 16:36:16 -0500
Subject: [PATCH 03/20] evo: shared masternode consensus rules, state, and
 special transactions

Implements the consensus core of the decentralized masternode shares DIP. These
concerns are combined into one commit because they interlock through the shared
special-transaction machinery (the CheckSpecialTxInner dispatch, the special-tx
JSON writers, and the deterministic-list rebuild), and do not build in isolation.

- Shared registration: a version 4 ProRegTx with a non-empty share table is a
  shared registration. Stateless rules (share count 2..8, per-share minimum and
  exact collateral sum, penalty bounds, P2PKH/P2SH non-template refund/reward
  scripts, no duplicate owner keys or refund scripts, null keyIDOwner, empty
  DIP-0026 payouts) plus the SharedRegConsentHash digest that every share owner
  signs, binding the funding inputs, all outputs, the share table, the penalty
  terms and the registrar configuration. CheckProRegTx additionally requires the
  internal collateral to pay exactly the template script and enforces cross-list
  owner-key uniqueness.
- Masternode state: CDeterministicMNState stores the share table (excluded from
  joinSigs), early period and penalty, with a single Field_shares diff plus the
  penalty-term diff bits; share owner keys occupy the keyIDOwner uniqueness
  namespace so reuse is rejected in both directions; the null owner key of a
  shared masternode is handled in AddMN/RemoveMN and the revive path.
- ProDisTx (type 10): dissolves a shared masternode, refunding every share to
  its refund script. One signature (unilateral, penalised in the early period)
  or one per share (unanimous, penalty-free); the count is committed into the
  signed digest. Minimum-based output rules with a non-increasing required
  penalty make validity monotone. Removal happens in the collateral-spend phase
  of list construction, so an update and a dissolution of the same masternode
  are valid together in one block in either order.
- ProUpShareTx (type 11) updates one share's reward script; ProUpSharedRegTx
  (type 12) updates the operator and voting keys with a signature from every
  share owner. A plain ProUpRegTx on a shared masternode is invalid.
- Template covenant: consensus restricts creation of the 7-byte template output
  (only as the collateral of a valid shared registration, checked for every
  transaction including the coinbase) and its spending (only via a ProDisTx),
  hooked at mempool acceptance and block connection. Asset-unlock destinations
  are covered by the generic creation check.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
---
 src/core_write.cpp           |  12 +
 src/evo/assetlocktx.cpp      |   5 +
 src/evo/core_write.cpp       |  83 ++++++-
 src/evo/deterministicmns.cpp |  25 +-
 src/evo/dmnstate.cpp         |  15 +-
 src/evo/dmnstate.h           |  16 +-
 src/evo/providertx.cpp       | 141 +++++++++++
 src/evo/providertx.h         | 121 +++++++++
 src/evo/specialtx.cpp        |   9 +
 src/evo/specialtx.h          |   1 +
 src/evo/specialtxman.cpp     | 459 ++++++++++++++++++++++++++++++++++-
 src/evo/specialtxman.h       |  31 +++
 src/messagesigner.cpp        |  34 +++
 src/messagesigner.h          |   3 +
 src/rpc/rawtransaction.cpp   |   3 +
 src/validation.cpp           |  26 ++
 16 files changed, 967 insertions(+), 17 deletions(-)

diff --git a/src/core_write.cpp b/src/core_write.cpp
index e94b0af4add7..ed47d6a9ff3f 100644
--- a/src/core_write.cpp
+++ b/src/core_write.cpp
@@ -324,6 +324,18 @@ void TxToUniv(const CTransaction& tx, const uint256& block_hash, UniValue& entry
         if (const auto opt_assetUnlockTx = GetTxPayload<CAssetUnlockPayload>(tx)) {
             entry.pushKV("assetUnlockTx", opt_assetUnlockTx->ToJson());
         }
+    } else if (tx.nType == TRANSACTION_PROVIDER_DISSOLVE) {
+        if (const auto opt_proTx = GetTxPayload<CProDisTx>(tx)) {
+            entry.pushKV("proDisTx", opt_proTx->ToJson());
+        }
+    } else if (tx.nType == TRANSACTION_PROVIDER_UPDATE_SHARE) {
+        if (const auto opt_proTx = GetTxPayload<CProUpShareTx>(tx)) {
+            entry.pushKV("proUpShareTx", opt_proTx->ToJson());
+        }
+    } else if (tx.nType == TRANSACTION_PROVIDER_UPDATE_SHARED_REGISTRAR) {
+        if (const auto opt_proTx = GetTxPayload<CProUpSharedRegTx>(tx)) {
+            entry.pushKV("proUpSharedRegTx", opt_proTx->ToJson());
+        }
     }
 
     if (have_undo) {
diff --git a/src/evo/assetlocktx.cpp b/src/evo/assetlocktx.cpp
index cba0bdc55534..636488aa26c8 100644
--- a/src/evo/assetlocktx.cpp
+++ b/src/evo/assetlocktx.cpp
@@ -155,6 +155,11 @@ bool CheckAssetUnlockTx(const BlockManager& blockman, const llmq::CQuorumManager
         return state.Invalid(TxValidationResult::TX_BAD_SPECIAL, "bad-assetunlocktx-too-many-outs");
     }
 
+    // A withdrawal paying the shared-collateral template is rejected by the generic template
+    // creation rule (CheckSharedCollateralTemplateOutputs), which is gated on v24. It is
+    // deliberately NOT re-checked here: this function has no v24 activation status available, and
+    // an unconditional rejection would diverge from pre-activation consensus and split the chain.
+
     const auto opt_assetUnlockTx = GetTxPayload<CAssetUnlockPayload>(tx);
     if (!opt_assetUnlockTx) {
         return state.Invalid(TxValidationResult::TX_BAD_SPECIAL, "bad-assetunlocktx-payload");
diff --git a/src/evo/core_write.cpp b/src/evo/core_write.cpp
index 2374b2093592..7d31b3d865bc 100644
--- a/src/evo/core_write.cpp
+++ b/src/evo/core_write.cpp
@@ -244,6 +244,9 @@ RPCResult CDeterministicMNState::GetJsonHelp(const std::string& key, bool option
         GetRpcResult("platformHTTPPort", /*optional=*/true),
         GetRpcResult("payoutAddress", /*optional=*/true),
         GetRpcResult("payouts", /*optional=*/true),
+        GetRpcResult("shares", /*optional=*/true),
+        GetRpcResult("earlyPeriodBlocks", /*optional=*/true),
+        GetRpcResult("earlyPenalty", /*optional=*/true),
         GetRpcResult("pubKeyOperator"),
         GetRpcResult("operatorPayoutAddress", /*optional=*/true),
     }};
@@ -275,7 +278,11 @@ UniValue CDeterministicMNState::ToJson(MnType nType) const
     }
 
     CTxDestination dest;
-    if (nVersion >= ProTxVersion::ExtAddr) {
+    if (IsShared()) {
+        obj.pushKV("shares", ShareListToJson(shares));
+        obj.pushKV("earlyPeriodBlocks", static_cast<int64_t>(nEarlyPeriodBlocks));
+        obj.pushKV("earlyPenalty", nEarlyPenalty);
+    } else if (nVersion >= ProTxVersion::ExtAddr) {
         obj.pushKV("payouts", PayoutListToJson(payouts));
     } else if (ExtractDestination(scriptPayout, dest)) {
         obj.pushKV("payoutAddress", EncodeDestination(dest));
@@ -305,6 +312,9 @@ RPCResult CDeterministicMNStateDiff::GetJsonHelp(const std::string& key, bool op
         GetRpcResult("votingAddress", /*optional=*/true),
         GetRpcResult("payoutAddress", /*optional=*/true),
         GetRpcResult("payouts", /*optional=*/true),
+        GetRpcResult("shares", /*optional=*/true),
+        GetRpcResult("earlyPeriodBlocks", /*optional=*/true),
+        GetRpcResult("earlyPenalty", /*optional=*/true),
         GetRpcResult("operatorPayoutAddress", /*optional=*/true),
         GetRpcResult("pubKeyOperator", /*optional=*/true),
         GetRpcResult("platformNodeID", /*optional=*/true),
@@ -426,6 +436,77 @@ UniValue CProUpRevTx::ToJson() const
     return ret;
 }
 
+RPCResult CProDisTx::GetJsonHelp(const std::string& key, bool optional)
+{
+    return {RPCResult::Type::OBJ, key, optional, key.empty() ? "" : "The shared masternode dissolution special transaction",
+    {
+        GetRpcResult("version"),
+        GetRpcResult("proTxHash"),
+        {RPCResult::Type::NUM, "actorIndex", "Index into the share table of the participant paying the penalty (if any) and the fee"},
+        {RPCResult::Type::NUM, "sigCount", "Number of signatures: 1 = unilateral, one per share = unanimous"},
+    }};
+}
+
+UniValue CProDisTx::ToJson() const
+{
+    UniValue ret(UniValue::VOBJ);
+    ret.pushKV("version", nVersion);
+    ret.pushKV("proTxHash", proTxHash.ToString());
+    ret.pushKV("actorIndex", actorIndex);
+    ret.pushKV("sigCount", static_cast<uint64_t>(vchSigs.size()));
+    return ret;
+}
+
+RPCResult CProUpShareTx::GetJsonHelp(const std::string& key, bool optional)
+{
+    return {RPCResult::Type::OBJ, key, optional, key.empty() ? "" : "The shared masternode share update special transaction",
+    {
+        GetRpcResult("version"),
+        GetRpcResult("proTxHash"),
+        {RPCResult::Type::NUM, "shareIndex", "Index into the share table of the share being updated"},
+        {RPCResult::Type::STR, "rewardAddress", /*optional=*/true, "New Dash address for this share's owner rewards; omitted when reverting to the refund script"},
+        GetRpcResult("inputsHash"),
+    }};
+}
+
+UniValue CProUpShareTx::ToJson() const
+{
+    UniValue ret(UniValue::VOBJ);
+    ret.pushKV("version", nVersion);
+    ret.pushKV("proTxHash", proTxHash.ToString());
+    ret.pushKV("shareIndex", shareIndex);
+    if (CTxDestination dest; !scriptReward.empty() && ExtractDestination(scriptReward, dest)) {
+        ret.pushKV("rewardAddress", EncodeDestination(dest));
+    }
+    ret.pushKV("inputsHash", inputsHash.ToString());
+    return ret;
+}
+
+RPCResult CProUpSharedRegTx::GetJsonHelp(const std::string& key, bool optional)
+{
+    return {RPCResult::Type::OBJ, key, optional, key.empty() ? "" : "The shared masternode registrar update special transaction",
+    {
+        GetRpcResult("version"),
+        GetRpcResult("proTxHash"),
+        GetRpcResult("votingAddress"),
+        GetRpcResult("pubKeyOperator"),
+        GetRpcResult("inputsHash"),
+        {RPCResult::Type::NUM, "sigCount", "Number of signatures; must equal the share count"},
+    }};
+}
+
+UniValue CProUpSharedRegTx::ToJson() const
+{
+    UniValue ret(UniValue::VOBJ);
+    ret.pushKV("version", nVersion);
+    ret.pushKV("proTxHash", proTxHash.ToString());
+    ret.pushKV("votingAddress", EncodeDestination(PKHash(keyIDVoting)));
+    ret.pushKV("pubKeyOperator", pubKeyOperator.ToString());
+    ret.pushKV("inputsHash", inputsHash.ToString());
+    ret.pushKV("sigCount", static_cast<uint64_t>(vchSigs.size()));
+    return ret;
+}
+
 RPCResult CProUpServTx::GetJsonHelp(const std::string& key, bool optional)
 {
     return {RPCResult::Type::OBJ, key, optional, key.empty() ? "" : "The masternode update service special transaction",
diff --git a/src/evo/deterministicmns.cpp b/src/evo/deterministicmns.cpp
index 20db7a1f08ec..5af3a1c47e52 100644
--- a/src/evo/deterministicmns.cpp
+++ b/src/evo/deterministicmns.cpp
@@ -431,7 +431,19 @@ void CDeterministicMNList::AddMN(const CDeterministicMNCPtr& dmn, bool fBumpTota
                 strprintf("%s: Can't add a masternode %s with invalid address", __func__, dmn->proTxHash.ToString()));
         }
     }
-    if (!AddUniqueProperty(*dmn, dmn->pdmnState->keyIDOwner)) {
+    if (dmn->pdmnState->IsShared()) {
+        // A shared masternode has a null keyIDOwner; each share owner key takes its place. Share
+        // owner keys deliberately land in the same uniqueness namespace as keyIDOwner
+        // (GetUniquePropertyHash is an untagged SerializeHash of the value), which is what makes
+        // owner-key reuse between shared and non-shared masternodes impossible in both directions.
+        for (const auto& share : dmn->pdmnState->shares) {
+            if (!AddUniqueProperty(*dmn, share.keyIDOwner)) {
+                mnUniquePropertyMap = mnUniquePropertyMapSaved;
+                throw(std::runtime_error(strprintf("%s: Can't add a masternode %s with a duplicate share ownerKeyID=%s", __func__,
+                        dmn->proTxHash.ToString(), EncodeDestination(PKHash(share.keyIDOwner)))));
+            }
+        }
+    } else if (!AddUniqueProperty(*dmn, dmn->pdmnState->keyIDOwner)) {
         mnUniquePropertyMap = mnUniquePropertyMapSaved;
         throw(std::runtime_error(strprintf("%s: Can't add a masternode %s with a duplicate keyIDOwner=%s", __func__,
                 dmn->proTxHash.ToString(), EncodeDestination(PKHash(dmn->pdmnState->keyIDOwner)))));
@@ -588,7 +600,16 @@ void CDeterministicMNList::RemoveMN(const uint256& proTxHash)
                                                dmn->proTxHash.ToString()));
         }
     }
-    if (!DeleteUniqueProperty(*dmn, dmn->pdmnState->keyIDOwner)) {
+    if (dmn->pdmnState->IsShared()) {
+        // Shared masternodes have a null keyIDOwner; the share owner keys were registered instead
+        for (const auto& share : dmn->pdmnState->shares) {
+            if (!DeleteUniqueProperty(*dmn, share.keyIDOwner)) {
+                mnUniquePropertyMap = mnUniquePropertyMapSaved;
+                throw(std::runtime_error(strprintf("%s: Can't delete a masternode %s with a share ownerKeyID=%s", __func__,
+                        proTxHash.ToString(), EncodeDestination(PKHash(share.keyIDOwner)))));
+            }
+        }
+    } else if (!DeleteUniqueProperty(*dmn, dmn->pdmnState->keyIDOwner)) {
         mnUniquePropertyMap = mnUniquePropertyMapSaved;
         throw(std::runtime_error(strprintf("%s: Can't delete a masternode %s with a keyIDOwner=%s", __func__,
                 proTxHash.ToString(), EncodeDestination(PKHash(dmn->pdmnState->keyIDOwner)))));
diff --git a/src/evo/dmnstate.cpp b/src/evo/dmnstate.cpp
index de22a18c8ede..caa65f974832 100644
--- a/src/evo/dmnstate.cpp
+++ b/src/evo/dmnstate.cpp
@@ -16,8 +16,10 @@ std::string CDeterministicMNState::ToString() const
     if (ExtractDestination(scriptPayout, dest)) {
         payoutAddress = EncodeDestination(dest);
     }
-    const auto owner_payouts = GetOwnerPayouts(*this);
-    const std::string payoutList = PayoutListToString(owner_payouts);
+    const std::string payoutList = IsShared()
+                                       ? strprintf("shares(%s), earlyPeriodBlocks=%d, earlyPenalty=%d",
+                                                   ShareListToString(shares), nEarlyPeriodBlocks, nEarlyPenalty)
+                                       : PayoutListToString(GetOwnerPayouts(*this));
     if (ExtractDestination(scriptOperatorPayout, dest)) {
         operatorPayoutAddress = EncodeDestination(dest);
     }
@@ -78,6 +80,15 @@ UniValue CDeterministicMNStateDiff::ToJson(MnType nType) const
     if (fields & Field_payouts) {
         obj.pushKV("payouts", PayoutListToJson(state.payouts));
     }
+    if (fields & Field_shares) {
+        obj.pushKV("shares", ShareListToJson(state.shares));
+    }
+    if (fields & Field_nEarlyPeriodBlocks) {
+        obj.pushKV("earlyPeriodBlocks", static_cast<int64_t>(state.nEarlyPeriodBlocks));
+    }
+    if (fields & Field_nEarlyPenalty) {
+        obj.pushKV("earlyPenalty", state.nEarlyPenalty);
+    }
     if (fields & Field_scriptOperatorPayout) {
         CTxDestination dest;
         if (ExtractDestination(state.scriptOperatorPayout, dest)) {
diff --git a/src/evo/dmnstate.h b/src/evo/dmnstate.h
index 7513e6080934..4bbe0400780c 100644
--- a/src/evo/dmnstate.h
+++ b/src/evo/dmnstate.h
@@ -58,6 +58,9 @@ class CDeterministicMNState
     std::shared_ptr<NetInfoInterface> netInfo{nullptr};
     CScript scriptPayout;
     MasternodePayoutShares payouts;
+    CollateralShares shares; // non-empty = shared masternode (joinSigs are not kept in state)
+    uint32_t nEarlyPeriodBlocks{0};
+    CAmount nEarlyPenalty{0};
     CScript scriptOperatorPayout;
 
     uint160 platformNodeID{};
@@ -74,6 +77,9 @@ class CDeterministicMNState
         netInfo(proTx.netInfo),
         scriptPayout(proTx.scriptPayout),
         payouts(proTx.payouts),
+        shares(proTx.shares),
+        nEarlyPeriodBlocks(proTx.nEarlyPeriodBlocks),
+        nEarlyPenalty(proTx.nEarlyPenalty),
         platformNodeID(proTx.platformNodeID),
         platformP2PPort(proTx.platformP2PPort),
         platformHTTPPort(proTx.platformHTTPPort)
@@ -102,7 +108,7 @@ class CDeterministicMNState
             NetInfoSerWrapper(const_cast<std::shared_ptr<NetInfoInterface>&>(obj.netInfo),
                               obj.nVersion >= ProTxVersion::ExtAddr));
         if (obj.nVersion >= ProTxVersion::ExtAddr) {
-            READWRITE(obj.payouts);
+            READWRITE(obj.payouts, obj.shares, obj.nEarlyPeriodBlocks, obj.nEarlyPenalty);
         } else {
             READWRITE(obj.scriptPayout);
         }
@@ -145,6 +151,8 @@ class CDeterministicMNState
         nPoSeBanHeight = -1;
         nPoSeRevivedHeight = nRevivedHeight;
     }
+    /** Whether this is a shared masternode (DIP: decentralized masternode shares) */
+    [[nodiscard]] bool IsShared() const { return !shares.empty(); }
     void UpdateConfirmedHash(const uint256& _proTxHash, const uint256& _confirmedHash)
     {
         confirmedHash = _confirmedHash;
@@ -184,6 +192,9 @@ class CDeterministicMNStateDiff
         Field_platformP2PPort = 0x20000,
         Field_platformHTTPPort = 0x40000,
         Field_payouts = 0x80000,
+        Field_shares = 0x100000,
+        Field_nEarlyPeriodBlocks = 0x200000,
+        Field_nEarlyPenalty = 0x400000,
     };
 
 private:
@@ -212,6 +223,9 @@ class CDeterministicMNStateDiff
         DMN_STATE_MEMBER(netInfo),
         DMN_STATE_MEMBER(scriptPayout),
         DMN_STATE_MEMBER(payouts),
+        DMN_STATE_MEMBER(shares),
+        DMN_STATE_MEMBER(nEarlyPeriodBlocks),
+        DMN_STATE_MEMBER(nEarlyPenalty),
         DMN_STATE_MEMBER(scriptOperatorPayout),
         DMN_STATE_MEMBER(nConsecutivePayments),
         DMN_STATE_MEMBER(platformNodeID),
diff --git a/src/evo/providertx.cpp b/src/evo/providertx.cpp
index 4cb49fb365ab..2712f5481a81 100644
--- a/src/evo/providertx.cpp
+++ b/src/evo/providertx.cpp
@@ -9,6 +9,7 @@
 #include <util/std23.h>
 
 #include <chainparams.h>
+#include <clientversion.h>
 #include <consensus/validation.h>
 #include <deploymentstatus.h>
 #include <hash.h>
@@ -256,6 +257,43 @@ bool CProRegTx::IsTriviallyValid(TxValidationState& state) const
     return true;
 }
 
+uint256 CProRegTx::MakeSharedRegConsentHash(const CTransaction& tx) const
+{
+    // Per the decentralized masternode shares DIP the consent digest binds every participant to
+    // the exact funding inputs (prevouts and sequences), all outputs (including the collateral
+    // output and every change output), the full share table, the penalty terms and the registrar
+    // configuration. It deliberately does not rely on the sighash modes of funding-input
+    // signatures. Covering the sequences matters: BIP68 gives them consensus meaning on
+    // version >= 2 transactions, so an uncovered sequence rewrite could impose a months-long
+    // relative timelock on a fully consented registration.
+    CHashWriter hw(SER_GETHASH, CLIENT_VERSION);
+    hw << std::string("DashSharedMNReg");
+    hw << nVersion;
+    hw << tx.nVersion;
+    hw << tx.nType;
+    hw << tx.nLockTime;
+    hw << CalcTxInputsHash(tx);
+    for (const auto& in : tx.vin) {
+        hw << in.nSequence;
+    }
+    hw << CalcTxOutputsHash(tx);
+    hw << nType;
+    hw << nMode;
+    hw << NetInfoSerWrapper(const_cast<std::shared_ptr<NetInfoInterface>&>(netInfo),
+                            nVersion >= ProTxVersion::ExtAddr);
+    hw << keyIDVoting;
+    hw << CBLSLazyPublicKeyVersionWrapper(const_cast<CBLSLazyPublicKey&>(pubKeyOperator),
+                                          nVersion == ProTxVersion::LegacyBLS);
+    hw << nOperatorReward;
+    hw << static_cast<uint8_t>(shares.size());
+    for (const auto& share : shares) {
+        hw << share;
+    }
+    hw << nEarlyPeriodBlocks;
+    hw << nEarlyPenalty;
+    return hw.GetHash();
+}
+
 std::string CProRegTx::MakeSignString() const
 {
     std::string s;
@@ -384,3 +422,106 @@ std::string CProUpRevTx::ToString() const
     return strprintf("CProUpRevTx(nVersion=%d, proTxHash=%s, nReason=%d)",
         nVersion, proTxHash.ToString(), nReason);
 }
+
+uint256 CProDisTx::MakeSignHash(const CTransaction& tx) const
+{
+    // The digest commits to the transaction's actual input(s) and outputs directly; the payload
+    // deliberately carries no inputsHash/outputsHash copies. Together with the empty-scriptSig
+    // rule and the low-S requirement this pins every free byte of a ProDisTx, so its txid is
+    // non-malleable by third parties.
+    CHashWriter hw(SER_GETHASH, CLIENT_VERSION);
+    hw << std::string("DashSharedMNDissolve");
+    hw << nVersion;
+    hw << tx.nVersion;
+    hw << tx.nType;
+    hw << tx.nLockTime;
+    for (const auto& in : tx.vin) {
+        hw << in.prevout;
+    }
+    for (const auto& in : tx.vin) {
+        hw << in.nSequence;
+    }
+    for (const auto& out : tx.vout) {
+        hw << out;
+    }
+    hw << proTxHash;
+    hw << actorIndex;
+    return hw.GetHash();
+}
+
+bool CProDisTx::IsTriviallyValid(TxValidationState& state) const
+{
+    if (nVersion == 0 || nVersion > CURRENT_VERSION) {
+        return state.Invalid(TxValidationResult::TX_CONSENSUS, "bad-prodis-version");
+    }
+    if (vchSigs.empty() || vchSigs.size() > CProRegTx::MAX_SHARES) {
+        return state.Invalid(TxValidationResult::TX_BAD_SPECIAL, "bad-prodis-sig-count");
+    }
+    for (const auto& sig : vchSigs) {
+        if (sig.size() != CPubKey::COMPACT_SIGNATURE_SIZE) {
+            return state.Invalid(TxValidationResult::TX_BAD_SPECIAL, "bad-prodis-sig-size");
+        }
+    }
+    return true;
+}
+
+std::string CProDisTx::ToString() const
+{
+    return strprintf("CProDisTx(nVersion=%d, proTxHash=%s, actorIndex=%d, sigCount=%d)",
+        nVersion, proTxHash.ToString(), actorIndex, vchSigs.size());
+}
+
+bool CProUpShareTx::IsTriviallyValid(TxValidationState& state) const
+{
+    if (nVersion == 0 || nVersion > CURRENT_VERSION) {
+        return state.Invalid(TxValidationResult::TX_CONSENSUS, "bad-proupshare-version");
+    }
+    if (!scriptReward.empty()) {
+        if (sharedcollateral::IsSharedCollateralScript(scriptReward)) {
+            return state.Invalid(TxValidationResult::TX_BAD_SPECIAL, "bad-proupshare-payee-template");
+        }
+        if (!IsValidPayoutScript(scriptReward)) {
+            return state.Invalid(TxValidationResult::TX_BAD_SPECIAL, "bad-proupshare-payee");
+        }
+    }
+    return true;
+}
+
+std::string CProUpShareTx::ToString() const
+{
+    CTxDestination dest;
+    const std::string reward = scriptReward.empty()
+        ? "refund"
+        : (ExtractDestination(scriptReward, dest) ? EncodeDestination(dest) : HexStr(scriptReward));
+    return strprintf("CProUpShareTx(nVersion=%d, proTxHash=%s, shareIndex=%d, rewardAddress=%s)",
+        nVersion, proTxHash.ToString(), shareIndex, reward);
+}
+
+bool CProUpSharedRegTx::IsTriviallyValid(TxValidationState& state) const
+{
+    if (nVersion == 0 || nVersion > CURRENT_VERSION) {
+        return state.Invalid(TxValidationResult::TX_CONSENSUS, "bad-proupsharedreg-version");
+    }
+    if (!pubKeyOperator.Get().IsValid() || keyIDVoting.IsNull()) {
+        return state.Invalid(TxValidationResult::TX_BAD_SPECIAL, "bad-protx-key-null");
+    }
+    if (pubKeyOperator.IsLegacy()) {
+        return state.Invalid(TxValidationResult::TX_BAD_SPECIAL, "bad-protx-operator-pubkey");
+    }
+    if (vchSigs.empty() || vchSigs.size() > CProRegTx::MAX_SHARES) {
+        return state.Invalid(TxValidationResult::TX_BAD_SPECIAL, "bad-proupsharedreg-sig-count");
+    }
+    for (const auto& sig : vchSigs) {
+        if (sig.size() != CPubKey::COMPACT_SIGNATURE_SIZE) {
+            return state.Invalid(TxValidationResult::TX_BAD_SPECIAL, "bad-proupsharedreg-sig-size");
+        }
+    }
+    return true;
+}
+
+std::string CProUpSharedRegTx::ToString() const
+{
+    return strprintf("CProUpSharedRegTx(nVersion=%d, proTxHash=%s, pubKeyOperator=%s, votingAddress=%s, sigCount=%d)",
+        nVersion, proTxHash.ToString(), pubKeyOperator.ToString(), EncodeDestination(PKHash(keyIDVoting)),
+        vchSigs.size());
+}
diff --git a/src/evo/providertx.h b/src/evo/providertx.h
index a6a05f1d32a6..39948ab9f3f9 100644
--- a/src/evo/providertx.h
+++ b/src/evo/providertx.h
@@ -216,6 +216,11 @@ class CProRegTx
     /** Whether this is a shared masternode registration (DIP: decentralized masternode shares) */
     [[nodiscard]] bool IsShared() const { return !shares.empty(); }
 
+    /** The digest each share owner signs (joinSigs) to consent to a shared registration. It binds
+     *  every participant to the exact funding inputs, all outputs, the full share table, the
+     *  penalty terms and the registrar configuration of the containing transaction. */
+    [[nodiscard]] uint256 MakeSharedRegConsentHash(const CTransaction& tx) const;
+
     // When signing with the collateral key, we don't sign the hash but a generated message instead
     // This is needed for HW wallet support which can only sign text messages as of now
     std::string MakeSignString() const;
@@ -415,6 +420,122 @@ class CProUpRevTx
     bool IsTriviallyValid(TxValidationState& state) const;
 };
 
+class CProDisTx
+{
+public:
+    static constexpr auto SPECIALTX_TYPE = TRANSACTION_PROVIDER_DISSOLVE;
+    static constexpr uint16_t CURRENT_VERSION = 1;
+
+    uint16_t nVersion{CURRENT_VERSION};
+    uint256 proTxHash;
+    uint16_t actorIndex{0};
+    // Exactly one signature (unilateral, by shares[actorIndex]) or one per share in share order
+    // (unanimous); the signature count defines the mode
+    std::vector<std::vector<unsigned char>> vchSigs;
+
+    SERIALIZE_METHODS(CProDisTx, obj)
+    {
+        READWRITE(obj.nVersion, obj.proTxHash, obj.actorIndex);
+        uint8_t sig_count{0};
+        SER_WRITE(obj, sig_count = static_cast<uint8_t>(obj.vchSigs.size()));
+        READWRITE(sig_count);
+        SER_READ(obj, obj.vchSigs.resize(sig_count));
+        for (auto& sig : obj.vchSigs) {
+            READWRITE(Using<CompactSignatureFormatter>(sig));
+        }
+    }
+
+    /** The digest every dissolution signature commits to. It covers the transaction's actual
+     *  input(s) and outputs directly, pinning every free byte of the transaction. */
+    [[nodiscard]] uint256 MakeSignHash(const CTransaction& tx) const;
+
+    std::string ToString() const;
+
+    [[nodiscard]] static RPCResult GetJsonHelp(const std::string& key, bool optional);
+    [[nodiscard]] UniValue ToJson() const;
+
+    /**
+     * Note: this check validates only some trivial consensus rules
+     * Use `Check*Tx` or GetValidatedPayload<T> helper for full validation
+     */
+    bool IsTriviallyValid(TxValidationState& state) const;
+};
+
+class CProUpShareTx
+{
+public:
+    static constexpr auto SPECIALTX_TYPE = TRANSACTION_PROVIDER_UPDATE_SHARE;
+    static constexpr uint16_t CURRENT_VERSION = 1;
+
+    uint16_t nVersion{CURRENT_VERSION};
+    uint256 proTxHash;
+    uint16_t shareIndex{0};
+    CScript scriptReward; //!< empty means "use the refund script"
+    uint256 inputsHash;   // replay protection
+    std::vector<unsigned char> vchSig;
+
+    SERIALIZE_METHODS(CProUpShareTx, obj)
+    {
+        READWRITE(obj.nVersion, obj.proTxHash, obj.shareIndex, obj.scriptReward, obj.inputsHash);
+        if (!(s.GetType() & SER_GETHASH)) {
+            READWRITE(obj.vchSig);
+        }
+    }
+
+    std::string ToString() const;
+
+    [[nodiscard]] static RPCResult GetJsonHelp(const std::string& key, bool optional);
+    [[nodiscard]] UniValue ToJson() const;
+
+    /**
+     * Note: this check validates only some trivial consensus rules
+     * Use `Check*Tx` or GetValidatedPayload<T> helper for full validation
+     */
+    bool IsTriviallyValid(TxValidationState& state) const;
+};
+
+class CProUpSharedRegTx
+{
+public:
+    static constexpr auto SPECIALTX_TYPE = TRANSACTION_PROVIDER_UPDATE_SHARED_REGISTRAR;
+    static constexpr uint16_t CURRENT_VERSION = 1;
+
+    uint16_t nVersion{CURRENT_VERSION};
+    uint256 proTxHash;
+    CBLSLazyPublicKey pubKeyOperator;
+    CKeyID keyIDVoting;
+    uint256 inputsHash; // replay protection
+    // One signature per share, in share order; a shared registrar update requires unanimity
+    std::vector<std::vector<unsigned char>> vchSigs;
+
+    SERIALIZE_METHODS(CProUpSharedRegTx, obj)
+    {
+        READWRITE(obj.nVersion, obj.proTxHash,
+                  CBLSLazyPublicKeyVersionWrapper(const_cast<CBLSLazyPublicKey&>(obj.pubKeyOperator), /*legacy=*/false),
+                  obj.keyIDVoting, obj.inputsHash);
+        if (!(s.GetType() & SER_GETHASH)) {
+            uint8_t sig_count{0};
+            SER_WRITE(obj, sig_count = static_cast<uint8_t>(obj.vchSigs.size()));
+            READWRITE(sig_count);
+            SER_READ(obj, obj.vchSigs.resize(sig_count));
+            for (auto& sig : obj.vchSigs) {
+                READWRITE(Using<CompactSignatureFormatter>(sig));
+            }
+        }
+    }
+
+    std::string ToString() const;
+
+    [[nodiscard]] static RPCResult GetJsonHelp(const std::string& key, bool optional);
+    [[nodiscard]] UniValue ToJson() const;
+
+    /**
+     * Note: this check validates only some trivial consensus rules
+     * Use `Check*Tx` or GetValidatedPayload<T> helper for full validation
+     */
+    bool IsTriviallyValid(TxValidationState& state) const;
+};
+
 template <typename ProTx>
 static bool CheckInputsHash(const CTransaction& tx, const ProTx& proTx, TxValidationState& state)
 {
diff --git a/src/evo/specialtx.cpp b/src/evo/specialtx.cpp
index 77aae4d1bd2c..4a62209cb3a8 100644
--- a/src/evo/specialtx.cpp
+++ b/src/evo/specialtx.cpp
@@ -15,3 +15,12 @@ uint256 CalcTxInputsHash(const CTransaction& tx)
     }
     return hw.GetHash();
 }
+
+uint256 CalcTxOutputsHash(const CTransaction& tx)
+{
+    CHashWriter hw(SER_GETHASH, CLIENT_VERSION);
+    for (const auto& out : tx.vout) {
+        hw << out;
+    }
+    return hw.GetHash();
+}
diff --git a/src/evo/specialtx.h b/src/evo/specialtx.h
index 55a53a4175d0..977c150fa0c1 100644
--- a/src/evo/specialtx.h
+++ b/src/evo/specialtx.h
@@ -43,5 +43,6 @@ void SetTxPayload(CMutableTransaction& tx, const T& payload)
 }
 
 uint256 CalcTxInputsHash(const CTransaction& tx);
+uint256 CalcTxOutputsHash(const CTransaction& tx);
 
 #endif // BITCOIN_EVO_SPECIALTX_H
diff --git a/src/evo/specialtxman.cpp b/src/evo/specialtxman.cpp
index bb3578524d81..afcfa573d244 100644
--- a/src/evo/specialtxman.cpp
+++ b/src/evo/specialtxman.cpp
@@ -13,6 +13,7 @@
 #include <evo/deterministicmns.h>
 #include <evo/mnhftx.h>
 #include <evo/netinfo.h>
+#include <evo/sharedcollateral.h>
 #include <evo/simplifiedmns.h>
 #include <llmq/blockprocessor.h>
 #include <llmq/commitment.h>
@@ -21,6 +22,7 @@
 #include <messagesigner.h>
 #include <util/helpers.h>
 
+#include <arith_uint256.h>
 #include <chainparams.h>
 #include <consensus/amount.h>
 #include <consensus/validation.h>
@@ -180,8 +182,8 @@ bool CheckCbTxBestChainlock(const CCbTx& cbTx, const CBlockIndex* pindex, const
 static bool CheckSpecialTxInner(CDeterministicMNManager& dmnman, llmq::CQuorumSnapshotManager& qsnapman,
                                 const ChainstateManager& chainman, const llmq::CQuorumManager& qman,
                                 const CTransaction& tx, const CBlockIndex* pindexPrev, const CCoinsViewCache& view,
-                                const std::optional<CRangesSet>& indexes, bool check_sigs, TxValidationState& state)
-    EXCLUSIVE_LOCKS_REQUIRED(::cs_main)
+                                const std::optional<CRangesSet>& indexes, bool check_sigs, SpecialTxContext context,
+                                TxValidationState& state) EXCLUSIVE_LOCKS_REQUIRED(::cs_main)
 {
     AssertLockHeld(::cs_main);
 
@@ -202,6 +204,12 @@ static bool CheckSpecialTxInner(CDeterministicMNManager& dmnman, llmq::CQuorumSn
             return CheckProUpRegTx(tx, pindexPrev, dmnman, view, chainman, state, check_sigs);
         case TRANSACTION_PROVIDER_UPDATE_REVOKE:
             return CheckProUpRevTx(tx, pindexPrev, dmnman, chainman, state, check_sigs);
+        case TRANSACTION_PROVIDER_DISSOLVE:
+            return CheckProDisTx(tx, pindexPrev, dmnman, chainman, state, check_sigs, context);
+        case TRANSACTION_PROVIDER_UPDATE_SHARE:
+            return CheckProUpShareTx(tx, pindexPrev, dmnman, chainman, state, check_sigs);
+        case TRANSACTION_PROVIDER_UPDATE_SHARED_REGISTRAR:
+            return CheckProUpSharedRegTx(tx, pindexPrev, dmnman, chainman, state, check_sigs);
         case TRANSACTION_COINBASE: {
             if (!tx.IsCoinBase()) {
                 return state.Invalid(TxValidationResult::TX_CONSENSUS, "bad-cbtx-invalid");
@@ -233,7 +241,7 @@ bool CSpecialTxProcessor::CheckSpecialTx(const CTransaction& tx, const CBlockInd
 {
     AssertLockHeld(::cs_main);
     return CheckSpecialTxInner(m_dmnman, m_qsnapman, m_chainman, m_qman, tx, pindexPrev, view, std::nullopt, check_sigs,
-                               state);
+                               SpecialTxContext::Mempool, state);
 }
 
 static void HandleQuorumCommitment(const llmq::CFinalCommitment& qc, const std::vector<CDeterministicMNCPtr>& members,
@@ -370,7 +378,16 @@ bool CSpecialTxProcessor::RebuildListFromBlock(const CBlock& block, gsl::not_nul
                     return state.Invalid(BlockValidationResult::BLOCK_CONSENSUS, "bad-protx-netinfo-entry");
                 }
             }
-            if (newList.HasUniqueProperty(proTx.keyIDOwner) || newList.HasUniqueProperty(proTx.pubKeyOperator)) {
+            if (proTx.IsShared()) {
+                for (const auto& share : proTx.shares) {
+                    if (newList.HasUniqueProperty(share.keyIDOwner)) {
+                        return state.Invalid(BlockValidationResult::BLOCK_CONSENSUS, "bad-protx-dup-key");
+                    }
+                }
+                if (newList.HasUniqueProperty(proTx.pubKeyOperator)) {
+                    return state.Invalid(BlockValidationResult::BLOCK_CONSENSUS, "bad-protx-dup-key");
+                }
+            } else if (newList.HasUniqueProperty(proTx.keyIDOwner) || newList.HasUniqueProperty(proTx.pubKeyOperator)) {
                 return state.Invalid(BlockValidationResult::BLOCK_CONSENSUS, "bad-protx-dup-key");
             }
 
@@ -451,9 +468,10 @@ bool CSpecialTxProcessor::RebuildListFromBlock(const CBlock& block, gsl::not_nul
                 return false;
             }
             if (newState->IsBanned()) {
-                // only revive when all keys are set
+                // only revive when all keys are set (a shared masternode has a null keyIDOwner;
+                // its share owner keys are immutable and always set)
                 if (newState->pubKeyOperator != CBLSLazyPublicKey() && !newState->keyIDVoting.IsNull() &&
-                    !newState->keyIDOwner.IsNull()) {
+                    (newState->IsShared() || !newState->keyIDOwner.IsNull())) {
                     newState->Revive(nHeight);
                     if (debugLogs) {
                         LogPrintf("%s -- MN %s revived at height %d\n", __func__, opt_proTx->proTxHash.ToString(), nHeight);
@@ -476,6 +494,10 @@ bool CSpecialTxProcessor::RebuildListFromBlock(const CBlock& block, gsl::not_nul
             if (!dmn) {
                 return state.Invalid(BlockValidationResult::BLOCK_CONSENSUS, "bad-protx-hash");
             }
+            if (dmn->pdmnState->IsShared()) {
+                // shared masternodes are updated via ProUpShareTx / ProUpSharedRegTx exclusively
+                return state.Invalid(BlockValidationResult::BLOCK_CONSENSUS, "bad-protx-shared-mn");
+            }
             auto newState = std::make_shared<CDeterministicMNState>(*dmn->pdmnState);
             const uint16_t old_version{static_cast<uint16_t>(newState->nVersion)};
             const bool operator_changed{newState->pubKeyOperator != opt_proTx->pubKeyOperator};
@@ -542,6 +564,90 @@ bool CSpecialTxProcessor::RebuildListFromBlock(const CBlock& block, gsl::not_nul
                 LogPrintf("%s -- MN %s revoked operator key at height %d: %s\n", __func__,
                           opt_proTx->proTxHash.ToString(), nHeight, opt_proTx->ToString());
             }
+        } else if (tx.nType == TRANSACTION_PROVIDER_DISSOLVE) {
+            const auto opt_proTx = GetTxPayload<CProDisTx>(tx);
+            if (!opt_proTx) {
+                return state.Invalid(BlockValidationResult::BLOCK_CONSENSUS, "bad-protx-payload");
+            }
+
+            // Authoritative validation: newList at this position equals the previous block's list
+            // plus earlier transactions in this block, so a masternode registered and dissolved
+            // within one block is handled per the DIP
+            if (TxValidationState tx_state;
+                !CheckProDisTxForList(tx, *opt_proTx, newList, nHeight, tx_state, /*check_sigs=*/true)) {
+                return state.Invalid(BlockValidationResult::BLOCK_CONSENSUS, tx_state.GetRejectReason(),
+                                     tx_state.GetDebugMessage());
+            }
+
+            newList.RemoveMN(opt_proTx->proTxHash);
+
+            if (debugLogs) {
+                LogPrintf("%s -- MN %s dissolved at height %d: %s\n", __func__, opt_proTx->proTxHash.ToString(),
+                          nHeight, opt_proTx->ToString());
+            }
+        } else if (tx.nType == TRANSACTION_PROVIDER_UPDATE_SHARE) {
+            const auto opt_proTx = GetTxPayload<CProUpShareTx>(tx);
+            if (!opt_proTx) {
+                return state.Invalid(BlockValidationResult::BLOCK_CONSENSUS, "bad-protx-payload");
+            }
+
+            auto dmn = newList.GetMN(opt_proTx->proTxHash);
+            if (!dmn) {
+                return state.Invalid(BlockValidationResult::BLOCK_CONSENSUS, "bad-protx-hash");
+            }
+            if (!dmn->pdmnState->IsShared() || opt_proTx->shareIndex >= dmn->pdmnState->shares.size()) {
+                return state.Invalid(BlockValidationResult::BLOCK_CONSENSUS, "bad-proupshare-index");
+            }
+
+            auto newState = std::make_shared<CDeterministicMNState>(*dmn->pdmnState);
+            newState->shares[opt_proTx->shareIndex].scriptReward = opt_proTx->scriptReward;
+
+            newList.UpdateMN(opt_proTx->proTxHash, newState);
+
+            if (debugLogs) {
+                LogPrintf("%s -- MN %s updated share at height %d: %s\n", __func__, opt_proTx->proTxHash.ToString(),
+                          nHeight, opt_proTx->ToString());
+            }
+        } else if (tx.nType == TRANSACTION_PROVIDER_UPDATE_SHARED_REGISTRAR) {
+            const auto opt_proTx = GetTxPayload<CProUpSharedRegTx>(tx);
+            if (!opt_proTx) {
+                return state.Invalid(BlockValidationResult::BLOCK_CONSENSUS, "bad-protx-payload");
+            }
+
+            auto dmn = newList.GetMN(opt_proTx->proTxHash);
+            if (!dmn) {
+                return state.Invalid(BlockValidationResult::BLOCK_CONSENSUS, "bad-protx-hash");
+            }
+            if (!dmn->pdmnState->IsShared()) {
+                return state.Invalid(BlockValidationResult::BLOCK_CONSENSUS, "bad-proupsharedreg-not-shared");
+            }
+
+            auto newState = std::make_shared<CDeterministicMNState>(*dmn->pdmnState);
+            const uint16_t old_version{static_cast<uint16_t>(newState->nVersion)};
+            const bool operator_changed{newState->pubKeyOperator != opt_proTx->pubKeyOperator};
+            if (operator_changed) {
+                // Operator-key change semantics match ProUpRegTx: reset all operator related
+                // fields and put the MN into PoSe-banned state until a new ProUpServTx arrives
+                newState->ResetOperatorFields();
+                newState->BanIfNotBanned(nHeight);
+                newState->pubKeyOperator = opt_proTx->pubKeyOperator;
+            }
+            newState->keyIDVoting = opt_proTx->keyIDVoting;
+            // Shared masternodes are always ExtAddr or later; restore the state version that
+            // ResetOperatorFields() cleared
+            if (!SetStateVersion(*newState, old_version, dmn->nType, state)) {
+                return false;
+            }
+            if (operator_changed) {
+                newState->pubKeyOperator.SetLegacy(false);
+            }
+
+            newList.UpdateMN(opt_proTx->proTxHash, newState);
+
+            if (debugLogs) {
+                LogPrintf("%s -- MN %s updated shared registrar at height %d: %s\n", __func__,
+                          opt_proTx->proTxHash.ToString(), nHeight, opt_proTx->ToString());
+            }
         } else if (tx.nType == TRANSACTION_QUORUM_COMMITMENT) {
             const auto opt_qc = GetTxPayload<llmq::CFinalCommitmentTxPayload>(tx);
             if (!opt_qc) {
@@ -579,6 +685,12 @@ bool CSpecialTxProcessor::RebuildListFromBlock(const CBlock& block, gsl::not_nul
         for (const auto& in : tx.vin) {
             auto dmn = newList.GetMNByCollateral(in.prevout);
             if (dmn && dmn->collateralOutpoint == in.prevout) {
+                if (dmn->pdmnState->IsShared()) {
+                    // Shared collateral may only be spent by a valid ProDisTx, which already
+                    // removed its masternode in the transaction loop above; any spend that still
+                    // sees a shared masternode here is not a valid dissolution
+                    return state.Invalid(BlockValidationResult::BLOCK_CONSENSUS, "bad-shared-collateral-spend");
+                }
                 newList.RemoveMN(dmn->proTxHash);
 
                 if (debugLogs) {
@@ -685,7 +797,18 @@ bool CSpecialTxProcessor::ProcessSpecialTxsInBlock(const CBlock& block, const CB
             indexes = std::move(creditPool.indexes);
         }
 
+        const bool is_v24_active{DeploymentActiveAt(*pindex, m_chainman, Consensus::DEPLOYMENT_V24)};
         for (size_t i = 0; i < block.vtx.size(); ++i) {
+            // The shared-collateral creation rule applies to every transaction, including the
+            // coinbase and non-special transactions, which CheckSpecialTxInner never sees
+            if (is_v24_active) {
+                if (TxValidationState tx_state; !CheckSharedCollateralTemplateOutputs(*block.vtx[i], tx_state)) {
+                    return state.Invalid(BlockValidationResult::BLOCK_CONSENSUS, tx_state.GetRejectReason(),
+                                         strprintf("Shared collateral check failed (tx hash %s) %s",
+                                                   block.vtx[i]->GetHash().ToString(), tx_state.GetDebugMessage()));
+                }
+            }
+
             // we validated CCbTx above, starts from the 2nd transaction
             if (i == 0 && block.vtx[i]->nType == TRANSACTION_COINBASE) continue;
 
@@ -694,7 +817,7 @@ bool CSpecialTxProcessor::ProcessSpecialTxsInBlock(const CBlock& block, const CB
             // At this moment CheckSpecialTx() may fail by 2 possible ways:
             // consensus failures and "TX_BAD_SPECIAL"
             if (!CheckSpecialTxInner(m_dmnman, m_qsnapman, m_chainman, m_qman, *ptr_tx, pindex->pprev, view, indexes,
-                                     fCheckCbTxMerkleRoots, tx_state)) {
+                                     fCheckCbTxMerkleRoots, SpecialTxContext::Block, tx_state)) {
                 assert(tx_state.GetResult() == TxValidationResult::TX_CONSENSUS || tx_state.GetResult() == TxValidationResult::TX_BAD_SPECIAL);
                 return state.Invalid(BlockValidationResult::BLOCK_CONSENSUS, tx_state.GetRejectReason(),
                                  strprintf("Special Transaction check failed (tx hash %s) %s", ptr_tx->GetHash().ToString(), tx_state.GetDebugMessage()));
@@ -1088,7 +1211,12 @@ bool CheckProRegTx(const CTransaction& tx, gsl::not_null<const CBlockIndex*> pin
             return state.Invalid(TxValidationResult::TX_BAD_SPECIAL, "bad-protx-collateral");
         }
 
-        if (!ExtractDestination(tx.vout[opt_ptx->collateralOutpoint.n].scriptPubKey, collateralTxDest)) {
+        if (opt_ptx->IsShared()) {
+            // Shared collateral must use exactly the template script; there is no destination to extract
+            if (!sharedcollateral::IsSharedCollateralScript(tx.vout[opt_ptx->collateralOutpoint.n].scriptPubKey)) {
+                return state.Invalid(TxValidationResult::TX_BAD_SPECIAL, "bad-protx-shares-collateral-script");
+            }
+        } else if (!ExtractDestination(tx.vout[opt_ptx->collateralOutpoint.n].scriptPubKey, collateralTxDest)) {
             return state.Invalid(TxValidationResult::TX_BAD_SPECIAL, "bad-protx-collateral-dest");
         }
 
@@ -1097,7 +1225,9 @@ bool CheckProRegTx(const CTransaction& tx, gsl::not_null<const CBlockIndex*> pin
 
     // don't allow reuse of collateral key for other keys (don't allow people to put the collateral key onto an online server)
     // this check applies to internal and external collateral, but internal collaterals are not necessarily a P2PKH
-    if (!IsPayoutListKeySafe(GetOwnerPayouts(*opt_ptx),
+    // (shared collateral has no destination at all; refund/reward key reuse is checked in IsShareListTriviallyValid)
+    if (!opt_ptx->IsShared() &&
+        !IsPayoutListKeySafe(GetOwnerPayouts(*opt_ptx),
                              collateralTxDest, opt_ptx->keyIDOwner, opt_ptx->keyIDVoting,
                              opt_ptx->nVersion >= ProTxVersion::ExtAddr, state)) return false;
 
@@ -1121,8 +1251,19 @@ bool CheckProRegTx(const CTransaction& tx, gsl::not_null<const CBlockIndex*> pin
             }
         }
 
-        // never allow duplicate keys, even if this ProTx would replace an existing MN
-        if (mnList.HasUniqueProperty(opt_ptx->keyIDOwner) || mnList.HasUniqueProperty(opt_ptx->pubKeyOperator)) {
+        // never allow duplicate keys, even if this ProTx would replace an existing MN. Share owner
+        // keys live in the same uniqueness namespace as keyIDOwner, so reuse is blocked in both
+        // directions between shared and non-shared masternodes.
+        if (opt_ptx->IsShared()) {
+            for (const auto& share : opt_ptx->shares) {
+                if (mnList.HasUniqueProperty(share.keyIDOwner)) {
+                    return state.Invalid(TxValidationResult::TX_BAD_SPECIAL, "bad-protx-dup-key");
+                }
+            }
+            if (mnList.HasUniqueProperty(opt_ptx->pubKeyOperator)) {
+                return state.Invalid(TxValidationResult::TX_BAD_SPECIAL, "bad-protx-dup-key");
+            }
+        } else if (mnList.HasUniqueProperty(opt_ptx->keyIDOwner) || mnList.HasUniqueProperty(opt_ptx->pubKeyOperator)) {
             return state.Invalid(TxValidationResult::TX_BAD_SPECIAL, "bad-protx-dup-key");
         }
 
@@ -1156,6 +1297,18 @@ bool CheckProRegTx(const CTransaction& tx, gsl::not_null<const CBlockIndex*> pin
         if (!opt_ptx->vchSig.empty()) {
             return state.Invalid(TxValidationResult::TX_CONSENSUS, "bad-protx-sig");
         }
+        if (opt_ptx->IsShared() && check_sigs) {
+            // every participant must consent to the exact funding inputs, outputs, share table,
+            // penalty terms and registrar configuration
+            const uint256 consent_hash = opt_ptx->MakeSharedRegConsentHash(tx);
+            for (size_t i = 0; i < opt_ptx->shares.size(); i++) {
+                if (std::string strError;
+                    !CHashSigner::VerifyHashCanonical(consent_hash, opt_ptx->shares[i].keyIDOwner,
+                                                      opt_ptx->vchJoinSigs[i], strError)) {
+                    return state.Invalid(TxValidationResult::TX_BAD_SPECIAL, "bad-protx-shares-sig");
+                }
+            }
+        }
     }
 
     return true;
@@ -1256,6 +1409,12 @@ bool CheckProUpRegTx(const CTransaction& tx, gsl::not_null<const CBlockIndex*> p
         return state.Invalid(TxValidationResult::TX_CONSENSUS, "bad-protx-hash");
     }
 
+    // Shared masternodes have no registrar owner key; they are updated via ProUpShareTx and
+    // ProUpSharedRegTx exclusively
+    if (dmn->pdmnState->IsShared()) {
+        return state.Invalid(TxValidationResult::TX_BAD_SPECIAL, "bad-protx-shared-mn");
+    }
+
     if (!IsVersionChangeValid(pindexPrev, dmn->pdmnState->nVersion, opt_ptx->nVersion, chainman, state)) {
         // pass the state returned by the function above
         return false;
@@ -1337,6 +1496,284 @@ bool CheckProUpRevTx(const CTransaction& tx, gsl::not_null<const CBlockIndex*> p
     return true;
 }
 
+bool CheckProUpShareTx(const CTransaction& tx, gsl::not_null<const CBlockIndex*> pindexPrev,
+                       CDeterministicMNManager& dmnman, const ChainstateManager& chainman, TxValidationState& state,
+                       bool check_sigs)
+{
+    const auto opt_ptx = GetValidatedPayload<CProUpShareTx>(tx, pindexPrev, chainman, state);
+    if (!opt_ptx) {
+        // pass the state returned by the function above
+        return false;
+    }
+    if (!DeploymentActiveAfter(pindexPrev, chainman, Consensus::DEPLOYMENT_V24)) {
+        return state.Invalid(TxValidationResult::TX_CONSENSUS, "bad-proupshare-too-early");
+    }
+
+    const auto mnList = dmnman.GetListForBlock(pindexPrev);
+    const auto dmn = mnList.GetMN(opt_ptx->proTxHash);
+    if (!dmn) {
+        return state.Invalid(TxValidationResult::TX_BAD_SPECIAL, "bad-proupshare-hash");
+    }
+    const auto& mnState = *dmn->pdmnState;
+    if (!mnState.IsShared()) {
+        return state.Invalid(TxValidationResult::TX_BAD_SPECIAL, "bad-proupshare-not-shared");
+    }
+    if (opt_ptx->shareIndex >= mnState.shares.size()) {
+        return state.Invalid(TxValidationResult::TX_BAD_SPECIAL, "bad-proupshare-index");
+    }
+
+    // The new reward script is subject to the same payee-reuse restrictions as at registration
+    if (!opt_ptx->scriptReward.empty()) {
+        CTxDestination dest;
+        if (!ExtractDestination(opt_ptx->scriptReward, dest)) {
+            return state.Invalid(TxValidationResult::TX_BAD_SPECIAL, "bad-proupshare-payee-dest");
+        }
+        if (dest == CTxDestination(PKHash(mnState.keyIDVoting))) {
+            return state.Invalid(TxValidationResult::TX_BAD_SPECIAL, "bad-proupshare-payee-reuse");
+        }
+        for (const auto& share : mnState.shares) {
+            if (dest == CTxDestination(PKHash(share.keyIDOwner))) {
+                return state.Invalid(TxValidationResult::TX_BAD_SPECIAL, "bad-proupshare-payee-reuse");
+            }
+        }
+    }
+
+    if (!CheckInputsHash(tx, *opt_ptx, state)) {
+        // pass the state returned by the function above
+        return false;
+    }
+    if (check_sigs) {
+        if (std::string strError;
+            !CHashSigner::VerifyHashCanonical(::SerializeHash(*opt_ptx),
+                                              mnState.shares[opt_ptx->shareIndex].keyIDOwner, opt_ptx->vchSig,
+                                              strError)) {
+            return state.Invalid(TxValidationResult::TX_BAD_SPECIAL, "bad-proupshare-sig");
+        }
+    }
+
+    return true;
+}
+
+bool CheckProUpSharedRegTx(const CTransaction& tx, gsl::not_null<const CBlockIndex*> pindexPrev,
+                           CDeterministicMNManager& dmnman, const ChainstateManager& chainman,
+                           TxValidationState& state, bool check_sigs)
+{
+    const auto opt_ptx = GetValidatedPayload<CProUpSharedRegTx>(tx, pindexPrev, chainman, state);
+    if (!opt_ptx) {
+        // pass the state returned by the function above
+        return false;
+    }
+    if (!DeploymentActiveAfter(pindexPrev, chainman, Consensus::DEPLOYMENT_V24)) {
+        return state.Invalid(TxValidationResult::TX_CONSENSUS, "bad-proupsharedreg-too-early");
+    }
+
+    const auto mnList = dmnman.GetListForBlock(pindexPrev);
+    const auto dmn = mnList.GetMN(opt_ptx->proTxHash);
+    if (!dmn) {
+        return state.Invalid(TxValidationResult::TX_BAD_SPECIAL, "bad-proupsharedreg-hash");
+    }
+    const auto& mnState = *dmn->pdmnState;
+    if (!mnState.IsShared()) {
+        return state.Invalid(TxValidationResult::TX_BAD_SPECIAL, "bad-proupsharedreg-not-shared");
+    }
+
+    // A shared registrar update requires unanimity: one signature per share, in share order
+    if (opt_ptx->vchSigs.size() != mnState.shares.size()) {
+        return state.Invalid(TxValidationResult::TX_BAD_SPECIAL, "bad-proupsharedreg-sig-count");
+    }
+
+    if (mnList.HasUniqueProperty(opt_ptx->pubKeyOperator)) {
+        auto otherDmn = mnList.GetUniquePropertyMN(opt_ptx->pubKeyOperator);
+        if (opt_ptx->proTxHash != otherDmn->proTxHash) {
+            return state.Invalid(TxValidationResult::TX_BAD_SPECIAL, "bad-protx-dup-key");
+        }
+    }
+
+    if (!CheckInputsHash(tx, *opt_ptx, state)) {
+        // pass the state returned by the function above
+        return false;
+    }
+    if (check_sigs) {
+        const uint256 payload_hash = ::SerializeHash(*opt_ptx);
+        for (size_t i = 0; i < mnState.shares.size(); i++) {
+            if (std::string strError; !CHashSigner::VerifyHashCanonical(payload_hash, mnState.shares[i].keyIDOwner,
+                                                                        opt_ptx->vchSigs[i], strError)) {
+                return state.Invalid(TxValidationResult::TX_BAD_SPECIAL, "bad-proupsharedreg-sig");
+            }
+        }
+    }
+
+    return true;
+}
+
+bool CheckProDisTxForList(const CTransaction& tx, const CProDisTx& ptx, const CDeterministicMNList& mnList,
+                          int nSpendHeight, TxValidationState& state, bool check_sigs)
+{
+    const auto dmn = mnList.GetMN(ptx.proTxHash);
+    if (!dmn) {
+        return state.Invalid(TxValidationResult::TX_BAD_SPECIAL, "bad-prodis-hash");
+    }
+    const auto& mnState = *dmn->pdmnState;
+    if (!mnState.IsShared()) {
+        return state.Invalid(TxValidationResult::TX_BAD_SPECIAL, "bad-prodis-not-shared");
+    }
+    const auto& shares = mnState.shares;
+
+    // Exactly one input: the masternode's collateral outpoint, with an empty scriptSig (the
+    // empty-scriptSig rule keeps the txid non-malleable; the template script needs no witness)
+    if (tx.vin.size() != 1 || tx.vin[0].prevout != dmn->collateralOutpoint || !tx.vin[0].scriptSig.empty()) {
+        return state.Invalid(TxValidationResult::TX_BAD_SPECIAL, "bad-prodis-input");
+    }
+    if (ptx.actorIndex >= shares.size()) {
+        return state.Invalid(TxValidationResult::TX_BAD_SPECIAL, "bad-prodis-actor");
+    }
+
+    // The signature count defines the mode: exactly one (unilateral, by the actor) or exactly one
+    // per share in share order (unanimous). shares.size() >= 2, so the two cannot coincide.
+    if (ptx.vchSigs.size() != 1 && ptx.vchSigs.size() != shares.size()) {
+        return state.Invalid(TxValidationResult::TX_BAD_SPECIAL, "bad-prodis-sig-count");
+    }
+    const bool unanimous{ptx.vchSigs.size() == shares.size()};
+
+    // requiredPenalty is non-increasing in nSpendHeight, which makes ProDisTx validity monotone:
+    // once valid, always valid (see the DIP's "Output rules" section)
+    const bool early{nSpendHeight - mnState.nRegisteredHeight < static_cast<int64_t>(mnState.nEarlyPeriodBlocks)};
+    const CAmount required_penalty{(unanimous || !early) ? 0 : mnState.nEarlyPenalty};
+
+    // One output per non-actor share, paying its refund script, in share order, plus optionally
+    // one final actor output. A zero-value actor output must be omitted. No other outputs.
+    const size_t non_actor_count{shares.size() - 1};
+    if (tx.vout.size() != non_actor_count && tx.vout.size() != non_actor_count + 1) {
+        return state.Invalid(TxValidationResult::TX_BAD_SPECIAL, "bad-prodis-payee-count");
+    }
+
+    CAmount non_actor_total{0};
+    for (size_t i = 0; i < shares.size(); i++) {
+        if (i != ptx.actorIndex) non_actor_total += shares[i].amount;
+    }
+
+    size_t out_idx{0};
+    CAmount bonus_total{0};
+    for (size_t i = 0; i < shares.size(); i++) {
+        if (i == ptx.actorIndex) continue;
+        const auto& out = tx.vout[out_idx++];
+        if (out.scriptPubKey != shares[i].scriptRefund) {
+            return state.Invalid(TxValidationResult::TX_BAD_SPECIAL, "bad-prodis-payee");
+        }
+        // Minimum-based rules: bonus[i] >= floor(P * amount[i] / W). The floor is element-wise
+        // monotone in P, which is what preserves monotone validity; overpaying is always valid.
+        const CAmount bonus{out.nValue - shares[i].amount};
+        const CAmount min_bonus{[&]() {
+            if (required_penalty == 0) return CAmount{0};
+            // 128-bit intermediate: penalty and amount can each approach the full collateral
+            arith_uint256 v{static_cast<uint64_t>(required_penalty)};
+            v *= arith_uint256{static_cast<uint64_t>(shares[i].amount)};
+            v /= arith_uint256{static_cast<uint64_t>(non_actor_total)};
+            return static_cast<CAmount>(v.GetLow64());
+        }()};
+        if (bonus < min_bonus) {
+            return state.Invalid(TxValidationResult::TX_BAD_SPECIAL, "bad-prodis-penalty-floor");
+        }
+        bonus_total += bonus;
+    }
+    if (tx.vout.size() == non_actor_count + 1) {
+        const auto& actor_out = tx.vout.back();
+        if (actor_out.scriptPubKey != shares[ptx.actorIndex].scriptRefund) {
+            return state.Invalid(TxValidationResult::TX_BAD_SPECIAL, "bad-prodis-payee");
+        }
+        if (actor_out.nValue == 0) {
+            return state.Invalid(TxValidationResult::TX_BAD_SPECIAL, "bad-prodis-actor-output-zero");
+        }
+    }
+    // The per-recipient floors discard sub-duff remainders; the bonus sum rule forces the
+    // remainder onto some non-actor output
+    if (bonus_total < required_penalty) {
+        return state.Invalid(TxValidationResult::TX_BAD_SPECIAL, "bad-prodis-penalty-sum");
+    }
+
+    if (check_sigs) {
+        const uint256 sign_hash{ptx.MakeSignHash(tx)};
+        if (unanimous) {
+            for (size_t i = 0; i < shares.size(); i++) {
+                if (std::string strError; !CHashSigner::VerifyHashCanonical(sign_hash, shares[i].keyIDOwner,
+                                                                            ptx.vchSigs[i], strError)) {
+                    return state.Invalid(TxValidationResult::TX_BAD_SPECIAL, "bad-prodis-sig");
+                }
+            }
+        } else {
+            if (std::string strError; !CHashSigner::VerifyHashCanonical(sign_hash, shares[ptx.actorIndex].keyIDOwner,
+                                                                        ptx.vchSigs[0], strError)) {
+                return state.Invalid(TxValidationResult::TX_BAD_SPECIAL, "bad-prodis-sig");
+            }
+        }
+    }
+
+    return true;
+}
+
+bool CheckProDisTx(const CTransaction& tx, gsl::not_null<const CBlockIndex*> pindexPrev,
+                   CDeterministicMNManager& dmnman, const ChainstateManager& chainman, TxValidationState& state,
+                   bool check_sigs, SpecialTxContext context)
+{
+    const auto opt_ptx = GetValidatedPayload<CProDisTx>(tx, pindexPrev, chainman, state);
+    if (!opt_ptx) {
+        // pass the state returned by the function above
+        return false;
+    }
+    if (!DeploymentActiveAfter(pindexPrev, chainman, Consensus::DEPLOYMENT_V24)) {
+        return state.Invalid(TxValidationResult::TX_CONSENSUS, "bad-prodis-too-early");
+    }
+
+    const auto mnList = dmnman.GetListForBlock(pindexPrev);
+    if (!mnList.GetMN(opt_ptx->proTxHash)) {
+        if (context == SpecialTxContext::Block) {
+            // The masternode may have been registered earlier in the same block, which this
+            // pindexPrev-based list cannot see. RebuildListFromBlock performs the authoritative
+            // check against the evolving list and rejects the block if the masternode is still
+            // unknown at the transaction's position.
+            return true;
+        }
+        return state.Invalid(TxValidationResult::TX_BAD_SPECIAL, "bad-prodis-hash");
+    }
+    return CheckProDisTxForList(tx, *opt_ptx, mnList, pindexPrev->nHeight + 1, state, check_sigs);
+}
+
+bool CheckSharedCollateralSpends(const CTransaction& tx, const CCoinsViewCache& view, TxValidationState& state)
+{
+    if (tx.IsCoinBase()) return true;
+    for (const auto& in : tx.vin) {
+        // The template is anyone-can-spend at the script layer, so this consensus-level rule is
+        // the only thing restricting spends: only a ProDisTx may consume a template output. The
+        // ProDisTx's own validation then ties the outpoint to its masternode. Pre-activation
+        // template outputs belong to no masternode and are permanently frozen by this rule.
+        const Coin& coin = view.AccessCoin(in.prevout);
+        if (!coin.IsSpent() && sharedcollateral::IsSharedCollateralScript(coin.out.scriptPubKey)) {
+            if (!tx.IsSpecialTxVersion() || tx.nType != TRANSACTION_PROVIDER_DISSOLVE) {
+                return state.Invalid(TxValidationResult::TX_CONSENSUS, "bad-shared-collateral-spend");
+            }
+        }
+    }
+    return true;
+}
+
+bool CheckSharedCollateralTemplateOutputs(const CTransaction& tx, TxValidationState& state)
+{
+    for (uint32_t i = 0; i < tx.vout.size(); i++) {
+        if (!sharedcollateral::IsSharedCollateralScript(tx.vout[i].scriptPubKey)) continue;
+        // An output paying the template script is only valid as the collateral output of a shared
+        // registration. Anywhere else it would either escape the spend covenant or freeze funds.
+        if (!tx.IsSpecialTxVersion() || tx.nType != TRANSACTION_PROVIDER_REGISTER) {
+            return state.Invalid(TxValidationResult::TX_CONSENSUS, "bad-shared-collateral-create");
+        }
+        const auto opt_ptx = GetTxPayload<CProRegTx>(tx);
+        if (!opt_ptx || !opt_ptx->IsShared() || !opt_ptx->collateralOutpoint.hash.IsNull() ||
+            opt_ptx->collateralOutpoint.n != i) {
+            return state.Invalid(TxValidationResult::TX_CONSENSUS, "bad-shared-collateral-create");
+        }
+    }
+    return true;
+}
+
 bool IsStandardSpecialTx(const CTransaction& tx, std::string& reason)
 {
     if (!tx.IsSpecialTxVersion()) return true;
diff --git a/src/evo/specialtxman.h b/src/evo/specialtxman.h
index b4e0d7168538..e5ad1d5c4c4a 100644
--- a/src/evo/specialtxman.h
+++ b/src/evo/specialtxman.h
@@ -20,12 +20,21 @@ class CCoinsViewCache;
 class CCreditPoolManager;
 class CDeterministicMNList;
 class CDeterministicMNManager;
+class CProDisTx;
 class CTransaction;
 class ChainstateManager;
 class CMNHFManager;
 class TxValidationState;
 struct MNListUpdates;
 
+/** Where a special transaction is being validated. Some checks (currently only ProDisTx) must
+ *  defer to RebuildListFromBlock in block context because the referenced masternode may have been
+ *  registered earlier in the same block. */
+enum class SpecialTxContext : uint8_t {
+    Mempool,
+    Block,
+};
+
 namespace chainlock {
 class Chainlocks;
 }
@@ -117,6 +126,28 @@ bool CheckProUpRegTx(const CTransaction& tx, gsl::not_null<const CBlockIndex*> p
                      TxValidationState& state, bool check_sigs);
 bool CheckProUpRevTx(const CTransaction& tx, gsl::not_null<const CBlockIndex*> pindexPrev, CDeterministicMNManager& dmnman,
                      const ChainstateManager& chainman, TxValidationState& state, bool check_sigs);
+bool CheckProDisTx(const CTransaction& tx, gsl::not_null<const CBlockIndex*> pindexPrev, CDeterministicMNManager& dmnman,
+                   const ChainstateManager& chainman, TxValidationState& state, bool check_sigs,
+                   SpecialTxContext context);
+bool CheckProUpShareTx(const CTransaction& tx, gsl::not_null<const CBlockIndex*> pindexPrev,
+                       CDeterministicMNManager& dmnman, const ChainstateManager& chainman, TxValidationState& state,
+                       bool check_sigs);
+bool CheckProUpSharedRegTx(const CTransaction& tx, gsl::not_null<const CBlockIndex*> pindexPrev,
+                           CDeterministicMNManager& dmnman, const ChainstateManager& chainman,
+                           TxValidationState& state, bool check_sigs);
+/** Full ProDisTx validation against a given masternode list and spend height. Used by mempool
+ *  validation (tip list, tip height + 1) and by RebuildListFromBlock (the evolving list, which
+ *  includes masternodes registered earlier in the same block, per the DIP). */
+bool CheckProDisTxForList(const CTransaction& tx, const CProDisTx& ptx, const CDeterministicMNList& mnList,
+                          int nSpendHeight, TxValidationState& state, bool check_sigs);
+
+/** Consensus rule (v24): an input whose prevout pays the shared-collateral template script may
+ *  only be spent by a ProDisTx. Applies to every transaction; callers gate on v24 activation. */
+bool CheckSharedCollateralSpends(const CTransaction& tx, const CCoinsViewCache& view, TxValidationState& state);
+/** Consensus rule (v24): an output paying the shared-collateral template script is only valid as
+ *  the collateral output of a shared registration. Applies to every transaction, including the
+ *  coinbase; callers gate on v24 activation. */
+bool CheckSharedCollateralTemplateOutputs(const CTransaction& tx, TxValidationState& state);
 
 
 /**
diff --git a/src/messagesigner.cpp b/src/messagesigner.cpp
index ec6b5d91e8dd..7fb75ac041e9 100644
--- a/src/messagesigner.cpp
+++ b/src/messagesigner.cpp
@@ -9,6 +9,8 @@
 #include <tinyformat.h>
 #include <util/strencodings.h>
 
+#include <cstring>
+
 bool CMessageSigner::GetKeysFromSecret(const std::string& strSecret, CKey& keyRet, CPubKey& pubkeyRet)
 {
     keyRet = DecodeSecret(strSecret);
@@ -53,6 +55,38 @@ bool CHashSigner::VerifyHash(const uint256& hash, const CPubKey& pubkey, const s
     return VerifyHash(hash, pubkey.GetID(), vchSig, strErrorRet);
 }
 
+bool CHashSigner::VerifyHashCanonical(const uint256& hash, const CKeyID& keyID, const std::vector<unsigned char>& vchSig, std::string& strErrorRet)
+{
+    if (vchSig.size() != CPubKey::COMPACT_SIGNATURE_SIZE) {
+        strErrorRet = "Signature is not 65 bytes.";
+        return false;
+    }
+    // The header byte must be canonical. CPubKey::RecoverCompact only masks (header - 27) with 3
+    // (recovery id) and 4 (compression flag) and never bounds-checks it, so header bytes differing
+    // in any higher bit (e.g. 31 and 39) recover the same key. Restricting the header to the eight
+    // values SignCompact can produce (27..34) removes those aliases, so together with low-S all 65
+    // bytes are pinned and the signature is non-malleable by third parties.
+    if (vchSig[0] < 27 || vchSig[0] > 34) {
+        strErrorRet = "Signature has a non-canonical recovery header.";
+        return false;
+    }
+    // A compact recoverable signature is <header byte> <32-byte R> <32-byte S>, with R and S
+    // big-endian. Enforce low-S: S must not exceed half the secp256k1 group order. Note that
+    // CKey::SignCompact always produces low-S signatures, so this only rejects third-party
+    // malleated signatures.
+    static constexpr unsigned char SECP256K1_HALF_ORDER[32] = {
+        0x7f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+        0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+        0x5d, 0x57, 0x6e, 0x73, 0x57, 0xa4, 0x50, 0x1d,
+        0xdf, 0xe9, 0x2f, 0x46, 0x68, 0x1b, 0x20, 0xa0,
+    };
+    if (std::memcmp(vchSig.data() + 33, SECP256K1_HALF_ORDER, 32) > 0) {
+        strErrorRet = "Signature is not low-S.";
+        return false;
+    }
+    return VerifyHash(hash, keyID, vchSig, strErrorRet);
+}
+
 bool CHashSigner::VerifyHash(const uint256& hash, const CKeyID& keyID, const std::vector<unsigned char>& vchSig, std::string& strErrorRet)
 {
     CPubKey pubkeyFromSig;
diff --git a/src/messagesigner.h b/src/messagesigner.h
index bdc1efd5b674..97a053eb30aa 100644
--- a/src/messagesigner.h
+++ b/src/messagesigner.h
@@ -33,6 +33,9 @@ class CHashSigner
     static bool VerifyHash(const uint256& hash, const CPubKey& pubkey, const std::vector<unsigned char>& vchSig, std::string& strErrorRet);
     /// Verify the hash signature, returns true if successful
     static bool VerifyHash(const uint256& hash, const CKeyID& keyID, const std::vector<unsigned char>& vchSig, std::string& strErrorRet);
+    /// Verify the hash signature and additionally require the exact 65-byte size and a low-S value,
+    /// making the signature bytes non-malleable by third parties. Returns true if successful.
+    static bool VerifyHashCanonical(const uint256& hash, const CKeyID& keyID, const std::vector<unsigned char>& vchSig, std::string& strErrorRet);
 };
 
 #endif // BITCOIN_MESSAGESIGNER_H
diff --git a/src/rpc/rawtransaction.cpp b/src/rpc/rawtransaction.cpp
index a8f60bbba753..77ca8bc3f4e2 100644
--- a/src/rpc/rawtransaction.cpp
+++ b/src/rpc/rawtransaction.cpp
@@ -215,6 +215,9 @@ static std::vector<RPCResult> DecodeTxDoc(const std::string& txid_field_doc)
         MNHFTxPayload::GetJsonHelp(/*key=*/"mnhfTx", /*optional=*/true),
         CAssetLockPayload::GetJsonHelp(/*key=*/"assetLockTx", /*optional=*/true),
         CAssetUnlockPayload::GetJsonHelp(/*key=*/"assetUnlockTx", /*optional=*/true),
+        CProDisTx::GetJsonHelp(/*key=*/"proDisTx", /*optional=*/true),
+        CProUpShareTx::GetJsonHelp(/*key=*/"proUpShareTx", /*optional=*/true),
+        CProUpSharedRegTx::GetJsonHelp(/*key=*/"proUpSharedRegTx", /*optional=*/true),
     };
 }
 
diff --git a/src/validation.cpp b/src/validation.cpp
index 2d57f0739ea5..85be8ead19bd 100644
--- a/src/validation.cpp
+++ b/src/validation.cpp
@@ -916,6 +916,18 @@ bool MemPoolAccept::PreChecks(ATMPArgs& args, Workspace& ws)
         return false; // state filled in by CheckTxInputs
     }
 
+    // Shared-collateral covenant rules apply to every transaction, including normal transactions
+    // that never reach CheckSpecialTx below
+    if (DeploymentActiveAfter(m_active_chainstate.m_chain.Tip(), m_active_chainstate.m_chainman,
+                              Consensus::DEPLOYMENT_V24)) {
+        if (!CheckSharedCollateralSpends(tx, m_view, state)) {
+            return false; // state filled in by CheckSharedCollateralSpends
+        }
+        if (!CheckSharedCollateralTemplateOutputs(tx, state)) {
+            return false; // state filled in by CheckSharedCollateralTemplateOutputs
+        }
+    }
+
     if (fRequireStandard && !AreInputsStandard(tx, m_view)) {
         return state.Invalid(TxValidationResult::TX_INPUTS_NOT_STANDARD, "bad-txns-nonstandard-inputs");
     }
@@ -2328,6 +2340,7 @@ bool Chainstate::ConnectBlock(const CBlock& block, BlockValidationState& state,
     int64_t nTime2_1 = GetTimeMicros(); nTimeProcessSpecial += nTime2_1 - nTime2;
     LogPrint(BCLog::BENCHMARK, "      - ProcessSpecialTxsInBlock: %.2fms [%.2fs (%.2fms/blk)]\n", MILLI * (nTime2_1 - nTime2), nTimeProcessSpecial * MICRO, nTimeProcessSpecial * MILLI / nBlocksTotal);
 
+    const bool fV24Active_context{DeploymentActiveAt(*pindex, m_chainman, Consensus::DEPLOYMENT_V24)};
     for (unsigned int i = 0; i < block.vtx.size(); i++)
     {
         const CTransaction &tx = *(block.vtx[i]);
@@ -2344,6 +2357,19 @@ bool Chainstate::ConnectBlock(const CBlock& block, BlockValidationState& state,
                 return state.Invalid(BlockValidationResult::BLOCK_CONSENSUS,
                             tx_state.GetRejectReason(), tx_state.GetDebugMessage());
             }
+            // The spend side of the shared-collateral covenant runs here (not in
+            // ProcessSpecialTxsInBlock) because this view already contains outputs created by
+            // earlier transactions in this block. The creation side runs in
+            // ProcessSpecialTxsInBlock, which also covers the coinbase.
+            if (fV24Active_context) {
+                TxValidationState shared_state;
+                if (!CheckSharedCollateralSpends(tx, view, shared_state)) {
+                    LogPrintf("ERROR: %s: CheckSharedCollateralSpends: %s, %s\n", __func__, tx.GetHash().ToString(),
+                              shared_state.ToString());
+                    return state.Invalid(BlockValidationResult::BLOCK_CONSENSUS, shared_state.GetRejectReason(),
+                                         shared_state.GetDebugMessage());
+                }
+            }
             nFees += txfee;
             if (!MoneyRange(nFees)) {
                 LogPrintf("ERROR: %s: accumulated fee in the block out of range.\n", __func__);

From 7cad2a635bac96f89d3f74e0ecbfd8ea79a30080 Mon Sep 17 00:00:00 2001
From: Pasta <pasta@dashboost.org>
Date: Thu, 9 Jul 2026 16:40:36 -0500
Subject: [PATCH 04/20] masternode: split shared masternode rewards by share
 amounts

The owner reward of a shared masternode is split across the share table with
DIP-0026's single rounding convention, using the recorded collateral amounts
as weights: every entry except the last receives
floor(ownerReward * amount / collateral) over a 128-bit intermediate and the
last entry receives the remainder, so the split sums exactly. Each portion
pays the share's reward script, falling back to its refund script when no
reward script is set; zero-value outputs are omitted and operator reward
handling is unchanged. The v24 multiplicity-correct coinbase matching already
handles duplicate reward scripts across shares.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
---
 src/evo/providertx.h        |  4 ++++
 src/evo/providertx_util.cpp | 29 +++++++++++++++++++++++++++++
 src/masternode/payments.cpp | 30 +++++++++++++++++++++---------
 3 files changed, 54 insertions(+), 9 deletions(-)

diff --git a/src/evo/providertx.h b/src/evo/providertx.h
index 39948ab9f3f9..a1e871a17312 100644
--- a/src/evo/providertx.h
+++ b/src/evo/providertx.h
@@ -121,6 +121,10 @@ template<class T>
                                              TxValidationState& state);
 [[nodiscard]] std::string ShareListToString(const CollateralShares& shares);
 [[nodiscard]] UniValue ShareListToJson(const CollateralShares& shares);
+/** Split an amount across shares proportionally to their collateral amounts: sequential floor,
+ *  remainder to the last entry. The result always sums to total exactly. */
+[[nodiscard]] std::vector<CAmount> SplitAmountByShares(CAmount total, const CollateralShares& shares);
+
 class CProRegTx
 {
 public:
diff --git a/src/evo/providertx_util.cpp b/src/evo/providertx_util.cpp
index 834dc4dc4d9a..4595391db200 100644
--- a/src/evo/providertx_util.cpp
+++ b/src/evo/providertx_util.cpp
@@ -5,6 +5,7 @@
 #include <evo/providertx.h>
 #include <evo/dmnstate.h>
 
+#include <arith_uint256.h>
 #include <key_io.h>
 #include <script/standard.h>
 #include <tinyformat.h>
@@ -95,3 +96,31 @@ UniValue ShareListToJson(const CollateralShares& shares)
     return ret;
 }
 
+std::vector<CAmount> SplitAmountByShares(const CAmount total, const CollateralShares& shares)
+{
+    // DIP-0026's single rounding convention, with share amounts as weights: every entry except
+    // the last receives floor(total * amount / weight_total) and the last entry receives the
+    // remainder, so the split always sums to total exactly.
+    CAmount weight_total{0};
+    for (const auto& share : shares) {
+        weight_total += share.amount;
+    }
+    std::vector<CAmount> ret;
+    ret.reserve(shares.size());
+    CAmount paid{0};
+    for (size_t i = 0; i < shares.size(); i++) {
+        CAmount payout;
+        if (i + 1 == shares.size()) {
+            payout = total - paid;
+        } else {
+            // 128-bit intermediate: total * amount overflows int64 for real-world values
+            arith_uint256 v{static_cast<uint64_t>(total)};
+            v *= arith_uint256{static_cast<uint64_t>(shares[i].amount)};
+            v /= arith_uint256{static_cast<uint64_t>(weight_total)};
+            payout = static_cast<CAmount>(v.GetLow64());
+        }
+        paid += payout;
+        ret.push_back(payout);
+    }
+    return ret;
+}
diff --git a/src/masternode/payments.cpp b/src/masternode/payments.cpp
index 6c655f05bc76..c5eeda1959d1 100644
--- a/src/masternode/payments.cpp
+++ b/src/masternode/payments.cpp
@@ -168,15 +168,27 @@ CAmount GetMasternodePayment(int nHeight, CAmount blockValue, const Consensus::P
         masternodeReward -= operatorReward;
     }
 
-    const auto owner_payouts = GetOwnerPayouts(*dmnPayee->pdmnState);
-    CAmount paid_owner_reward{0};
-    for (size_t i = 0; i < owner_payouts.size(); ++i) {
-        const bool last = i + 1 == owner_payouts.size();
-        const CAmount payout_amount = last ? masternodeReward - paid_owner_reward
-                                           : (masternodeReward * owner_payouts[i].reward) / MasternodePayoutShare::MAX_REWARD;
-        paid_owner_reward += payout_amount;
-        if (payout_amount > 0) {
-            voutMasternodePaymentsRet.emplace_back(payout_amount, owner_payouts[i].scriptPayout);
+    if (dmnPayee->pdmnState->IsShared()) {
+        // Shared masternodes split the owner reward by recorded collateral contribution, paying
+        // each share's reward script (or its refund script when no reward script is set)
+        const auto& shares = dmnPayee->pdmnState->shares;
+        const auto amounts = SplitAmountByShares(masternodeReward, shares);
+        for (size_t i = 0; i < shares.size(); ++i) {
+            if (amounts[i] > 0) {
+                voutMasternodePaymentsRet.emplace_back(amounts[i], shares[i].RewardScript());
+            }
+        }
+    } else {
+        const auto owner_payouts = GetOwnerPayouts(*dmnPayee->pdmnState);
+        CAmount paid_owner_reward{0};
+        for (size_t i = 0; i < owner_payouts.size(); ++i) {
+            const bool last = i + 1 == owner_payouts.size();
+            const CAmount payout_amount = last ? masternodeReward - paid_owner_reward
+                                               : (masternodeReward * owner_payouts[i].reward) / MasternodePayoutShare::MAX_REWARD;
+            paid_owner_reward += payout_amount;
+            if (payout_amount > 0) {
+                voutMasternodePaymentsRet.emplace_back(payout_amount, owner_payouts[i].scriptPayout);
+            }
         }
     }
     if (operatorReward > 0) {

From 1ff331dbd7e9714bed318a219a29a068ca7309d5 Mon Sep 17 00:00:00 2001
From: Pasta <pasta@dashboost.org>
Date: Thu, 9 Jul 2026 16:40:55 -0500
Subject: [PATCH 05/20] mempool: conflict tracking and eviction for shared
 masternode transactions

Shared registrations track each share owner key in mapProTxPubKeyIDs (the
null keyIDOwner must never enter the map, or two shared registrations would
silently collide on it and the wrong entry would be erased on removal), so
pending shared and non-shared registrations conflict on owner keys in both
directions. ProDisTx, ProUpShareTx and ProUpSharedRegTx register in
mapProTxRefs, which makes the existing spent-collateral sweep evict pending
updates for a masternode (and any competing dissolution) when its ProDisTx
confirms. ProUpSharedRegTx reuses the ProUpRegTx operator-key-change
bookkeeping: one pending key change per masternode, and eviction of
transactions signed with a replaced key. Competing dissolutions conflict
naturally on the collateral input; there is no replacement, first-seen wins.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
---
 src/txmempool.cpp | 105 ++++++++++++++++++++++++++++++++++++++++++++--
 1 file changed, 101 insertions(+), 4 deletions(-)

diff --git a/src/txmempool.cpp b/src/txmempool.cpp
index 8524d6a07e71..f18d5ee10a4d 100644
--- a/src/txmempool.cpp
+++ b/src/txmempool.cpp
@@ -673,7 +673,15 @@ void CTxMemPool::addUncheckedProTx(CDeterministicMNManager& dmnman, indexed_tran
         for (const auto& entry : proTx.netInfo->GetEntries()) {
             mapProTxAddresses.emplace(entry, tx_hash);
         }
-        mapProTxPubKeyIDs.emplace(proTx.keyIDOwner, tx_hash);
+        if (proTx.IsShared()) {
+            // A shared registration has a null keyIDOwner (which must never enter the map, or two
+            // shared registrations would collide on it); the share owner keys take its place
+            for (const auto& share : proTx.shares) {
+                mapProTxPubKeyIDs.emplace(share.keyIDOwner, tx_hash);
+            }
+        } else {
+            mapProTxPubKeyIDs.emplace(proTx.keyIDOwner, tx_hash);
+        }
         mapProTxBlsPubKeyHashes.emplace(proTx.pubKeyOperator.GetHash(), tx_hash);
         if (proTx.nType == MnType::Evo && !proTx.platformNodeID.IsNull()) {
             mapProTxPlatformNodeIDs.emplace(proTx.platformNodeID, tx_hash);
@@ -714,6 +722,23 @@ void CTxMemPool::addUncheckedProTx(CDeterministicMNManager& dmnman, indexed_tran
         mapAssetUnlockExpiry.insert({tx_hash, assetUnlockTx.getHeightToExpiry()});
     } else if (tx.nType == TRANSACTION_MNHF_SIGNAL) {
         PrioritiseTransaction(tx_hash, 0.1 * COIN);
+    } else if (tx.nType == TRANSACTION_PROVIDER_DISSOLVE) {
+        // Registering in mapProTxRefs makes removeProTxSpentCollateralConflicts evict pending
+        // updates for the masternode (and any competing dissolution) when a ProDisTx confirms
+        auto proTx = *Assert(GetTxPayload<CProDisTx>(tx));
+        mapProTxRefs.emplace(proTx.proTxHash, tx_hash);
+    } else if (tx.nType == TRANSACTION_PROVIDER_UPDATE_SHARE) {
+        auto proTx = *Assert(GetTxPayload<CProUpShareTx>(tx));
+        mapProTxRefs.emplace(proTx.proTxHash, tx_hash);
+    } else if (tx.nType == TRANSACTION_PROVIDER_UPDATE_SHARED_REGISTRAR) {
+        auto proTx = *Assert(GetTxPayload<CProUpSharedRegTx>(tx));
+        mapProTxRefs.emplace(proTx.proTxHash, tx_hash);
+        mapProTxBlsPubKeyHashes.emplace(proTx.pubKeyOperator.GetHash(), tx_hash);
+        auto dmn = Assert(dmnman.GetListAtChainTip().GetMN(proTx.proTxHash));
+        newit->validForProTxKey = ::SerializeHash(dmn->pdmnState->pubKeyOperator);
+        if (dmn->pdmnState->pubKeyOperator != proTx.pubKeyOperator) {
+            newit->isKeyChangeProTx = true;
+        }
     }
 }
 
@@ -783,7 +808,13 @@ void CTxMemPool::removeUncheckedProTx(const CTransaction& tx)
         for (const auto& entry : proTx.netInfo->GetEntries()) {
             mapProTxAddresses.erase(entry);
         }
-        mapProTxPubKeyIDs.erase(proTx.keyIDOwner);
+        if (proTx.IsShared()) {
+            for (const auto& share : proTx.shares) {
+                mapProTxPubKeyIDs.erase(share.keyIDOwner);
+            }
+        } else {
+            mapProTxPubKeyIDs.erase(proTx.keyIDOwner);
+        }
         mapProTxBlsPubKeyHashes.erase(proTx.pubKeyOperator.GetHash());
         if (proTx.nType == MnType::Evo && !proTx.platformNodeID.IsNull()) {
             mapProTxPlatformNodeIDs.erase(proTx.platformNodeID);
@@ -808,6 +839,16 @@ void CTxMemPool::removeUncheckedProTx(const CTransaction& tx)
         eraseProTxRef(proTx.proTxHash, tx_hash);
     } else if (tx.nType == TRANSACTION_ASSET_UNLOCK) {
         mapAssetUnlockExpiry.erase(tx_hash);
+    } else if (tx.nType == TRANSACTION_PROVIDER_DISSOLVE) {
+        auto proTx = *Assert(GetTxPayload<CProDisTx>(tx));
+        eraseProTxRef(proTx.proTxHash, tx_hash);
+    } else if (tx.nType == TRANSACTION_PROVIDER_UPDATE_SHARE) {
+        auto proTx = *Assert(GetTxPayload<CProUpShareTx>(tx));
+        eraseProTxRef(proTx.proTxHash, tx_hash);
+    } else if (tx.nType == TRANSACTION_PROVIDER_UPDATE_SHARED_REGISTRAR) {
+        auto proTx = *Assert(GetTxPayload<CProUpSharedRegTx>(tx));
+        eraseProTxRef(proTx.proTxHash, tx_hash);
+        mapProTxBlsPubKeyHashes.erase(proTx.pubKeyOperator.GetHash());
     }
 }
 
@@ -1012,6 +1053,13 @@ void CTxMemPool::removeProTxKeyChangedConflicts(const CTransaction &tx, const ui
         if (txit == mapTx.end()) {
             continue;
         }
+        // ProDisTx and ProUpShareTx are authorized by share owner keys, not the operator key, so
+        // an operator-key change (or revocation) must not evict them. They carry the default
+        // zero validForProTxKey and would otherwise always be treated as stale here.
+        const uint16_t refType{txit->GetTx().nType};
+        if (refType == TRANSACTION_PROVIDER_DISSOLVE || refType == TRANSACTION_PROVIDER_UPDATE_SHARE) {
+            continue;
+        }
         if (txit->validForProTxKey != newKeyHash) {
             conflictingTxs.emplace(txit->GetTx().GetHash());
         }
@@ -1043,7 +1091,13 @@ void CTxMemPool::removeProTxConflicts(const CTransaction &tx)
                 }
             }
         }
-        removeProTxPubKeyConflicts(tx, proTx.keyIDOwner);
+        if (proTx.IsShared()) {
+            for (const auto& share : proTx.shares) {
+                removeProTxPubKeyConflicts(tx, share.keyIDOwner);
+            }
+        } else {
+            removeProTxPubKeyConflicts(tx, proTx.keyIDOwner);
+        }
         removeProTxPubKeyConflicts(tx, proTx.pubKeyOperator);
         if (proTx.nType == MnType::Evo && !proTx.platformNodeID.IsNull()) {
             removeProTxPlatformNodeIDConflicts(tx, proTx.platformNodeID);
@@ -1088,6 +1142,15 @@ void CTxMemPool::removeProTxConflicts(const CTransaction &tx)
         }
 
         removeProTxKeyChangedConflicts(tx, opt_proTx->proTxHash, ::SerializeHash(CBLSPublicKey()));
+    } else if (tx.nType == TRANSACTION_PROVIDER_UPDATE_SHARED_REGISTRAR) {
+        const auto opt_proTx = GetTxPayload<CProUpSharedRegTx>(tx);
+        if (!opt_proTx) {
+            LogPrint(BCLog::MEMPOOL, "%s: ERROR: Invalid transaction payload, tx: %s\n", __func__, tx_hash.ToString());
+            return;
+        }
+
+        removeProTxPubKeyConflicts(tx, opt_proTx->pubKeyOperator);
+        removeProTxKeyChangedConflicts(tx, opt_proTx->proTxHash, ::SerializeHash(opt_proTx->pubKeyOperator));
     }
 }
 
@@ -1407,7 +1470,18 @@ bool CTxMemPool::existsProviderTxConflict(const CTransaction &tx) const {
                 return true;
             }
         }
-        if (mapProTxPubKeyIDs.count(proTx.keyIDOwner) || mapProTxBlsPubKeyHashes.count(proTx.pubKeyOperator.GetHash())) {
+        if (proTx.IsShared()) {
+            // share owner keys occupy the same conflict namespace as keyIDOwner, in both
+            // directions between pending shared and non-shared registrations
+            for (const auto& share : proTx.shares) {
+                if (mapProTxPubKeyIDs.count(share.keyIDOwner)) {
+                    return true;
+                }
+            }
+            if (mapProTxBlsPubKeyHashes.count(proTx.pubKeyOperator.GetHash())) {
+                return true;
+            }
+        } else if (mapProTxPubKeyIDs.count(proTx.keyIDOwner) || mapProTxBlsPubKeyHashes.count(proTx.pubKeyOperator.GetHash())) {
             return true;
         }
         if (proTx.nType == MnType::Evo && !proTx.platformNodeID.IsNull() && mapProTxPlatformNodeIDs.count(proTx.platformNodeID)) {
@@ -1484,6 +1558,29 @@ bool CTxMemPool::existsProviderTxConflict(const CTransaction &tx) const {
                 return true;
             }
         }
+    } else if (tx.nType == TRANSACTION_PROVIDER_UPDATE_SHARED_REGISTRAR) {
+        const auto opt_proTx = GetTxPayload<CProUpSharedRegTx>(tx);
+        if (!opt_proTx) {
+            LogPrint(BCLog::MEMPOOL, "%s: ERROR: Invalid transaction payload, tx: %s\n", __func__, tx_hash.ToString());
+            return true; // i.e. can't decode payload == conflict
+        }
+        auto& proTx = *opt_proTx;
+
+        // this method should only be called with validated ProTxs
+        auto dmn = dmnman->GetListAtChainTip().GetMN(proTx.proTxHash);
+        if (!dmn) {
+            LogPrint(BCLog::MEMPOOL, "%s: ERROR: Masternode is not in the list, proTxHash: %s\n", __func__, proTx.proTxHash.ToString());
+            return true; // i.e. failed to find validated ProTx == conflict
+        }
+        // only allow one operator key change in the mempool
+        if (dmn->pdmnState->pubKeyOperator != proTx.pubKeyOperator) {
+            if (hasKeyChangeInMempool(proTx.proTxHash)) {
+                return true;
+            }
+        }
+
+        auto it = mapProTxBlsPubKeyHashes.find(proTx.pubKeyOperator.GetHash());
+        return it != mapProTxBlsPubKeyHashes.end() && it->second != proTx.proTxHash;
     }
     return false;
 }

From 912a0b356cd60be81c07f4149e84281ea79c82cc Mon Sep 17 00:00:00 2001
From: Pasta <pasta@dashboost.org>
Date: Thu, 9 Jul 2026 16:40:56 -0500
Subject: [PATCH 06/20] policy: relay carve-outs for the shared collateral
 template

The template output is nonstandard by Solver, so two targeted exemptions are
needed for well-formed shared-masternode transactions to relay: IsStandardTx
permits a template output only inside a ProRegTx (consensus restricts it to
the collateral slot of a valid shared registration), and AreInputsStandard
permits a template prevout only inside a ProDisTx (which spends it with an
empty scriptSig; 7 bytes of OP_DROP/OP_TRUE carry no script-evaluation DoS
surface). Everywhere else the template remains nonstandard, which is also the
required pre-activation posture.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
---
 src/policy/policy.cpp | 25 ++++++++++++++++++++++++-
 1 file changed, 24 insertions(+), 1 deletion(-)

diff --git a/src/policy/policy.cpp b/src/policy/policy.cpp
index c91471f8d959..f73ee116a71d 100644
--- a/src/policy/policy.cpp
+++ b/src/policy/policy.cpp
@@ -11,6 +11,9 @@
 #include <consensus/amount.h>
 #include <consensus/consensus.h>
 #include <consensus/validation.h>
+#include <evo/providertx.h>
+#include <evo/sharedcollateral.h>
+#include <evo/specialtx.h>
 #include <policy/feerate.h>
 #include <primitives/transaction.h>
 #include <script/interpreter.h>
@@ -108,8 +111,21 @@ bool IsStandardTx(const CTransaction& tx, bool permit_bare_multisig, const CFeeR
 
     unsigned int nDataOut = 0;
     TxoutType whichType;
-    for (const CTxOut& txout : tx.vout) {
+    for (uint32_t i = 0; i < tx.vout.size(); i++) {
+        const CTxOut& txout = tx.vout[i];
         if (!::IsStandard(txout.scriptPubKey, whichType)) {
+            // The shared-collateral template is intentionally nonstandard everywhere except in the
+            // one shape the consensus creation rule can accept: the declared collateral output of a
+            // shared registration. A template output in any other shape can never be spent, so
+            // relaying it would only propagate permanently frozen outputs.
+            if (tx.IsSpecialTxVersion() && tx.nType == TRANSACTION_PROVIDER_REGISTER &&
+                sharedcollateral::IsSharedCollateralScript(txout.scriptPubKey)) {
+                if (const auto opt_ptx = GetTxPayload<CProRegTx>(tx);
+                    opt_ptx && opt_ptx->IsShared() && opt_ptx->collateralOutpoint.hash.IsNull() &&
+                    opt_ptx->collateralOutpoint.n == i) {
+                    continue;
+                }
+            }
             reason = "scriptpubkey";
             return false;
         }
@@ -162,6 +178,13 @@ bool AreInputsStandard(const CTransaction& tx, const CCoinsViewCache& mapInputs)
         std::vector<std::vector<unsigned char> > vSolutions;
         TxoutType whichType = Solver(prev.scriptPubKey, vSolutions);
         if (whichType == TxoutType::NONSTANDARD) {
+            // A ProDisTx spends the (nonstandard) shared-collateral template with an empty
+            // scriptSig; consensus pins everything else about the spend, and 7 bytes of
+            // OP_DROP/OP_TRUE carry no script-evaluation DoS surface
+            if (tx.IsSpecialTxVersion() && tx.nType == TRANSACTION_PROVIDER_DISSOLVE &&
+                sharedcollateral::IsSharedCollateralScript(prev.scriptPubKey)) {
+                continue;
+            }
             return false;
         } else if (whichType == TxoutType::SCRIPTHASH) {
             std::vector<std::vector<unsigned char> > stack;

From 6b04a73d406f00bd38c1036a5499a721a8436fd3 Mon Sep 17 00:00:00 2001
From: Pasta <pasta@dashboost.org>
Date: Thu, 9 Jul 2026 16:40:57 -0500
Subject: [PATCH 07/20] filters: match shared masternode fields in bloom and
 compact filters

Bloom filters and compact-filter element extraction (kept in lockstep, per
the note in both files) now cover shared registrations (every refund script,
reward script and share owner key), ProDisTx (proTxHash; the refund payments
are literal outputs already matched by the base filter), ProUpShareTx
(proTxHash and the new reward script) and ProUpSharedRegTx (proTxHash and
voting key, matching ProUpRegTx). Share data stays out of the simplified
masternode list entry hash, matching DIP-0026's treatment of payout data.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
---
 src/common/bloom.cpp         | 40 +++++++++++++++++++++++++++++++++++-
 src/evo/specialtx_filter.cpp | 35 +++++++++++++++++++++++++++++++
 2 files changed, 74 insertions(+), 1 deletion(-)

diff --git a/src/common/bloom.cpp b/src/common/bloom.cpp
index b9a17600b6be..0a0fb5829d40 100644
--- a/src/common/bloom.cpp
+++ b/src/common/bloom.cpp
@@ -135,10 +135,16 @@ bool CBloomFilter::CheckSpecialTransactionMatchesAndUpdate(const CTransaction &t
             const auto owner_payouts = GetOwnerPayouts(*opt_proTx);
             const bool found_payout = std::any_of(owner_payouts.begin(), owner_payouts.end(),
                                                   [&](const auto& payout) { return CheckScript(payout.scriptPayout); });
+            const bool found_share = std::any_of(opt_proTx->shares.begin(), opt_proTx->shares.end(),
+                                                 [&](const auto& share) {
+                                                     return CheckScript(share.scriptRefund) ||
+                                                            CheckScript(share.RewardScript()) ||
+                                                            contains(share.keyIDOwner);
+                                                 });
             if(contains(opt_proTx->collateralOutpoint) ||
                     contains(opt_proTx->keyIDOwner) ||
                     contains(opt_proTx->keyIDVoting) ||
-                    found_payout) {
+                    found_payout || found_share) {
                 if ((nFlags & BLOOM_UPDATE_MASK) == BLOOM_UPDATE_ALL)
                     insert(tx.GetHash());
                 return true;
@@ -182,6 +188,38 @@ bool CBloomFilter::CheckSpecialTransactionMatchesAndUpdate(const CTransaction &t
         }
         return false;
     }
+    case(TRANSACTION_PROVIDER_DISSOLVE): {
+        // the refund payments are literal transaction outputs, matched by the generic output loop
+        if (const auto opt_proTx = GetTxPayload<CProDisTx>(tx)) {
+            if(contains(opt_proTx->proTxHash))
+                return true;
+        }
+        return false;
+    }
+    case(TRANSACTION_PROVIDER_UPDATE_SHARE): {
+        if (const auto opt_proTx = GetTxPayload<CProUpShareTx>(tx)) {
+            if(contains(opt_proTx->proTxHash))
+                return true;
+            if(CheckScript(opt_proTx->scriptReward)) {
+                if ((nFlags & BLOOM_UPDATE_MASK) == BLOOM_UPDATE_ALL)
+                    insert(opt_proTx->proTxHash);
+                return true;
+            }
+        }
+        return false;
+    }
+    case(TRANSACTION_PROVIDER_UPDATE_SHARED_REGISTRAR): {
+        if (const auto opt_proTx = GetTxPayload<CProUpSharedRegTx>(tx)) {
+            if(contains(opt_proTx->proTxHash))
+                return true;
+            if(contains(opt_proTx->keyIDVoting)) {
+                if ((nFlags & BLOOM_UPDATE_MASK) == BLOOM_UPDATE_ALL)
+                    insert(opt_proTx->proTxHash);
+                return true;
+            }
+        }
+        return false;
+    }
     case(TRANSACTION_ASSET_LOCK): {
         // inputs of Asset Lock transactions are standard. But some outputs are special
         if (const auto opt_assetlockTx = GetTxPayload<CAssetLockPayload>(tx)) {
diff --git a/src/evo/specialtx_filter.cpp b/src/evo/specialtx_filter.cpp
index ac5c0adcce70..17167749ec68 100644
--- a/src/evo/specialtx_filter.cpp
+++ b/src/evo/specialtx_filter.cpp
@@ -76,6 +76,13 @@ void ExtractSpecialTxFilterElements(const CTransaction& tx, const std::function<
             for (const auto& payout : GetOwnerPayouts(*opt_proTx)) {
                 AddScriptElement(payout.scriptPayout, addElement);
             }
+
+            // Add collateral share refund/reward scripts and owner key IDs
+            for (const auto& share : opt_proTx->shares) {
+                AddScriptElement(share.scriptRefund, addElement);
+                AddScriptElement(share.RewardScript(), addElement);
+                AddHashElement(share.keyIDOwner, addElement);
+            }
         }
         break;
     }
@@ -111,6 +118,34 @@ void ExtractSpecialTxFilterElements(const CTransaction& tx, const std::function<
         }
         break;
     }
+    case TRANSACTION_PROVIDER_DISSOLVE: {
+        // The refund payments are literal transaction outputs, already in the base filter
+        if (const auto opt_proTx = GetTxPayload<CProDisTx>(tx)) {
+            // Add ProTx hash
+            AddHashElement(opt_proTx->proTxHash, addElement);
+        }
+        break;
+    }
+    case TRANSACTION_PROVIDER_UPDATE_SHARE: {
+        if (const auto opt_proTx = GetTxPayload<CProUpShareTx>(tx)) {
+            // Add ProTx hash
+            AddHashElement(opt_proTx->proTxHash, addElement);
+
+            // Add new reward script
+            AddScriptElement(opt_proTx->scriptReward, addElement);
+        }
+        break;
+    }
+    case TRANSACTION_PROVIDER_UPDATE_SHARED_REGISTRAR: {
+        if (const auto opt_proTx = GetTxPayload<CProUpSharedRegTx>(tx)) {
+            // Add ProTx hash
+            AddHashElement(opt_proTx->proTxHash, addElement);
+
+            // Add voting key ID
+            AddHashElement(opt_proTx->keyIDVoting, addElement);
+        }
+        break;
+    }
     case TRANSACTION_ASSET_LOCK: {
         // Asset Lock transactions have special outputs (creditOutputs) that should be included
         if (const auto opt_assetlockTx = GetTxPayload<CAssetLockPayload>(tx)) {

From 8b3b59b5ab30fb2f7dfa8657e68b6b24deb7c088 Mon Sep 17 00:00:00 2001
From: Pasta <pasta@dashboost.org>
Date: Thu, 9 Jul 2026 16:41:20 -0500
Subject: [PATCH 08/20] rpc: shared masternode registration, dissolution and
 update commands

Adds the RPC surface for shared masternodes:

- protx register_shared_prepare appends the template collateral output and a
  v4 shared payload to a caller-supplied funding transaction (which must
  already contain every participant's inputs and change outputs; the consent
  digest binds all of them) and returns the consent hash.
- protx shared_sign signs a shared registration, dissolution or shared
  registrar update with every share owner key the wallet holds; protx
  shared_combine inserts the collected signatures and can submit dissolutions
  and registrar updates directly (a combined registration still needs its
  funding inputs signed, then sendrawtransaction).
- protx dissolve builds, signs and submits a unilateral ProDisTx, paying the
  early-period penalty when required; with submit=false it returns hex
  suitable for offline standby storage (ProDisTx validity is monotone).
  protx dissolve_prepare builds the unanimous, penalty-free variant.
- protx update_share updates one share's reward address with that share
  owner's key; protx update_shared_registrar_prepare builds an unsigned
  ProUpSharedRegTx with signed fee inputs (re-signed on combine, since
  inserting signatures changes the payload).

protx update_registrar now rejects shared masternodes up front instead of
dereferencing their (empty) payout list.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
---
 src/rpc/client.cpp |  14 +
 src/rpc/evo.cpp    | 744 +++++++++++++++++++++++++++++++++++++++++++++
 2 files changed, 758 insertions(+)

diff --git a/src/rpc/client.cpp b/src/rpc/client.cpp
index 2579ed364274..fb7ec84d17dd 100644
--- a/src/rpc/client.cpp
+++ b/src/rpc/client.cpp
@@ -317,8 +317,22 @@ static const CRPCConvertParam vRPCConvertParams[] =
     { "protx register_prepare_evo", 8, "payoutAddress", true },
     { "protx register_prepare_evo", 10, "platformP2PAddrs", true },
     { "protx register_prepare_evo", 11, "platformHTTPSAddrs", true },
+    { "protx register_shared_prepare", 2, "shares" },
+    { "protx register_shared_prepare", 3, "coreP2PAddrs", true },
+    { "protx register_shared_prepare", 7, "earlyPeriodBlocks" },
+    { "protx register_shared_prepare", 8, "earlyPenalty" },
     { "protx revoke", 3, "reason" },
     { "protx revoke", 5, "submit" },
+    { "protx shared_combine", 2, "signatures" },
+    { "protx shared_combine", 3, "submit" },
+    { "protx dissolve", 2, "actorIndex" },
+    { "protx dissolve", 3, "fee" },
+    { "protx dissolve", 4, "submit" },
+    { "protx dissolve", 5, "payPenalty" },
+    { "protx dissolve_prepare", 2, "actorIndex" },
+    { "protx dissolve_prepare", 3, "fee" },
+    { "protx update_share", 2, "shareIndex" },
+    { "protx update_share", 5, "submit" },
     { "protx update_registrar", 4, "payoutAddress", true },
     { "protx update_registrar", 6, "submit" },
     { "protx update_registrar_legacy", 4, "payoutAddress", true },
diff --git a/src/rpc/evo.cpp b/src/rpc/evo.cpp
index e15bc74a18ea..6d6b5a7113a4 100644
--- a/src/rpc/evo.cpp
+++ b/src/rpc/evo.cpp
@@ -2,6 +2,7 @@
 // Distributed under the MIT software license, see the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
+#include <arith_uint256.h>
 #include <bls/bls.h>
 #include <chainparams.h>
 #include <consensus/validation.h>
@@ -11,6 +12,7 @@
 #include <evo/deterministicmns.h>
 #include <evo/dmn_types.h>
 #include <evo/providertx.h>
+#include <evo/sharedcollateral.h>
 #include <evo/smldiff.h>
 #include <evo/specialtx.h>
 #include <evo/specialtxman.h>
@@ -272,6 +274,129 @@ static CBLSSecretKey ParseBLSSecretKey(const std::string& hexKey, const std::str
 }
 
 #ifdef ENABLE_WALLET
+// The shared-masternode helpers and RPCs below all feed into wallet-gated signing (protx
+// shared_sign / dissolve), so they are only compiled with wallet support.
+
+static CollateralShares ParseShares(const UniValue& value, const std::string& paramName)
+{
+    if (!value.isArray()) {
+        throw JSONRPCError(RPC_INVALID_PARAMETER, strprintf("%s must be an array", paramName));
+    }
+    const auto& arr = value.get_array();
+    if (arr.size() < CProRegTx::MIN_SHARES || arr.size() > CProRegTx::MAX_SHARES) {
+        throw JSONRPCError(RPC_INVALID_PARAMETER,
+                           strprintf("%s must contain between %d and %d entries", paramName, CProRegTx::MIN_SHARES,
+                                     CProRegTx::MAX_SHARES));
+    }
+    CollateralShares shares;
+    for (size_t i = 0; i < arr.size(); ++i) {
+        const UniValue& entry = arr[i];
+        if (!entry.isObject()) {
+            throw JSONRPCError(RPC_INVALID_PARAMETER, strprintf("%s entries must be objects", paramName));
+        }
+        const UniValue& amount_value = entry.find_value("amount");
+        const UniValue& refund_value = entry.find_value("refundAddress");
+        const UniValue& reward_value = entry.find_value("rewardAddress");
+        const UniValue& owner_value = entry.find_value("ownerAddress");
+        if (!amount_value.isNum() || !refund_value.isStr() || !owner_value.isStr()) {
+            throw JSONRPCError(RPC_INVALID_PARAMETER,
+                               strprintf("%s entries must include numeric amount, refundAddress and ownerAddress", paramName));
+        }
+        const CAmount amount = amount_value.getInt<int64_t>();
+        CTxDestination refund_dest = DecodeDestination(refund_value.get_str());
+        if (!IsValidDestination(refund_dest)) {
+            throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, strprintf("invalid refund address: %s", refund_value.get_str()));
+        }
+        CScript script_reward;
+        if (reward_value.isStr() && !reward_value.get_str().empty()) {
+            CTxDestination reward_dest = DecodeDestination(reward_value.get_str());
+            if (!IsValidDestination(reward_dest)) {
+                throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, strprintf("invalid reward address: %s", reward_value.get_str()));
+            }
+            script_reward = GetScriptForDestination(reward_dest);
+        }
+        CTxDestination owner_dest = DecodeDestination(owner_value.get_str());
+        const PKHash* owner_pkhash = std::get_if<PKHash>(&owner_dest);
+        if (!owner_pkhash) {
+            throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, strprintf("invalid share owner address: %s", owner_value.get_str()));
+        }
+        shares.emplace_back(amount, GetScriptForDestination(refund_dest), script_reward, ToKeyID(*owner_pkhash));
+    }
+    return shares;
+}
+
+//! Builds an unsigned ProDisTx transaction paying each non-actor share its principal plus its
+//! pro-rata slice of the penalty (sequential floor, remainder to the last non-actor entry, which
+//! always satisfies the consensus minimums), with the actor absorbing penalty and fee
+static CMutableTransaction BuildProDisTx(const CDeterministicMN& dmn, uint16_t actorIndex, CAmount penalty,
+                                         CAmount fee, CProDisTx& ptxRet)
+{
+    const auto& shares = dmn.pdmnState->shares;
+    if (actorIndex >= shares.size()) {
+        throw JSONRPCError(RPC_INVALID_PARAMETER, "actorIndex out of range");
+    }
+    if (fee <= 0) {
+        throw JSONRPCError(RPC_INVALID_PARAMETER, "fee must be positive");
+    }
+    const CAmount actor_output = shares[actorIndex].amount - penalty - fee;
+    if (actor_output < 0) {
+        throw JSONRPCError(RPC_INVALID_PARAMETER, "penalty and fee exceed the actor's share");
+    }
+
+    CMutableTransaction tx;
+    tx.nVersion = 3;
+    tx.nType = TRANSACTION_PROVIDER_DISSOLVE;
+    tx.vin.emplace_back(dmn.collateralOutpoint);
+
+    CAmount non_actor_total{0};
+    size_t last_non_actor{0};
+    for (size_t i = 0; i < shares.size(); i++) {
+        if (i != actorIndex) {
+            non_actor_total += shares[i].amount;
+            last_non_actor = i;
+        }
+    }
+    CAmount distributed{0};
+    for (size_t i = 0; i < shares.size(); i++) {
+        if (i == actorIndex) continue;
+        CAmount bonus;
+        if (i == last_non_actor) {
+            bonus = penalty - distributed;
+        } else {
+            arith_uint256 v{static_cast<uint64_t>(penalty)};
+            v *= arith_uint256{static_cast<uint64_t>(shares[i].amount)};
+            v /= arith_uint256{static_cast<uint64_t>(non_actor_total)};
+            bonus = static_cast<CAmount>(v.GetLow64());
+        }
+        distributed += bonus;
+        tx.vout.emplace_back(shares[i].amount + bonus, shares[i].scriptRefund);
+    }
+    if (actor_output > 0) {
+        tx.vout.emplace_back(actor_output, shares[actorIndex].scriptRefund);
+    }
+
+    ptxRet = CProDisTx();
+    ptxRet.proTxHash = dmn.proTxHash;
+    ptxRet.actorIndex = actorIndex;
+    return tx;
+}
+
+static std::string SubmitSpecialTx(const JSONRPCRequest& request, CChainstateHelper& chain_helper,
+                                   const ChainstateManager& chainman, const CMutableTransaction& tx)
+{
+    {
+        LOCK(::cs_main);
+        TxValidationState state;
+        if (!chain_helper.special_tx->CheckSpecialTx(CTransaction(tx), chainman.ActiveChain().Tip(),
+                                                     chainman.ActiveChainstate().CoinsTip(), true, state)) {
+            throw std::runtime_error(state.ToString());
+        }
+    }
+    JSONRPCRequest sendRequest(request);
+    sendRequest.params.setArray();
+    sendRequest.params.push_back(EncodeHexTx(CTransaction(tx)));
+    return ::sendrawtransaction().HandleRequest(sendRequest).get_str();
+}
 
 static CKeyID ParsePubKeyIDFromAddress(const std::string& strAddress, const std::string& paramName)
 {
@@ -1239,6 +1364,10 @@ static RPCHelpMan protx_update_registrar_wrapper(const bool specific_legacy_bls_
     if (!dmn) {
         throw JSONRPCError(RPC_INVALID_PARAMETER, strprintf("masternode %s not found", ptx.proTxHash.ToString()));
     }
+    if (dmn->pdmnState->IsShared()) {
+        throw JSONRPCError(RPC_INVALID_PARAMETER,
+                           "masternode is shared; use protx update_share or protx update_shared_registrar_prepare");
+    }
 
     ptx.keyIDVoting = dmn->pdmnState->keyIDVoting;
     ptx.scriptPayout = dmn->pdmnState->scriptPayout;
@@ -1415,6 +1544,453 @@ static RPCHelpMan protx_revoke()
     };
 }
 
+static RPCHelpMan protx_shared_sign()
+{
+    return RPCHelpMan{"protx shared_sign",
+        "\nSigns a shared masternode transaction (shared ProRegTx, ProDisTx or ProUpSharedRegTx) with every\n"
+        "share owner key this wallet holds and returns the produced signatures. The transaction itself is\n"
+        "not modified; pass the signatures to \"protx shared_combine\".\n"
+        + HELP_REQUIRING_PASSPHRASE,
+        {
+            {"tx", RPCArg::Type::STR_HEX, RPCArg::Optional::NO, "The serialized transaction in hex format."},
+        },
+        RPCResult{RPCResult::Type::ARR, "", "",
+        {
+            {RPCResult::Type::OBJ, "", "",
+            {
+                {RPCResult::Type::NUM, "shareIndex", "Index into the share table"},
+                {RPCResult::Type::STR, "signature", "Base64-encoded signature by this share's owner key"},
+            }},
+        }},
+        RPCExamples{HelpExampleCli("protx", "shared_sign \"tx\"")},
+        [&](const RPCHelpMan& self, const JSONRPCRequest& request) -> UniValue
+{
+    const NodeContext& node = EnsureAnyNodeContext(request.context);
+    CDeterministicMNManager& dmnman = *CHECK_NONFATAL(node.dmnman);
+
+    std::shared_ptr<CWallet> const pwallet = GetWalletForJSONRPCRequest(request);
+    if (!pwallet) return UniValue::VNULL;
+    EnsureWalletIsUnlocked(*pwallet);
+
+    CMutableTransaction tx;
+    if (!DecodeHexTx(tx, request.params[0].get_str())) {
+        throw JSONRPCError(RPC_INVALID_PARAMETER, "transaction not deserializable");
+    }
+
+    // Resolve the share table and the digest to sign from the transaction type
+    CollateralShares shares;
+    uint256 sign_hash;
+    if (tx.nType == TRANSACTION_PROVIDER_REGISTER) {
+        const auto opt_ptx = GetTxPayload<CProRegTx>(tx);
+        if (!opt_ptx || !opt_ptx->IsShared()) {
+            throw JSONRPCError(RPC_INVALID_PARAMETER, "transaction is not a shared masternode registration");
+        }
+        shares = opt_ptx->shares;
+        sign_hash = opt_ptx->MakeSharedRegConsentHash(CTransaction(tx));
+    } else if (tx.nType == TRANSACTION_PROVIDER_DISSOLVE) {
+        const auto opt_ptx = GetTxPayload<CProDisTx>(tx);
+        if (!opt_ptx) {
+            throw JSONRPCError(RPC_INVALID_PARAMETER, "transaction payload not deserializable");
+        }
+        const auto dmn = dmnman.GetListAtChainTip().GetMN(opt_ptx->proTxHash);
+        if (!dmn || !dmn->pdmnState->IsShared()) {
+            throw JSONRPCError(RPC_INVALID_PARAMETER, "shared masternode not found");
+        }
+        shares = dmn->pdmnState->shares;
+        sign_hash = opt_ptx->MakeSignHash(CTransaction(tx));
+    } else if (tx.nType == TRANSACTION_PROVIDER_UPDATE_SHARED_REGISTRAR) {
+        const auto opt_ptx = GetTxPayload<CProUpSharedRegTx>(tx);
+        if (!opt_ptx) {
+            throw JSONRPCError(RPC_INVALID_PARAMETER, "transaction payload not deserializable");
+        }
+        const auto dmn = dmnman.GetListAtChainTip().GetMN(opt_ptx->proTxHash);
+        if (!dmn || !dmn->pdmnState->IsShared()) {
+            throw JSONRPCError(RPC_INVALID_PARAMETER, "shared masternode not found");
+        }
+        shares = dmn->pdmnState->shares;
+        sign_hash = ::SerializeHash(*opt_ptx);
+    } else {
+        throw JSONRPCError(RPC_INVALID_PARAMETER, "transaction is not a shared masternode transaction");
+    }
+
+    UniValue ret(UniValue::VARR);
+    for (size_t i = 0; i < shares.size(); i++) {
+        std::vector<unsigned char> vchSig;
+        if (!pwallet->SignSpecialTxPayload(sign_hash, shares[i].keyIDOwner, vchSig)) {
+            continue; // this wallet does not hold this share's owner key
+        }
+        UniValue entry(UniValue::VOBJ);
+        entry.pushKV("shareIndex", static_cast<uint64_t>(i));
+        entry.pushKV("signature", EncodeBase64(vchSig));
+        ret.push_back(entry);
+    }
+    if (ret.empty()) {
+        throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, "none of the share owner keys were found in this wallet");
+    }
+    return ret;
+},
+    };
+}
+
+static RPCHelpMan protx_dissolve()
+{
+    return RPCHelpMan{"protx dissolve",
+        "\nCreates, signs and optionally submits a unilateral ProDisTx that dissolves a shared masternode,\n"
+        "refunding every participant's principal to its immutable refund script. During the early period a\n"
+        "unilateral dissolution pays the configured penalty, redistributed pro-rata to the other shares.\n"
+        "The wallet must hold the actor share's owner key. With submit=false the signed transaction hex is\n"
+        "returned instead, which can be stored offline as a standby dissolution: ProDisTx validity is\n"
+        "monotone, so a transaction that is valid now stays valid forever.\n"
+        + HELP_REQUIRING_PASSPHRASE,
+        {
+            {"proTxHash", RPCArg::Type::STR_HEX, RPCArg::Optional::NO, "The hash of the initial ProRegTx."},
+            {"actorIndex", RPCArg::Type::NUM, RPCArg::Optional::NO, "Index into the share table of the dissolving participant."},
+            {"fee", RPCArg::Type::NUM, RPCArg::Default{100000}, "Transaction fee in duffs, paid from the actor's share."},
+            {"submit", RPCArg::Type::BOOL, RPCArg::Default{true}, "Submit the transaction to the network."},
+            {"payPenalty", RPCArg::Type::BOOL, RPCArg::DefaultHint{"determined by the current height"}, "Pay the early-period penalty. Pass true to build a standby valid at any height, false for one valid only after the early period ends."},
+        },
+        RPCResult{RPCResult::Type::STR_HEX, "result", "The transaction id if submitted, otherwise the signed transaction hex"},
+        RPCExamples{HelpExampleCli("protx", "dissolve \"proTxHash\" 0")},
+        [&](const RPCHelpMan& self, const JSONRPCRequest& request) -> UniValue
+{
+    const NodeContext& node = EnsureAnyNodeContext(request.context);
+    const ChainstateManager& chainman = EnsureChainman(node);
+    CDeterministicMNManager& dmnman = *CHECK_NONFATAL(node.dmnman);
+    CChainstateHelper& chain_helper = *CHECK_NONFATAL(node.chain_helper);
+
+    std::shared_ptr<CWallet> const pwallet = GetWalletForJSONRPCRequest(request);
+    if (!pwallet) return UniValue::VNULL;
+    EnsureWalletIsUnlocked(*pwallet);
+
+    const uint256 proTxHash(ParseHashV(request.params[0], "proTxHash"));
+    const int actorIndex{request.params[1].getInt<int>()};
+    if (actorIndex < 0 || actorIndex > std::numeric_limits<uint16_t>::max()) {
+        throw JSONRPCError(RPC_INVALID_PARAMETER, "actorIndex out of range");
+    }
+    const CAmount fee{request.params[2].isNull() ? 100000 : request.params[2].getInt<int64_t>()};
+    const bool fSubmit{request.params[3].isNull() ? true : ParseBoolV(request.params[3], "submit")};
+
+    const auto dmn = dmnman.GetListAtChainTip().GetMN(proTxHash);
+    if (!dmn || !dmn->pdmnState->IsShared()) {
+        throw JSONRPCError(RPC_INVALID_PARAMETER, "shared masternode not found");
+    }
+
+    const bool early{[&]() {
+        const int next_height{WITH_LOCK(::cs_main, return chainman.ActiveChain().Height()) + 1};
+        return next_height - dmn->pdmnState->nRegisteredHeight <
+               static_cast<int64_t>(dmn->pdmnState->nEarlyPeriodBlocks);
+    }()};
+    const bool pay_penalty{request.params[4].isNull() ? early : ParseBoolV(request.params[4], "payPenalty")};
+    if (early && !pay_penalty) {
+        // Deliberate: a zero-penalty standby signed during the early period becomes valid at the
+        // boundary. Warn via error only when it would also be submitted now.
+        if (fSubmit) {
+            throw JSONRPCError(RPC_INVALID_PARAMETER,
+                               "a unilateral dissolution during the early period must pay the penalty; "
+                               "pass submit=false to build a standby for later");
+        }
+    }
+
+    CProDisTx ptx;
+    CMutableTransaction tx = BuildProDisTx(*dmn, static_cast<uint16_t>(actorIndex),
+                                           pay_penalty ? dmn->pdmnState->nEarlyPenalty : 0, fee, ptx);
+
+    std::vector<unsigned char> vchSig;
+    if (!pwallet->SignSpecialTxPayload(ptx.MakeSignHash(CTransaction(tx)),
+                                       dmn->pdmnState->shares[actorIndex].keyIDOwner, vchSig)) {
+        throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY,
+                           "private key for the actor share's owner address not found in this wallet");
+    }
+    ptx.vchSigs = {vchSig};
+    SetTxPayload(tx, ptx);
+
+    if (!fSubmit) {
+        return EncodeHexTx(CTransaction(tx));
+    }
+    return SubmitSpecialTx(request, chain_helper, chainman, tx);
+},
+    };
+}
+
+static RPCHelpMan protx_update_share()
+{
+    return RPCHelpMan{"protx update_share",
+        "\nCreates and sends a ProUpShareTx updating one collateral share's reward script. Only the share's\n"
+        "owner key (which this wallet must hold) can update it; all other share fields are immutable.\n"
+        + HELP_REQUIRING_PASSPHRASE,
+        {
+            {"proTxHash", RPCArg::Type::STR_HEX, RPCArg::Optional::NO, "The hash of the initial ProRegTx."},
+            {"shareIndex", RPCArg::Type::NUM, RPCArg::Optional::NO, "Index into the share table of the share to update."},
+            {"rewardAddress", RPCArg::Type::STR, RPCArg::Optional::NO, "The new reward address, or an empty string to pay rewards to the refund script again."},
+            {"feeSourceAddress", RPCArg::Type::STR, RPCArg::Optional::NO, "Wallet address to pay the transaction fee from."},
+            {"submit", RPCArg::Type::BOOL, RPCArg::Default{true}, "Submit the transaction to the network."},
+        },
+        RPCResult{RPCResult::Type::STR_HEX, "txid", "The transaction id"},
+        RPCExamples{HelpExampleCli("protx", "update_share \"proTxHash\" 0 \"" + EXAMPLE_ADDRESS[1] + "\" \"" + EXAMPLE_ADDRESS[0] + "\"")},
+        [&](const RPCHelpMan& self, const JSONRPCRequest& request) -> UniValue
+{
+    const NodeContext& node = EnsureAnyNodeContext(request.context);
+    const ChainstateManager& chainman = EnsureChainman(node);
+    CDeterministicMNManager& dmnman = *CHECK_NONFATAL(node.dmnman);
+    CChainstateHelper& chain_helper = *CHECK_NONFATAL(node.chain_helper);
+
+    std::shared_ptr<CWallet> const pwallet = GetWalletForJSONRPCRequest(request);
+    if (!pwallet) return UniValue::VNULL;
+    EnsureWalletIsUnlocked(*pwallet);
+
+    CProUpShareTx ptx;
+    ptx.proTxHash = ParseHashV(request.params[0], "proTxHash");
+    const int shareIndex{request.params[1].getInt<int>()};
+    if (shareIndex < 0 || shareIndex > std::numeric_limits<uint16_t>::max()) {
+        throw JSONRPCError(RPC_INVALID_PARAMETER, "shareIndex out of range");
+    }
+    ptx.shareIndex = static_cast<uint16_t>(shareIndex);
+
+    const auto dmn = dmnman.GetListAtChainTip().GetMN(ptx.proTxHash);
+    if (!dmn || !dmn->pdmnState->IsShared()) {
+        throw JSONRPCError(RPC_INVALID_PARAMETER, "shared masternode not found");
+    }
+    if (ptx.shareIndex >= dmn->pdmnState->shares.size()) {
+        throw JSONRPCError(RPC_INVALID_PARAMETER, "shareIndex out of range");
+    }
+
+    if (!request.params[2].get_str().empty()) {
+        CTxDestination rewardDest = DecodeDestination(request.params[2].get_str());
+        if (!IsValidDestination(rewardDest)) {
+            throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, strprintf("invalid reward address: %s", request.params[2].get_str()));
+        }
+        ptx.scriptReward = GetScriptForDestination(rewardDest);
+    }
+
+    CTxDestination feeSourceDest = DecodeDestination(request.params[3].get_str());
+    if (!IsValidDestination(feeSourceDest)) {
+        throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, std::string("Invalid Dash address: ") + request.params[3].get_str());
+    }
+
+    bool fSubmit{true};
+    if (!request.params[4].isNull()) {
+        fSubmit = ParseBoolV(request.params[4], "submit");
+    }
+
+    CMutableTransaction tx;
+    tx.nVersion = 3;
+    tx.nType = TRANSACTION_PROVIDER_UPDATE_SHARE;
+
+    // make sure we get enough fees added
+    ptx.vchSig.resize(65);
+
+    FundSpecialTx(*pwallet, tx, ptx, feeSourceDest);
+    SignSpecialTxPayloadByHash(tx, ptx, dmn->pdmnState->shares[ptx.shareIndex].keyIDOwner, *pwallet);
+    SetTxPayload(tx, ptx);
+
+    return SignAndSendSpecialTx(request, chain_helper, chainman, tx, fSubmit);
+},
+    };
+}
+
+static RPCHelpMan protx_update_shared_registrar_prepare()
+{
+    return RPCHelpMan{"protx update_shared_registrar_prepare",
+        "\nCreates an unsigned ProUpSharedRegTx updating a shared masternode's operator key and/or voting\n"
+        "key. Fee inputs from this wallet are added and signed. Every share owner must then sign the\n"
+        "returned transaction with \"protx shared_sign\"; combine the signatures with \"protx shared_combine\".\n"
+        + HELP_REQUIRING_PASSPHRASE,
+        {
+            {"proTxHash", RPCArg::Type::STR_HEX, RPCArg::Optional::NO, "The hash of the initial ProRegTx."},
+            {"operatorPubKey", RPCArg::Type::STR, RPCArg::Optional::NO, "The new operator BLS public key, or an empty string to keep the current key."},
+            {"votingAddress", RPCArg::Type::STR, RPCArg::Optional::NO, "The new voting address, or an empty string to keep the current address."},
+            {"feeSourceAddress", RPCArg::Type::STR, RPCArg::Optional::NO, "Wallet address to pay the transaction fee from."},
+        },
+        RPCResult{RPCResult::Type::OBJ, "", "",
+        {
+            {RPCResult::Type::STR_HEX, "tx", "The serialized unsigned ProUpSharedRegTx"},
+            {RPCResult::Type::STR_HEX, "signHash", "The payload hash every share owner must sign"},
+        }},
+        RPCExamples{HelpExampleCli("protx", "update_shared_registrar_prepare \"proTxHash\" \"operatorPubKey\" \"\" \"" + EXAMPLE_ADDRESS[0] + "\"")},
+        [&](const RPCHelpMan& self, const JSONRPCRequest& request) -> UniValue
+{
+    const NodeContext& node = EnsureAnyNodeContext(request.context);
+    CDeterministicMNManager& dmnman = *CHECK_NONFATAL(node.dmnman);
+
+    std::shared_ptr<CWallet> const pwallet = GetWalletForJSONRPCRequest(request);
+    if (!pwallet) return UniValue::VNULL;
+    EnsureWalletIsUnlocked(*pwallet);
+
+    CProUpSharedRegTx ptx;
+    ptx.proTxHash = ParseHashV(request.params[0], "proTxHash");
+
+    const auto dmn = dmnman.GetListAtChainTip().GetMN(ptx.proTxHash);
+    if (!dmn || !dmn->pdmnState->IsShared()) {
+        throw JSONRPCError(RPC_INVALID_PARAMETER, "shared masternode not found");
+    }
+
+    if (!request.params[1].get_str().empty()) {
+        ptx.pubKeyOperator.Set(ParseBLSPubKey(request.params[1].get_str(), "operator BLS address", /*specific_legacy_bls_scheme=*/false),
+                               /*specificLegacyScheme=*/false);
+    } else {
+        ptx.pubKeyOperator = dmn->pdmnState->pubKeyOperator;
+    }
+    if (!request.params[2].get_str().empty()) {
+        ptx.keyIDVoting = ParsePubKeyIDFromAddress(request.params[2].get_str(), "voting address");
+    } else {
+        ptx.keyIDVoting = dmn->pdmnState->keyIDVoting;
+    }
+
+    CTxDestination feeSourceDest = DecodeDestination(request.params[3].get_str());
+    if (!IsValidDestination(feeSourceDest)) {
+        throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, std::string("Invalid Dash address: ") + request.params[3].get_str());
+    }
+
+    CMutableTransaction tx;
+    tx.nVersion = 3;
+    tx.nType = TRANSACTION_PROVIDER_UPDATE_SHARED_REGISTRAR;
+
+    // make sure we get enough fees added: one signature per share
+    ptx.vchSigs.assign(dmn->pdmnState->shares.size(), std::vector<unsigned char>(CPubKey::COMPACT_SIGNATURE_SIZE, 0));
+
+    FundSpecialTx(*pwallet, tx, ptx, feeSourceDest);
+    UpdateSpecialTxInputsHash(tx, ptx);
+    SetTxPayload(tx, ptx);
+
+    UniValue ret(UniValue::VOBJ);
+    ret.pushKV("tx", EncodeHexTx(CTransaction(tx)));
+    ret.pushKV("signHash", ::SerializeHash(ptx).ToString());
+    return ret;
+},
+    };
+}
+
+static RPCHelpMan protx_shared_combine()
+{
+    return RPCHelpMan{"protx shared_combine",
+        "\nCombines share owner signatures produced by \"protx shared_sign\" into a shared masternode\n"
+        "transaction. For a shared ProRegTx the completed transaction hex is returned and the funding\n"
+        "inputs still have to be signed (e.g. by passing the result around signrawtransactionwithwallet).\n"
+        "For a ProDisTx or ProUpSharedRegTx the transaction can be submitted directly.\n",
+        {
+            {"tx", RPCArg::Type::STR_HEX, RPCArg::Optional::NO, "The serialized transaction in hex format."},
+            {"signatures", RPCArg::Type::ARR, RPCArg::Optional::NO, "Signature entries collected from \"protx shared_sign\".",
+            {
+                {"", RPCArg::Type::OBJ, RPCArg::Optional::OMITTED, "",
+                {
+                    {"shareIndex", RPCArg::Type::NUM, RPCArg::Optional::NO, "Index into the share table"},
+                    {"signature", RPCArg::Type::STR, RPCArg::Optional::NO, "Base64-encoded signature"},
+                }},
+            }},
+            {"submit", RPCArg::Type::BOOL, RPCArg::Default{false}, "Submit the transaction to the network (not available for registrations, whose funding inputs still need signing)."},
+        },
+        RPCResult{RPCResult::Type::STR_HEX, "result", "The transaction id if submitted, otherwise the combined transaction hex"},
+        RPCExamples{HelpExampleCli("protx", "shared_combine \"tx\" \"[{\\\"shareIndex\\\":0,\\\"signature\\\":\\\"...\\\"}]\"")},
+        [&](const RPCHelpMan& self, const JSONRPCRequest& request) -> UniValue
+{
+    const NodeContext& node = EnsureAnyNodeContext(request.context);
+    const ChainstateManager& chainman = EnsureChainman(node);
+    CDeterministicMNManager& dmnman = *CHECK_NONFATAL(node.dmnman);
+    CChainstateHelper& chain_helper = *CHECK_NONFATAL(node.chain_helper);
+
+    CMutableTransaction tx;
+    if (!DecodeHexTx(tx, request.params[0].get_str())) {
+        throw JSONRPCError(RPC_INVALID_PARAMETER, "transaction not deserializable");
+    }
+
+    // Collect (shareIndex, signature) pairs
+    std::map<size_t, std::vector<unsigned char>> sigs;
+    for (const auto& entry : request.params[1].get_array().getValues()) {
+        const int64_t index{entry.find_value("shareIndex").getInt<int64_t>()};
+        auto opt_sig = DecodeBase64(entry.find_value("signature").get_str());
+        if (index < 0 || !opt_sig.has_value() || opt_sig->size() != CPubKey::COMPACT_SIGNATURE_SIZE) {
+            throw JSONRPCError(RPC_INVALID_PARAMETER, "invalid signature entry");
+        }
+        if (!sigs.emplace(static_cast<size_t>(index), *opt_sig).second) {
+            throw JSONRPCError(RPC_INVALID_PARAMETER, "duplicate shareIndex");
+        }
+    }
+
+    const bool fSubmit{request.params[2].isNull() ? false : ParseBoolV(request.params[2], "submit")};
+
+    if (tx.nType == TRANSACTION_PROVIDER_REGISTER) {
+        auto opt_ptx = GetTxPayload<CProRegTx>(tx);
+        if (!opt_ptx || !opt_ptx->IsShared()) {
+            throw JSONRPCError(RPC_INVALID_PARAMETER, "transaction is not a shared masternode registration");
+        }
+        if (fSubmit) {
+            throw JSONRPCError(RPC_INVALID_PARAMETER, "a combined registration still needs its funding inputs signed; submit it with sendrawtransaction afterwards");
+        }
+        if (sigs.size() != opt_ptx->shares.size()) {
+            throw JSONRPCError(RPC_INVALID_PARAMETER, "a registration requires a signature from every share");
+        }
+        for (const auto& [index, sig] : sigs) {
+            if (index >= opt_ptx->shares.size()) {
+                throw JSONRPCError(RPC_INVALID_PARAMETER, "shareIndex out of range");
+            }
+            opt_ptx->vchJoinSigs[index] = sig;
+        }
+        SetTxPayload(tx, *opt_ptx);
+        return EncodeHexTx(CTransaction(tx));
+    } else if (tx.nType == TRANSACTION_PROVIDER_DISSOLVE) {
+        auto opt_ptx = GetTxPayload<CProDisTx>(tx);
+        if (!opt_ptx) {
+            throw JSONRPCError(RPC_INVALID_PARAMETER, "transaction payload not deserializable");
+        }
+        const auto dmn = dmnman.GetListAtChainTip().GetMN(opt_ptx->proTxHash);
+        if (!dmn || !dmn->pdmnState->IsShared()) {
+            throw JSONRPCError(RPC_INVALID_PARAMETER, "shared masternode not found");
+        }
+        const size_t share_count{dmn->pdmnState->shares.size()};
+        opt_ptx->vchSigs.clear();
+        if (sigs.size() == 1) {
+            // unilateral: the single signature must be the actor's
+            if (sigs.begin()->first != opt_ptx->actorIndex) {
+                throw JSONRPCError(RPC_INVALID_PARAMETER, "a single signature must be by the actor share");
+            }
+            opt_ptx->vchSigs.push_back(sigs.begin()->second);
+        } else if (sigs.size() == share_count) {
+            for (size_t i = 0; i < share_count; i++) {
+                const auto it = sigs.find(i);
+                if (it == sigs.end()) {
+                    throw JSONRPCError(RPC_INVALID_PARAMETER, strprintf("missing signature for share %d", i));
+                }
+                opt_ptx->vchSigs.push_back(it->second);
+            }
+        } else {
+            throw JSONRPCError(RPC_INVALID_PARAMETER, "a dissolution requires exactly one signature or one per share");
+        }
+        SetTxPayload(tx, *opt_ptx);
+        if (!fSubmit) {
+            return EncodeHexTx(CTransaction(tx));
+        }
+        return SubmitSpecialTx(request, chain_helper, chainman, tx);
+    } else if (tx.nType == TRANSACTION_PROVIDER_UPDATE_SHARED_REGISTRAR) {
+        auto opt_ptx = GetTxPayload<CProUpSharedRegTx>(tx);
+        if (!opt_ptx) {
+            throw JSONRPCError(RPC_INVALID_PARAMETER, "transaction payload not deserializable");
+        }
+        const auto dmn = dmnman.GetListAtChainTip().GetMN(opt_ptx->proTxHash);
+        if (!dmn || !dmn->pdmnState->IsShared()) {
+            throw JSONRPCError(RPC_INVALID_PARAMETER, "shared masternode not found");
+        }
+        const size_t share_count{dmn->pdmnState->shares.size()};
+        if (sigs.size() != share_count) {
+            throw JSONRPCError(RPC_INVALID_PARAMETER, "a shared registrar update requires a signature from every share");
+        }
+        opt_ptx->vchSigs.clear();
+        for (size_t i = 0; i < share_count; i++) {
+            const auto it = sigs.find(i);
+            if (it == sigs.end()) {
+                throw JSONRPCError(RPC_INVALID_PARAMETER, strprintf("missing signature for share %d", i));
+            }
+            opt_ptx->vchSigs.push_back(it->second);
+        }
+        SetTxPayload(tx, *opt_ptx);
+        // Inserting the signatures changed the payload, so the fee inputs signed at prepare time
+        // are stale; SignAndSendSpecialTx re-signs them with this wallet before submitting
+        return SignAndSendSpecialTx(request, chain_helper, chainman, tx, fSubmit);
+    }
+    throw JSONRPCError(RPC_INVALID_PARAMETER, "transaction is not a shared masternode transaction");
+},
+    };
+}
+
 #endif//ENABLE_WALLET
 
 #ifdef ENABLE_WALLET
@@ -2011,6 +2587,160 @@ static RPCHelpMan evodb_repair()
     };
 }
 
+#ifdef ENABLE_WALLET
+static RPCHelpMan protx_register_shared_prepare()
+{
+    return RPCHelpMan{"protx register_shared_prepare",
+        "\nCreates an unsigned shared masternode registration (a version 3 ProRegTx with a collateral share\n"
+        "table) by appending the shared-collateral output and payload to a caller-supplied funding\n"
+        "transaction. The funding transaction must already contain every participant's contribution inputs\n"
+        "and any change outputs; the consent digest binds all of them. Every share owner must sign the\n"
+        "returned consent hash via \"protx shared_sign\"; combine with \"protx shared_combine\", then have the\n"
+        "funding inputs signed (signrawtransactionwithwallet) and broadcast with sendrawtransaction.\n",
+        {
+            {"fundingTx", RPCArg::Type::STR_HEX, RPCArg::Optional::NO, "The serialized funding transaction with all participants' inputs and change outputs."},
+            {"shares", RPCArg::Type::ARR, RPCArg::Optional::NO, "The collateral share table, in consensus-significant order. Amounts must sum to the collateral.",
+            {
+                {"", RPCArg::Type::OBJ, RPCArg::Optional::OMITTED, "",
+                {
+                    {"amount", RPCArg::Type::NUM, RPCArg::Optional::NO, "Collateral contribution in duffs (at least 100 DASH)"},
+                    {"refundAddress", RPCArg::Type::STR, RPCArg::Optional::NO, "Immutable address the principal is refunded to at dissolution"},
+                    {"rewardAddress", RPCArg::Type::STR, RPCArg::Optional::OMITTED, "Address this share's owner rewards are paid to (defaults to the refund address)"},
+                    {"ownerAddress", RPCArg::Type::STR, RPCArg::Optional::NO, "P2PKH address of the immutable share owner key"},
+                }},
+            }},
+            {"coreP2PAddrs", RPCArg::Type::STR, RPCArg::Optional::NO, "IP address and port of the masternode, leave empty to bank on a later ProUpServTx."},
+            {"operatorPubKey", RPCArg::Type::STR, RPCArg::Optional::NO, "The operator BLS public key."},
+            {"votingAddress", RPCArg::Type::STR, RPCArg::Optional::NO, "The voting key address."},
+            {"operatorReward", RPCArg::Type::STR, RPCArg::Optional::NO, "The fraction in %% to share with the operator (0.00 to 100.00)."},
+            {"earlyPeriodBlocks", RPCArg::Type::NUM, RPCArg::Optional::NO, "Length in blocks of the early period during which unilateral dissolution is penalized (up to 420480)."},
+            {"earlyPenalty", RPCArg::Type::NUM, RPCArg::Optional::NO, "Penalty in duffs for unilateral dissolution during the early period (must be below the smallest share)."},
+        },
+        RPCResult{RPCResult::Type::OBJ, "", "",
+        {
+            {RPCResult::Type::STR_HEX, "tx", "The serialized unsigned shared ProRegTx"},
+            {RPCResult::Type::NUM, "collateralIndex", "Output index of the shared collateral"},
+            {RPCResult::Type::STR_HEX, "consentHash", "The consent digest every share owner must sign"},
+        }},
+        RPCExamples{HelpExampleCli("protx", "register_shared_prepare \"fundingTx\" \"[...]\" \"1.2.3.4:1234\" \"operatorPubKey\" \"" + EXAMPLE_ADDRESS[1] + "\" 0 10000 5000000000")},
+        [&](const RPCHelpMan& self, const JSONRPCRequest& request) -> UniValue
+{
+    const NodeContext& node = EnsureAnyNodeContext(request.context);
+    const ChainstateManager& chainman = EnsureChainman(node);
+
+    CMutableTransaction tx;
+    if (!DecodeHexTx(tx, request.params[0].get_str())) {
+        throw JSONRPCError(RPC_INVALID_PARAMETER, "funding transaction not deserializable");
+    }
+    tx.nVersion = 3;
+    tx.nType = TRANSACTION_PROVIDER_REGISTER;
+
+    CProRegTx ptx;
+    ptx.nType = MnType::Regular;
+    ptx.nVersion = DeploymentToProtxVersion(WITH_LOCK(::cs_main, return chainman.ActiveChain().Tip()), chainman);
+    if (ptx.nVersion < ProTxVersion::ExtAddr) {
+        throw JSONRPCError(RPC_INVALID_PARAMETER, "shared masternode registration requires provider transaction version 3");
+    }
+    ptx.netInfo = NetInfoInterface::MakeNetInfo(ptx.nVersion);
+
+    ptx.shares = ParseShares(request.params[1], "shares");
+
+    ProcessNetInfoCore(ptx, request.params[2], /*optional=*/true);
+
+    ptx.pubKeyOperator.Set(ParseBLSPubKey(request.params[3].get_str(), "operator BLS address", /*specific_legacy_bls_scheme=*/false),
+                           /*specificLegacyScheme=*/false);
+
+    {
+        CTxDestination voting_dest = DecodeDestination(request.params[4].get_str());
+        const PKHash* voting_pkhash = std::get_if<PKHash>(&voting_dest);
+        if (!voting_pkhash) {
+            throw JSONRPCError(RPC_INVALID_PARAMETER, strprintf("voting address must be a valid P2PKH address, not %s", request.params[4].get_str()));
+        }
+        ptx.keyIDVoting = ToKeyID(*voting_pkhash);
+    }
+
+    int64_t operatorReward;
+    if (!ParseFixedPoint(request.params[5].getValStr(), 2, &operatorReward)) {
+        throw JSONRPCError(RPC_INVALID_PARAMETER, "operatorReward must be a number");
+    }
+    if (operatorReward < 0 || operatorReward > 10000) {
+        throw JSONRPCError(RPC_INVALID_PARAMETER, "operatorReward must be between 0 and 10000");
+    }
+    ptx.nOperatorReward = operatorReward;
+
+    const int64_t earlyPeriodBlocks{request.params[6].getInt<int64_t>()};
+    if (earlyPeriodBlocks < 0 || earlyPeriodBlocks > CProRegTx::MAX_EARLY_PERIOD_BLOCKS) {
+        throw JSONRPCError(RPC_INVALID_PARAMETER, "earlyPeriodBlocks out of range");
+    }
+    ptx.nEarlyPeriodBlocks = static_cast<uint32_t>(earlyPeriodBlocks);
+    ptx.nEarlyPenalty = request.params[7].getInt<int64_t>();
+
+    // Append the shared collateral output; the collateral is always internal
+    tx.vout.emplace_back(GetMnType(ptx.nType).collat_amount, sharedcollateral::SharedCollateralScript());
+    ptx.collateralOutpoint = COutPoint(uint256(), static_cast<uint32_t>(tx.vout.size() - 1));
+
+    // Placeholder consent signatures; filled in by "protx shared_combine"
+    ptx.vchJoinSigs.assign(ptx.shares.size(), std::vector<unsigned char>(CPubKey::COMPACT_SIGNATURE_SIZE, 0));
+
+    UpdateSpecialTxInputsHash(tx, ptx);
+    SetTxPayload(tx, ptx);
+
+    UniValue ret(UniValue::VOBJ);
+    ret.pushKV("tx", EncodeHexTx(CTransaction(tx)));
+    ret.pushKV("collateralIndex", static_cast<uint64_t>(ptx.collateralOutpoint.n));
+    ret.pushKV("consentHash", ptx.MakeSharedRegConsentHash(CTransaction(tx)).ToString());
+    return ret;
+},
+    };
+}
+
+static RPCHelpMan protx_dissolve_prepare()
+{
+    return RPCHelpMan{"protx dissolve_prepare",
+        "\nCreates an unsigned unanimous ProDisTx dissolving a shared masternode without penalty at any\n"
+        "height. Every share owner must sign it via \"protx shared_sign\"; combine and submit the result\n"
+        "with \"protx shared_combine\". For a unilateral dissolution use \"protx dissolve\" instead.\n",
+        {
+            {"proTxHash", RPCArg::Type::STR_HEX, RPCArg::Optional::NO, "The hash of the initial ProRegTx."},
+            {"actorIndex", RPCArg::Type::NUM, RPCArg::Optional::NO, "Index into the share table of the participant paying the transaction fee."},
+            {"fee", RPCArg::Type::NUM, RPCArg::Default{100000}, "Transaction fee in duffs, paid from the actor's share."},
+        },
+        RPCResult{RPCResult::Type::OBJ, "", "",
+        {
+            {RPCResult::Type::STR_HEX, "tx", "The serialized unsigned ProDisTx"},
+            {RPCResult::Type::STR_HEX, "signHash", "The digest every share owner must sign"},
+        }},
+        RPCExamples{HelpExampleCli("protx", "dissolve_prepare \"proTxHash\" 0")},
+        [&](const RPCHelpMan& self, const JSONRPCRequest& request) -> UniValue
+{
+    const NodeContext& node = EnsureAnyNodeContext(request.context);
+    CDeterministicMNManager& dmnman = *CHECK_NONFATAL(node.dmnman);
+
+    const uint256 proTxHash(ParseHashV(request.params[0], "proTxHash"));
+    const int actorIndex{request.params[1].getInt<int>()};
+    if (actorIndex < 0 || actorIndex > std::numeric_limits<uint16_t>::max()) {
+        throw JSONRPCError(RPC_INVALID_PARAMETER, "actorIndex out of range");
+    }
+    const CAmount fee{request.params[2].isNull() ? 100000 : request.params[2].getInt<int64_t>()};
+
+    const auto dmn = dmnman.GetListAtChainTip().GetMN(proTxHash);
+    if (!dmn || !dmn->pdmnState->IsShared()) {
+        throw JSONRPCError(RPC_INVALID_PARAMETER, "shared masternode not found");
+    }
+
+    CProDisTx ptx;
+    CMutableTransaction tx = BuildProDisTx(*dmn, static_cast<uint16_t>(actorIndex), /*penalty=*/0, fee, ptx);
+    SetTxPayload(tx, ptx);
+
+    UniValue ret(UniValue::VOBJ);
+    ret.pushKV("tx", EncodeHexTx(CTransaction(tx)));
+    ret.pushKV("signHash", ptx.MakeSignHash(CTransaction(tx)).ToString());
+    return ret;
+},
+    };
+}
+#endif // ENABLE_WALLET
+
 static RPCHelpMan protx_help()
 {
     return RPCHelpMan{
@@ -2029,6 +2759,7 @@ static RPCHelpMan protx_help()
         "  register_fund_legacy     - (DEPRECATED) Fund and create a ProTx by parsing BLS using the legacy scheme, then send it to network\n"
         "  register_prepare_legacy  - (DEPRECATED) Create an unsigned ProTx by parsing BLS using the legacy scheme\n"
         "  register_submit          - Sign and submit a ProTx\n"
+        "  register_shared_prepare  - Create an unsigned shared masternode ProTx\n"
 #endif
         "  list                     - List ProTxs\n"
         "  info                     - Return information about a ProTx\n"
@@ -2038,6 +2769,12 @@ static RPCHelpMan protx_help()
         "  update_registrar         - Create and send ProUpRegTx to network\n"
         "  update_registrar_legacy  - (DEPRECATED) Create ProUpRegTx by parsing BLS using the legacy scheme, then send it to network\n"
         "  revoke                   - Create and send ProUpRevTx to network\n"
+        "  shared_sign              - Sign a shared masternode transaction with this wallet's share owner keys\n"
+        "  shared_combine           - Combine share owner signatures into a shared masternode transaction\n"
+        "  dissolve                 - Create, sign and send a unilateral ProDisTx\n"
+        "  update_share             - Create and send a ProUpShareTx updating one share's reward address\n"
+        "  update_shared_registrar_prepare - Create an unsigned ProUpSharedRegTx\n"
+        "  dissolve_prepare         - Create an unsigned unanimous ProDisTx\n"
 #endif
         "  diff                     - Calculate a diff and a proof between two masternode lists\n"
         "  listdiff                 - Calculate a full MN list diff between two masternode lists\n",
@@ -2160,6 +2897,13 @@ Span<const CRPCCommand> GetWalletEvoRPCCommands()
         {"evo", &protx_register_submit},
         {"evo", &protx_update_registrar},
         {"evo", &protx_revoke},
+        {"evo", &protx_register_shared_prepare},
+        {"evo", &protx_shared_sign},
+        {"evo", &protx_shared_combine},
+        {"evo", &protx_dissolve},
+        {"evo", &protx_dissolve_prepare},
+        {"evo", &protx_update_share},
+        {"evo", &protx_update_shared_registrar_prepare},
         {"hidden", &protx_register_legacy},
         {"hidden", &protx_register_fund_legacy},
         {"hidden", &protx_register_prepare_legacy},

From 2e5df745a428852465b811f8f398eb7888cb3daf Mon Sep 17 00:00:00 2001
From: Pasta <pasta@dashboost.org>
Date: Thu, 9 Jul 2026 16:41:21 -0500
Subject: [PATCH 09/20] test: unit and functional coverage for decentralized
 masternode shares

evo_sharedmn_tests covers the template script constant and its script-layer
spendability, the share-list validation matrix, shared payload serialization
round-trips, consent-digest field coverage, canonical (low-S) signature
verification including a malleated high-S rejection, the amount-weighted
reward split, state serialization and single-logical-field share diffs,
bidirectional owner-key uniqueness (pinning the untagged unique-property
hashing it relies on), and the full ProDisTx validation matrix including
monotone validity across the early-period boundary.

feature_masternode_shares exercises the feature end to end on regtest:
registration via prepare/sign/combine, reward split to the duff via
getblocktemplate, template covenant rejections at the mempool, reward script
updates, unanimous registrar updates, plain ProUpRegTx rejection, penalized
unilateral dissolution with exact refund outputs, standby dissolutions
becoming valid across the early-period boundary, and penalty-free unanimous
dissolution.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
---
 src/Makefile.test.include                    |   1 +
 src/test/evo_sharedmn_tests.cpp              | 765 +++++++++++++++++++
 test/functional/feature_masternode_shares.py | 317 ++++++++
 test/functional/test_runner.py               |   1 +
 4 files changed, 1084 insertions(+)
 create mode 100644 src/test/evo_sharedmn_tests.cpp
 create mode 100755 test/functional/feature_masternode_shares.py

diff --git a/src/Makefile.test.include b/src/Makefile.test.include
index 807fcc9d80f5..4b05c4b762b5 100644
--- a/src/Makefile.test.include
+++ b/src/Makefile.test.include
@@ -114,6 +114,7 @@ BITCOIN_TESTS =\
   test/evo_islock_tests.cpp \
   test/evo_mnhf_tests.cpp \
   test/evo_netinfo_tests.cpp \
+  test/evo_sharedmn_tests.cpp \
   test/evo_simplifiedmns_tests.cpp \
   test/evo_trivialvalidation.cpp \
   test/evo_utils_tests.cpp \
diff --git a/src/test/evo_sharedmn_tests.cpp b/src/test/evo_sharedmn_tests.cpp
new file mode 100644
index 000000000000..5cf90b9e3685
--- /dev/null
+++ b/src/test/evo_sharedmn_tests.cpp
@@ -0,0 +1,765 @@
+// 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 <test/util/setup_common.h>
+
+#include <evo/deterministicmns.h>
+#include <evo/dmn_types.h>
+#include <evo/dmnstate.h>
+#include <evo/providertx.h>
+#include <evo/sharedcollateral.h>
+#include <evo/specialtxman.h>
+
+#include <arith_uint256.h>
+#include <clientversion.h>
+#include <key.h>
+#include <messagesigner.h>
+#include <policy/policy.h>
+#include <random.h>
+#include <script/interpreter.h>
+#include <script/script.h>
+#include <script/standard.h>
+#include <streams.h>
+#include <util/strencodings.h>
+
+#include <boost/test/unit_test.hpp>
+
+#include <optional>
+
+BOOST_FIXTURE_TEST_SUITE(evo_sharedmn_tests, BasicTestingSetup)
+
+BOOST_AUTO_TEST_CASE(shared_collateral_template)
+{
+    const CScript& templ = sharedcollateral::SharedCollateralScript();
+
+    // The template must be exactly the 7 bytes specified by the DIP
+    BOOST_CHECK_EQUAL(HexStr(templ), "04445348437551");
+    BOOST_CHECK(sharedcollateral::IsSharedCollateralScript(templ));
+
+    // Matching is exact-script, never prefix or near-miss
+    {
+        CScript prefix_extended{templ};
+        prefix_extended << OP_NOP;
+        BOOST_CHECK(!sharedcollateral::IsSharedCollateralScript(prefix_extended));
+    }
+    {
+        // Same tag, missing OP_TRUE
+        CScript truncated = CScript() << std::vector<unsigned char>{'D', 'S', 'H', 'C'} << OP_DROP;
+        BOOST_CHECK(!sharedcollateral::IsSharedCollateralScript(truncated));
+    }
+    {
+        // Different tag byte
+        CScript wrong_tag = CScript() << std::vector<unsigned char>{'D', 'S', 'H', 'D'} << OP_DROP << OP_TRUE;
+        BOOST_CHECK(!sharedcollateral::IsSharedCollateralScript(wrong_tag));
+    }
+    BOOST_CHECK(!sharedcollateral::IsSharedCollateralScript(CScript()));
+}
+
+BOOST_AUTO_TEST_CASE(shared_collateral_template_spendable_at_script_layer)
+{
+    // The template must evaluate true with an empty scriptSig under standard
+    // flags (including CLEANSTACK); all spend protection is consensus-level.
+    ScriptError err;
+    BOOST_CHECK(VerifyScript(CScript(), sharedcollateral::SharedCollateralScript(), STANDARD_SCRIPT_VERIFY_FLAGS,
+                             BaseSignatureChecker(), &err));
+    BOOST_CHECK_EQUAL(err, SCRIPT_ERR_OK);
+}
+
+static CScript NewP2PKHScript(CKey& key)
+{
+    key.MakeNewKey(true);
+    return GetScriptForDestination(PKHash(key.GetPubKey()));
+}
+
+static CCollateralShare NewShare(CAmount amount, CKey& refund_key, CKey& owner_key)
+{
+    owner_key.MakeNewKey(true);
+    return {amount, NewP2PKHScript(refund_key), CScript(), owner_key.GetPubKey().GetID()};
+}
+
+static std::vector<std::vector<unsigned char>> DummyJoinSigs(size_t count)
+{
+    return {count, std::vector<unsigned char>(CPubKey::COMPACT_SIGNATURE_SIZE, 0)};
+}
+
+static void CheckShares(const CollateralShares& shares, const std::vector<std::vector<unsigned char>>& join_sigs,
+                        uint32_t early_period_blocks, CAmount early_penalty, const CKeyID& voting,
+                        const std::optional<std::string>& expected_error)
+{
+    TxValidationState state;
+    BOOST_CHECK_EQUAL(IsShareListTriviallyValid(shares, join_sigs, early_period_blocks, early_penalty,
+                                                dmn_types::Regular.collat_amount, voting, state),
+                      !expected_error.has_value());
+    if (expected_error.has_value()) {
+        BOOST_CHECK_EQUAL(state.GetRejectReason(), *expected_error);
+    }
+}
+
+BOOST_AUTO_TEST_CASE(share_list_validation)
+{
+    CKey voting_key;
+    voting_key.MakeNewKey(true);
+    const CKeyID voting_id = voting_key.GetPubKey().GetID();
+
+    CKey refund_keys[8], owner_keys[8];
+    CollateralShares two_shares{NewShare(600 * COIN, refund_keys[0], owner_keys[0]),
+                                NewShare(400 * COIN, refund_keys[1], owner_keys[1])};
+    CheckShares(two_shares, DummyJoinSigs(2), 0, 0, voting_id, std::nullopt);
+    CheckShares(two_shares, DummyJoinSigs(2), CProRegTx::MAX_EARLY_PERIOD_BLOCKS, 399 * COIN, voting_id, std::nullopt);
+
+    CollateralShares eight_shares;
+    for (size_t i = 0; i < 8; i++) {
+        eight_shares.push_back(NewShare(125 * COIN, refund_keys[i], owner_keys[i]));
+    }
+    CheckShares(eight_shares, DummyJoinSigs(8), 100, 100 * COIN, voting_id, std::nullopt);
+
+    // Count bounds: 0, 1 and 9 shares are invalid
+    CheckShares({}, DummyJoinSigs(0), 0, 0, voting_id, "bad-protx-shares-count");
+    CheckShares({two_shares[0]}, DummyJoinSigs(1), 0, 0, voting_id, "bad-protx-shares-count");
+    {
+        CollateralShares nine_shares{eight_shares};
+        CKey k1, k2;
+        nine_shares.push_back(NewShare(125 * COIN, k1, k2));
+        CheckShares(nine_shares, DummyJoinSigs(9), 0, 0, voting_id, "bad-protx-shares-count");
+    }
+
+    // One join signature per share, each 65 bytes
+    CheckShares(two_shares, DummyJoinSigs(1), 0, 0, voting_id, "bad-protx-shares-sig-count");
+    CheckShares(two_shares, DummyJoinSigs(3), 0, 0, voting_id, "bad-protx-shares-sig-count");
+    {
+        auto bad_sigs = DummyJoinSigs(2);
+        bad_sigs[1].resize(64);
+        CheckShares(two_shares, bad_sigs, 0, 0, voting_id, "bad-protx-shares-sig-size");
+    }
+
+    // Early period cap and penalty bounds
+    CheckShares(two_shares, DummyJoinSigs(2), CProRegTx::MAX_EARLY_PERIOD_BLOCKS + 1, 0, voting_id,
+                "bad-protx-shares-early-period");
+    CheckShares(two_shares, DummyJoinSigs(2), 100, -1, voting_id, "bad-protx-shares-penalty");
+    // earlyPenalty must be strictly below the smallest share amount
+    CheckShares(two_shares, DummyJoinSigs(2), 100, 400 * COIN, voting_id, "bad-protx-shares-penalty");
+
+    // Amount bounds: below the 100 DASH minimum and sums different from the collateral
+    {
+        CollateralShares shares{two_shares};
+        shares[0].amount = 99 * COIN;
+        CheckShares(shares, DummyJoinSigs(2), 0, 0, voting_id, "bad-protx-shares-amount");
+        shares[0].amount = 599 * COIN;
+        CheckShares(shares, DummyJoinSigs(2), 0, 0, voting_id, "bad-protx-shares-amount-sum");
+        shares[0].amount = 601 * COIN;
+        CheckShares(shares, DummyJoinSigs(2), 0, 0, voting_id, "bad-protx-shares-amount-sum");
+    }
+
+    // Duplicate owner keys and refund scripts within the table
+    {
+        CollateralShares shares{two_shares};
+        shares[1].keyIDOwner = shares[0].keyIDOwner;
+        CheckShares(shares, DummyJoinSigs(2), 0, 0, voting_id, "bad-protx-shares-dup-key");
+    }
+    {
+        CollateralShares shares{two_shares};
+        shares[1].scriptRefund = shares[0].scriptRefund;
+        CheckShares(shares, DummyJoinSigs(2), 0, 0, voting_id, "bad-protx-shares-dup-refund");
+    }
+    // Duplicate reward scripts are allowed
+    {
+        CollateralShares shares{two_shares};
+        CKey reward_key;
+        const CScript reward = NewP2PKHScript(reward_key);
+        shares[0].scriptReward = reward;
+        shares[1].scriptReward = reward;
+        CheckShares(shares, DummyJoinSigs(2), 0, 0, voting_id, std::nullopt);
+    }
+
+    // Null owner key
+    {
+        CollateralShares shares{two_shares};
+        shares[0].keyIDOwner = CKeyID();
+        CheckShares(shares, DummyJoinSigs(2), 0, 0, voting_id, "bad-protx-shares-key-null");
+    }
+
+    // Script type restrictions: template, non-standard, P2SH allowed
+    {
+        CollateralShares shares{two_shares};
+        shares[0].scriptReward = sharedcollateral::SharedCollateralScript();
+        CheckShares(shares, DummyJoinSigs(2), 0, 0, voting_id, "bad-protx-shares-payee-template");
+        shares[0].scriptReward = CScript() << OP_TRUE;
+        CheckShares(shares, DummyJoinSigs(2), 0, 0, voting_id, "bad-protx-shares-payee");
+        shares[0].scriptReward = GetScriptForDestination(ScriptHash(CScript() << OP_TRUE));
+        CheckShares(shares, DummyJoinSigs(2), 0, 0, voting_id, std::nullopt);
+    }
+    {
+        CollateralShares shares{two_shares};
+        shares[0].scriptRefund = sharedcollateral::SharedCollateralScript();
+        CheckShares(shares, DummyJoinSigs(2), 0, 0, voting_id, "bad-protx-shares-payee-template");
+    }
+
+    // Refund/reward scripts must not pay any table owner key or the voting key
+    {
+        CollateralShares shares{two_shares};
+        shares[0].scriptReward = GetScriptForDestination(PKHash(shares[1].keyIDOwner));
+        CheckShares(shares, DummyJoinSigs(2), 0, 0, voting_id, "bad-protx-shares-payee-reuse");
+        shares[0].scriptReward = GetScriptForDestination(PKHash(voting_key.GetPubKey()));
+        CheckShares(shares, DummyJoinSigs(2), 0, 0, voting_id, "bad-protx-shares-payee-reuse");
+    }
+}
+
+BOOST_AUTO_TEST_CASE(shared_proregtx_serialization)
+{
+    CKey refund_keys[8], owner_keys[8], voting_key, collateral_key;
+    voting_key.MakeNewKey(true);
+
+    for (const size_t count : {size_t{2}, size_t{8}}) {
+        CProRegTx proTx;
+        proTx.nVersion = ProTxVersion::ExtAddr;
+        proTx.netInfo = NetInfoInterface::MakeNetInfo(proTx.nVersion);
+        proTx.keyIDVoting = voting_key.GetPubKey().GetID();
+        proTx.collateralOutpoint = COutPoint(uint256(), 0);
+        for (size_t i = 0; i < count; i++) {
+            proTx.shares.push_back(NewShare(dmn_types::Regular.collat_amount / count, refund_keys[i], owner_keys[i]));
+        }
+        proTx.vchJoinSigs = DummyJoinSigs(count);
+        proTx.nEarlyPeriodBlocks = 1000;
+        proTx.nEarlyPenalty = 50 * COIN;
+
+        CDataStream ss(SER_NETWORK, CLIENT_VERSION);
+        ss << proTx;
+        CProRegTx proTx2;
+        ss >> proTx2;
+
+        BOOST_CHECK(proTx2.IsShared());
+        BOOST_CHECK_EQUAL(proTx2.shares.size(), count);
+        BOOST_CHECK(proTx2.shares == proTx.shares);
+        BOOST_CHECK(proTx2.vchJoinSigs == proTx.vchJoinSigs);
+        BOOST_CHECK_EQUAL(proTx2.nEarlyPeriodBlocks, proTx.nEarlyPeriodBlocks);
+        BOOST_CHECK_EQUAL(proTx2.nEarlyPenalty, proTx.nEarlyPenalty);
+
+        // Serialization must be deterministic and round-trip byte-identically
+        CDataStream ss2(SER_NETWORK, CLIENT_VERSION);
+        ss2 << proTx2;
+        CDataStream ss3(SER_NETWORK, CLIENT_VERSION);
+        ss3 << proTx;
+        BOOST_CHECK(ss2.str() == ss3.str());
+    }
+
+    // A non-shared extended payload serializes an empty share list and zeroed penalty fields
+    CProRegTx nonShared;
+    nonShared.nVersion = ProTxVersion::ExtAddr;
+    nonShared.netInfo = NetInfoInterface::MakeNetInfo(nonShared.nVersion);
+    CDataStream ss(SER_NETWORK, CLIENT_VERSION);
+    ss << nonShared;
+    CProRegTx nonShared2;
+    ss >> nonShared2;
+    BOOST_CHECK(!nonShared2.IsShared());
+    BOOST_CHECK(nonShared2.vchJoinSigs.empty());
+    BOOST_CHECK_EQUAL(nonShared2.nEarlyPeriodBlocks, uint32_t{0});
+    BOOST_CHECK_EQUAL(nonShared2.nEarlyPenalty, CAmount{0});
+}
+
+BOOST_AUTO_TEST_CASE(canonical_signature_verification)
+{
+    CKey key;
+    key.MakeNewKey(true);
+    const CKeyID key_id = key.GetPubKey().GetID();
+    const uint256 hash = GetRandHash();
+
+    std::vector<unsigned char> sig;
+    BOOST_REQUIRE(CHashSigner::SignHash(hash, key, sig));
+    BOOST_REQUIRE_EQUAL(sig.size(), CPubKey::COMPACT_SIGNATURE_SIZE);
+
+    std::string err;
+    BOOST_CHECK(CHashSigner::VerifyHashCanonical(hash, key_id, sig, err));
+
+    // Wrong size is rejected
+    {
+        auto short_sig = sig;
+        short_sig.resize(64);
+        BOOST_CHECK(!CHashSigner::VerifyHashCanonical(hash, key_id, short_sig, err));
+    }
+
+    // Malleate to the high-S form: s' = N - s, recovery id parity flips. The plain VerifyHash
+    // accepts it (same key recovered), the canonical form must reject it.
+    {
+        auto high_s = sig;
+        static constexpr unsigned char ORDER[32] = {
+            0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+            0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfe,
+            0xba, 0xae, 0xdc, 0xe6, 0xaf, 0x48, 0xa0, 0x3b,
+            0xbf, 0xd2, 0x5e, 0x8c, 0xd0, 0x36, 0x41, 0x41,
+        };
+        int borrow{0};
+        for (int i = 31; i >= 0; i--) {
+            const int diff = int{ORDER[i]} - int{high_s[33 + i]} - borrow;
+            high_s[33 + i] = static_cast<unsigned char>(diff & 0xff);
+            borrow = diff < 0 ? 1 : 0;
+        }
+        BOOST_REQUIRE_EQUAL(borrow, 0);
+        // negating S flips the parity of the recovery id (the low two bits of header - 27);
+        // the compression flag (bit 2) must be preserved
+        const int header = high_s[0] - 27;
+        high_s[0] = static_cast<unsigned char>(27 + (header & 4) + ((header & 3) ^ 1));
+
+        BOOST_CHECK(CHashSigner::VerifyHash(hash, key_id, high_s, err));
+        BOOST_CHECK(!CHashSigner::VerifyHashCanonical(hash, key_id, high_s, err));
+    }
+
+    // Non-canonical recovery header aliases must be rejected. RecoverCompact only masks
+    // (header - 27) with 3 and 4, so header + 8*k recovers the same key; the plain VerifyHash
+    // accepts such aliases, the canonical form must not (else the txid stays malleable).
+    {
+        BOOST_REQUIRE(sig[0] >= 27 && sig[0] <= 34);
+        auto aliased = sig;
+        aliased[0] = static_cast<unsigned char>(sig[0] + 8);
+        BOOST_CHECK(CHashSigner::VerifyHash(hash, key_id, aliased, err));
+        BOOST_CHECK(!CHashSigner::VerifyHashCanonical(hash, key_id, aliased, err));
+    }
+
+    // Wrong key is rejected
+    {
+        CKey other;
+        other.MakeNewKey(true);
+        BOOST_CHECK(!CHashSigner::VerifyHashCanonical(hash, other.GetPubKey().GetID(), sig, err));
+    }
+}
+
+BOOST_AUTO_TEST_CASE(shared_reg_consent_hash)
+{
+    CKey refund_keys[2], owner_keys[2], voting_key;
+    voting_key.MakeNewKey(true);
+
+    CProRegTx proTx;
+    proTx.nVersion = ProTxVersion::ExtAddr;
+    proTx.netInfo = NetInfoInterface::MakeNetInfo(proTx.nVersion);
+    proTx.keyIDVoting = voting_key.GetPubKey().GetID();
+    proTx.collateralOutpoint = COutPoint(uint256(), 0);
+    proTx.shares.push_back(NewShare(600 * COIN, refund_keys[0], owner_keys[0]));
+    proTx.shares.push_back(NewShare(400 * COIN, refund_keys[1], owner_keys[1]));
+    proTx.vchJoinSigs = DummyJoinSigs(2);
+    proTx.nEarlyPeriodBlocks = 1000;
+    proTx.nEarlyPenalty = 50 * COIN;
+
+    CMutableTransaction mtx;
+    mtx.nVersion = 3;
+    mtx.nType = TRANSACTION_PROVIDER_REGISTER;
+    mtx.vin.emplace_back(COutPoint(GetRandHash(), 0));
+    mtx.vin.emplace_back(COutPoint(GetRandHash(), 1));
+    mtx.vout.emplace_back(dmn_types::Regular.collat_amount, sharedcollateral::SharedCollateralScript());
+    CKey change_key;
+    mtx.vout.emplace_back(5 * COIN, NewP2PKHScript(change_key));
+
+    const uint256 base = proTx.MakeSharedRegConsentHash(CTransaction(mtx));
+    BOOST_CHECK(!base.IsNull());
+
+    // Signatures are not covered: filling in a joinSig must not change the digest
+    {
+        CProRegTx mutated{proTx};
+        mutated.vchJoinSigs[0][0] = 0x42;
+        BOOST_CHECK(mutated.MakeSharedRegConsentHash(CTransaction(mtx)) == base);
+    }
+
+    // Every covered field changes the digest
+    {
+        CProRegTx mutated{proTx};
+        mutated.shares[0].amount += 1;
+        BOOST_CHECK(mutated.MakeSharedRegConsentHash(CTransaction(mtx)) != base);
+    }
+    {
+        CProRegTx mutated{proTx};
+        mutated.nEarlyPenalty += 1;
+        BOOST_CHECK(mutated.MakeSharedRegConsentHash(CTransaction(mtx)) != base);
+    }
+    {
+        CProRegTx mutated{proTx};
+        mutated.nEarlyPeriodBlocks += 1;
+        BOOST_CHECK(mutated.MakeSharedRegConsentHash(CTransaction(mtx)) != base);
+    }
+    {
+        CProRegTx mutated{proTx};
+        mutated.nOperatorReward = 100;
+        BOOST_CHECK(mutated.MakeSharedRegConsentHash(CTransaction(mtx)) != base);
+    }
+    {
+        CProRegTx mutated{proTx};
+        CKey new_voting;
+        new_voting.MakeNewKey(true);
+        mutated.keyIDVoting = new_voting.GetPubKey().GetID();
+        BOOST_CHECK(mutated.MakeSharedRegConsentHash(CTransaction(mtx)) != base);
+    }
+    {
+        // Funding inputs are covered
+        CMutableTransaction mtx2{mtx};
+        mtx2.vin[0].prevout.n = 5;
+        BOOST_CHECK(proTx.MakeSharedRegConsentHash(CTransaction(mtx2)) != base);
+    }
+    {
+        // All outputs are covered, including change
+        CMutableTransaction mtx2{mtx};
+        mtx2.vout[1].nValue += 1;
+        BOOST_CHECK(proTx.MakeSharedRegConsentHash(CTransaction(mtx2)) != base);
+    }
+    {
+        // Input sequences are covered: an uncovered sequence rewrite could impose a BIP68
+        // relative timelock on a fully consented registration
+        CMutableTransaction mtx2{mtx};
+        mtx2.vin[1].nSequence = 0xffff;
+        BOOST_CHECK(proTx.MakeSharedRegConsentHash(CTransaction(mtx2)) != base);
+    }
+    {
+        // nLockTime is covered
+        CMutableTransaction mtx2{mtx};
+        mtx2.nLockTime += 1;
+        BOOST_CHECK(proTx.MakeSharedRegConsentHash(CTransaction(mtx2)) != base);
+    }
+}
+
+BOOST_AUTO_TEST_CASE(split_amount_by_shares)
+{
+    CKey refund_keys[3], owner_keys[3];
+    CollateralShares shares{NewShare(600 * COIN, refund_keys[0], owner_keys[0]),
+                            NewShare(300 * COIN, refund_keys[1], owner_keys[1]),
+                            NewShare(100 * COIN, refund_keys[2], owner_keys[2])};
+
+    // Conservation and remainder-to-last for an amount that doesn't divide evenly
+    const CAmount total{123456789};
+    const auto amounts = SplitAmountByShares(total, shares);
+    BOOST_REQUIRE_EQUAL(amounts.size(), shares.size());
+    BOOST_CHECK_EQUAL(amounts[0] + amounts[1] + amounts[2], total);
+    BOOST_CHECK_EQUAL(amounts[0], total * 6 / 10);
+    BOOST_CHECK_EQUAL(amounts[1], total * 3 / 10);
+    BOOST_CHECK_EQUAL(amounts[2], total - amounts[0] - amounts[1]);
+
+    // No 64-bit overflow for realistic values: reward in duffs times a 1000 DASH share
+    const auto big = SplitAmountByShares(566 * COIN, shares);
+    BOOST_CHECK_EQUAL(big[0] + big[1] + big[2], 566 * COIN);
+    BOOST_CHECK_EQUAL(big[0], 566 * COIN * 6 / 10);
+}
+
+BOOST_AUTO_TEST_CASE(dmn_state_shares_roundtrip)
+{
+    CKey refund_keys[2], owner_keys[2], voting_key;
+    voting_key.MakeNewKey(true);
+
+    CProRegTx proTx;
+    proTx.nVersion = ProTxVersion::ExtAddr;
+    proTx.netInfo = NetInfoInterface::MakeNetInfo(proTx.nVersion);
+    proTx.keyIDVoting = voting_key.GetPubKey().GetID();
+    proTx.shares.push_back(NewShare(600 * COIN, refund_keys[0], owner_keys[0]));
+    proTx.shares.push_back(NewShare(400 * COIN, refund_keys[1], owner_keys[1]));
+    proTx.vchJoinSigs = DummyJoinSigs(2);
+    proTx.nEarlyPeriodBlocks = 123;
+    proTx.nEarlyPenalty = 7 * COIN;
+
+    CDeterministicMNState state(proTx);
+    BOOST_CHECK(state.IsShared());
+    BOOST_CHECK(state.shares == proTx.shares);
+    BOOST_CHECK_EQUAL(state.nEarlyPeriodBlocks, proTx.nEarlyPeriodBlocks);
+    BOOST_CHECK_EQUAL(state.nEarlyPenalty, proTx.nEarlyPenalty);
+
+    CDataStream ss(SER_DISK, CLIENT_VERSION);
+    ss << state;
+    CDeterministicMNState state2;
+    ss >> state2;
+    BOOST_CHECK(state2.shares == state.shares);
+    BOOST_CHECK_EQUAL(state2.nEarlyPeriodBlocks, state.nEarlyPeriodBlocks);
+    BOOST_CHECK_EQUAL(state2.nEarlyPenalty, state.nEarlyPenalty);
+
+    // A reward-script change is reported as one logical field carrying the whole table
+    CDeterministicMNState changed{state};
+    CKey reward_key;
+    changed.shares[1].scriptReward = NewP2PKHScript(reward_key);
+    CDeterministicMNStateDiff diff(state, changed);
+    BOOST_CHECK(diff.fields & CDeterministicMNStateDiff::Field_shares);
+    BOOST_CHECK(!(diff.fields & CDeterministicMNStateDiff::Field_nEarlyPeriodBlocks));
+
+    CDataStream ss_diff(SER_DISK, CLIENT_VERSION);
+    ss_diff << diff;
+    CDeterministicMNStateDiff diff2;
+    ss_diff >> diff2;
+    CDeterministicMNState applied{state};
+    diff2.ApplyToState(applied);
+    BOOST_CHECK(applied.shares == changed.shares);
+}
+
+BOOST_AUTO_TEST_CASE(shared_unique_properties)
+{
+    CKey refund_keys[2], owner_keys[2], voting_key;
+    voting_key.MakeNewKey(true);
+
+    CProRegTx proTx;
+    proTx.nVersion = ProTxVersion::ExtAddr;
+    proTx.netInfo = NetInfoInterface::MakeNetInfo(proTx.nVersion);
+    proTx.keyIDVoting = voting_key.GetPubKey().GetID();
+    proTx.shares.push_back(NewShare(600 * COIN, refund_keys[0], owner_keys[0]));
+    proTx.shares.push_back(NewShare(400 * COIN, refund_keys[1], owner_keys[1]));
+
+    CDeterministicMNList list(uint256(), 0, 0);
+    auto dmn = std::make_shared<CDeterministicMN>(0, MnType::Regular);
+    dmn->proTxHash = GetRandHash();
+    dmn->collateralOutpoint = COutPoint(dmn->proTxHash, 0);
+    dmn->pdmnState = std::make_shared<CDeterministicMNState>(proTx);
+    list.AddMN(dmn);
+
+    // Share owner keys land in the same uniqueness namespace as keyIDOwner: a normal
+    // registration reusing a share owner key must be detected, and vice versa. This relies on
+    // GetUniquePropertyHash being an untagged SerializeHash of the CKeyID.
+    BOOST_CHECK(list.HasUniqueProperty(owner_keys[0].GetPubKey().GetID()));
+    BOOST_CHECK(list.HasUniqueProperty(owner_keys[1].GetPubKey().GetID()));
+    // the null keyIDOwner of a shared masternode is never registered
+    BOOST_CHECK(!list.HasUniqueProperty(CKeyID()));
+
+    list.RemoveMN(dmn->proTxHash);
+    BOOST_CHECK(!list.HasUniqueProperty(owner_keys[0].GetPubKey().GetID()));
+    BOOST_CHECK(!list.HasUniqueProperty(owner_keys[1].GetPubKey().GetID()));
+}
+
+struct ProDisTestSetup {
+    CKey refund_keys[3], owner_keys[3], voting_key;
+    CDeterministicMNList list{uint256(), 0, 0};
+    std::shared_ptr<CDeterministicMN> dmn;
+    static constexpr int REGISTERED_HEIGHT{1000};
+    static constexpr uint32_t EARLY_PERIOD{100};
+    static constexpr CAmount PENALTY{50 * COIN};
+    static constexpr CAmount FEE{100000};
+
+    ProDisTestSetup()
+    {
+        voting_key.MakeNewKey(true);
+        CProRegTx proTx;
+        proTx.nVersion = ProTxVersion::ExtAddr;
+        proTx.netInfo = NetInfoInterface::MakeNetInfo(proTx.nVersion);
+        proTx.keyIDVoting = voting_key.GetPubKey().GetID();
+        proTx.shares.push_back(NewShareFor(500 * COIN, refund_keys[0], owner_keys[0]));
+        proTx.shares.push_back(NewShareFor(300 * COIN, refund_keys[1], owner_keys[1]));
+        proTx.shares.push_back(NewShareFor(200 * COIN, refund_keys[2], owner_keys[2]));
+        proTx.nEarlyPeriodBlocks = EARLY_PERIOD;
+        proTx.nEarlyPenalty = PENALTY;
+
+        dmn = std::make_shared<CDeterministicMN>(0, MnType::Regular);
+        dmn->proTxHash = GetRandHash();
+        dmn->collateralOutpoint = COutPoint(dmn->proTxHash, 0);
+        auto state = std::make_shared<CDeterministicMNState>(proTx);
+        state->nRegisteredHeight = REGISTERED_HEIGHT;
+        dmn->pdmnState = state;
+        list.AddMN(dmn);
+    }
+
+    static CCollateralShare NewShareFor(CAmount amount, CKey& refund_key, CKey& owner_key)
+    {
+        return NewShare(amount, refund_key, owner_key);
+    }
+
+    const CollateralShares& Shares() const { return dmn->pdmnState->shares; }
+
+    //! Builds a well-formed ProDisTx: non-actor refunds in share order (+pro-rata penalty,
+    //! remainder to last), optional actor output, and valid signatures
+    CMutableTransaction BuildTx(uint16_t actor, CAmount penalty, bool unanimous, CProDisTx& ptxRet) const
+    {
+        const auto& shares = Shares();
+        CMutableTransaction tx;
+        tx.nVersion = 3;
+        tx.nType = TRANSACTION_PROVIDER_DISSOLVE;
+        tx.vin.emplace_back(dmn->collateralOutpoint);
+
+        CAmount W{0};
+        size_t last_non_actor{0};
+        for (size_t i = 0; i < shares.size(); i++) {
+            if (i != actor) {
+                W += shares[i].amount;
+                last_non_actor = i;
+            }
+        }
+        CAmount distributed{0};
+        for (size_t i = 0; i < shares.size(); i++) {
+            if (i == actor) continue;
+            CAmount bonus;
+            if (i == last_non_actor) {
+                bonus = penalty - distributed;
+            } else {
+                // 128-bit intermediate, like the consensus code
+                arith_uint256 v{static_cast<uint64_t>(penalty)};
+                v *= arith_uint256{static_cast<uint64_t>(shares[i].amount)};
+                v /= arith_uint256{static_cast<uint64_t>(W)};
+                bonus = static_cast<CAmount>(v.GetLow64());
+            }
+            distributed += bonus;
+            tx.vout.emplace_back(shares[i].amount + bonus, shares[i].scriptRefund);
+        }
+        const CAmount actor_out = shares[actor].amount - penalty - FEE;
+        if (actor_out > 0) {
+            tx.vout.emplace_back(actor_out, shares[actor].scriptRefund);
+        }
+
+        ptxRet = CProDisTx();
+        ptxRet.proTxHash = dmn->proTxHash;
+        ptxRet.actorIndex = actor;
+        Sign(tx, ptxRet, unanimous);
+        return tx;
+    }
+
+    void Sign(const CMutableTransaction& tx, CProDisTx& ptx, bool unanimous) const
+    {
+        const uint256 hash = ptx.MakeSignHash(CTransaction(tx));
+        ptx.vchSigs.clear();
+        if (unanimous) {
+            for (const auto& key : owner_keys) {
+                std::vector<unsigned char> sig;
+                BOOST_REQUIRE(CHashSigner::SignHash(hash, key, sig));
+                ptx.vchSigs.push_back(sig);
+            }
+        } else {
+            std::vector<unsigned char> sig;
+            BOOST_REQUIRE(CHashSigner::SignHash(hash, owner_keys[ptx.actorIndex], sig));
+            ptx.vchSigs.push_back(sig);
+        }
+    }
+
+    void Check(const CMutableTransaction& tx, const CProDisTx& ptx, int spend_height,
+               const std::optional<std::string>& expected_error) const
+    {
+        TxValidationState state;
+        BOOST_CHECK_EQUAL(CheckProDisTxForList(CTransaction(tx), ptx, list, spend_height, state, /*check_sigs=*/true),
+                          !expected_error.has_value());
+        if (expected_error.has_value()) {
+            BOOST_CHECK_EQUAL(state.GetRejectReason(), *expected_error);
+        }
+    }
+};
+
+BOOST_AUTO_TEST_CASE(prodis_validation)
+{
+    ProDisTestSetup t;
+    constexpr int IN_EARLY{ProDisTestSetup::REGISTERED_HEIGHT + 50};
+    constexpr int AFTER_EARLY{ProDisTestSetup::REGISTERED_HEIGHT + ProDisTestSetup::EARLY_PERIOD};
+
+    // Unilateral with penalty: valid during the early period and, by monotonicity, forever after
+    {
+        CProDisTx ptx;
+        const auto tx = t.BuildTx(/*actor=*/2, ProDisTestSetup::PENALTY, /*unanimous=*/false, ptx);
+        t.Check(tx, ptx, IN_EARLY, std::nullopt);
+        t.Check(tx, ptx, AFTER_EARLY + 100000, std::nullopt);
+    }
+    // Unilateral without penalty: invalid during the early period, valid at and after the boundary
+    {
+        CProDisTx ptx;
+        const auto tx = t.BuildTx(2, 0, false, ptx);
+        t.Check(tx, ptx, IN_EARLY, "bad-prodis-penalty-floor");
+        t.Check(tx, ptx, AFTER_EARLY, std::nullopt);
+    }
+    // Unanimous without penalty: valid at any height
+    {
+        CProDisTx ptx;
+        const auto tx = t.BuildTx(0, 0, true, ptx);
+        t.Check(tx, ptx, IN_EARLY, std::nullopt);
+    }
+    // Overpaying the penalty is always valid
+    {
+        CProDisTx ptx;
+        const auto tx = t.BuildTx(2, ProDisTestSetup::PENALTY + 12345, false, ptx);
+        t.Check(tx, ptx, IN_EARLY, std::nullopt);
+    }
+    // Unknown masternode / not-shared handled by callers; unknown hash here
+    {
+        CProDisTx ptx;
+        auto tx = t.BuildTx(0, 0, true, ptx);
+        ptx.proTxHash = GetRandHash();
+        t.Check(tx, ptx, IN_EARLY, "bad-prodis-hash");
+    }
+    // Wrong input, extra input, non-empty scriptSig
+    {
+        CProDisTx ptx;
+        auto tx = t.BuildTx(0, 0, true, ptx);
+        tx.vin[0].prevout.n = 1;
+        t.Sign(tx, ptx, true);
+        t.Check(tx, ptx, IN_EARLY, "bad-prodis-input");
+    }
+    {
+        CProDisTx ptx;
+        auto tx = t.BuildTx(0, 0, true, ptx);
+        tx.vin.emplace_back(COutPoint(GetRandHash(), 0));
+        t.Sign(tx, ptx, true);
+        t.Check(tx, ptx, IN_EARLY, "bad-prodis-input");
+    }
+    {
+        CProDisTx ptx;
+        auto tx = t.BuildTx(0, 0, true, ptx);
+        tx.vin[0].scriptSig = CScript() << OP_TRUE;
+        t.Sign(tx, ptx, true);
+        t.Check(tx, ptx, IN_EARLY, "bad-prodis-input");
+    }
+    // Actor index out of range
+    {
+        CProDisTx ptx;
+        auto tx = t.BuildTx(0, 0, true, ptx);
+        ptx.actorIndex = 3;
+        t.Sign(tx, ptx, true);
+        t.Check(tx, ptx, IN_EARLY, "bad-prodis-actor");
+    }
+    // Signature count other than 1 or sharesCount
+    {
+        CProDisTx ptx;
+        auto tx = t.BuildTx(0, 0, true, ptx);
+        ptx.vchSigs.resize(2);
+        t.Check(tx, ptx, IN_EARLY, "bad-prodis-sig-count");
+    }
+    // Wrong actor signature (signed by a non-actor share)
+    {
+        CProDisTx ptx;
+        auto tx = t.BuildTx(2, ProDisTestSetup::PENALTY, false, ptx);
+        std::vector<unsigned char> sig;
+        BOOST_REQUIRE(CHashSigner::SignHash(ptx.MakeSignHash(CTransaction(tx)), t.owner_keys[0], sig));
+        ptx.vchSigs = {sig};
+        t.Check(tx, ptx, IN_EARLY, "bad-prodis-sig");
+    }
+    // Unanimous signatures out of share order
+    {
+        CProDisTx ptx;
+        auto tx = t.BuildTx(0, 0, true, ptx);
+        std::swap(ptx.vchSigs[0], ptx.vchSigs[1]);
+        t.Check(tx, ptx, IN_EARLY, "bad-prodis-sig");
+    }
+    // Redirected refund output
+    {
+        CProDisTx ptx;
+        auto tx = t.BuildTx(0, 0, true, ptx);
+        tx.vout[0].scriptPubKey = t.Shares()[0].scriptRefund; // should be share 1's refund
+        t.Sign(tx, ptx, true);
+        t.Check(tx, ptx, IN_EARLY, "bad-prodis-payee");
+    }
+    // Reordered refund outputs
+    {
+        CProDisTx ptx;
+        auto tx = t.BuildTx(0, 0, true, ptx);
+        std::swap(tx.vout[0], tx.vout[1]);
+        t.Sign(tx, ptx, true);
+        t.Check(tx, ptx, IN_EARLY, "bad-prodis-payee");
+    }
+    // Extra output
+    {
+        CProDisTx ptx;
+        auto tx = t.BuildTx(0, 0, true, ptx);
+        tx.vout.emplace_back(1, t.Shares()[0].scriptRefund);
+        t.Sign(tx, ptx, true);
+        t.Check(tx, ptx, IN_EARLY, "bad-prodis-payee-count");
+    }
+    // Underpaying one non-actor share fails the per-recipient floor
+    {
+        CProDisTx ptx;
+        auto tx = t.BuildTx(2, ProDisTestSetup::PENALTY, false, ptx);
+        tx.vout[0].nValue -= 1;
+        t.Sign(tx, ptx, false);
+        t.Check(tx, ptx, IN_EARLY, "bad-prodis-penalty-floor");
+    }
+    // Zero-value actor output must be omitted
+    {
+        CProDisTx ptx;
+        auto tx = t.BuildTx(0, 0, true, ptx);
+        // replace the actor output with a zero-value one; the output count stays valid
+        tx.vout.pop_back();
+        tx.vout.emplace_back(0, t.Shares()[0].scriptRefund);
+        t.Sign(tx, ptx, true);
+        t.Check(tx, ptx, IN_EARLY, "bad-prodis-actor-output-zero");
+    }
+}
+
+BOOST_AUTO_TEST_SUITE_END()
diff --git a/test/functional/feature_masternode_shares.py b/test/functional/feature_masternode_shares.py
new file mode 100755
index 000000000000..fdbca29f7dfd
--- /dev/null
+++ b/test/functional/feature_masternode_shares.py
@@ -0,0 +1,317 @@
+#!/usr/bin/env python3
+# 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.
+"""Test decentralized masternode shares (shared collateral, reward split, dissolution)."""
+
+import base64
+from decimal import Decimal
+
+from test_framework.messages import COIN, CTxOut, tx_from_hex
+from test_framework.script import CScript
+from test_framework.test_framework import DashTestFramework, p2p_port
+from test_framework.util import (
+    assert_equal,
+    assert_greater_than,
+    assert_raises_rpc_error,
+    softfork_active,
+)
+
+V24_ACTIVATION_THRESHOLD = 100
+COLLATERAL = 1000 * COIN
+SHARED_COLLATERAL_SCRIPT = "04445348437551"
+EARLY_PERIOD_BLOCKS = 20
+EARLY_PENALTY = 50 * COIN
+DISSOLVE_FEE = 100000
+
+
+class MasternodeSharesTest(DashTestFramework):
+    def add_options(self, parser):
+        self.add_wallet_options(parser)
+
+    def set_test_params(self):
+        self.set_dash_test_params(1, 0, extra_args=[[
+            f"-vbparams=v24:{self.mocktime}:999999999999:{V24_ACTIVATION_THRESHOLD}:10:8:6:5:0",
+        ]])
+
+    def activate_v24(self):
+        while not softfork_active(self.nodes[0], "v24"):
+            self.bump_mocktime(50)
+            self.generate(self.nodes[0], 50, sync_fun=self.no_op)
+        assert softfork_active(self.nodes[0], "v24")
+
+    def build_funding_tx(self, node):
+        """Returns hex of a transaction with enough inputs to fund the collateral plus fee
+        and a change output, but without the collateral output itself (register_shared_prepare
+        appends it)."""
+        dummy = node.getnewaddress()
+        raw = node.createrawtransaction([], {dummy: 1000})
+        funded = node.fundrawtransaction(raw, {"feeRate": 0.00010000})["hex"]
+        tx = tx_from_hex(funded)
+        vout = [out for out in tx.vout if out.nValue != COLLATERAL]
+        assert_equal(len(vout), len(tx.vout) - 1)
+        tx.vout = vout
+        return tx.serialize().hex()
+
+    def register_shared(self, node, shares, port_offset, early_period_blocks=EARLY_PERIOD_BLOCKS,
+                        early_penalty=EARLY_PENALTY):
+        operator_key = node.bls("generate")["public"]
+        voting_address = node.getnewaddress()
+        funding_hex = self.build_funding_tx(node)
+        prepared = node.protx(
+            "register_shared_prepare", funding_hex, shares, f"127.0.0.1:{p2p_port(port_offset)}",
+            operator_key, voting_address, 0, early_period_blocks, early_penalty)
+        assert_equal(len(prepared["consentHash"]), 64)
+
+        sigs = node.protx("shared_sign", prepared["tx"])
+        assert_equal(sorted(s["shareIndex"] for s in sigs), list(range(len(shares))))
+        combined = node.protx("shared_combine", prepared["tx"], sigs)
+
+        signed = node.signrawtransactionwithwallet(combined)
+        assert_equal(signed["complete"], True)
+        protx_hash = node.sendrawtransaction(signed["hex"])
+        self.bump_mocktime(10 * 60 + 1)
+        self.generate(node, 1, sync_fun=self.no_op)
+        return protx_hash, prepared["collateralIndex"]
+
+    def owner_gbt_payees(self, node):
+        return [p for p in node.getblocktemplate()["masternode"] if p["script"] != "6a"]
+
+    def run_test(self):
+        node = self.nodes[0]
+        self.activate_v24()
+
+        self.log.info("Register a two-participant shared masternode")
+        refund1, refund2 = node.getnewaddress(), node.getnewaddress()
+        owner1, owner2 = node.getnewaddress(), node.getnewaddress()
+        shares = [
+            {"amount": 600 * COIN, "refundAddress": refund1, "ownerAddress": owner1},
+            {"amount": 400 * COIN, "refundAddress": refund2, "ownerAddress": owner2},
+        ]
+        protx_hash, collateral_index = self.register_shared(node, shares, port_offset=1)
+
+        raw = node.getrawtransaction(protx_hash, 1)
+        assert_equal(raw["proRegTx"]["version"], 3)
+        assert_equal([s["refundAddress"] for s in raw["proRegTx"]["shares"]], [refund1, refund2])
+        assert_equal([s["amount"] for s in raw["proRegTx"]["shares"]], [600 * COIN, 400 * COIN])
+        # empty reward script falls back to the refund script
+        assert_equal([s["rewardAddress"] for s in raw["proRegTx"]["shares"]], [refund1, refund2])
+        assert_equal(raw["proRegTx"]["earlyPeriodBlocks"], EARLY_PERIOD_BLOCKS)
+        assert_equal(raw["proRegTx"]["earlyPenalty"], EARLY_PENALTY)
+        assert_equal(raw["vout"][collateral_index]["scriptPubKey"]["hex"], SHARED_COLLATERAL_SCRIPT)
+
+        info = node.protx("info", protx_hash)
+        assert_equal(info["state"]["version"], 3)
+        assert_equal([s["ownerAddress"] for s in info["state"]["shares"]], [owner1, owner2])
+        assert "payoutAddress" not in info["state"]
+        assert "payouts" not in info["state"]
+
+        self.log.info("A registration with a tampered or misplaced consent signature is rejected by consensus")
+        refund_a, refund_b = node.getnewaddress(), node.getnewaddress()
+        owner_a, owner_b = node.getnewaddress(), node.getnewaddress()
+        shares_sigtest = [
+            {"amount": 600 * COIN, "refundAddress": refund_a, "ownerAddress": owner_a},
+            {"amount": 400 * COIN, "refundAddress": refund_b, "ownerAddress": owner_b},
+        ]
+        sigtest_funding = self.build_funding_tx(node)
+        sigtest_prepared = node.protx(
+            "register_shared_prepare", sigtest_funding, shares_sigtest, f"127.0.0.1:{p2p_port(4)}",
+            node.bls("generate")["public"], node.getnewaddress(), 0, EARLY_PERIOD_BLOCKS, EARLY_PENALTY)
+        sigtest_sigs = node.protx("shared_sign", sigtest_prepared["tx"])
+        assert_equal(sorted(s["shareIndex"] for s in sigtest_sigs), [0, 1])
+
+        def submit_with_sigs(sigs):
+            combined = node.protx("shared_combine", sigtest_prepared["tx"], sigs)
+            signed = node.signrawtransactionwithwallet(combined)
+            assert_equal(signed["complete"], True)
+            return node.testmempoolaccept([signed["hex"]])[0], signed["hex"]
+
+        # A single flipped bit in one consent signature must invalidate the registration
+        tampered = [dict(s) for s in sigtest_sigs]
+        raw_sig = bytearray(base64.b64decode(tampered[0]["signature"]))
+        raw_sig[10] ^= 0x01
+        tampered[0]["signature"] = base64.b64encode(bytes(raw_sig)).decode()
+        res, _ = submit_with_sigs(tampered)
+        assert_equal(res["allowed"], False)
+        assert_equal(res["reject-reason"], "bad-protx-shares-sig")
+
+        # Two valid consent signatures in each other's slots must also be rejected: each
+        # signature is verified against its own share's owner key, in share order
+        swapped = [
+            {"shareIndex": 0, "signature": sigtest_sigs[1]["signature"]},
+            {"shareIndex": 1, "signature": sigtest_sigs[0]["signature"]},
+        ]
+        res, _ = submit_with_sigs(swapped)
+        assert_equal(res["allowed"], False)
+        assert_equal(res["reject-reason"], "bad-protx-shares-sig")
+
+        # The untampered signatures in the right slots are accepted, proving the two
+        # rejections above were caused by the signatures alone
+        res, good_hex = submit_with_sigs(sigtest_sigs)
+        assert_equal(res["allowed"], True)
+
+        self.log.info("A template output that is not the declared collateral does not relay")
+        # The standardness carve-out only excuses the template script at the payload's declared
+        # collateral index; a second template output would become permanently unspendable, so
+        # policy must refuse to relay it even inside an otherwise valid shared registration
+        extra_out_tx = tx_from_hex(good_hex)
+        extra_out_tx.vout.append(CTxOut(1000, CScript(bytes.fromhex(SHARED_COLLATERAL_SCRIPT))))
+        res = node.testmempoolaccept([extra_out_tx.serialize().hex()])[0]
+        assert_equal(res["allowed"], False)
+        assert_equal(res["reject-reason"], "scriptpubkey")
+
+        self.log.info("Owner reward is split by share amounts, remainder to the last entry")
+        payees = self.owner_gbt_payees(node)
+        assert_equal([p["payee"] for p in payees], [refund1, refund2])
+        owner_total = sum(p["amount"] for p in payees)
+        assert_equal(payees[0]["amount"], owner_total * (600 * COIN) // COLLATERAL)
+        assert_equal(payees[1]["amount"], owner_total - payees[0]["amount"])
+        self.generate(node, 1, sync_fun=self.no_op)
+
+        miner_addr = node.getnewaddress()
+
+        self.log.info("A normal transaction cannot spend the shared collateral (consensus, not just policy)")
+        # The template input is anyone-can-spend at the script layer, so an empty scriptSig is a
+        # complete spend. Drive it through block connection (generateblock runs consensus, not
+        # policy) to prove the covenant rule rejects it, and specifically for that reason.
+        steal_raw = node.createrawtransaction(
+            [{"txid": protx_hash, "vout": collateral_index}], {node.getnewaddress(): 999.99})
+        assert_raises_rpc_error(-25, "bad-shared-collateral-spend", self.generateblock, node, miner_addr,
+                                [steal_raw], sync_fun=self.no_op)
+        # It is also nonstandard for relay
+        assert_equal(node.testmempoolaccept([steal_raw])[0]["allowed"], False)
+
+        self.log.info("A normal transaction cannot create a template output (consensus, not just policy)")
+        create_raw = node.createrawtransaction([], {node.getnewaddress(): 1})
+        create_funded = node.fundrawtransaction(create_raw)["hex"]
+        create_tx = tx_from_hex(create_funded)
+        create_tx.vout[0].scriptPubKey = CScript(bytes.fromhex(SHARED_COLLATERAL_SCRIPT))
+        # Sign the funding input so the only thing left to reject is the template output itself
+        create_signed = node.signrawtransactionwithwallet(create_tx.serialize().hex())
+        assert_equal(create_signed["complete"], True)
+        assert_raises_rpc_error(-25, "bad-shared-collateral-create", self.generateblock, node, miner_addr,
+                                [create_signed["hex"]], sync_fun=self.no_op)
+
+        self.log.info("A share owner can update their reward script")
+        # fee source must hold mature wallet funds (masternode rewards are still immature coinbase)
+        fee_addr = node.getnewaddress()
+        node.sendtoaddress(fee_addr, 1)
+        self.generate(node, 1, sync_fun=self.no_op)
+        reward1 = node.getnewaddress()
+        node.protx("update_share", protx_hash, 0, reward1, fee_addr)
+        self.bump_mocktime(10 * 60 + 1)
+        self.generate(node, 1, sync_fun=self.no_op)
+        info = node.protx("info", protx_hash)
+        assert_equal(info["state"]["shares"][0]["rewardAddress"], reward1)
+        payees = self.owner_gbt_payees(node)
+        assert_equal([p["payee"] for p in payees], [reward1, refund2])
+
+        self.log.info("The coinbase actually pays the share reward script while the MN is active")
+        # reward1 only ever receives coinbase owner rewards (dissolution refunds go to refund1/2),
+        # so a mined coinbase paying it proves shared rewards are really paid, not just templated.
+        reward1_script = node.getaddressinfo(reward1)["scriptPubKey"]
+        paid_reward1 = False
+        for _ in range(6):
+            self.bump_mocktime(10 * 60 + 1)
+            block_hash = self.generate(node, 1, sync_fun=self.no_op)[0]
+            coinbase = node.getblock(block_hash, 2)["tx"][0]
+            if any(o["scriptPubKey"]["hex"] == reward1_script for o in coinbase["vout"]):
+                paid_reward1 = True
+                break
+        assert paid_reward1, "shared masternode reward was never paid to the share reward script"
+
+        self.log.info("A plain ProUpRegTx cannot update a shared masternode")
+        assert_raises_rpc_error(-8, "masternode is shared", node.protx,
+                                "update_registrar", protx_hash, "", "", fee_addr)
+
+        self.log.info("A unanimous registrar update changes the voting key")
+        node.sendtoaddress(fee_addr, 1)
+        self.generate(node, 1, sync_fun=self.no_op)
+        new_voting = node.getnewaddress()
+        prepared = node.protx("update_shared_registrar_prepare", protx_hash, "", new_voting, fee_addr)
+        sigs = node.protx("shared_sign", prepared["tx"])
+        assert_equal(len(sigs), 2)
+        node.protx("shared_combine", prepared["tx"], sigs, True)
+        self.bump_mocktime(10 * 60 + 1)
+        self.generate(node, 1, sync_fun=self.no_op)
+        info = node.protx("info", protx_hash)
+        assert_equal(info["state"]["votingAddress"], new_voting)
+        # the share table is untouched
+        assert_equal([s["ownerAddress"] for s in info["state"]["shares"]], [owner1, owner2])
+
+        self.log.info("A registrar update with swapped share signatures is rejected by consensus")
+        node.sendtoaddress(fee_addr, 1)
+        self.generate(node, 1, sync_fun=self.no_op)
+        prepared = node.protx("update_shared_registrar_prepare", protx_hash, "", node.getnewaddress(), fee_addr)
+        sigs = node.protx("shared_sign", prepared["tx"])
+        assert_equal(sorted(s["shareIndex"] for s in sigs), [0, 1])
+        swapped = [
+            {"shareIndex": 0, "signature": sigs[1]["signature"]},
+            {"shareIndex": 1, "signature": sigs[0]["signature"]},
+        ]
+        assert_raises_rpc_error(None, "bad-proupsharedreg-sig", node.protx,
+                                "shared_combine", prepared["tx"], swapped, True)
+
+        self.log.info("A zero-penalty unilateral dissolution is invalid during the early period")
+        assert_raises_rpc_error(-8, "must pay the penalty", node.protx,
+                                "dissolve", protx_hash, 1, DISSOLVE_FEE, True, False)
+        standby_hex = node.protx("dissolve", protx_hash, 1, DISSOLVE_FEE, False, False)
+        standby_res = node.testmempoolaccept([standby_hex])[0]
+        assert_equal(standby_res["allowed"], False)
+        assert_equal(standby_res["reject-reason"], "bad-prodis-penalty-floor")
+
+        self.log.info("A penalty-paying unilateral dissolution succeeds during the early period")
+        registered_height = node.protx("info", protx_hash)["state"]["registeredHeight"]
+        assert_greater_than(registered_height + EARLY_PERIOD_BLOCKS, node.getblockcount() + 1)
+        dissolve_txid = node.protx("dissolve", protx_hash, 1, DISSOLVE_FEE)
+        dissolve_tx = node.getrawtransaction(dissolve_txid, 1)
+        assert_equal(dissolve_tx["proDisTx"]["proTxHash"], protx_hash)
+        assert_equal(dissolve_tx["proDisTx"]["actorIndex"], 1)
+        assert_equal(dissolve_tx["proDisTx"]["sigCount"], 1)
+        # non-actor share is refunded principal plus the entire penalty, the actor absorbs it
+        assert_equal(dissolve_tx["vout"][0]["scriptPubKey"]["address"], refund1)
+        assert_equal(int(dissolve_tx["vout"][0]["value"] * COIN), 600 * COIN + EARLY_PENALTY)
+        assert_equal(dissolve_tx["vout"][1]["scriptPubKey"]["address"], refund2)
+        assert_equal(int(dissolve_tx["vout"][1]["value"] * COIN), 400 * COIN - EARLY_PENALTY - DISSOLVE_FEE)
+        self.bump_mocktime(10 * 60 + 1)
+        self.generate(node, 1, sync_fun=self.no_op)
+        assert_raises_rpc_error(None, None, node.protx, "info", protx_hash)
+        assert_equal(node.masternodelist(), {})
+
+        self.log.info("A standby dissolution signed inside the early period is valid after it ends")
+        refund3, refund4 = node.getnewaddress(), node.getnewaddress()
+        owner3, owner4 = node.getnewaddress(), node.getnewaddress()
+        shares2 = [
+            {"amount": 500 * COIN, "refundAddress": refund3, "ownerAddress": owner3},
+            {"amount": 500 * COIN, "refundAddress": refund4, "rewardAddress": node.getnewaddress(),
+             "ownerAddress": owner4},
+        ]
+        protx_hash2, _ = self.register_shared(node, shares2, port_offset=2)
+        standby_hex = node.protx("dissolve", protx_hash2, 0, DISSOLVE_FEE, False, False)
+        assert_equal(node.testmempoolaccept([standby_hex])[0]["allowed"], False)
+        # mine past the early-period boundary; the same signed hex becomes and stays valid
+        self.bump_mocktime(10 * 60 + 1)
+        self.generate(node, EARLY_PERIOD_BLOCKS + 1, sync_fun=self.no_op)
+        assert_equal(node.testmempoolaccept([standby_hex])[0]["allowed"], True)
+
+        self.log.info("A unanimous dissolution is penalty-free")
+        prepared = node.protx("dissolve_prepare", protx_hash2, 0, DISSOLVE_FEE)
+        sigs = node.protx("shared_sign", prepared["tx"])
+        assert_equal(len(sigs), 2)
+        dissolve_txid2 = node.protx("shared_combine", prepared["tx"], sigs, True)
+        dissolve_tx2 = node.getrawtransaction(dissolve_txid2, 1)
+        assert_equal(dissolve_tx2["proDisTx"]["sigCount"], 2)
+        assert_equal(int(dissolve_tx2["vout"][0]["value"] * COIN), 500 * COIN)
+        self.bump_mocktime(10 * 60 + 1)
+        self.generate(node, 1, sync_fun=self.no_op)
+        assert_equal(node.masternodelist(), {})
+
+        self.log.info("Every participant's principal was refunded by the dissolutions")
+        # refund1/refund2 were refunded by the first MN's unilateral dissolution, refund3/refund4
+        # by the second MN's unanimous dissolution (reward receipts are checked separately above)
+        for addr in (refund1, refund2, refund3, refund4):
+            assert_greater_than(node.getreceivedbyaddress(addr, 1), Decimal(0))
+
+
+if __name__ == '__main__':
+    MasternodeSharesTest().main()
diff --git a/test/functional/test_runner.py b/test/functional/test_runner.py
index 5d5399043579..7c9815c9f01a 100755
--- a/test/functional/test_runner.py
+++ b/test/functional/test_runner.py
@@ -120,6 +120,7 @@
     'feature_dip3_deterministicmns.py --legacy-wallet', # NOTE: needs dash_hash to pass
     'feature_dip3_deterministicmns.py --descriptors', # NOTE: needs dash_hash to pass
     'feature_masternode_payout_shares.py',
+    'feature_masternode_shares.py',
     'feature_llmq_signing.py', # NOTE: needs dash_hash to pass
     'feature_llmq_signing.py --spork21', # NOTE: needs dash_hash to pass
     'feature_llmq_rotation.py', # NOTE: needs dash_hash to pass

From 2f6e09db165c4ca8e115a199ff1423e8c1ed033e Mon Sep 17 00:00:00 2001
From: Pasta <pasta@dashboost.org>
Date: Thu, 9 Jul 2026 16:41:22 -0500
Subject: [PATCH 10/20] doc: release notes for decentralized masternode shares

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
---
 doc/release-notes-7437.md | 54 +++++++++++++++++++++++++++++++++++++++
 1 file changed, 54 insertions(+)
 create mode 100644 doc/release-notes-7437.md

diff --git a/doc/release-notes-7437.md b/doc/release-notes-7437.md
new file mode 100644
index 000000000000..d514c5708768
--- /dev/null
+++ b/doc/release-notes-7437.md
@@ -0,0 +1,54 @@
+# Decentralized Masternode Shares
+
+This release implements the Decentralized Masternode Shares DIP, activating
+together with DIP-0026 multi-party payouts as part of the v24 hard fork
+(`DEPLOYMENT_V24`). Before activation there is no behavior change.
+
+## Consensus changes (active with v24)
+
+- A version 3 (extended addresses) ProRegTx may carry a collateral share table: 2 to 8 participants
+  fund the masternode collateral atomically in one registration, each recording
+  an immutable amount, refund script and share owner key, plus an updatable
+  reward script. Every participant consents by signing a digest that binds the
+  exact funding inputs, all outputs, the share table, the penalty terms and the
+  registrar configuration.
+- The shared collateral is paid to the 7-byte template script
+  `04445348437551` (`0x04 "DSHC" OP_DROP OP_TRUE`). From activation, an output
+  paying this exact script is valid only as the collateral of a valid shared
+  registration, and spending such an output is valid only via a ProDisTx.
+  Template outputs mined before activation become permanently unspendable.
+- Three new special transaction types:
+  - **ProDisTx (type 10)** dissolves a shared masternode, refunding every
+    participant's principal to its immutable refund script. Exactly one
+    signature (unilateral, penalized during the configured early period) or one
+    per share (unanimous, penalty-free). Validity is monotone: a ProDisTx that
+    is valid at some height is valid at every later height, which makes offline
+    "standby dissolutions" safe.
+  - **ProUpShareTx (type 11)** lets one share owner update their reward script.
+  - **ProUpSharedRegTx (type 12)** updates the operator key and/or voting key
+    with a signature from every share owner. A plain ProUpRegTx is invalid for
+    shared masternodes.
+- The owner reward of a shared masternode is split across the share table
+  proportionally to the recorded contributions (sequential floor, remainder to
+  the last entry), paying each share's reward script (or its refund script when
+  none is set). Operator rewards are unchanged.
+- Withdrawal (asset unlock) transactions may not pay the template script.
+
+## Relay policy changes
+
+- The template output relays only as the declared collateral output of a shared
+  registration, and a template prevout is accepted only inside a ProDisTx; both
+  remain nonstandard everywhere else.
+
+## New RPCs
+
+- `protx register_shared_prepare` builds an unsigned shared registration from a
+  caller-supplied funding transaction.
+- `protx shared_sign` signs a shared registration, dissolution or shared
+  registrar update with every share owner key the wallet holds.
+- `protx shared_combine` combines collected signatures and optionally submits.
+- `protx dissolve` creates, signs and submits a unilateral ProDisTx (or, with
+  `submit=false`, returns hex suitable for offline standby storage).
+- `protx dissolve_prepare` builds an unsigned unanimous ProDisTx.
+- `protx update_share` updates one share's reward address.
+- `protx update_shared_registrar_prepare` builds an unsigned ProUpSharedRegTx.

From a87101cae5c9dcc33418a66e2372e0cb0ee751e4 Mon Sep 17 00:00:00 2001
From: Pasta <pasta@dashboost.org>
Date: Thu, 9 Jul 2026 18:12:22 -0500
Subject: [PATCH 11/20] evo: apply shared masternode dissolution in the
 collateral-spend phase

Defer a ProDisTx's RemoveMN out of the provider-transaction loop in
RebuildListFromBlock and into the existing collateral-spend sweep, so a shared
masternode's removal happens in the same phase as every other collateral
spend. Previously the removal ran mid-loop, so a ProDisTx ordered before a
same-masternode ProUpShareTx / ProUpSharedRegTx in a block removed the
masternode before the later update was processed, failing BuildNewListFromBlock
and aborting block-template production (a miner-liveness DoS reachable by any
participant of a shared masternode). With the removal deferred, the update
always applies during the provider-transaction pass and the sweep removes the
masternode afterward, so the block is valid regardless of ordering.

The collateral-spend guard is folded into the sweep: a shared masternode's
collateral spent by anything other than a ProDisTx is still rejected. A
functional case mines a pending dissolution together with a same-masternode
update and asserts the masternode dissolves without aborting the miner.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
---
 src/evo/specialtxman.cpp                     | 26 ++++++++--------
 test/functional/feature_masternode_shares.py | 32 +++++++++++++++++++-
 2 files changed, 45 insertions(+), 13 deletions(-)

diff --git a/src/evo/specialtxman.cpp b/src/evo/specialtxman.cpp
index afcfa573d244..c311f8c7a89a 100644
--- a/src/evo/specialtxman.cpp
+++ b/src/evo/specialtxman.cpp
@@ -572,19 +572,19 @@ bool CSpecialTxProcessor::RebuildListFromBlock(const CBlock& block, gsl::not_nul
 
             // Authoritative validation: newList at this position equals the previous block's list
             // plus earlier transactions in this block, so a masternode registered and dissolved
-            // within one block is handled per the DIP
+            // within one block is handled per the DIP.
+            //
+            // The masternode is NOT removed here. Removal is deferred to the collateral-spend
+            // sweep below, exactly as an ordinary collateral spend is handled. This keeps the
+            // effect of a dissolution independent of its position among the block's other provider
+            // transactions: a same-masternode ProUpShareTx / ProUpSharedRegTx placed after the
+            // ProDisTx still applies during this pass (the masternode is still present) and only
+            // then does the sweep remove it, so the block is valid regardless of ordering.
             if (TxValidationState tx_state;
                 !CheckProDisTxForList(tx, *opt_proTx, newList, nHeight, tx_state, /*check_sigs=*/true)) {
                 return state.Invalid(BlockValidationResult::BLOCK_CONSENSUS, tx_state.GetRejectReason(),
                                      tx_state.GetDebugMessage());
             }
-
-            newList.RemoveMN(opt_proTx->proTxHash);
-
-            if (debugLogs) {
-                LogPrintf("%s -- MN %s dissolved at height %d: %s\n", __func__, opt_proTx->proTxHash.ToString(),
-                          nHeight, opt_proTx->ToString());
-            }
         } else if (tx.nType == TRANSACTION_PROVIDER_UPDATE_SHARE) {
             const auto opt_proTx = GetTxPayload<CProUpShareTx>(tx);
             if (!opt_proTx) {
@@ -685,12 +685,14 @@ bool CSpecialTxProcessor::RebuildListFromBlock(const CBlock& block, gsl::not_nul
         for (const auto& in : tx.vin) {
             auto dmn = newList.GetMNByCollateral(in.prevout);
             if (dmn && dmn->collateralOutpoint == in.prevout) {
-                if (dmn->pdmnState->IsShared()) {
-                    // Shared collateral may only be spent by a valid ProDisTx, which already
-                    // removed its masternode in the transaction loop above; any spend that still
-                    // sees a shared masternode here is not a valid dissolution
+                if (dmn->pdmnState->IsShared() && tx.nType != TRANSACTION_PROVIDER_DISSOLVE) {
+                    // Shared collateral may only be spent by a ProDisTx. Any other spender is
+                    // invalid (the ProDisTx that spends it was already validated in the loop above).
                     return state.Invalid(BlockValidationResult::BLOCK_CONSENSUS, "bad-shared-collateral-spend");
                 }
+                // A shared masternode's dissolution takes effect here, in the same collateral-spend
+                // phase as every other masternode removal, so its timing does not depend on where
+                // the ProDisTx sits among the block's other provider transactions.
                 newList.RemoveMN(dmn->proTxHash);
 
                 if (debugLogs) {
diff --git a/test/functional/feature_masternode_shares.py b/test/functional/feature_masternode_shares.py
index fdbca29f7dfd..4dff741f8e5c 100755
--- a/test/functional/feature_masternode_shares.py
+++ b/test/functional/feature_masternode_shares.py
@@ -306,10 +306,40 @@ def submit_with_sigs(sigs):
         self.generate(node, 1, sync_fun=self.no_op)
         assert_equal(node.masternodelist(), {})
 
+        self.log.info("A pending dissolution and a same-masternode update can be mined together")
+        # A ProDisTx removes the MN in the collateral-spend phase, after all other provider txs in
+        # the block are applied, so a same-MN update and the dissolution can share a block in
+        # either order. Regression guard: with the removal done mid-provider-loop instead, a block
+        # ordering the ProDisTx before the update would fail BuildNewListFromBlock and abort mining.
+        refund5, refund6 = node.getnewaddress(), node.getnewaddress()
+        owner5, owner6 = node.getnewaddress(), node.getnewaddress()
+        shares3 = [
+            {"amount": 700 * COIN, "refundAddress": refund5, "ownerAddress": owner5},
+            {"amount": 300 * COIN, "refundAddress": refund6, "ownerAddress": owner6},
+        ]
+        protx_hash3, _ = self.register_shared(node, shares3, port_offset=3)
+        fee_addr2 = node.getnewaddress()
+        node.sendtoaddress(fee_addr2, 1)
+        self.generate(node, 1, sync_fun=self.no_op)
+        # Both transactions coexist in the mempool (no false provider conflict). The dissolution
+        # pays a high feerate so the assembler tends to order it first — the ordering that used to
+        # abort BuildNewListFromBlock.
+        dissolve_txid = node.protx("dissolve", protx_hash3, 0, 500000)
+        update_txid = node.protx("update_share", protx_hash3, 1, node.getnewaddress(), fee_addr2)
+        mempool = node.getrawmempool()
+        assert dissolve_txid in mempool
+        assert update_txid in mempool
+        # Mining must not abort and must eventually confirm the dissolution (whether the pair lands
+        # in one block or the update mines first and the dissolution follows).
+        self.bump_mocktime(10 * 60 + 1)
+        self.generate(node, 2, sync_fun=self.no_op)
+        assert_equal(node.getrawmempool(), [])
+        assert_raises_rpc_error(None, None, node.protx, "info", protx_hash3)
+
         self.log.info("Every participant's principal was refunded by the dissolutions")
         # refund1/refund2 were refunded by the first MN's unilateral dissolution, refund3/refund4
         # by the second MN's unanimous dissolution (reward receipts are checked separately above)
-        for addr in (refund1, refund2, refund3, refund4):
+        for addr in (refund1, refund2, refund3, refund4, refund5, refund6):
             assert_greater_than(node.getreceivedbyaddress(addr, 1), Decimal(0))
 
 

From 1a3004199b668b65e22ab0f65cc53efdbe0876b5 Mon Sep 17 00:00:00 2001
From: Pasta <pasta@dashboost.org>
Date: Thu, 9 Jul 2026 18:39:10 -0500
Subject: [PATCH 12/20] rpc: preflight shared registration terms and document
 standby dissolutions
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

protx register_shared_prepare now runs the payload through the same stateless
validation consensus applies (IsTriviallyValid), so consensus-invalid terms —
share sums, penalty bounds, payee reuse, script types — fail immediately with
a clear error instead of after every participant has signed the consent hash
and the funding inputs are finalized.

The registration help text now points participants at the standby-dissolution
workflow the DIP recommends: create "protx dissolve <proTxHash> <shareIndex>
<fee> false" once the registration confirms and store the hex with the
refund-key backup, so a lost owner key can never strand the principal.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
---
 src/rpc/evo.cpp                              | 16 +++++++++++++++-
 test/functional/feature_masternode_shares.py | 15 +++++++++++++++
 2 files changed, 30 insertions(+), 1 deletion(-)

diff --git a/src/rpc/evo.cpp b/src/rpc/evo.cpp
index 6d6b5a7113a4..1f3b617ba465 100644
--- a/src/rpc/evo.cpp
+++ b/src/rpc/evo.cpp
@@ -2596,7 +2596,12 @@ static RPCHelpMan protx_register_shared_prepare()
         "transaction. The funding transaction must already contain every participant's contribution inputs\n"
         "and any change outputs; the consent digest binds all of them. Every share owner must sign the\n"
         "returned consent hash via \"protx shared_sign\"; combine with \"protx shared_combine\", then have the\n"
-        "funding inputs signed (signrawtransactionwithwallet) and broadcast with sendrawtransaction.\n",
+        "funding inputs signed (signrawtransactionwithwallet) and broadcast with sendrawtransaction.\n"
+        "\nIMPORTANT: once the registration confirms, every participant should create a standby dissolution\n"
+        "(\"protx dissolve <proTxHash> <shareIndex> <fee> false\") and store the returned hex with their\n"
+        "refund-key backup, separately from the share owner key. Dissolution validity is monotone, so a\n"
+        "standby never expires; if the owner key is later lost, broadcasting the standby recovers the\n"
+        "participant's principal without any other party's cooperation.\n",
         {
             {"fundingTx", RPCArg::Type::STR_HEX, RPCArg::Optional::NO, "The serialized funding transaction with all participants' inputs and change outputs."},
             {"shares", RPCArg::Type::ARR, RPCArg::Optional::NO, "The collateral share table, in consensus-significant order. Amounts must sum to the collateral.",
@@ -2683,6 +2688,15 @@ static RPCHelpMan protx_register_shared_prepare()
     ptx.vchJoinSigs.assign(ptx.shares.size(), std::vector<unsigned char>(CPubKey::COMPACT_SIGNATURE_SIZE, 0));
 
     UpdateSpecialTxInputsHash(tx, ptx);
+
+    // Preflight the payload with the same stateless rules consensus applies, so consensus-invalid
+    // terms (bad share sums, penalty bounds, payee reuse, ...) fail here with a clear error
+    // instead of after every participant has signed and the funding inputs are finalized
+    if (TxValidationState state; !ptx.IsTriviallyValid(state)) {
+        throw JSONRPCError(RPC_INVALID_PARAMETER,
+                           strprintf("invalid shared registration terms: %s", state.GetRejectReason()));
+    }
+
     SetTxPayload(tx, ptx);
 
     UniValue ret(UniValue::VOBJ);
diff --git a/test/functional/feature_masternode_shares.py b/test/functional/feature_masternode_shares.py
index 4dff741f8e5c..43e5e00904dd 100755
--- a/test/functional/feature_masternode_shares.py
+++ b/test/functional/feature_masternode_shares.py
@@ -88,6 +88,21 @@ def run_test(self):
             {"amount": 600 * COIN, "refundAddress": refund1, "ownerAddress": owner1},
             {"amount": 400 * COIN, "refundAddress": refund2, "ownerAddress": owner2},
         ]
+
+        # register_shared_prepare preflights the consensus rules so consensus-invalid terms fail
+        # before any participant signs: a share sum below the collateral, and a penalty that is
+        # not strictly below the smallest share
+        preflight_funding = self.build_funding_tx(node)
+        preflight_args = [f"127.0.0.1:{p2p_port(1)}", node.bls("generate")["public"],
+                          node.getnewaddress(), 0, EARLY_PERIOD_BLOCKS]
+        bad_shares = [dict(shares[0], amount=shares[0]["amount"] - 1), shares[1]]
+        assert_raises_rpc_error(-8, "invalid shared registration terms", node.protx,
+                                "register_shared_prepare", preflight_funding, bad_shares,
+                                *preflight_args, EARLY_PENALTY)
+        assert_raises_rpc_error(-8, "invalid shared registration terms", node.protx,
+                                "register_shared_prepare", preflight_funding, shares,
+                                *preflight_args, 400 * COIN)
+
         protx_hash, collateral_index = self.register_shared(node, shares, port_offset=1)
 
         raw = node.getrawtransaction(protx_hash, 1)

From ef371ede6486e8457a879bada2f1ba237b42d9c1 Mon Sep 17 00:00:00 2001
From: Pasta <pasta@dashboost.org>
Date: Thu, 9 Jul 2026 19:03:02 -0500
Subject: [PATCH 13/20] evo: commit the signature count into the ProDisTx
 signing digest

CProDisTx::MakeSignHash now also commits the signature count, which selects the
dissolution mode (1 = unilateral, sharesCount = unanimous). Without it, a
penalty-free unanimous dissolution (or an early-period unanimous one that
overpays the penalty) has outputs byte-identical to a valid unilateral
dissolution, so a third party could drop all signatures except the actor's and
rebroadcast a variant with the same inputs and outputs but a different txid,
invalidating a pre-signed refund spend or an actor-output CPFP child. Callers
pass the count the transaction will carry (1 for protx dissolve, sharesCount
for the dissolve_prepare/shared_sign unanimous flow); verification passes the
actual vchSigs.size(), so a mutated count no longer verifies.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
---
 src/evo/providertx.cpp          | 11 +++++++----
 src/evo/providertx.h            |  8 ++++++--
 src/evo/specialtxman.cpp        |  2 +-
 src/rpc/evo.cpp                 | 10 +++++++---
 src/test/evo_sharedmn_tests.cpp | 15 +++++++++++++--
 5 files changed, 34 insertions(+), 12 deletions(-)

diff --git a/src/evo/providertx.cpp b/src/evo/providertx.cpp
index 2712f5481a81..2dedf0e4b26a 100644
--- a/src/evo/providertx.cpp
+++ b/src/evo/providertx.cpp
@@ -423,12 +423,14 @@ std::string CProUpRevTx::ToString() const
         nVersion, proTxHash.ToString(), nReason);
 }
 
-uint256 CProDisTx::MakeSignHash(const CTransaction& tx) const
+uint256 CProDisTx::MakeSignHash(const CTransaction& tx, uint8_t sig_count) const
 {
     // The digest commits to the transaction's actual input(s) and outputs directly; the payload
-    // deliberately carries no inputsHash/outputsHash copies. Together with the empty-scriptSig
-    // rule and the low-S requirement this pins every free byte of a ProDisTx, so its txid is
-    // non-malleable by third parties.
+    // deliberately carries no inputsHash/outputsHash copies. It also commits to the signature
+    // count, which selects the dissolution mode, so a third party cannot reinterpret a penalty-free
+    // unanimous dissolution as a unilateral one (or vice versa) by dropping/adding signatures.
+    // Together with the empty-scriptSig rule and the low-S requirement this pins every free byte of
+    // a ProDisTx, so its txid is non-malleable by third parties.
     CHashWriter hw(SER_GETHASH, CLIENT_VERSION);
     hw << std::string("DashSharedMNDissolve");
     hw << nVersion;
@@ -446,6 +448,7 @@ uint256 CProDisTx::MakeSignHash(const CTransaction& tx) const
     }
     hw << proTxHash;
     hw << actorIndex;
+    hw << sig_count;
     return hw.GetHash();
 }
 
diff --git a/src/evo/providertx.h b/src/evo/providertx.h
index a1e871a17312..a0c690c91592 100644
--- a/src/evo/providertx.h
+++ b/src/evo/providertx.h
@@ -450,8 +450,12 @@ class CProDisTx
     }
 
     /** The digest every dissolution signature commits to. It covers the transaction's actual
-     *  input(s) and outputs directly, pinning every free byte of the transaction. */
-    [[nodiscard]] uint256 MakeSignHash(const CTransaction& tx) const;
+     *  input(s) and outputs directly, plus the signature count, which selects the mode
+     *  (1 = unilateral, sharesCount = unanimous). Committing the count is what stops a third party
+     *  from reinterpreting a penalty-free unanimous dissolution as a unilateral one (or vice
+     *  versa) by dropping/adding signatures, which would change the txid. Callers pass the count
+     *  the transaction will carry; verification passes the actual vchSigs.size(). */
+    [[nodiscard]] uint256 MakeSignHash(const CTransaction& tx, uint8_t sig_count) const;
 
     std::string ToString() const;
 
diff --git a/src/evo/specialtxman.cpp b/src/evo/specialtxman.cpp
index c311f8c7a89a..e0e3d1ecf175 100644
--- a/src/evo/specialtxman.cpp
+++ b/src/evo/specialtxman.cpp
@@ -1694,7 +1694,7 @@ bool CheckProDisTxForList(const CTransaction& tx, const CProDisTx& ptx, const CD
     }
 
     if (check_sigs) {
-        const uint256 sign_hash{ptx.MakeSignHash(tx)};
+        const uint256 sign_hash{ptx.MakeSignHash(tx, static_cast<uint8_t>(ptx.vchSigs.size()))};
         if (unanimous) {
             for (size_t i = 0; i < shares.size(); i++) {
                 if (std::string strError; !CHashSigner::VerifyHashCanonical(sign_hash, shares[i].keyIDOwner,
diff --git a/src/rpc/evo.cpp b/src/rpc/evo.cpp
index 1f3b617ba465..6d0741745be8 100644
--- a/src/rpc/evo.cpp
+++ b/src/rpc/evo.cpp
@@ -1597,7 +1597,9 @@ static RPCHelpMan protx_shared_sign()
             throw JSONRPCError(RPC_INVALID_PARAMETER, "shared masternode not found");
         }
         shares = dmn->pdmnState->shares;
-        sign_hash = opt_ptx->MakeSignHash(CTransaction(tx));
+        // shared_sign only ever signs unanimous dissolutions (built by dissolve_prepare); a
+        // unilateral dissolution is signed inline by "protx dissolve"
+        sign_hash = opt_ptx->MakeSignHash(CTransaction(tx), static_cast<uint8_t>(shares.size()));
     } else if (tx.nType == TRANSACTION_PROVIDER_UPDATE_SHARED_REGISTRAR) {
         const auto opt_ptx = GetTxPayload<CProUpSharedRegTx>(tx);
         if (!opt_ptx) {
@@ -1696,7 +1698,7 @@ static RPCHelpMan protx_dissolve()
                                            pay_penalty ? dmn->pdmnState->nEarlyPenalty : 0, fee, ptx);
 
     std::vector<unsigned char> vchSig;
-    if (!pwallet->SignSpecialTxPayload(ptx.MakeSignHash(CTransaction(tx)),
+    if (!pwallet->SignSpecialTxPayload(ptx.MakeSignHash(CTransaction(tx), /*sig_count=*/1),
                                        dmn->pdmnState->shares[actorIndex].keyIDOwner, vchSig)) {
         throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY,
                            "private key for the actor share's owner address not found in this wallet");
@@ -2748,7 +2750,9 @@ static RPCHelpMan protx_dissolve_prepare()
 
     UniValue ret(UniValue::VOBJ);
     ret.pushKV("tx", EncodeHexTx(CTransaction(tx)));
-    ret.pushKV("signHash", ptx.MakeSignHash(CTransaction(tx)).ToString());
+    // Unanimous dissolution: every share owner signs, so the count is the share count
+    ret.pushKV("signHash",
+               ptx.MakeSignHash(CTransaction(tx), static_cast<uint8_t>(dmn->pdmnState->shares.size())).ToString());
     return ret;
 },
     };
diff --git a/src/test/evo_sharedmn_tests.cpp b/src/test/evo_sharedmn_tests.cpp
index 5cf90b9e3685..6d6b24d89d11 100644
--- a/src/test/evo_sharedmn_tests.cpp
+++ b/src/test/evo_sharedmn_tests.cpp
@@ -599,7 +599,8 @@ struct ProDisTestSetup {
 
     void Sign(const CMutableTransaction& tx, CProDisTx& ptx, bool unanimous) const
     {
-        const uint256 hash = ptx.MakeSignHash(CTransaction(tx));
+        const uint8_t sig_count{unanimous ? static_cast<uint8_t>(std::size(owner_keys)) : uint8_t{1}};
+        const uint256 hash = ptx.MakeSignHash(CTransaction(tx), sig_count);
         ptx.vchSigs.clear();
         if (unanimous) {
             for (const auto& key : owner_keys) {
@@ -707,7 +708,7 @@ BOOST_AUTO_TEST_CASE(prodis_validation)
         CProDisTx ptx;
         auto tx = t.BuildTx(2, ProDisTestSetup::PENALTY, false, ptx);
         std::vector<unsigned char> sig;
-        BOOST_REQUIRE(CHashSigner::SignHash(ptx.MakeSignHash(CTransaction(tx)), t.owner_keys[0], sig));
+        BOOST_REQUIRE(CHashSigner::SignHash(ptx.MakeSignHash(CTransaction(tx), /*sig_count=*/1), t.owner_keys[0], sig));
         ptx.vchSigs = {sig};
         t.Check(tx, ptx, IN_EARLY, "bad-prodis-sig");
     }
@@ -718,6 +719,16 @@ BOOST_AUTO_TEST_CASE(prodis_validation)
         std::swap(ptx.vchSigs[0], ptx.vchSigs[1]);
         t.Check(tx, ptx, IN_EARLY, "bad-prodis-sig");
     }
+    // Non-malleable mode: a penalty-free unanimous dissolution cannot be stripped to just the
+    // actor's signature and re-interpreted as unilateral. Outputs are byte-identical to a valid
+    // unilateral penalty-free dissolution, but the retained signature committed to sigCount=3, so
+    // verifying it as a 1-signature transaction (which recomputes the digest with sigCount=1) fails.
+    {
+        CProDisTx ptx;
+        auto tx = t.BuildTx(0, 0, true, ptx); // unanimous, penalty 0, actor 0
+        ptx.vchSigs = {ptx.vchSigs[0]};       // keep only the actor share's signature
+        t.Check(tx, ptx, AFTER_EARLY, "bad-prodis-sig");
+    }
     // Redirected refund output
     {
         CProDisTx ptx;

From c34070131d7ceeb76d56fb966040d0348003e45d Mon Sep 17 00:00:00 2001
From: Pasta <pasta@dashboost.org>
Date: Thu, 9 Jul 2026 19:03:23 -0500
Subject: [PATCH 14/20] mempool: guard removeProTxKeyChangedConflicts against
 already-removed entries

The eviction loop dereferenced mapTx.find(txHash) without checking for end().
If two stale provider updates for one masternode form a parent/child chain,
removeRecursive() on the parent also evicts the child, so the child's saved
hash then resolves to mapTx.end() and dereferencing it can crash the node.
This is a pre-existing hazard in the conflict-eviction path (surfaced while
reviewing the shared-masternode changes to this function); guard the lookup and
skip entries already gone.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
---
 src/txmempool.cpp | 10 ++++++++--
 1 file changed, 8 insertions(+), 2 deletions(-)

diff --git a/src/txmempool.cpp b/src/txmempool.cpp
index f18d5ee10a4d..f72834b7a89e 100644
--- a/src/txmempool.cpp
+++ b/src/txmempool.cpp
@@ -1065,8 +1065,14 @@ void CTxMemPool::removeProTxKeyChangedConflicts(const CTransaction &tx, const ui
         }
     }
     for (const auto& txHash : conflictingTxs) {
-        auto& tx = mapTx.find(txHash)->GetTx();
-        removeRecursive(tx, MemPoolRemovalReason::CONFLICT);
+        // An earlier removeRecursive() may have already evicted this entry as a descendant of a
+        // previously-processed conflict, so it can be absent here; dereferencing mapTx.end() would
+        // crash. (Pre-existing hazard; guarded here to be safe.)
+        auto it = mapTx.find(txHash);
+        if (it == mapTx.end()) {
+            continue;
+        }
+        removeRecursive(it->GetTx(), MemPoolRemovalReason::CONFLICT);
     }
 }
 

From 0c15a430a6f1b139796dc3397280cb428c625ba4 Mon Sep 17 00:00:00 2001
From: pasta <pasta@dashboost.org>
Date: Sat, 1 Aug 2026 13:29:53 -0500
Subject: [PATCH 15/20] evo: disallow same-block registration and dissolution
 of a shared masternode

A ProDisTx whose masternode is not in the previous block's list is now
invalid in blocks exactly as it always was in the mempool. The mempool
could never hold a dissolution for an unconfirmed registration anyway
(the masternode is not in the list yet), so no miner could assemble the
pair from normal operation; only a hand-crafted block could, and a
standby dissolution simply becomes valid one block after registration.

Everything a dissolution is validated against (refund scripts, amounts,
registration height) is immutable after registration, so the
pindexPrev-based check in CheckProDisTx is complete and blocks need no
re-validation against the evolving list. This deletes the
SpecialTxContext plumbing and the RebuildListFromBlock re-check, and
dissolution signatures are now verified exactly once per block, gated by
the same check_sigs flag as every other provider transaction (they were
previously verified twice for fresh blocks, and unconditionally during
sync where other types skip them).

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
---
 src/evo/specialtxman.cpp | 44 ++++++++++------------------------------
 src/evo/specialtxman.h   | 17 ++++------------
 2 files changed, 15 insertions(+), 46 deletions(-)

diff --git a/src/evo/specialtxman.cpp b/src/evo/specialtxman.cpp
index e0e3d1ecf175..bf1afe7cdf25 100644
--- a/src/evo/specialtxman.cpp
+++ b/src/evo/specialtxman.cpp
@@ -182,7 +182,7 @@ bool CheckCbTxBestChainlock(const CCbTx& cbTx, const CBlockIndex* pindex, const
 static bool CheckSpecialTxInner(CDeterministicMNManager& dmnman, llmq::CQuorumSnapshotManager& qsnapman,
                                 const ChainstateManager& chainman, const llmq::CQuorumManager& qman,
                                 const CTransaction& tx, const CBlockIndex* pindexPrev, const CCoinsViewCache& view,
-                                const std::optional<CRangesSet>& indexes, bool check_sigs, SpecialTxContext context,
+                                const std::optional<CRangesSet>& indexes, bool check_sigs,
                                 TxValidationState& state) EXCLUSIVE_LOCKS_REQUIRED(::cs_main)
 {
     AssertLockHeld(::cs_main);
@@ -205,7 +205,7 @@ static bool CheckSpecialTxInner(CDeterministicMNManager& dmnman, llmq::CQuorumSn
         case TRANSACTION_PROVIDER_UPDATE_REVOKE:
             return CheckProUpRevTx(tx, pindexPrev, dmnman, chainman, state, check_sigs);
         case TRANSACTION_PROVIDER_DISSOLVE:
-            return CheckProDisTx(tx, pindexPrev, dmnman, chainman, state, check_sigs, context);
+            return CheckProDisTx(tx, pindexPrev, dmnman, chainman, state, check_sigs);
         case TRANSACTION_PROVIDER_UPDATE_SHARE:
             return CheckProUpShareTx(tx, pindexPrev, dmnman, chainman, state, check_sigs);
         case TRANSACTION_PROVIDER_UPDATE_SHARED_REGISTRAR:
@@ -241,7 +241,7 @@ bool CSpecialTxProcessor::CheckSpecialTx(const CTransaction& tx, const CBlockInd
 {
     AssertLockHeld(::cs_main);
     return CheckSpecialTxInner(m_dmnman, m_qsnapman, m_chainman, m_qman, tx, pindexPrev, view, std::nullopt, check_sigs,
-                               SpecialTxContext::Mempool, state);
+                               state);
 }
 
 static void HandleQuorumCommitment(const llmq::CFinalCommitment& qc, const std::vector<CDeterministicMNCPtr>& members,
@@ -564,27 +564,6 @@ bool CSpecialTxProcessor::RebuildListFromBlock(const CBlock& block, gsl::not_nul
                 LogPrintf("%s -- MN %s revoked operator key at height %d: %s\n", __func__,
                           opt_proTx->proTxHash.ToString(), nHeight, opt_proTx->ToString());
             }
-        } else if (tx.nType == TRANSACTION_PROVIDER_DISSOLVE) {
-            const auto opt_proTx = GetTxPayload<CProDisTx>(tx);
-            if (!opt_proTx) {
-                return state.Invalid(BlockValidationResult::BLOCK_CONSENSUS, "bad-protx-payload");
-            }
-
-            // Authoritative validation: newList at this position equals the previous block's list
-            // plus earlier transactions in this block, so a masternode registered and dissolved
-            // within one block is handled per the DIP.
-            //
-            // The masternode is NOT removed here. Removal is deferred to the collateral-spend
-            // sweep below, exactly as an ordinary collateral spend is handled. This keeps the
-            // effect of a dissolution independent of its position among the block's other provider
-            // transactions: a same-masternode ProUpShareTx / ProUpSharedRegTx placed after the
-            // ProDisTx still applies during this pass (the masternode is still present) and only
-            // then does the sweep remove it, so the block is valid regardless of ordering.
-            if (TxValidationState tx_state;
-                !CheckProDisTxForList(tx, *opt_proTx, newList, nHeight, tx_state, /*check_sigs=*/true)) {
-                return state.Invalid(BlockValidationResult::BLOCK_CONSENSUS, tx_state.GetRejectReason(),
-                                     tx_state.GetDebugMessage());
-            }
         } else if (tx.nType == TRANSACTION_PROVIDER_UPDATE_SHARE) {
             const auto opt_proTx = GetTxPayload<CProUpShareTx>(tx);
             if (!opt_proTx) {
@@ -819,7 +798,7 @@ bool CSpecialTxProcessor::ProcessSpecialTxsInBlock(const CBlock& block, const CB
             // At this moment CheckSpecialTx() may fail by 2 possible ways:
             // consensus failures and "TX_BAD_SPECIAL"
             if (!CheckSpecialTxInner(m_dmnman, m_qsnapman, m_chainman, m_qman, *ptr_tx, pindex->pprev, view, indexes,
-                                     fCheckCbTxMerkleRoots, SpecialTxContext::Block, tx_state)) {
+                                     fCheckCbTxMerkleRoots, tx_state)) {
                 assert(tx_state.GetResult() == TxValidationResult::TX_CONSENSUS || tx_state.GetResult() == TxValidationResult::TX_BAD_SPECIAL);
                 return state.Invalid(BlockValidationResult::BLOCK_CONSENSUS, tx_state.GetRejectReason(),
                                  strprintf("Special Transaction check failed (tx hash %s) %s", ptr_tx->GetHash().ToString(), tx_state.GetDebugMessage()));
@@ -1715,7 +1694,7 @@ bool CheckProDisTxForList(const CTransaction& tx, const CProDisTx& ptx, const CD
 
 bool CheckProDisTx(const CTransaction& tx, gsl::not_null<const CBlockIndex*> pindexPrev,
                    CDeterministicMNManager& dmnman, const ChainstateManager& chainman, TxValidationState& state,
-                   bool check_sigs, SpecialTxContext context)
+                   bool check_sigs)
 {
     const auto opt_ptx = GetValidatedPayload<CProDisTx>(tx, pindexPrev, chainman, state);
     if (!opt_ptx) {
@@ -1726,15 +1705,14 @@ bool CheckProDisTx(const CTransaction& tx, gsl::not_null<const CBlockIndex*> pin
         return state.Invalid(TxValidationResult::TX_CONSENSUS, "bad-prodis-too-early");
     }
 
+    // The masternode must exist at the previous block: registering and dissolving a shared
+    // masternode in the same block is deliberately invalid (as is any same-block
+    // ProUpShareTx/ProUpSharedRegTx for a just-registered masternode). Everything a dissolution
+    // is validated against (refund scripts, amounts, registration height) is immutable after
+    // registration, so this pindexPrev-based check is complete and blocks need no re-validation
+    // against the evolving list.
     const auto mnList = dmnman.GetListForBlock(pindexPrev);
     if (!mnList.GetMN(opt_ptx->proTxHash)) {
-        if (context == SpecialTxContext::Block) {
-            // The masternode may have been registered earlier in the same block, which this
-            // pindexPrev-based list cannot see. RebuildListFromBlock performs the authoritative
-            // check against the evolving list and rejects the block if the masternode is still
-            // unknown at the transaction's position.
-            return true;
-        }
         return state.Invalid(TxValidationResult::TX_BAD_SPECIAL, "bad-prodis-hash");
     }
     return CheckProDisTxForList(tx, *opt_ptx, mnList, pindexPrev->nHeight + 1, state, check_sigs);
diff --git a/src/evo/specialtxman.h b/src/evo/specialtxman.h
index e5ad1d5c4c4a..bb07bb9131c3 100644
--- a/src/evo/specialtxman.h
+++ b/src/evo/specialtxman.h
@@ -27,14 +27,6 @@ class CMNHFManager;
 class TxValidationState;
 struct MNListUpdates;
 
-/** Where a special transaction is being validated. Some checks (currently only ProDisTx) must
- *  defer to RebuildListFromBlock in block context because the referenced masternode may have been
- *  registered earlier in the same block. */
-enum class SpecialTxContext : uint8_t {
-    Mempool,
-    Block,
-};
-
 namespace chainlock {
 class Chainlocks;
 }
@@ -127,17 +119,16 @@ bool CheckProUpRegTx(const CTransaction& tx, gsl::not_null<const CBlockIndex*> p
 bool CheckProUpRevTx(const CTransaction& tx, gsl::not_null<const CBlockIndex*> pindexPrev, CDeterministicMNManager& dmnman,
                      const ChainstateManager& chainman, TxValidationState& state, bool check_sigs);
 bool CheckProDisTx(const CTransaction& tx, gsl::not_null<const CBlockIndex*> pindexPrev, CDeterministicMNManager& dmnman,
-                   const ChainstateManager& chainman, TxValidationState& state, bool check_sigs,
-                   SpecialTxContext context);
+                   const ChainstateManager& chainman, TxValidationState& state, bool check_sigs);
 bool CheckProUpShareTx(const CTransaction& tx, gsl::not_null<const CBlockIndex*> pindexPrev,
                        CDeterministicMNManager& dmnman, const ChainstateManager& chainman, TxValidationState& state,
                        bool check_sigs);
 bool CheckProUpSharedRegTx(const CTransaction& tx, gsl::not_null<const CBlockIndex*> pindexPrev,
                            CDeterministicMNManager& dmnman, const ChainstateManager& chainman,
                            TxValidationState& state, bool check_sigs);
-/** Full ProDisTx validation against a given masternode list and spend height. Used by mempool
- *  validation (tip list, tip height + 1) and by RebuildListFromBlock (the evolving list, which
- *  includes masternodes registered earlier in the same block, per the DIP). */
+/** Full ProDisTx validation against a given masternode list and spend height. The masternode must
+ *  already be in the list at the previous block: registering and dissolving a shared masternode in
+ *  the same block is deliberately invalid, which lets block validation reuse the mempool path. */
 bool CheckProDisTxForList(const CTransaction& tx, const CProDisTx& ptx, const CDeterministicMNList& mnList,
                           int nSpendHeight, TxValidationState& state, bool check_sigs);
 

From 31936dfc1070b7923bc342a3ac7f3f143b5ee4c4 Mon Sep 17 00:00:00 2001
From: pasta <pasta@dashboost.org>
Date: Sat, 1 Aug 2026 15:26:52 -0500
Subject: [PATCH 16/20] rpc: fail clearly when special transaction inputs
 cannot be signed at submit time

SignAndSendSpecialTx ignored the completeness of the wallet signing
step, so submitting a transaction whose inputs this wallet cannot sign
died later in the mempool with an opaque script-verification error
("Operation not valid with the current stack size"). Check the signing
result and fail with the actual cause and the recovery path instead.

The typical way to hit this is running "protx shared_combine" for a
ProUpSharedRegTx on a wallet other than the one that ran
update_shared_registrar_prepare: combining inserts the share signatures
into the payload, which invalidates the prepare-time fee-input
signatures, and only the preparing wallet can re-sign them. Document
that wallet affinity in both RPCs' help text.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
---
 src/rpc/evo.cpp | 28 ++++++++++++++++++++++++++--
 1 file changed, 26 insertions(+), 2 deletions(-)

diff --git a/src/rpc/evo.cpp b/src/rpc/evo.cpp
index 6d0741745be8..702363f1d5a1 100644
--- a/src/rpc/evo.cpp
+++ b/src/rpc/evo.cpp
@@ -596,6 +596,25 @@ static std::string SignAndSendSpecialTx(const JSONRPCRequest& request, CChainsta
         return signResult["hex"].get_str();
     }
 
+    // Submitting a partially signed transaction would only fail later in the mempool with an
+    // opaque script-verification error, so fail here with the actual cause. The typical way to
+    // hit this is running "protx shared_combine" on a wallet other than the one whose coins fund
+    // the transaction: combining changes the payload, which invalidates the fee-input signatures,
+    // and only the funding wallet can re-sign them.
+    if (!signResult["complete"].get_bool()) {
+        std::string sign_errors;
+        if (const UniValue& errors = signResult["errors"]; errors.isArray()) {
+            for (const auto& err : errors.getValues()) {
+                if (!sign_errors.empty()) sign_errors += ", ";
+                sign_errors += err["error"].get_str();
+            }
+        }
+        throw JSONRPCError(RPC_WALLET_ERROR,
+                           strprintf("transaction inputs could not be fully signed by this wallet; run this "
+                                     "command on the wallet that funded the transaction, or finish signing "
+                                     "there with signrawtransactionwithwallet (%s)", sign_errors));
+    }
+
     JSONRPCRequest sendRequest(request);
     sendRequest.params.setArray();
     sendRequest.params.push_back(signResult["hex"].get_str());
@@ -1795,7 +1814,9 @@ static RPCHelpMan protx_update_shared_registrar_prepare()
     return RPCHelpMan{"protx update_shared_registrar_prepare",
         "\nCreates an unsigned ProUpSharedRegTx updating a shared masternode's operator key and/or voting\n"
         "key. Fee inputs from this wallet are added and signed. Every share owner must then sign the\n"
-        "returned transaction with \"protx shared_sign\"; combine the signatures with \"protx shared_combine\".\n"
+        "returned transaction with \"protx shared_sign\"; combine the signatures with \"protx shared_combine\"\n"
+        "on this same wallet (combining invalidates the fee-input signatures, which only this wallet can\n"
+        "re-sign).\n"
         + HELP_REQUIRING_PASSPHRASE,
         {
             {"proTxHash", RPCArg::Type::STR_HEX, RPCArg::Optional::NO, "The hash of the initial ProRegTx."},
@@ -1868,7 +1889,10 @@ static RPCHelpMan protx_shared_combine()
         "\nCombines share owner signatures produced by \"protx shared_sign\" into a shared masternode\n"
         "transaction. For a shared ProRegTx the completed transaction hex is returned and the funding\n"
         "inputs still have to be signed (e.g. by passing the result around signrawtransactionwithwallet).\n"
-        "For a ProDisTx or ProUpSharedRegTx the transaction can be submitted directly.\n",
+        "For a ProDisTx or ProUpSharedRegTx the transaction can be submitted directly. Submit a\n"
+        "ProUpSharedRegTx from the wallet that ran \"protx update_shared_registrar_prepare\": combining\n"
+        "re-signs its fee inputs, which only that wallet can do (with submit=false the returned hex can\n"
+        "be finished there with signrawtransactionwithwallet).\n",
         {
             {"tx", RPCArg::Type::STR_HEX, RPCArg::Optional::NO, "The serialized transaction in hex format."},
             {"signatures", RPCArg::Type::ARR, RPCArg::Optional::NO, "Signature entries collected from \"protx shared_sign\".",

From 0e5941d5d40a6fb876d4356d0a2c329d863f9f66 Mon Sep 17 00:00:00 2001
From: pasta <pasta@dashboost.org>
Date: Sat, 1 Aug 2026 15:36:06 -0500
Subject: [PATCH 17/20] test: filter matching and reorg coverage for shared
 masternodes

Unit: bloom filters match a shared registration on every share's
refund script, effective reward script and share owner key id, and the
lifecycle transactions (ProDisTx, ProUpShareTx, ProUpSharedRegTx) on
proTxHash plus their own new elements; BLOOM_UPDATE_ALL inserts the
proTxHash on a registration or reward-script match so a watcher follows
the masternode lifecycle automatically. Compact-filter element
extraction is checked against the same field set, guarding the sync
requirement between CheckSpecialTransactionMatchesAndUpdate and
ExtractSpecialTxFilterElements.

Functional: disconnecting a block containing a ProUpShareTx rolls the
share table back and reconnecting replays it; disconnecting a
dissolution restores the masternode with an identical share table and
registration height and returns the ProDisTx to the mempool (where the
restored masternode makes it valid again), and reconnecting removes
both.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
---
 src/test/evo_sharedmn_tests.cpp              | 148 +++++++++++++++++++
 test/functional/feature_masternode_shares.py |  45 +++++-
 2 files changed, 192 insertions(+), 1 deletion(-)

diff --git a/src/test/evo_sharedmn_tests.cpp b/src/test/evo_sharedmn_tests.cpp
index 6d6b24d89d11..bf9f686e545d 100644
--- a/src/test/evo_sharedmn_tests.cpp
+++ b/src/test/evo_sharedmn_tests.cpp
@@ -9,10 +9,13 @@
 #include <evo/dmnstate.h>
 #include <evo/providertx.h>
 #include <evo/sharedcollateral.h>
+#include <evo/specialtx.h>
+#include <evo/specialtx_filter.h>
 #include <evo/specialtxman.h>
 
 #include <arith_uint256.h>
 #include <clientversion.h>
+#include <common/bloom.h>
 #include <key.h>
 #include <messagesigner.h>
 #include <policy/policy.h>
@@ -773,4 +776,149 @@ BOOST_AUTO_TEST_CASE(prodis_validation)
     }
 }
 
+BOOST_AUTO_TEST_CASE(shared_tx_filter_matching)
+{
+    CKey refund_keys[2], owner_keys[2], reward_key, voting_key, new_voting_key;
+    voting_key.MakeNewKey(true);
+    new_voting_key.MakeNewKey(true);
+
+    CProRegTx proTx;
+    proTx.nVersion = ProTxVersion::ExtAddr;
+    proTx.netInfo = NetInfoInterface::MakeNetInfo(proTx.nVersion);
+    proTx.keyIDVoting = voting_key.GetPubKey().GetID();
+    proTx.collateralOutpoint = COutPoint(uint256(), 0);
+    proTx.shares.push_back(NewShare(600 * COIN, refund_keys[0], owner_keys[0]));
+    proTx.shares.push_back(NewShare(400 * COIN, refund_keys[1], owner_keys[1]));
+    proTx.shares[1].scriptReward = NewP2PKHScript(reward_key);
+    proTx.vchJoinSigs = DummyJoinSigs(2);
+
+    CMutableTransaction reg_mtx;
+    reg_mtx.nVersion = 3;
+    reg_mtx.nType = TRANSACTION_PROVIDER_REGISTER;
+    reg_mtx.vin.emplace_back(COutPoint(GetRandHash(), 0));
+    reg_mtx.vout.emplace_back(dmn_types::Regular.collat_amount, sharedcollateral::SharedCollateralScript());
+    SetTxPayload(reg_mtx, proTx);
+    const CTransaction reg_tx(reg_mtx);
+
+    const auto hash_vec = [](const auto& h) { return std::vector<unsigned char>(h.begin(), h.end()); };
+    const auto script_vec = [](const CScript& script) { return std::vector<unsigned char>(script.begin(), script.end()); };
+    // Fresh single-element filter each time so one match cannot bleed into the next check
+    const auto matches = [](const CTransaction& tx, const std::vector<unsigned char>& element) {
+        CBloomFilter filter(20, 0.001, 0, BLOOM_UPDATE_NONE);
+        filter.insert(element);
+        return filter.IsRelevantAndUpdate(tx);
+    };
+
+    // A registration matches on every share's refund script, effective reward script and owner
+    // key id, so a light client sees the formation whichever of its own elements it watches
+    for (size_t i = 0; i < proTx.shares.size(); i++) {
+        BOOST_CHECK(matches(reg_tx, hash_vec(refund_keys[i].GetPubKey().GetID())));
+        BOOST_CHECK(matches(reg_tx, hash_vec(proTx.shares[i].keyIDOwner)));
+    }
+    BOOST_CHECK(matches(reg_tx, hash_vec(reward_key.GetPubKey().GetID())));
+    BOOST_CHECK(!matches(reg_tx, hash_vec(GetRandHash())));
+
+    // The lifecycle transactions are matched by proTxHash. With BLOOM_UPDATE_ALL, matching the
+    // registration inserts its hash, so an owner-key watcher follows the lifecycle automatically.
+    const uint256 protx_hash = reg_tx.GetHash();
+
+    CProDisTx dis;
+    dis.proTxHash = protx_hash;
+    dis.actorIndex = 0;
+    dis.vchSigs = DummyJoinSigs(1);
+    CMutableTransaction dis_mtx;
+    dis_mtx.nVersion = 3;
+    dis_mtx.nType = TRANSACTION_PROVIDER_DISSOLVE;
+    dis_mtx.vin.emplace_back(COutPoint(protx_hash, 0));
+    dis_mtx.vout.emplace_back(400 * COIN, proTx.shares[1].scriptRefund);
+    SetTxPayload(dis_mtx, dis);
+    const CTransaction dis_tx(dis_mtx);
+
+    {
+        CBloomFilter filter(20, 0.001, 0, BLOOM_UPDATE_ALL);
+        filter.insert(hash_vec(proTx.shares[0].keyIDOwner));
+        BOOST_CHECK(!filter.contains(protx_hash));
+        BOOST_CHECK(filter.IsRelevantAndUpdate(reg_tx));
+        BOOST_CHECK(filter.contains(protx_hash));
+        BOOST_CHECK(filter.IsRelevantAndUpdate(dis_tx));
+    }
+    BOOST_CHECK(matches(dis_tx, hash_vec(protx_hash)));
+    // A dissolution's refund payments are ordinary outputs, matched by the base output loop
+    BOOST_CHECK(matches(dis_tx, hash_vec(refund_keys[1].GetPubKey().GetID())));
+    BOOST_CHECK(!matches(dis_tx, hash_vec(GetRandHash())));
+
+    CKey new_reward_key;
+    CProUpShareTx upshare;
+    upshare.proTxHash = protx_hash;
+    upshare.shareIndex = 0;
+    upshare.scriptReward = NewP2PKHScript(new_reward_key);
+    CMutableTransaction upshare_mtx;
+    upshare_mtx.nVersion = 3;
+    upshare_mtx.nType = TRANSACTION_PROVIDER_UPDATE_SHARE;
+    upshare_mtx.vin.emplace_back(COutPoint(GetRandHash(), 0));
+    SetTxPayload(upshare_mtx, upshare);
+    const CTransaction upshare_tx(upshare_mtx);
+
+    BOOST_CHECK(matches(upshare_tx, hash_vec(protx_hash)));
+    BOOST_CHECK(matches(upshare_tx, hash_vec(new_reward_key.GetPubKey().GetID())));
+    BOOST_CHECK(!matches(upshare_tx, hash_vec(GetRandHash())));
+    {
+        // A reward-script match inserts the proTxHash so the watcher keeps following the MN
+        CBloomFilter filter(20, 0.001, 0, BLOOM_UPDATE_ALL);
+        filter.insert(hash_vec(new_reward_key.GetPubKey().GetID()));
+        BOOST_CHECK(!filter.contains(protx_hash));
+        BOOST_CHECK(filter.IsRelevantAndUpdate(upshare_tx));
+        BOOST_CHECK(filter.contains(protx_hash));
+    }
+
+    CProUpSharedRegTx upreg;
+    upreg.proTxHash = protx_hash;
+    upreg.pubKeyOperator.Set(CBLSPublicKey(), /*specificLegacyScheme=*/false);
+    upreg.keyIDVoting = new_voting_key.GetPubKey().GetID();
+    upreg.vchSigs = DummyJoinSigs(2);
+    CMutableTransaction upreg_mtx;
+    upreg_mtx.nVersion = 3;
+    upreg_mtx.nType = TRANSACTION_PROVIDER_UPDATE_SHARED_REGISTRAR;
+    upreg_mtx.vin.emplace_back(COutPoint(GetRandHash(), 0));
+    SetTxPayload(upreg_mtx, upreg);
+    const CTransaction upreg_tx(upreg_mtx);
+
+    BOOST_CHECK(matches(upreg_tx, hash_vec(protx_hash)));
+    BOOST_CHECK(matches(upreg_tx, hash_vec(upreg.keyIDVoting)));
+    BOOST_CHECK(!matches(upreg_tx, hash_vec(GetRandHash())));
+
+    // Compact filters must extract the same fields (see the sync note in specialtx_filter.cpp)
+    const auto extract = [](const CTransaction& tx) {
+        std::vector<std::vector<unsigned char>> ret;
+        ExtractSpecialTxFilterElements(tx, [&](Span<const unsigned char> e) { ret.emplace_back(e.begin(), e.end()); });
+        return ret;
+    };
+    const auto has = [](const std::vector<std::vector<unsigned char>>& elements, const std::vector<unsigned char>& v) {
+        return std::find(elements.begin(), elements.end(), v) != elements.end();
+    };
+
+    {
+        const auto elements = extract(reg_tx);
+        for (size_t i = 0; i < proTx.shares.size(); i++) {
+            BOOST_CHECK(has(elements, script_vec(proTx.shares[i].scriptRefund)));
+            BOOST_CHECK(has(elements, script_vec(proTx.shares[i].RewardScript())));
+            BOOST_CHECK(has(elements, hash_vec(proTx.shares[i].keyIDOwner)));
+        }
+    }
+    {
+        const auto elements = extract(dis_tx);
+        BOOST_CHECK(has(elements, hash_vec(protx_hash)));
+    }
+    {
+        const auto elements = extract(upshare_tx);
+        BOOST_CHECK(has(elements, hash_vec(protx_hash)));
+        BOOST_CHECK(has(elements, script_vec(upshare.scriptReward)));
+    }
+    {
+        const auto elements = extract(upreg_tx);
+        BOOST_CHECK(has(elements, hash_vec(protx_hash)));
+        BOOST_CHECK(has(elements, hash_vec(upreg.keyIDVoting)));
+    }
+}
+
 BOOST_AUTO_TEST_SUITE_END()
diff --git a/test/functional/feature_masternode_shares.py b/test/functional/feature_masternode_shares.py
index 43e5e00904dd..7fccfc784aa7 100755
--- a/test/functional/feature_masternode_shares.py
+++ b/test/functional/feature_masternode_shares.py
@@ -351,10 +351,53 @@ def submit_with_sigs(sigs):
         assert_equal(node.getrawmempool(), [])
         assert_raises_rpc_error(None, None, node.protx, "info", protx_hash3)
 
+        self.log.info("A reorg across a share update reverts the share table")
+        refund7, refund8 = node.getnewaddress(), node.getnewaddress()
+        owner7, owner8 = node.getnewaddress(), node.getnewaddress()
+        shares4 = [
+            {"amount": 800 * COIN, "refundAddress": refund7, "ownerAddress": owner7},
+            {"amount": 200 * COIN, "refundAddress": refund8, "ownerAddress": owner8},
+        ]
+        protx_hash4, _ = self.register_shared(node, shares4, port_offset=5)
+        registered_height4 = node.protx("info", protx_hash4)["state"]["registeredHeight"]
+
+        fee_addr3 = node.getnewaddress()
+        node.sendtoaddress(fee_addr3, 1)
+        self.generate(node, 1, sync_fun=self.no_op)
+        reward7 = node.getnewaddress()
+        node.protx("update_share", protx_hash4, 0, reward7, fee_addr3)
+        self.bump_mocktime(10 * 60 + 1)
+        update_block = self.generate(node, 1, sync_fun=self.no_op)[0]
+        assert_equal(node.protx("info", protx_hash4)["state"]["shares"][0]["rewardAddress"], reward7)
+        # disconnecting the block must roll the deterministic list state back to the refund
+        # fallback, and reconnecting must replay the update
+        node.invalidateblock(update_block)
+        assert_equal(node.protx("info", protx_hash4)["state"]["shares"][0]["rewardAddress"], refund7)
+        node.reconsiderblock(update_block)
+        assert_equal(node.protx("info", protx_hash4)["state"]["shares"][0]["rewardAddress"], reward7)
+
+        self.log.info("A reorg across a dissolution restores the masternode and its shares")
+        info_before_dissolve = node.protx("info", protx_hash4)
+        dissolve_txid4 = node.protx("dissolve", protx_hash4, 0, DISSOLVE_FEE)
+        self.bump_mocktime(10 * 60 + 1)
+        dissolve_block = self.generate(node, 1, sync_fun=self.no_op)[0]
+        assert_raises_rpc_error(None, None, node.protx, "info", protx_hash4)
+        node.invalidateblock(dissolve_block)
+        info_restored = node.protx("info", protx_hash4)
+        assert_equal(info_restored["state"]["shares"], info_before_dissolve["state"]["shares"])
+        assert_equal(info_restored["state"]["registeredHeight"], registered_height4)
+        # the disconnected dissolution returns to the mempool: the restored masternode makes it
+        # valid again, so it is not lost by the reorg
+        assert dissolve_txid4 in node.getrawmempool()
+        node.reconsiderblock(dissolve_block)
+        assert_raises_rpc_error(None, None, node.protx, "info", protx_hash4)
+        assert dissolve_txid4 not in node.getrawmempool()
+        assert_equal(node.masternodelist(), {})
+
         self.log.info("Every participant's principal was refunded by the dissolutions")
         # refund1/refund2 were refunded by the first MN's unilateral dissolution, refund3/refund4
         # by the second MN's unanimous dissolution (reward receipts are checked separately above)
-        for addr in (refund1, refund2, refund3, refund4, refund5, refund6):
+        for addr in (refund1, refund2, refund3, refund4, refund5, refund6, refund7, refund8):
             assert_greater_than(node.getreceivedbyaddress(addr, 1), Decimal(0))
 
 

From 3a827dbb52aabd0aa2ec063a18aa8b02e1377e4d Mon Sep 17 00:00:00 2001
From: pasta <pasta@dashboost.org>
Date: Sat, 1 Aug 2026 16:06:32 -0500
Subject: [PATCH 18/20] test: cover shared masternode revival and
 pre-activation rejection

The vbparams start time rendered as 0 (self.mocktime is unset when set_test_params runs) and the min_activation_height of 100 falls inside the ~119 blocks the framework setup mines, so v24 was already active when run_test began and activate_v24() was a silent no-op: no pre-activation behavior was ever exercised. Raise the earliest activation height to 250 and assert the pre-activation window actually exists.

New coverage: each lifecycle transaction type (ProDisTx, ProUpShareTx, ProUpSharedRegTx) carries a trivially-valid payload and is driven through block connection before activation, rejecting with its dedicated too-early reason; the same dissolution after activation fails at the masternode lookup instead, proving the gate itself caused the rejections. The wallet path is also closed pre-activation (register_shared_prepare requires payload version 3).

Also exercise the shared-specific revive gate: an operator-key change via ProUpSharedRegTx resets operator fields and PoSe-bans the masternode, and the new operator's ProUpServTx must revive it despite the null keyIDOwner (without the IsShared() carve-out in the revive condition a banned shared masternode could never be revived). Verify the reward split resumes from the unchanged share table afterwards.
---
 test/functional/feature_masternode_shares.py | 96 +++++++++++++++++++-
 1 file changed, 92 insertions(+), 4 deletions(-)

diff --git a/test/functional/feature_masternode_shares.py b/test/functional/feature_masternode_shares.py
index 7fccfc784aa7..38ae215ae23e 100755
--- a/test/functional/feature_masternode_shares.py
+++ b/test/functional/feature_masternode_shares.py
@@ -5,9 +5,10 @@
 """Test decentralized masternode shares (shared collateral, reward split, dissolution)."""
 
 import base64
+import struct
 from decimal import Decimal
 
-from test_framework.messages import COIN, CTxOut, tx_from_hex
+from test_framework.messages import COIN, COutPoint, CTransaction, CTxIn, CTxOut, tx_from_hex
 from test_framework.script import CScript
 from test_framework.test_framework import DashTestFramework, p2p_port
 from test_framework.util import (
@@ -17,12 +18,19 @@
     softfork_active,
 )
 
-V24_ACTIVATION_THRESHOLD = 100
+# Keep the earliest activation height above the ~119 blocks the framework setup mines, so
+# run_test starts with v24 locked in but not yet active and can exercise pre-activation rules
+V24_MIN_ACTIVATION_HEIGHT = 250
 COLLATERAL = 1000 * COIN
 SHARED_COLLATERAL_SCRIPT = "04445348437551"
-EARLY_PERIOD_BLOCKS = 20
+# Must comfortably exceed the blocks mined between the first registration and its early-period
+# dissolution checks (~16 worst case), so the masternode is still inside the early period there
+EARLY_PERIOD_BLOCKS = 30
 EARLY_PENALTY = 50 * COIN
 DISSOLVE_FEE = 100000
+TRANSACTION_PROVIDER_DISSOLVE = 10
+TRANSACTION_PROVIDER_UPDATE_SHARE = 11
+TRANSACTION_PROVIDER_UPDATE_SHARED_REGISTRAR = 12
 
 
 class MasternodeSharesTest(DashTestFramework):
@@ -31,7 +39,7 @@ def add_options(self, parser):
 
     def set_test_params(self):
         self.set_dash_test_params(1, 0, extra_args=[[
-            f"-vbparams=v24:{self.mocktime}:999999999999:{V24_ACTIVATION_THRESHOLD}:10:8:6:5:0",
+            f"-vbparams=v24:{self.mocktime}:999999999999:{V24_MIN_ACTIVATION_HEIGHT}:10:8:6:5:0",
         ]])
 
     def activate_v24(self):
@@ -77,10 +85,61 @@ def register_shared(self, node, shares, port_offset, early_period_blocks=EARLY_P
     def owner_gbt_payees(self, node):
         return [p for p in node.getblocktemplate()["masternode"] if p["script"] != "6a"]
 
+    def build_lifecycle_tx(self, n_type, payload):
+        """Returns hex of a minimally well-formed special transaction of the given type. The dummy
+        input never resolves, but block connection runs special-transaction validation before input
+        lookups, so the reject reason isolates the special-tx rule under test."""
+        tx = CTransaction()
+        tx.nVersion = 3
+        tx.nType = n_type
+        tx.vExtraPayload = payload
+        tx.vin.append(CTxIn(COutPoint(1, 0)))
+        tx.vout.append(CTxOut(1, CScript(b"\x51")))
+        return tx.serialize().hex()
+
     def run_test(self):
         node = self.nodes[0]
+
+        self.log.info("Shared masternode transactions are rejected before v24 activation")
+        assert not softfork_active(node, "v24")
+        pre_miner = node.getnewaddress()
+        # The wallet path is closed while provider transaction version 3 is unavailable
+        pre_shares = [
+            {"amount": 600 * COIN, "refundAddress": node.getnewaddress(), "ownerAddress": node.getnewaddress()},
+            {"amount": 400 * COIN, "refundAddress": node.getnewaddress(), "ownerAddress": node.getnewaddress()},
+        ]
+        pre_funding = node.createrawtransaction([], {node.getnewaddress(): 1})
+        assert_raises_rpc_error(-8, "provider transaction version 3", node.protx, "register_shared_prepare",
+                                pre_funding, pre_shares, "", node.bls("generate")["public"],
+                                node.getnewaddress(), 0, EARLY_PERIOD_BLOCKS, EARLY_PENALTY)
+
+        # Consensus gate: each lifecycle type carries a trivially-valid payload (version 1, empty or
+        # zeroed fields, 65-byte placeholder signatures, a valid operator key where one is required),
+        # so block connection gets past payload deserialization and fails at the deployment check
+        # with the type's dedicated "too early" reason, not a payload or lookup error
+        prodis_hex = self.build_lifecycle_tx(
+            TRANSACTION_PROVIDER_DISSOLVE,
+            struct.pack("<H", 1) + b"\x00" * 32 + struct.pack("<H", 0) + bytes([1]) + b"\x00" * 65)
+        upshare_hex = self.build_lifecycle_tx(
+            TRANSACTION_PROVIDER_UPDATE_SHARE,
+            struct.pack("<H", 1) + b"\x00" * 32 + struct.pack("<H", 0) + b"\x00" + b"\x00" * 32 + b"\x00")
+        upsharedreg_hex = self.build_lifecycle_tx(
+            TRANSACTION_PROVIDER_UPDATE_SHARED_REGISTRAR,
+            struct.pack("<H", 1) + b"\x00" * 32 + bytes.fromhex(node.bls("generate")["public"]) +
+            b"\x01" * 20 + b"\x00" * 32 + bytes([1]) + b"\x00" * 65)
+        for tx_hex, reason in ((prodis_hex, "bad-prodis-too-early"),
+                               (upshare_hex, "bad-proupshare-too-early"),
+                               (upsharedreg_hex, "bad-proupsharedreg-too-early")):
+            assert_raises_rpc_error(-25, reason, self.generateblock, node, pre_miner, [tx_hex],
+                                    sync_fun=self.no_op)
+
         self.activate_v24()
 
+        # The same dissolution now clears the deployment gate and fails at the masternode lookup
+        # instead, proving the pre-activation rejections above came from the gate itself
+        assert_raises_rpc_error(-25, "bad-prodis-hash", self.generateblock, node, pre_miner,
+                                [prodis_hex], sync_fun=self.no_op)
+
         self.log.info("Register a two-participant shared masternode")
         refund1, refund2 = node.getnewaddress(), node.getnewaddress()
         owner1, owner2 = node.getnewaddress(), node.getnewaddress()
@@ -267,6 +326,35 @@ def submit_with_sigs(sigs):
         assert_raises_rpc_error(None, "bad-proupsharedreg-sig", node.protx,
                                 "shared_combine", prepared["tx"], swapped, True)
 
+        self.log.info("An operator-key change PoSe-bans the shared masternode until a ProUpServTx revives it")
+        node.sendtoaddress(fee_addr, 1)
+        self.generate(node, 1, sync_fun=self.no_op)
+        new_operator = node.bls("generate")
+        prepared = node.protx("update_shared_registrar_prepare", protx_hash, new_operator["public"], "", fee_addr)
+        sigs = node.protx("shared_sign", prepared["tx"])
+        node.protx("shared_combine", prepared["tx"], sigs, True)
+        self.bump_mocktime(10 * 60 + 1)
+        self.generate(node, 1, sync_fun=self.no_op)
+        info = node.protx("info", protx_hash)
+        assert_equal(info["state"]["pubKeyOperator"], new_operator["public"])
+        # operator-key change semantics match ProUpRegTx: operator fields reset, masternode banned
+        assert_greater_than(info["state"]["PoSeBanHeight"], 0)
+        assert_equal(self.owner_gbt_payees(node), [])
+
+        # The revive gate requires all keys to be set, and a shared masternode has a null
+        # keyIDOwner: this exercises the shared-specific carve-out, without which a banned shared
+        # masternode could never be revived
+        node.sendtoaddress(fee_addr, 1)
+        self.generate(node, 1, sync_fun=self.no_op)
+        node.protx("update_service", protx_hash, [f"127.0.0.1:{p2p_port(1)}"], new_operator["secret"], "", fee_addr)
+        self.bump_mocktime(10 * 60 + 1)
+        self.generate(node, 1, sync_fun=self.no_op)
+        info = node.protx("info", protx_hash)
+        assert_equal(info["state"]["PoSeBanHeight"], -1)
+        # revived: the reward split resumes from the unchanged share table
+        payees = self.owner_gbt_payees(node)
+        assert_equal([p["payee"] for p in payees], [reward1, refund2])
+
         self.log.info("A zero-penalty unilateral dissolution is invalid during the early period")
         assert_raises_rpc_error(-8, "must pay the penalty", node.protx,
                                 "dissolve", protx_hash, 1, DISSOLVE_FEE, True, False)

From 56c13c7ec590a7d6584d5bd5411ed83594507750 Mon Sep 17 00:00:00 2001
From: pasta <pasta@dashboost.org>
Date: Sat, 1 Aug 2026 16:26:17 -0500
Subject: [PATCH 19/20] rpc, gui: surface shared masternodes in payee displays
 and wallet filters

GetOwnerPayouts on a shared masternode state is empty (the owner reward derives from the share table instead), which left shared masternodes invisible wherever that helper fed a display or wallet filter: masternode winners printed an empty payee list, masternodelist's payee mode showed UNKNOWN, the GUI could not attribute a masternode to a wallet holding a share, protx list wallet skipped it, protx info reported hasOwnerKey/ownsPayeeScript false, and update_service's default fee-source fallback called front() on an empty vector (undefined behavior, reachable by any shared masternode operator omitting feeSourceAddress with no operator payout script set).

Add CDeterministicMNState::GetOwnerRewardScripts(), returning each share's effective reward script for shared masternodes and the payout-list scripts otherwise, and use it in those display and filter paths. Wallet attribution also recognizes share owner keys (hasOwnerKey, protx list wallet). update_service now fails with a clear error asking for an explicit feeSourceAddress: a shared masternode's reward scripts belong to the participants, not the operator running the command, so there is no sensible default.
---
 src/evo/dmnstate.cpp                         | 16 +++++++++++
 src/evo/dmnstate.h                           |  4 +++
 src/node/interfaces.cpp                      |  8 +++---
 src/rpc/evo.cpp                              | 28 ++++++++++++++++----
 src/rpc/masternode.cpp                       |  8 +++---
 src/test/evo_sharedmn_tests.cpp              | 11 ++++++++
 test/functional/feature_masternode_shares.py | 18 +++++++++++++
 7 files changed, 79 insertions(+), 14 deletions(-)

diff --git a/src/evo/dmnstate.cpp b/src/evo/dmnstate.cpp
index caa65f974832..0a9ee14234ce 100644
--- a/src/evo/dmnstate.cpp
+++ b/src/evo/dmnstate.cpp
@@ -33,6 +33,22 @@ std::string CDeterministicMNState::ToString() const
                      EncodeDestination(PKHash(keyIDVoting)), netInfo->ToString(), payoutAddress, payoutList, operatorPayoutAddress);
 }
 
+std::vector<CScript> CDeterministicMNState::GetOwnerRewardScripts() const
+{
+    std::vector<CScript> ret;
+    if (IsShared()) {
+        ret.reserve(shares.size());
+        for (const auto& share : shares) {
+            ret.emplace_back(share.RewardScript());
+        }
+    } else {
+        for (const auto& payout : GetOwnerPayouts(*this)) {
+            ret.emplace_back(payout.scriptPayout);
+        }
+    }
+    return ret;
+}
+
 UniValue CDeterministicMNStateDiff::ToJson(MnType nType) const
 {
     UniValue obj(UniValue::VOBJ);
diff --git a/src/evo/dmnstate.h b/src/evo/dmnstate.h
index 4bbe0400780c..83325e7f9f81 100644
--- a/src/evo/dmnstate.h
+++ b/src/evo/dmnstate.h
@@ -153,6 +153,10 @@ class CDeterministicMNState
     }
     /** Whether this is a shared masternode (DIP: decentralized masternode shares) */
     [[nodiscard]] bool IsShared() const { return !shares.empty(); }
+    /** The scripts the owner portion of the block reward is paid to: each share's effective
+     *  reward script for a shared masternode, otherwise the (possibly DIP-0026 multi-party)
+     *  payout list */
+    [[nodiscard]] std::vector<CScript> GetOwnerRewardScripts() const;
     void UpdateConfirmedHash(const uint256& _proTxHash, const uint256& _confirmedHash)
     {
         confirmedHash = _confirmedHash;
diff --git a/src/node/interfaces.cpp b/src/node/interfaces.cpp
index c89bc48ec61b..e668476deeea 100644
--- a/src/node/interfaces.cpp
+++ b/src/node/interfaces.cpp
@@ -104,11 +104,9 @@ namespace node {
 namespace {
 std::vector<CScript> GetOwnerPayoutScripts(const CDeterministicMNState& state)
 {
-    std::vector<CScript> ret;
-    for (const auto& payout : GetOwnerPayouts(state)) {
-        ret.emplace_back(payout.scriptPayout);
-    }
-    return ret;
+    // Shared-aware: for a shared masternode this is each share's reward script, so the GUI
+    // recognizes masternodes a wallet participates in
+    return state.GetOwnerRewardScripts();
 }
 
 class MnEntryImpl : public MnEntry
diff --git a/src/rpc/evo.cpp b/src/rpc/evo.cpp
index 702363f1d5a1..af78a49fbc1c 100644
--- a/src/rpc/evo.cpp
+++ b/src/rpc/evo.cpp
@@ -1308,8 +1308,14 @@ static UniValue protx_update_service_common_wrapper(const JSONRPCRequest& reques
             // use operator reward address as default source for fees
             ExtractDestination(ptx.scriptOperatorPayout, feeSource);
         } else {
-            // use payout address as default source for fees
+            // use payout address as default source for fees. A shared masternode has no payout
+            // list; its share reward scripts belong to the participants, not the operator running
+            // this command, so there is no sensible default to fall back to.
             const auto owner_payouts = GetOwnerPayouts(*dmn->pdmnState);
+            if (owner_payouts.empty()) {
+                throw JSONRPCError(RPC_INVALID_PARAMETER,
+                                   "masternode has no default fee source; specify feeSourceAddress");
+            }
             ExtractDestination(owner_payouts.front().scriptPayout, feeSource);
         }
     }
@@ -2029,8 +2035,8 @@ static bool CheckWalletOwnsScript(const CWallet* const pwallet, const CScript& s
 
 static bool CheckWalletOwnsAnyPayout(const CWallet* const pwallet, const CDeterministicMNState& state)
 {
-    for (const auto& payout : GetOwnerPayouts(state)) {
-        if (CheckWalletOwnsScript(pwallet, payout.scriptPayout)) return true;
+    for (const auto& script : state.GetOwnerRewardScripts()) {
+        if (CheckWalletOwnsScript(pwallet, script)) return true;
     }
     return false;
 }
@@ -2038,6 +2044,18 @@ static bool CheckWalletOwnsAnyPayout(const CWallet* const pwallet, const CDeterm
 static bool CheckWalletOwnsKey(const CWallet* const pwallet, const CKeyID& keyID) {
     return CheckWalletOwnsScript(pwallet, GetScriptForDestination(PKHash(keyID)));
 }
+
+static bool CheckWalletOwnsAnyOwnerKey(const CWallet* const pwallet, const CDeterministicMNState& state)
+{
+    // A shared masternode has a null keyIDOwner; the share owner keys take its place
+    if (state.IsShared()) {
+        for (const auto& share : state.shares) {
+            if (CheckWalletOwnsKey(pwallet, share.keyIDOwner)) return true;
+        }
+        return false;
+    }
+    return CheckWalletOwnsKey(pwallet, state.keyIDOwner);
+}
 #endif
 
 static UniValue BuildDMNListEntry(const CWallet* const pwallet, const CDeterministicMN& dmn, CMasternodeMetaMan& mn_metaman, bool detailed, const ChainstateManager& chainman, const CBlockIndex* pindex = nullptr)
@@ -2066,7 +2084,7 @@ static UniValue BuildDMNListEntry(const CWallet* const pwallet, const CDetermini
     o.pushKV("confirmations", confirmations);
 
 #ifdef ENABLE_WALLET
-    bool hasOwnerKey = CheckWalletOwnsKey(pwallet, dmn.pdmnState->keyIDOwner);
+    bool hasOwnerKey = CheckWalletOwnsAnyOwnerKey(pwallet, *dmn.pdmnState);
     bool hasVotingKey = CheckWalletOwnsKey(pwallet, dmn.pdmnState->keyIDVoting);
 
     bool ownsCollateral = false;
@@ -2176,7 +2194,7 @@ static RPCHelpMan protx_list()
         CDeterministicMNList mnList = dmnman.GetListForBlock(chainman.ActiveChain()[height]);
         mnList.ForEachMN(/*onlyValid=*/false, [&](const auto& dmn) {
             if (setOutpts.count(dmn.collateralOutpoint) ||
-                CheckWalletOwnsKey(wallet.get(), dmn.pdmnState->keyIDOwner) ||
+                CheckWalletOwnsAnyOwnerKey(wallet.get(), *dmn.pdmnState) ||
                 CheckWalletOwnsKey(wallet.get(), dmn.pdmnState->keyIDVoting) ||
                 CheckWalletOwnsAnyPayout(wallet.get(), *dmn.pdmnState) ||
                 CheckWalletOwnsScript(wallet.get(), dmn.pdmnState->scriptOperatorPayout)) {
diff --git a/src/rpc/masternode.cpp b/src/rpc/masternode.cpp
index 9417fee601b8..6af8fef58f48 100644
--- a/src/rpc/masternode.cpp
+++ b/src/rpc/masternode.cpp
@@ -229,9 +229,9 @@ static std::string GetRequiredPaymentsString(governance::SuperblockManager& supe
     std::string strPayments = "Unknown";
     if (payee) {
         strPayments.clear();
-        for (const auto& payout : GetOwnerPayouts(*payee->pdmnState)) {
+        for (const auto& script : payee->pdmnState->GetOwnerRewardScripts()) {
             CTxDestination dest;
-            if (!ExtractDestination(payout.scriptPayout, dest)) {
+            if (!ExtractDestination(script, dest)) {
                 NONFATAL_UNREACHABLE();
             }
             if (!strPayments.empty()) strPayments += ", ";
@@ -268,9 +268,9 @@ static std::string GetRequiredPaymentsString(governance::SuperblockManager& supe
 static std::string GetOwnerPayoutsString(const CDeterministicMNState& state)
 {
     std::string str_payees;
-    for (const auto& payout : GetOwnerPayouts(state)) {
+    for (const auto& script : state.GetOwnerRewardScripts()) {
         CTxDestination dest;
-        if (!ExtractDestination(payout.scriptPayout, dest)) {
+        if (!ExtractDestination(script, dest)) {
             NONFATAL_UNREACHABLE();
         }
         if (!str_payees.empty()) str_payees += ", ";
diff --git a/src/test/evo_sharedmn_tests.cpp b/src/test/evo_sharedmn_tests.cpp
index bf9f686e545d..0599b9bc709b 100644
--- a/src/test/evo_sharedmn_tests.cpp
+++ b/src/test/evo_sharedmn_tests.cpp
@@ -467,6 +467,15 @@ BOOST_AUTO_TEST_CASE(dmn_state_shares_roundtrip)
     BOOST_CHECK_EQUAL(state2.nEarlyPeriodBlocks, state.nEarlyPeriodBlocks);
     BOOST_CHECK_EQUAL(state2.nEarlyPenalty, state.nEarlyPenalty);
 
+    // The owner reward scripts of a shared masternode are the per-share effective reward scripts
+    {
+        const auto scripts = state.GetOwnerRewardScripts();
+        BOOST_REQUIRE_EQUAL(scripts.size(), state.shares.size());
+        for (size_t i = 0; i < scripts.size(); i++) {
+            BOOST_CHECK(scripts[i] == state.shares[i].RewardScript());
+        }
+    }
+
     // A reward-script change is reported as one logical field carrying the whole table
     CDeterministicMNState changed{state};
     CKey reward_key;
@@ -482,6 +491,8 @@ BOOST_AUTO_TEST_CASE(dmn_state_shares_roundtrip)
     CDeterministicMNState applied{state};
     diff2.ApplyToState(applied);
     BOOST_CHECK(applied.shares == changed.shares);
+    // ... and the owner reward scripts follow the update
+    BOOST_CHECK(applied.GetOwnerRewardScripts()[1] == changed.shares[1].scriptReward);
 }
 
 BOOST_AUTO_TEST_CASE(shared_unique_properties)
diff --git a/test/functional/feature_masternode_shares.py b/test/functional/feature_masternode_shares.py
index 38ae215ae23e..007b700c98cd 100755
--- a/test/functional/feature_masternode_shares.py
+++ b/test/functional/feature_masternode_shares.py
@@ -180,6 +180,16 @@ def run_test(self):
         assert "payoutAddress" not in info["state"]
         assert "payouts" not in info["state"]
 
+        self.log.info("Shared masternodes are visible in payee displays and wallet filters")
+        # the payee list mode joins every share's effective reward address (here the refund
+        # fallbacks, as no reward scripts are set yet)
+        assert_equal(list(node.masternodelist("payee").values()), [f"{refund1}, {refund2}"])
+        # the wallet holds the share owner keys and reward scripts, so the masternode is
+        # attributed to it despite the null registrar owner key
+        assert_equal(info["wallet"]["hasOwnerKey"], True)
+        assert_equal(info["wallet"]["ownsPayeeScript"], True)
+        assert protx_hash in node.protx("list", "wallet")
+
         self.log.info("A registration with a tampered or misplaced consent signature is rejected by consensus")
         refund_a, refund_b = node.getnewaddress(), node.getnewaddress()
         owner_a, owner_b = node.getnewaddress(), node.getnewaddress()
@@ -279,6 +289,8 @@ def submit_with_sigs(sigs):
         assert_equal(info["state"]["shares"][0]["rewardAddress"], reward1)
         payees = self.owner_gbt_payees(node)
         assert_equal([p["payee"] for p in payees], [reward1, refund2])
+        # the payee display follows the reward-script update
+        assert_equal(list(node.masternodelist("payee").values()), [f"{reward1}, {refund2}"])
 
         self.log.info("The coinbase actually pays the share reward script while the MN is active")
         # reward1 only ever receives coinbase owner rewards (dissolution refunds go to refund1/2),
@@ -341,6 +353,12 @@ def submit_with_sigs(sigs):
         assert_greater_than(info["state"]["PoSeBanHeight"], 0)
         assert_equal(self.owner_gbt_payees(node), [])
 
+        # A shared masternode has no payout list to fall back to as an update_service fee source,
+        # so omitting feeSourceAddress must produce a clear error rather than picking a
+        # participant's script (or crashing on an empty payout list)
+        assert_raises_rpc_error(-8, "no default fee source", node.protx, "update_service", protx_hash,
+                                [f"127.0.0.1:{p2p_port(1)}"], new_operator["secret"])
+
         # The revive gate requires all keys to be set, and a shared masternode has a null
         # keyIDOwner: this exercises the shared-specific carve-out, without which a banned shared
         # masternode could never be revived

From e9e86aa56bfe4846c145cd84d55b549b69582bb3 Mon Sep 17 00:00:00 2001
From: pasta <pasta@dashboost.org>
Date: Sat, 1 Aug 2026 16:26:43 -0500
Subject: [PATCH 20/20] rpc: reject already-signed dissolutions in protx
 shared_sign

The ProDisTx signing digest commits to the signature count, and shared_sign always signs the unanimous digest (one signature per share). Passing it a transaction that already carries signatures - typically a unilateral standby built by "protx dissolve" with submit=false - silently produced signatures that could never verify on a one-signature transaction after shared_combine. A unilateral dissolution is built, signed and submitted in one step by "protx dissolve" and never involves the multi-party sign/combine flow, so fail fast with an error saying exactly that. Also spell the intended split out in the shared_sign help text.
---
 src/rpc/evo.cpp                              | 20 +++++++++++++++-----
 test/functional/feature_masternode_shares.py |  4 ++++
 2 files changed, 19 insertions(+), 5 deletions(-)

diff --git a/src/rpc/evo.cpp b/src/rpc/evo.cpp
index af78a49fbc1c..adcad0bd2fcd 100644
--- a/src/rpc/evo.cpp
+++ b/src/rpc/evo.cpp
@@ -1572,9 +1572,11 @@ static RPCHelpMan protx_revoke()
 static RPCHelpMan protx_shared_sign()
 {
     return RPCHelpMan{"protx shared_sign",
-        "\nSigns a shared masternode transaction (shared ProRegTx, ProDisTx or ProUpSharedRegTx) with every\n"
-        "share owner key this wallet holds and returns the produced signatures. The transaction itself is\n"
-        "not modified; pass the signatures to \"protx shared_combine\".\n"
+        "\nSigns a shared masternode transaction (shared ProRegTx, unanimous ProDisTx or ProUpSharedRegTx)\n"
+        "with every share owner key this wallet holds and returns the produced signatures. The transaction\n"
+        "itself is not modified; pass the signatures to \"protx shared_combine\".\n"
+        "Only the multi-party flows pass through here: a unilateral dissolution is built, signed and\n"
+        "submitted in one step by \"protx dissolve\" and never needs shared_sign.\n"
         + HELP_REQUIRING_PASSPHRASE,
         {
             {"tx", RPCArg::Type::STR_HEX, RPCArg::Optional::NO, "The serialized transaction in hex format."},
@@ -1617,13 +1619,21 @@ static RPCHelpMan protx_shared_sign()
         if (!opt_ptx) {
             throw JSONRPCError(RPC_INVALID_PARAMETER, "transaction payload not deserializable");
         }
+        // shared_sign only ever signs unanimous dissolutions (built unsigned by dissolve_prepare);
+        // the signing digest commits to the signature count, so signatures produced here would
+        // never verify on a transaction carrying a different count. A unilateral dissolution is
+        // built, signed and submitted in one step by "protx dissolve" and must not pass through
+        // here at all.
+        if (!opt_ptx->vchSigs.empty()) {
+            throw JSONRPCError(RPC_INVALID_PARAMETER,
+                               "transaction already carries dissolution signatures; a unilateral dissolution "
+                               "is created fully signed by \"protx dissolve\" and needs no shared_sign step");
+        }
         const auto dmn = dmnman.GetListAtChainTip().GetMN(opt_ptx->proTxHash);
         if (!dmn || !dmn->pdmnState->IsShared()) {
             throw JSONRPCError(RPC_INVALID_PARAMETER, "shared masternode not found");
         }
         shares = dmn->pdmnState->shares;
-        // shared_sign only ever signs unanimous dissolutions (built by dissolve_prepare); a
-        // unilateral dissolution is signed inline by "protx dissolve"
         sign_hash = opt_ptx->MakeSignHash(CTransaction(tx), static_cast<uint8_t>(shares.size()));
     } else if (tx.nType == TRANSACTION_PROVIDER_UPDATE_SHARED_REGISTRAR) {
         const auto opt_ptx = GetTxPayload<CProUpSharedRegTx>(tx);
diff --git a/test/functional/feature_masternode_shares.py b/test/functional/feature_masternode_shares.py
index 007b700c98cd..984bda44de3e 100755
--- a/test/functional/feature_masternode_shares.py
+++ b/test/functional/feature_masternode_shares.py
@@ -409,6 +409,10 @@ def submit_with_sigs(sigs):
         ]
         protx_hash2, _ = self.register_shared(node, shares2, port_offset=2)
         standby_hex = node.protx("dissolve", protx_hash2, 0, DISSOLVE_FEE, False, False)
+        # a signed unilateral dissolution must not be re-signed via the multi-party flow:
+        # shared_sign signs the unanimous digest, which can never verify on a one-signature
+        # transaction, so it fails fast instead of producing unusable signatures
+        assert_raises_rpc_error(-8, "needs no shared_sign step", node.protx, "shared_sign", standby_hex)
         assert_equal(node.testmempoolaccept([standby_hex])[0]["allowed"], False)
         # mine past the early-period boundary; the same signed hex becomes and stays valid
         self.bump_mocktime(10 * 60 + 1)