From a9385e39116adc8b892435681a47ce0c8ae5f079 Mon Sep 17 00:00:00 2001
From: Pasta <pasta@dashboost.org>
Date: Thu, 9 Jul 2026 16:34:48 -0500
Subject: [PATCH 01/21] 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 fb1ffde2529a..3013e6409d10 100644
--- a/src/Makefile.am
+++ b/src/Makefile.am
@@ -232,6 +232,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 14bfee27f524..adc489e80ac6 100644
--- a/src/validation.cpp
+++ b/src/validation.cpp
@@ -375,7 +375,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 0543adf4c80b4f9283ffc247c81b888276fda9bc Mon Sep 17 00:00:00 2001
From: Pasta <pasta@dashboost.org>
Date: Thu, 9 Jul 2026 16:35:34 -0500
Subject: [PATCH 02/21] 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        |  91 +++++++++++++++++++++++++++
 src/evo/providertx_util.cpp |  36 +++++++++++
 4 files changed, 266 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 9ccf89abfc61..01bf2a7f2dd5 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..e460c218ea01 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>
+    static 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>
+    static 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,23 @@ class CProRegTx
             for (auto& payout : obj.payouts) {
                 READWRITE(payout);
             }
+            uint8_t shares_count{0};
+            // One join signature per share: a mismatched in-memory object cannot round-trip, so
+            // fail the write up front like CompactSignatureFormatter does for a malformed signature
+            SER_WRITE(obj, if (obj.vchJoinSigs.size() != obj.shares.size()) {
+                throw std::ios_base::failure("join signature count mismatch");
+            });
+            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 +218,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 25a6fcb46502fb2fc8a2137598bab5342038124e Mon Sep 17 00:00:00 2001
From: Pasta <pasta@dashboost.org>
Date: Thu, 9 Jul 2026 16:36:16 -0500
Subject: [PATCH 03/21] 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 3 (extended) 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       |  87 ++++++-
 src/evo/deterministicmns.cpp |  27 +-
 src/evo/dmnstate.cpp         |  15 +-
 src/evo/dmnstate.h           |  16 +-
 src/evo/providertx.cpp       | 158 ++++++++++++
 src/evo/providertx.h         | 128 +++++++++
 src/evo/simplifiedmns.cpp    |   3 +-
 src/evo/simplifiedmns.h      |   5 +-
 src/evo/smldiff.cpp          |   1 +
 src/evo/smldiff.h            |   4 +
 src/evo/specialtx.cpp        |   9 +
 src/evo/specialtx.h          |   1 +
 src/evo/specialtxman.cpp     | 485 ++++++++++++++++++++++++++++++++++-
 src/evo/specialtxman.h       |  31 +++
 src/messagesigner.cpp        |  34 +++
 src/messagesigner.h          |   3 +
 src/rpc/rawtransaction.cpp   |   3 +
 src/validation.cpp           |  26 ++
 20 files changed, 1032 insertions(+), 21 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 966845f77ce9..0da9f1f24aa1 100644
--- a/src/evo/assetlocktx.cpp
+++ b/src/evo/assetlocktx.cpp
@@ -182,6 +182,11 @@ static bool CheckAssetUnlockTxImpl(const BlockManager& blockman, VerifySig&& ver
         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..d08ac91998a3 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",
@@ -577,6 +658,7 @@ RPCResult CSimplifiedMNListEntry::GetJsonHelp(const std::string& key, bool optio
         GetRpcResult("platformNodeID", /*optional=*/true),
         GetRpcResult("payoutAddress", /*optional=*/true),
         GetRpcResult("payouts", /*optional=*/true),
+        GetRpcResult("shares", /*optional=*/true),
         GetRpcResult("operatorPayoutAddress", /*optional=*/true),
     }};
 }
@@ -609,6 +691,9 @@ UniValue CSimplifiedMNListEntry::ToJson(bool extended) const
         } else if (ExtractDestination(scriptPayout, dest)) {
             obj.pushKV("payoutAddress", EncodeDestination(dest));
         }
+        if (!shares.empty()) {
+            obj.pushKV("shares", ShareListToJson(shares));
+        }
         if (ExtractDestination(scriptOperatorPayout, dest)) {
             obj.pushKV("operatorPayoutAddress", EncodeDestination(dest));
         }
diff --git a/src/evo/deterministicmns.cpp b/src/evo/deterministicmns.cpp
index 0eed499ba976..3a905761e231 100644
--- a/src/evo/deterministicmns.cpp
+++ b/src/evo/deterministicmns.cpp
@@ -46,7 +46,7 @@ CSimplifiedMNListEntry CDeterministicMN::to_sml_entry() const
     const CDeterministicMNState& state{*pdmnState};
     return CSimplifiedMNListEntry(proTxHash, state.confirmedHash, state.netInfo, state.pubKeyOperator,
                                   state.keyIDVoting, !state.IsBanned(), state.platformHTTPPort, state.platformNodeID,
-                                  state.scriptPayout, GetOwnerPayouts(state),
+                                  state.scriptPayout, GetOwnerPayouts(state), state.shares,
                                   state.scriptOperatorPayout, state.nVersion, nType);
 }
 
@@ -432,7 +432,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)))));
@@ -589,7 +601,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 5d92dd899fdf..039b611e4368 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 01bf2a7f2dd5..e1a10f5c660d 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>
@@ -136,6 +137,20 @@ bool IsShareListTriviallyValid(const CollateralShares& shares,
     return true;
 }
 
+bool IsShareListVotingKeySafe(const CollateralShares& shares, const CKeyID& keyIDVoting)
+{
+    const CTxDestination voting_dest{PKHash(keyIDVoting)};
+    for (const auto& share : shares) {
+        for (const CScript* script : {&share.scriptRefund, &share.RewardScript()}) {
+            CTxDestination dest;
+            if (ExtractDestination(*script, dest) && dest == voting_dest) {
+                return false;
+            }
+        }
+    }
+    return true;
+}
+
 bool IsPayoutListKeySafe(const MasternodePayoutShares& payouts, const CTxDestination& collateral_dest,
                          const CKeyID& keyIDOwner, const CKeyID& keyIDVoting,
                          bool check_payout_collateral_reuse, TxValidationState& state)
@@ -256,6 +271,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;
@@ -387,3 +439,109 @@ std::string CProUpRevTx::ToString() const
     return strprintf("CProUpRevTx(nVersion=%d, proTxHash=%s, nReason=%d)",
         nVersion, proTxHash.ToString(), nReason);
 }
+
+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. 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;
+    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;
+    hw << sig_count;
+    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 e460c218ea01..25390fe2114c 100644
--- a/src/evo/providertx.h
+++ b/src/evo/providertx.h
@@ -119,6 +119,9 @@ template<class T>
                                              uint32_t early_period_blocks, CAmount early_penalty,
                                              CAmount required_collateral, const CKeyID& keyIDVoting,
                                              TxValidationState& state);
+/** Whether no share refund or effective reward script pays the voting key's P2PKH destination,
+ *  the registration-time separation rule that voting-key and reward-script updates must preserve */
+[[nodiscard]] bool IsShareListVotingKeySafe(const CollateralShares& shares, const CKeyID& keyIDVoting);
 [[nodiscard]] std::string ShareListToString(const CollateralShares& shares);
 [[nodiscard]] UniValue ShareListToJson(const CollateralShares& shares);
 class CProRegTx
@@ -221,6 +224,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;
@@ -420,6 +428,126 @@ 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, 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;
+
+    [[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/simplifiedmns.cpp b/src/evo/simplifiedmns.cpp
index e3133dc63cdd..dc63317d88f5 100644
--- a/src/evo/simplifiedmns.cpp
+++ b/src/evo/simplifiedmns.cpp
@@ -23,7 +23,7 @@ CSimplifiedMNListEntry::CSimplifiedMNListEntry(const uint256& proreg_tx_hash, co
                                                const CBLSLazyPublicKey& pubkey_operator, const CKeyID& keyid_voting,
                                                bool is_valid, uint16_t platform_http_port,
                                                const uint160& platform_node_id, const CScript& script_payout,
-                                               const MasternodePayoutShares& payouts_in,
+                                               const MasternodePayoutShares& payouts_in, const CollateralShares& shares_in,
                                                const CScript& script_operator_payout, uint16_t version, MnType type) :
     proRegTxHash(proreg_tx_hash),
     confirmedHash(confirmed_hash),
@@ -35,6 +35,7 @@ CSimplifiedMNListEntry::CSimplifiedMNListEntry(const uint256& proreg_tx_hash, co
     platformNodeID(platform_node_id),
     scriptPayout(script_payout),
     payouts(payouts_in),
+    shares(shares_in),
     scriptOperatorPayout(script_operator_payout),
     nVersion(version),
     nType(type)
diff --git a/src/evo/simplifiedmns.h b/src/evo/simplifiedmns.h
index 52d1088e8893..ff9724c8bbbe 100644
--- a/src/evo/simplifiedmns.h
+++ b/src/evo/simplifiedmns.h
@@ -37,6 +37,7 @@ class CSimplifiedMNListEntry
     uint160 platformNodeID{};
     CScript scriptPayout; // mem-only
     MasternodePayoutShares payouts; // mem-only
+    CollateralShares shares; // mem-only
     CScript scriptOperatorPayout; // mem-only
     uint16_t nVersion{ProTxVersion::LegacyBLS};
     MnType nType{MnType::Regular};
@@ -46,8 +47,8 @@ class CSimplifiedMNListEntry
                            const std::shared_ptr<NetInfoInterface>& net_info, const CBLSLazyPublicKey& pubkey_operator,
                            const CKeyID& keyid_voting, bool is_valid, uint16_t platform_http_port,
                            const uint160& platform_node_id, const CScript& script_payout,
-                           const MasternodePayoutShares& payouts, const CScript& script_operator_payout,
-                           uint16_t version, MnType type);
+                           const MasternodePayoutShares& payouts, const CollateralShares& shares,
+                           const CScript& script_operator_payout, uint16_t version, MnType type);
 
     bool operator==(const CSimplifiedMNListEntry& rhs) const
     {
diff --git a/src/evo/smldiff.cpp b/src/evo/smldiff.cpp
index b0de56d2c964..a0bb1e6971c3 100644
--- a/src/evo/smldiff.cpp
+++ b/src/evo/smldiff.cpp
@@ -135,6 +135,7 @@ CSimplifiedMNListDiff BuildSimplifiedDiff(const CDeterministicMNList& from, cons
             CSimplifiedMNListEntry sme2(fromPtr->to_sml_entry());
             if ((sme1 != sme2) || (extended && (sme1.scriptPayout != sme2.scriptPayout ||
                                                 sme1.payouts != sme2.payouts ||
+                                                sme1.shares != sme2.shares ||
                                                 sme1.scriptOperatorPayout != sme2.scriptOperatorPayout))) {
                 diffRet.mnList.push_back(std::move(sme1));
             }
diff --git a/src/evo/smldiff.h b/src/evo/smldiff.h
index fe74a542b4b9..4ec3cdd63cfe 100644
--- a/src/evo/smldiff.h
+++ b/src/evo/smldiff.h
@@ -18,6 +18,7 @@
 #include <threadsafety.h>
 
 class CBlockIndex;
+class CDeterministicMNList;
 class CDeterministicMNManager;
 class UniValue;
 class ChainstateManager;
@@ -90,6 +91,9 @@ class CSimplifiedMNListDiff
     [[nodiscard]] UniValue ToJson(bool extended = false) const;
 };
 
+CSimplifiedMNListDiff BuildSimplifiedDiff(const CDeterministicMNList& from, const CDeterministicMNList& to,
+                                          bool extended);
+
 bool BuildSimplifiedMNListDiff(CDeterministicMNManager& dmnman, const ChainstateManager& chainman,
                                const llmq::CQuorumBlockProcessor& qblockman, const llmq::CQuorumManager& qman,
                                const uint256& baseBlockHash, const uint256& blockHash, CSimplifiedMNListDiff& mnListDiffRet,
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 0cb0f67c531f..56883117a228 100644
--- a/src/evo/specialtxman.cpp
+++ b/src/evo/specialtxman.cpp
@@ -14,6 +14,7 @@
 #include <evo/evodb.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>
@@ -22,6 +23,7 @@
 #include <messagesigner.h>
 #include <util/helpers.h>
 
+#include <arith_uint256.h>
 #include <chainparams.h>
 #include <consensus/amount.h>
 #include <consensus/validation.h>
@@ -202,8 +204,8 @@ static bool CheckSpecialTxInner(CDeterministicMNManager& dmnman, llmq::CQuorumSn
                                 const ChainstateManager& chainman, const llmq::CQuorumManager& qman,
                                 const CChain* chain,
                                 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);
 
@@ -224,6 +226,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");
@@ -257,7 +265,7 @@ bool CSpecialTxProcessor::CheckSpecialTx(const CTransaction& tx, const CBlockInd
 {
     AssertLockHeld(::cs_main);
     return CheckSpecialTxInner(m_dmnman, m_qsnapman, m_chainman, m_qman, nullptr, tx, pindexPrev, view, std::nullopt, check_sigs,
-                               state);
+                               SpecialTxContext::Mempool, state);
 }
 
 static void HandleQuorumCommitment(const llmq::CFinalCommitment& qc, const std::vector<CDeterministicMNCPtr>& members,
@@ -395,7 +403,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");
             }
 
@@ -485,9 +502,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);
@@ -521,6 +539,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};
@@ -604,6 +626,110 @@ 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) {
+                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;
+
+            // CheckProUpShareTx ran against pindexPrev, so a shared registrar update earlier in
+            // this block is invisible to it and could have moved the voting key onto this share's
+            // scripts. Recheck the separation rule against the state as rebuilt so far.
+            if (!IsShareListVotingKeySafe(newState->shares, newState->keyIDVoting)) {
+                return state.Invalid(BlockValidationResult::BLOCK_CONSENSUS, "bad-proupshare-payee-reuse");
+            }
+
+            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);
+            }
+
+            // CheckProUpSharedRegTx ran against pindexPrev, so transactions earlier in this same
+            // block are invisible to it. Re-evaluate against the list as rebuilt so far: another
+            // update may have taken the operator key (under either encoding; the re-key in
+            // UpdateMN() would throw out of block assembly), and a share reward update may have
+            // moved a share script onto the new voting key.
+            if (operator_changed && newList.HasOperatorKeyUnderAnyScheme(opt_proTx->pubKeyOperator.Get(),
+                                                                         /*self=*/opt_proTx->proTxHash)) {
+                return state.Invalid(BlockValidationResult::BLOCK_CONSENSUS, "bad-protx-dup-key");
+            }
+            if (!IsShareListVotingKeySafe(newState->shares, newState->keyIDVoting)) {
+                return state.Invalid(BlockValidationResult::BLOCK_CONSENSUS, "bad-proupsharedreg-payee-reuse");
+            }
+
+            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) {
@@ -641,6 +767,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() && 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) {
@@ -744,7 +878,18 @@ bool CSpecialTxProcessor::ProcessSpecialTxsInBlock(Chainstate& chainstate, const
             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;
 
@@ -754,7 +899,7 @@ bool CSpecialTxProcessor::ProcessSpecialTxsInBlock(Chainstate& chainstate, const
             // consensus failures and "TX_BAD_SPECIAL"
             if (!CheckSpecialTxInner(m_dmnman, m_qsnapman, m_chainman, m_qman, &chainstate.m_chain,
                                      *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()));
@@ -1160,7 +1305,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");
         }
 
@@ -1169,7 +1319,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;
 
@@ -1193,8 +1345,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");
         }
 
@@ -1237,6 +1400,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;
@@ -1355,6 +1530,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;
@@ -1452,6 +1633,288 @@ 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");
+    }
+
+    // Same rule as the ordinary registrar path: the legacy and basic encodings of one BLS key
+    // occupy different unique-property slots, so probe both
+    if (mnList.HasOperatorKeyUnderAnyScheme(opt_ptx->pubKeyOperator.Get(), /*self=*/opt_ptx->proTxHash)) {
+        return state.Invalid(TxValidationResult::TX_BAD_SPECIAL, "bad-protx-dup-key");
+    }
+
+    // The new voting key is subject to the same payee-separation rule as at registration
+    if (!IsShareListVotingKeySafe(mnState.shares, opt_ptx->keyIDVoting)) {
+        return state.Invalid(TxValidationResult::TX_BAD_SPECIAL, "bad-proupsharedreg-payee-reuse");
+    }
+
+    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, 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,
+                                                                            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 b2e7a33ec62e..77cdbb9d12a3 100644
--- a/src/evo/specialtxman.h
+++ b/src/evo/specialtxman.h
@@ -20,6 +20,7 @@ class CCoinsViewCache;
 class CCreditPoolManager;
 class CDeterministicMNList;
 class CDeterministicMNManager;
+class CProDisTx;
 class CTransaction;
 class ChainstateManager;
 class Chainstate;
@@ -27,6 +28,14 @@ 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;
 }
@@ -118,6 +127,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 ffa6793b0ace..9491670b5a24 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 adc489e80ac6..367bc5d735a6 100644
--- a/src/validation.cpp
+++ b/src/validation.cpp
@@ -923,6 +923,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 (m_pool.m_require_standard && !AreInputsStandard(tx, m_view)) {
         return state.Invalid(TxValidationResult::TX_INPUTS_NOT_STANDARD, "bad-txns-nonstandard-inputs");
     }
@@ -2373,6 +2385,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]);
@@ -2389,6 +2402,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 6a11e301d02d652b8ba34b91bcb1d2e9ffb64caf Mon Sep 17 00:00:00 2001
From: Pasta <pasta@dashboost.org>
Date: Thu, 9 Jul 2026 16:40:36 -0500
Subject: [PATCH 04/21] 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 25390fe2114c..b7fe7d4e7c95 100644
--- a/src/evo/providertx.h
+++ b/src/evo/providertx.h
@@ -124,6 +124,10 @@ template<class T>
 [[nodiscard]] bool IsShareListVotingKeySafe(const CollateralShares& shares, const CKeyID& keyIDVoting);
 [[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 e9e4438837c2c2d4448598e67d3c1d4c5c999859 Mon Sep 17 00:00:00 2001
From: Pasta <pasta@dashboost.org>
Date: Thu, 9 Jul 2026 16:40:55 -0500
Subject: [PATCH 05/21] 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 | 182 ++++++++++++++++++++++++++++++++++++++++++++--
 1 file changed, 174 insertions(+), 8 deletions(-)

diff --git a/src/txmempool.cpp b/src/txmempool.cpp
index 58c03b3baa6f..f6e4c302b582 100644
--- a/src/txmempool.cpp
+++ b/src/txmempool.cpp
@@ -663,7 +663,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);
@@ -704,6 +712,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;
+        }
     }
 }
 
@@ -773,7 +798,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);
@@ -798,6 +829,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());
     }
 }
 
@@ -1002,6 +1043,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());
         }
@@ -1040,7 +1088,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);
@@ -1085,6 +1139,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));
     }
 }
 
@@ -1391,11 +1454,18 @@ bool CTxMemPool::existsProviderTxCrossSchemeConflict(const CTransaction& tx) con
             auto txit = mapTx.find(it->second);
             if (txit == mapTx.end()) continue;
             if (txit->GetTx().GetHash() == tx.GetHash()) continue; // ourselves
-            if (!self_protx.IsNull() && txit->GetTx().nType == TRANSACTION_PROVIDER_UPDATE_REGISTRAR) {
+            if (!self_protx.IsNull()) {
                 // The same masternode's own in-flight registrar update is not a conflict.
-                if (const auto other = GetTxPayload<CProUpRegTx>(txit->GetTx());
-                    other && other->proTxHash == self_protx) {
-                    continue;
+                if (txit->GetTx().nType == TRANSACTION_PROVIDER_UPDATE_REGISTRAR) {
+                    if (const auto other = GetTxPayload<CProUpRegTx>(txit->GetTx());
+                        other && other->proTxHash == self_protx) {
+                        continue;
+                    }
+                } else if (txit->GetTx().nType == TRANSACTION_PROVIDER_UPDATE_SHARED_REGISTRAR) {
+                    if (const auto other = GetTxPayload<CProUpSharedRegTx>(txit->GetTx());
+                        other && other->proTxHash == self_protx) {
+                        continue;
+                    }
                 }
             }
             return true;
@@ -1425,6 +1495,18 @@ bool CTxMemPool::existsProviderTxCrossSchemeConflict(const CTransaction& tx) con
         }
         return probe(opt_proTx->pubKeyOperator, opt_proTx->proTxHash);
     }
+    if (tx.nType == TRANSACTION_PROVIDER_UPDATE_SHARED_REGISTRAR) {
+        const auto opt_proTx = GetTxPayload<CProUpSharedRegTx>(tx);
+        if (!opt_proTx) return true;
+        // Same-key skip as the ordinary registrar path above: a no-op key carry-over cannot
+        // create a new cross-scheme claim.
+        auto dmnman = Assert(m_dmnman.load(std::memory_order_acquire));
+        if (auto dmn = dmnman->GetListAtChainTip().GetMN(opt_proTx->proTxHash);
+            dmn && opt_proTx->pubKeyOperator == dmn->pdmnState->pubKeyOperator) {
+            return false;
+        }
+        return probe(opt_proTx->pubKeyOperator, opt_proTx->proTxHash);
+    }
     return false;
 }
 
@@ -1460,7 +1542,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)) {
@@ -1537,6 +1630,79 @@ 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;
+            }
+        }
+
+        // A pending share reward update could move a share script onto the new voting key, a
+        // combination block validation rejects in any order. Check each pending update
+        // independently, not a composed table: every subset of a pairwise-safe set is then valid
+        // in every block order, so an honest miner never assembles the forbidden pair. An empty
+        // pending reward script falls back to the immutable refund script, which the tip-level
+        // CheckProUpSharedRegTx already vetted.
+        const CTxDestination voting_dest{PKHash(proTx.keyIDVoting)};
+        for (auto its = mapProTxRefs.equal_range(proTx.proTxHash); its.first != its.second; ++its.first) {
+            auto txit = mapTx.find(its.first->second);
+            if (txit == mapTx.end() || txit->GetTx().nType != TRANSACTION_PROVIDER_UPDATE_SHARE) {
+                continue;
+            }
+            const auto other = GetTxPayload<CProUpShareTx>(txit->GetTx());
+            if (!other || other->scriptReward.empty()) {
+                continue;
+            }
+            if (CTxDestination dest; ExtractDestination(other->scriptReward, dest) && dest == voting_dest) {
+                return true;
+            }
+        }
+
+        auto it = mapProTxBlsPubKeyHashes.find(proTx.pubKeyOperator.GetHash());
+        return it != mapProTxBlsPubKeyHashes.end() && it->second != proTx.proTxHash;
+    } else if (tx.nType == TRANSACTION_PROVIDER_UPDATE_SHARE) {
+        const auto opt_proTx = GetTxPayload<CProUpShareTx>(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
+        }
+        // The mirror image of the check above: a pending shared registrar update could move the
+        // voting key onto this update's new reward script. An empty new reward script falls back
+        // to the immutable refund script, which the registrar update's own admission checks vetted.
+        if (CTxDestination dest; !proTx.scriptReward.empty() && ExtractDestination(proTx.scriptReward, dest)) {
+            for (auto its = mapProTxRefs.equal_range(proTx.proTxHash); its.first != its.second; ++its.first) {
+                auto txit = mapTx.find(its.first->second);
+                if (txit == mapTx.end() || txit->GetTx().nType != TRANSACTION_PROVIDER_UPDATE_SHARED_REGISTRAR) {
+                    continue;
+                }
+                if (const auto other = GetTxPayload<CProUpSharedRegTx>(txit->GetTx());
+                    other && dest == CTxDestination(PKHash(other->keyIDVoting))) {
+                    return true;
+                }
+            }
+        }
     }
     return false;
 }

From 4dd593c619da5c5ba3022ac2d5566a050deb3acf Mon Sep 17 00:00:00 2001
From: Pasta <pasta@dashboost.org>
Date: Thu, 9 Jul 2026 16:40:56 -0500
Subject: [PATCH 06/21] 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 67fab321ccde..0ca6f7b09de6 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>
@@ -109,8 +112,21 @@ bool IsStandardTx(const CTransaction& tx, const std::optional<unsigned>& max_dat
 
     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, max_datacarrier_bytes, 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;
         }
@@ -163,6 +179,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 f021946d7abd8003a4072816e54bd230bbd3efc7 Mon Sep 17 00:00:00 2001
From: Pasta <pasta@dashboost.org>
Date: Thu, 9 Jul 2026 16:40:57 -0500
Subject: [PATCH 07/21] 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 +++++++++++++++++++++++++++++++
 src/merkleblock.cpp          |  3 +++
 3 files changed, 77 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)) {
diff --git a/src/merkleblock.cpp b/src/merkleblock.cpp
index cfd164c64544..946c8f4d057c 100644
--- a/src/merkleblock.cpp
+++ b/src/merkleblock.cpp
@@ -43,6 +43,9 @@ CMerkleBlock::CMerkleBlock(const CBlock& block, CBloomFilter* filter, const std:
             TRANSACTION_PROVIDER_UPDATE_SERVICE,
             TRANSACTION_PROVIDER_UPDATE_REGISTRAR,
             TRANSACTION_PROVIDER_UPDATE_REVOKE,
+            TRANSACTION_PROVIDER_DISSOLVE,
+            TRANSACTION_PROVIDER_UPDATE_SHARE,
+            TRANSACTION_PROVIDER_UPDATE_SHARED_REGISTRAR,
             TRANSACTION_COINBASE,
             TRANSACTION_ASSET_LOCK,
             TRANSACTION_ASSET_UNLOCK,

From 03a7a1caebf58887fb21978b5c06e0c0f187e793 Mon Sep 17 00:00:00 2001
From: Pasta <pasta@dashboost.org>
Date: Thu, 9 Jul 2026 16:41:20 -0500
Subject: [PATCH 08/21] 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    | 763 +++++++++++++++++++++++++++++++++++++++++++++
 2 files changed, 777 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 6e61e43b8929..4eb2db35f8f9 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)
 {
@@ -1238,6 +1363,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;
@@ -1426,6 +1555,470 @@ static RPCHelpMan protx_revoke()
     };
 }
 
+static RPCHelpMan protx_shared_sign()
+{
+    return RPCHelpMan{"protx shared_sign",
+        "\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."},
+        },
+        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");
+        }
+        // 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;
+        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) {
+            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), /*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");
+    }
+    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{"if \"submit\" is not set or set to true",
+                RPCResult::Type::STR_HEX, "txid", "The transaction id"},
+            RPCResult{"if \"submit\" is set to false",
+                RPCResult::Type::STR_HEX, "hex", "The serialized signed ProUpShareTx in hex format"},
+        },
+        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
@@ -2014,6 +2607,162 @@ 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)));
+    // 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;
+},
+    };
+}
+#endif // ENABLE_WALLET
+
 static RPCHelpMan protx_help()
 {
     return RPCHelpMan{
@@ -2032,6 +2781,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"
@@ -2041,6 +2791,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",
@@ -2163,6 +2919,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 e533abb8b823047d5cebeecc263761dd0eb2b9bb Mon Sep 17 00:00:00 2001
From: Pasta <pasta@dashboost.org>
Date: Thu, 9 Jul 2026 16:41:21 -0500
Subject: [PATCH 09/21] 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              | 789 +++++++++++++++++++
 src/test/evo_simplifiedmns_tests.cpp         |  53 ++
 test/functional/feature_masternode_shares.py | 392 +++++++++
 test/functional/test_runner.py               |   1 +
 5 files changed, 1236 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 f83e11e2895e..6f8fd73eb306 100644
--- a/src/Makefile.test.include
+++ b/src/Makefile.test.include
@@ -116,6 +116,7 @@ BITCOIN_TESTS =\
   test/evo_mnauth_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..29c729fb00a8
--- /dev/null
+++ b/src/test/evo_sharedmn_tests.cpp
@@ -0,0 +1,789 @@
+// 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 join-signature count differing from the share count cannot round-trip, so serialization
+    // refuses to emit it
+    {
+        CProRegTx mismatched;
+        mismatched.nVersion = ProTxVersion::ExtAddr;
+        mismatched.netInfo = NetInfoInterface::MakeNetInfo(mismatched.nVersion);
+        mismatched.shares.push_back(NewShare(600 * COIN, refund_keys[0], owner_keys[0]));
+        mismatched.shares.push_back(NewShare(400 * COIN, refund_keys[1], owner_keys[1]));
+        mismatched.vchJoinSigs = DummyJoinSigs(1);
+        CDataStream ss_mismatch(SER_NETWORK, CLIENT_VERSION);
+        BOOST_CHECK_THROW(ss_mismatch << mismatched, std::ios_base::failure);
+    }
+
+    // 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 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) {
+                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), /*sig_count=*/1), 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");
+    }
+    // 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;
+        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/src/test/evo_simplifiedmns_tests.cpp b/src/test/evo_simplifiedmns_tests.cpp
index 1122ad6aef19..7b3aca07009b 100644
--- a/src/test/evo_simplifiedmns_tests.cpp
+++ b/src/test/evo_simplifiedmns_tests.cpp
@@ -5,8 +5,12 @@
 #include <test/util/setup_common.h>
 
 #include <bls/bls.h>
+#include <evo/deterministicmns.h>
+#include <evo/dmnstate.h>
 #include <evo/simplifiedmns.h>
+#include <evo/smldiff.h>
 #include <netbase.h>
+#include <script/standard.h>
 
 #include <boost/test/unit_test.hpp>
 
@@ -71,4 +75,53 @@ BOOST_AUTO_TEST_CASE(simplifiedmns_merkleroots)
 
     BOOST_CHECK(expectedMerkleRoot == calculatedMerkleRoot);
 }
+
+BOOST_AUTO_TEST_CASE(simplifiedmns_extended_diff_share_reward)
+{
+    bls::bls_legacy_scheme.store(false);
+
+    auto make_keyid = [](uint8_t i) {
+        CKeyID ret;
+        ret.SetHex(strprintf("%040x", i));
+        return ret;
+    };
+    auto make_p2pkh = [&](uint8_t i) { return GetScriptForDestination(PKHash(make_keyid(i))); };
+
+    auto state = std::make_shared<CDeterministicMNState>();
+    state->nVersion = ProTxVersion::ExtAddr;
+    state->confirmedHash.SetHex(strprintf("%064x", 1));
+    state->netInfo = NetInfoInterface::MakeNetInfo(state->nVersion);
+    BOOST_CHECK_EQUAL(state->netInfo->AddEntry(NetInfoPurpose::CORE_P2P, "1.1.1.1:9999"), NetInfoStatus::Success);
+    std::vector<unsigned char> vecBytes{1};
+    vecBytes.resize(CBLSSecretKey::SerSize);
+    state->pubKeyOperator.Set(CBLSSecretKey(vecBytes).GetPublicKey(), bls::bls_legacy_scheme.load());
+    state->keyIDVoting = make_keyid(2);
+    state->shares = CollateralShares{CCollateralShare(600 * COIN, make_p2pkh(3), CScript(), make_keyid(4)),
+                                     CCollateralShare(400 * COIN, make_p2pkh(5), CScript(), make_keyid(6))};
+
+    auto dmn = std::make_shared<CDeterministicMN>(/*_internalId=*/1, MnType::Regular);
+    dmn->proTxHash.SetHex(strprintf("%064x", 7));
+    dmn->collateralOutpoint = COutPoint(uint256::ONE, 0);
+    dmn->pdmnState = state;
+
+    CDeterministicMNList from(uint256::ONE, /*_height=*/1, /*_totalRegisteredCount=*/1);
+    from.AddMN(dmn);
+
+    // Same list except one share's reward script changed, as a ProUpShareTx would do
+    auto newState = std::make_shared<CDeterministicMNState>(*state);
+    newState->shares[1].scriptReward = make_p2pkh(8);
+    CDeterministicMNList to(from);
+    to.UpdateMN(dmn->proTxHash, newState);
+
+    // The consensus SML leaf must not be affected by share data
+    BOOST_CHECK(from.GetMN(dmn->proTxHash)->to_sml_entry().CalcHash() ==
+                to.GetMN(dmn->proTxHash)->to_sml_entry().CalcHash());
+
+    // A non-extended diff sees no change, but an extended diff must carry the updated entry
+    BOOST_CHECK(BuildSimplifiedDiff(from, to, /*extended=*/false).mnList.empty());
+    const auto extDiff = BuildSimplifiedDiff(from, to, /*extended=*/true);
+    BOOST_REQUIRE_EQUAL(extDiff.mnList.size(), 1U);
+    BOOST_CHECK(extDiff.mnList[0].proRegTxHash == dmn->proTxHash);
+    BOOST_CHECK(extDiff.mnList[0].shares == newState->shares);
+}
 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..c84be84f7134
--- /dev/null
+++ b/test/functional/feature_masternode_shares.py
@@ -0,0 +1,392 @@
+#!/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 registrar update cannot move the voting key onto a share's payee script")
+        node.sendtoaddress(fee_addr, 1)
+        self.generate(node, 1, sync_fun=self.no_op)
+        prepared = node.protx("update_shared_registrar_prepare", protx_hash, "", reward1, fee_addr)
+        sigs = node.protx("shared_sign", prepared["tx"])
+        assert_raises_rpc_error(None, "bad-proupsharedreg-payee-reuse", node.protx,
+                                "shared_combine", prepared["tx"], sigs, True)
+
+        self.log.info("A pending registrar update keeps a conflicting share update out of the mempool")
+        node.sendtoaddress(fee_addr, 1)
+        self.generate(node, 1, sync_fun=self.no_op)
+        pair_addr = node.getnewaddress()
+        prepared = node.protx("update_shared_registrar_prepare", protx_hash, "", pair_addr, fee_addr)
+        sigs = node.protx("shared_sign", prepared["tx"])
+        node.protx("shared_combine", prepared["tx"], sigs, True)
+        # both pass tip-level checks individually, so only the mempool pair guard keeps an honest
+        # miner from assembling a block that consensus would then reject
+        assert_raises_rpc_error(None, "protx-dup", node.protx, "update_share", protx_hash, 0, pair_addr, fee_addr)
+        self.bump_mocktime(10 * 60 + 1)
+        self.generate(node, 1, sync_fun=self.no_op)
+        assert_equal(node.protx("info", protx_hash)["state"]["votingAddress"], pair_addr)
+
+        # the reverse direction: a pending share update blocks a registrar update onto its script
+        node.sendtoaddress(fee_addr, 1)
+        self.generate(node, 1, sync_fun=self.no_op)
+        rev_addr = node.getnewaddress()
+        node.protx("update_share", protx_hash, 0, rev_addr, fee_addr)
+        prepared = node.protx("update_shared_registrar_prepare", protx_hash, "", rev_addr, fee_addr)
+        sigs = node.protx("shared_sign", prepared["tx"])
+        assert_raises_rpc_error(None, "protx-dup", node.protx,
+                                "shared_combine", prepared["tx"], sigs, True)
+        self.bump_mocktime(10 * 60 + 1)
+        self.generate(node, 1, sync_fun=self.no_op)
+        assert_equal(node.protx("info", protx_hash)["state"]["shares"][0]["rewardAddress"], rev_addr)
+        # restore share 0's reward script for the sections below
+        node.sendtoaddress(fee_addr, 1)
+        self.generate(node, 1, sync_fun=self.no_op)
+        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)
+        assert_equal(node.protx("info", protx_hash)["state"]["shares"][0]["rewardAddress"], reward1)
+        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)
+        # 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)
+        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("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, refund5, refund6):
+            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 56acde042f86..ff0dc4c5b2bf 100755
--- a/test/functional/test_runner.py
+++ b/test/functional/test_runner.py
@@ -117,6 +117,7 @@
     'feature_llmq_simplepose.py', # 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_simplepose.py --disable-spork23', # NOTE: needs dash_hash to pass

From bd4804daf661cc3b66475dd556718c2505258943 Mon Sep 17 00:00:00 2001
From: Pasta <pasta@dashboost.org>
Date: Thu, 9 Jul 2026 16:41:22 -0500
Subject: [PATCH 10/21] 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 d73f8343697eb186fbeb2746f5142d5090f96e4f Mon Sep 17 00:00:00 2001
From: Pasta <pasta@dashboost.org>
Date: Thu, 9 Jul 2026 18:39:10 -0500
Subject: [PATCH 11/21] 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 4eb2db35f8f9..7410508aab8b 100644
--- a/src/rpc/evo.cpp
+++ b/src/rpc/evo.cpp
@@ -2616,7 +2616,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 zero-penalty\n"
+        "standby dissolution (\"protx dissolve <proTxHash> <shareIndex> <fee> false false\") and store\n"
+        "the returned hex with their refund-key backup, separately from the share owner key. It becomes\n"
+        "valid when the early period ends (or immediately when no early period applies), then never expires;\n"
+        "broadcasting it after that point recovers the participant's principal without 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.",
@@ -2703,6 +2708,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 c84be84f7134..e2b442c1f772 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 63a1d2ccc8efb6f703e67923bf4f5b02e1241751 Mon Sep 17 00:00:00 2001
From: pasta <pasta@dashboost.org>
Date: Sat, 1 Aug 2026 13:29:53 -0500
Subject: [PATCH 12/21] 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 56883117a228..d7af054b4eee 100644
--- a/src/evo/specialtxman.cpp
+++ b/src/evo/specialtxman.cpp
@@ -204,7 +204,7 @@ static bool CheckSpecialTxInner(CDeterministicMNManager& dmnman, llmq::CQuorumSn
                                 const ChainstateManager& chainman, const llmq::CQuorumManager& qman,
                                 const CChain* chain,
                                 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);
@@ -227,7 +227,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:
@@ -265,7 +265,7 @@ bool CSpecialTxProcessor::CheckSpecialTx(const CTransaction& tx, const CBlockInd
 {
     AssertLockHeld(::cs_main);
     return CheckSpecialTxInner(m_dmnman, m_qsnapman, m_chainman, m_qman, nullptr, tx, pindexPrev, view, std::nullopt, check_sigs,
-                               SpecialTxContext::Mempool, state);
+                               state);
 }
 
 static void HandleQuorumCommitment(const llmq::CFinalCommitment& qc, const std::vector<CDeterministicMNCPtr>& members,
@@ -626,27 +626,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) {
@@ -899,7 +878,7 @@ bool CSpecialTxProcessor::ProcessSpecialTxsInBlock(Chainstate& chainstate, const
             // consensus failures and "TX_BAD_SPECIAL"
             if (!CheckSpecialTxInner(m_dmnman, m_qsnapman, m_chainman, m_qman, &chainstate.m_chain,
                                      *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()));
@@ -1854,7 +1833,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) {
@@ -1865,15 +1844,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 77cdbb9d12a3..9efeaf75ac97 100644
--- a/src/evo/specialtxman.h
+++ b/src/evo/specialtxman.h
@@ -28,14 +28,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;
 }
@@ -128,17 +120,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 c6830bee8a38a319a6956f45d8e5672850a08932 Mon Sep 17 00:00:00 2001
From: pasta <pasta@dashboost.org>
Date: Sat, 1 Aug 2026 15:26:52 -0500
Subject: [PATCH 13/21] 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 7410508aab8b..e4d385cd6433 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());
@@ -1821,7 +1840,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."},
@@ -1894,7 +1915,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 8453fb556876d7d2eaf01fe01a1421d22fccd084 Mon Sep 17 00:00:00 2001
From: pasta <pasta@dashboost.org>
Date: Sat, 1 Aug 2026 15:36:06 -0500
Subject: [PATCH 14/21] 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              | 165 +++++++++++++++++++
 test/functional/feature_masternode_shares.py |  45 ++++-
 2 files changed, 209 insertions(+), 1 deletion(-)

diff --git a/src/test/evo_sharedmn_tests.cpp b/src/test/evo_sharedmn_tests.cpp
index 29c729fb00a8..8619d0aa081a 100644
--- a/src/test/evo_sharedmn_tests.cpp
+++ b/src/test/evo_sharedmn_tests.cpp
@@ -9,11 +9,15 @@
 #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 <merkleblock.h>
 #include <messagesigner.h>
 #include <policy/policy.h>
 #include <random.h>
@@ -786,4 +790,165 @@ 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)));
+    }
+
+    // CMerkleBlock gates bloom matching through its special-tx-type allowlist, so cover the whole
+    // path a BIP37 client actually takes: a block containing the full lifecycle must match a
+    // filter that starts from a single share owner key
+    {
+        CBlock block;
+        block.vtx.push_back(MakeTransactionRef(reg_tx));
+        block.vtx.push_back(MakeTransactionRef(dis_tx));
+        block.vtx.push_back(MakeTransactionRef(upshare_tx));
+        block.vtx.push_back(MakeTransactionRef(upreg_tx));
+
+        CBloomFilter filter(20, 0.001, 0, BLOOM_UPDATE_ALL);
+        filter.insert(hash_vec(proTx.shares[0].keyIDOwner));
+        CMerkleBlock merkle_block(block, filter);
+        BOOST_CHECK_EQUAL(merkle_block.vMatchedTxn.size(), block.vtx.size());
+    }
+}
+
 BOOST_AUTO_TEST_SUITE_END()
diff --git a/test/functional/feature_masternode_shares.py b/test/functional/feature_masternode_shares.py
index e2b442c1f772..fcd7a750a92b 100755
--- a/test/functional/feature_masternode_shares.py
+++ b/test/functional/feature_masternode_shares.py
@@ -396,10 +396,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 f7413571a881a40bf83abba584d7c5a9ae0b9251 Mon Sep 17 00:00:00 2001
From: pasta <pasta@dashboost.org>
Date: Sat, 1 Aug 2026 16:06:32 -0500
Subject: [PATCH 15/21] 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 | 97 +++++++++++++++++++-
 1 file changed, 93 insertions(+), 4 deletions(-)

diff --git a/test/functional/feature_masternode_shares.py b/test/functional/feature_masternode_shares.py
index fcd7a750a92b..4e8654130dea 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()
@@ -308,6 +367,36 @@ def submit_with_sigs(sigs):
         self.bump_mocktime(10 * 60 + 1)
         self.generate(node, 1, sync_fun=self.no_op)
         assert_equal(node.protx("info", protx_hash)["state"]["shares"][0]["rewardAddress"], reward1)
+
+        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 fabd9bf9274b9ee52670ec78e7970dd80f72d492 Mon Sep 17 00:00:00 2001
From: pasta <pasta@dashboost.org>
Date: Sat, 1 Aug 2026 16:26:17 -0500
Subject: [PATCH 16/21] 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/interfaces/node.h                        |  1 +
 src/node/interfaces.cpp                      | 18 ++++++---
 src/qt/masternodelist.cpp                    |  6 +++
 src/qt/masternodemodel.cpp                   | 11 +++++-
 src/qt/masternodemodel.h                     |  1 +
 src/rpc/evo.cpp                              | 40 +++++++++++++++++---
 src/rpc/masternode.cpp                       |  8 ++--
 src/test/evo_sharedmn_tests.cpp              | 11 ++++++
 test/functional/feature_masternode_shares.py | 18 +++++++++
 11 files changed, 119 insertions(+), 15 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 039b611e4368..26f89fc0c624 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/interfaces/node.h b/src/interfaces/node.h
index ba85809416be..9058ed3cae8e 100644
--- a/src/interfaces/node.h
+++ b/src/interfaces/node.h
@@ -77,6 +77,7 @@ class MnEntry
     virtual MnType getType() const = 0;
     virtual UniValue toJson() const = 0;
     virtual const CKeyID& getKeyIdOwner() const = 0;
+    virtual std::vector<CKeyID> getShareOwnerKeyIds() const = 0;
     virtual const CKeyID& getKeyIdVoting() const = 0;
     virtual const COutPoint& getCollateralOutpoint() const = 0;
     virtual const CScript& getScriptPayout() const = 0;
diff --git a/src/node/interfaces.cpp b/src/node/interfaces.cpp
index 6cae82a144a6..7b9cea1bdd80 100644
--- a/src/node/interfaces.cpp
+++ b/src/node/interfaces.cpp
@@ -106,11 +106,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
@@ -136,6 +134,16 @@ class MnEntryImpl : public MnEntry
     MnType getType() const override { return m_dmn->nType; }
     UniValue toJson() const override { return m_dmn->ToJson(); }
     const CKeyID& getKeyIdOwner() const override { return m_dmn->pdmnState->keyIDOwner; }
+    std::vector<CKeyID> getShareOwnerKeyIds() const override
+    {
+        // Shared-aware: a shared masternode has a null keyIDOwner, its share owner keys take its place
+        std::vector<CKeyID> ret;
+        ret.reserve(m_dmn->pdmnState->shares.size());
+        for (const auto& share : m_dmn->pdmnState->shares) {
+            ret.push_back(share.keyIDOwner);
+        }
+        return ret;
+    }
     const CKeyID& getKeyIdVoting() const override { return m_dmn->pdmnState->keyIDVoting; }
     const COutPoint& getCollateralOutpoint() const override { return m_dmn->collateralOutpoint; }
     const CScript& getScriptPayout() const override { return m_script_payout; }
diff --git a/src/qt/masternodelist.cpp b/src/qt/masternodelist.cpp
index fd5d1fa9dbf9..17cddfb1405b 100644
--- a/src/qt/masternodelist.cpp
+++ b/src/qt/masternodelist.cpp
@@ -224,8 +224,14 @@ void MasternodeList::updateMasternodeList()
         const bool owns_payout{std::any_of(script_payouts.begin(), script_payouts.end(), [&](const auto& script) {
             return walletModel->wallet().isSpendable(script);
         })};
+        // A shared masternode has a null keyIDOwner; its share owner keys take its place
+        const auto share_owner_key_ids{entry->shareOwnerKeyIdsRaw()};
+        const bool owns_share{std::any_of(share_owner_key_ids.begin(), share_owner_key_ids.end(), [&](const auto& key_id) {
+            return walletModel->wallet().isSpendable(PKHash(key_id));
+        })};
         bool fMyMasternode{setOutpts.count(entry->collateralOutpointRaw()) ||
                            walletModel->wallet().isSpendable(PKHash(entry->keyIdOwnerRaw())) ||
+                           owns_share ||
                            walletModel->wallet().isSpendable(PKHash(entry->keyIdVotingRaw())) ||
                            owns_payout ||
                            walletModel->wallet().isSpendable(entry->scriptOperatorPayoutRaw())};
diff --git a/src/qt/masternodemodel.cpp b/src/qt/masternodemodel.cpp
index a99e754a0dc8..f94567fe0604 100644
--- a/src/qt/masternodemodel.cpp
+++ b/src/qt/masternodemodel.cpp
@@ -46,7 +46,6 @@ MasternodeEntry::MasternodeEntry(const interfaces::MnEntryCPtr& dmn, const QStri
     m_type{dmn->getType()},
     m_collateral_address{collateral_address},
     m_collateral_outpoint{QString::fromStdString(dmn->getCollateralOutpoint().ToStringShort())},
-    m_owner_address{QString::fromStdString(EncodeDestination(PKHash(dmn->getKeyIdOwner())))},
     m_protx_hash{QString::fromStdString(dmn->getProTxHash().ToString())},
     m_service{QString::fromStdString(dmn->getNetInfoPrimary().ToStringAddrPort())},
     m_type_description{QString::fromStdString(std::string(GetMnType(dmn->getType()).description))},
@@ -56,6 +55,16 @@ MasternodeEntry::MasternodeEntry(const interfaces::MnEntryCPtr& dmn, const QStri
     auto addr_key = dmn->getNetInfoPrimary().GetKey();
     m_service_key = QByteArray(reinterpret_cast<const char*>(addr_key.data()), addr_key.size());
 
+    // A shared masternode has a null keyIDOwner; its share owner keys take its place
+    QStringList owner_addresses;
+    if (const CKeyID& key_id_owner{dmn->getKeyIdOwner()}; !key_id_owner.IsNull()) {
+        owner_addresses << QString::fromStdString(EncodeDestination(PKHash(key_id_owner)));
+    }
+    for (const auto& key_id : dmn->getShareOwnerKeyIds()) {
+        owner_addresses << QString::fromStdString(EncodeDestination(PKHash(key_id)));
+    }
+    m_owner_address = owner_addresses.isEmpty() ? QObject::tr("UNKNOWN") : owner_addresses.join(", ");
+
     QStringList payout_addresses;
     for (const auto& script_payout : dmn->getScriptPayouts()) {
         if (CTxDestination dest; ExtractDestination(script_payout, dest)) {
diff --git a/src/qt/masternodemodel.h b/src/qt/masternodemodel.h
index 9db5bcf2741d..d5513a3c6a47 100644
--- a/src/qt/masternodemodel.h
+++ b/src/qt/masternodemodel.h
@@ -66,6 +66,7 @@ class MasternodeEntry
     uint16_t operatorRewardPct() const { return m_operator_reward_pct; }
 
     const CKeyID& keyIdOwnerRaw() const { return m_dmn->getKeyIdOwner(); }
+    std::vector<CKeyID> shareOwnerKeyIdsRaw() const { return m_dmn->getShareOwnerKeyIds(); }
     const CKeyID& keyIdVotingRaw() const { return m_dmn->getKeyIdVoting(); }
     const COutPoint& collateralOutpointRaw() const { return m_dmn->getCollateralOutpoint(); }
     const CScript& scriptOperatorPayoutRaw() const { return m_dmn->getScriptOperatorPayout(); }
diff --git a/src/rpc/evo.cpp b/src/rpc/evo.cpp
index e4d385cd6433..69a14138a5cb 100644
--- a/src/rpc/evo.cpp
+++ b/src/rpc/evo.cpp
@@ -1307,8 +1307,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);
         }
     }
@@ -2055,8 +2061,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;
 }
@@ -2064,6 +2070,29 @@ 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);
+}
+
+static bool CheckWalletOwnsAnyShareRefund(const CWallet* const pwallet, const CDeterministicMNState& state)
+{
+    // A dissolution returns each share's collateral to its refund script. The non-shared
+    // equivalent (the collateral UTXO) is matched via ListProTxCoins, which cannot see the
+    // shared covenant output, so match the refund destinations directly.
+    for (const auto& share : state.shares) {
+        if (CheckWalletOwnsScript(pwallet, share.scriptRefund)) return true;
+    }
+    return false;
+}
 #endif
 
 static UniValue BuildDMNListEntry(const CWallet* const pwallet, const CDeterministicMN& dmn, const CMasternodeMetaMan& mn_metaman, bool detailed, const ChainstateManager& chainman, const CBlockIndex* pindex = nullptr)
@@ -2092,7 +2121,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;
@@ -2202,9 +2231,10 @@ 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) ||
+                CheckWalletOwnsAnyShareRefund(wallet.get(), *dmn.pdmnState) ||
                 CheckWalletOwnsScript(wallet.get(), dmn.pdmnState->scriptOperatorPayout)) {
                 ret.push_back(BuildDMNListEntry(wallet.get(), dmn, mn_metaman, detailed, chainman));
             }
diff --git a/src/rpc/masternode.cpp b/src/rpc/masternode.cpp
index 7a7380dc1b75..13e5d7a13532 100644
--- a/src/rpc/masternode.cpp
+++ b/src/rpc/masternode.cpp
@@ -234,9 +234,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 += ", ";
@@ -273,9 +273,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 8619d0aa081a..a61138ad4b38 100644
--- a/src/test/evo_sharedmn_tests.cpp
+++ b/src/test/evo_sharedmn_tests.cpp
@@ -481,6 +481,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;
@@ -496,6 +505,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 4e8654130dea..5dd41ad75b45 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),
@@ -383,6 +395,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 13075107807a0d34db95c4e3a1750cd079bccffc Mon Sep 17 00:00:00 2001
From: pasta <pasta@dashboost.org>
Date: Mon, 17 Aug 2026 11:16:53 -0500
Subject: [PATCH 17/21] evo: cap dissolution fees and unilateral penalty
 overpayment

The minimum-based ProDisTx output rules left two unbounded paths by which value could leave the actor's share: the transaction fee and voluntary penalty overpayment. A single stolen share owner key could sign a unilateral dissolution paying the victim's entire share to miners as fee, or as bonus concentrated on a colluding participant, contradicting the DIP's guarantee that owner-key compromise never costs principal beyond the consented penalty.

Cap the fee at CProDisTx::MAX_FEE (0.01 DASH) in both modes and cap the unilateral bonus sum at the configured earlyPenalty, per the revised DIP. Both ceilings are height-independent, so validity stays monotone and early-period standbys paying the full penalty remain valid forever. Worst-case loss under key compromise is now earlyPenalty + MAX_FEE. Unanimous dissolutions keep unrestricted bonuses: every owner signed the exact outputs.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
---
 doc/release-notes-7437.md                    |  5 ++-
 src/evo/providertx.h                         |  3 ++
 src/evo/specialtxman.cpp                     | 16 +++++++++
 src/rpc/evo.cpp                              |  8 +++--
 src/test/evo_sharedmn_tests.cpp              | 35 +++++++++++++++++++-
 test/functional/feature_masternode_shares.py |  4 +++
 6 files changed, 67 insertions(+), 4 deletions(-)

diff --git a/doc/release-notes-7437.md b/doc/release-notes-7437.md
index d514c5708768..d23ea2573390 100644
--- a/doc/release-notes-7437.md
+++ b/doc/release-notes-7437.md
@@ -23,7 +23,10 @@ together with DIP-0026 multi-party payouts as part of the v24 hard fork
     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.
+    "standby dissolutions" safe. The transaction fee is capped at 1000000 duffs
+    and a unilateral dissolution may not pay bonuses beyond the configured
+    early penalty, bounding what a stolen share owner key can drain from its
+    own share.
   - **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
diff --git a/src/evo/providertx.h b/src/evo/providertx.h
index b7fe7d4e7c95..e9b1047b3a5c 100644
--- a/src/evo/providertx.h
+++ b/src/evo/providertx.h
@@ -437,6 +437,9 @@ class CProDisTx
 public:
     static constexpr auto SPECIALTX_TYPE = TRANSACTION_PROVIDER_DISSOLVE;
     static constexpr uint16_t CURRENT_VERSION = 1;
+    //! Consensus ceiling on the transaction fee. Together with the unilateral bonus ceiling
+    //! (earlyPenalty) it bounds what a stolen share owner key can drain from the actor's share.
+    static constexpr CAmount MAX_FEE{1000000};
 
     uint16_t nVersion{CURRENT_VERSION};
     uint256 proTxHash;
diff --git a/src/evo/specialtxman.cpp b/src/evo/specialtxman.cpp
index d7af054b4eee..7aaa63763cc8 100644
--- a/src/evo/specialtxman.cpp
+++ b/src/evo/specialtxman.cpp
@@ -1810,6 +1810,22 @@ bool CheckProDisTxForList(const CTransaction& tx, const CProDisTx& ptx, const CD
     if (bonus_total < required_penalty) {
         return state.Invalid(TxValidationResult::TX_BAD_SPECIAL, "bad-prodis-penalty-sum");
     }
+    // Everything not paid to the outputs is fee, which by value conservation comes from the
+    // actor's share. The fee ceiling (both modes) and the unilateral bonus ceiling close the two
+    // paths by which a stolen share owner key could drain the actor's principal beyond the
+    // consented penalty; both ceilings are height-independent, so validity stays monotone. A
+    // unanimous dissolution carries every owner's signature over the exact outputs, so bonuses
+    // beyond the configured penalty are consented and remain valid.
+    CAmount out_total{0};
+    for (const auto& out : tx.vout) {
+        out_total += out.nValue;
+    }
+    if (non_actor_total + shares[ptx.actorIndex].amount - out_total > CProDisTx::MAX_FEE) {
+        return state.Invalid(TxValidationResult::TX_BAD_SPECIAL, "bad-prodis-fee");
+    }
+    if (!unanimous && bonus_total > mnState.nEarlyPenalty) {
+        return state.Invalid(TxValidationResult::TX_BAD_SPECIAL, "bad-prodis-bonus");
+    }
 
     if (check_sigs) {
         const uint256 sign_hash{ptx.MakeSignHash(tx, static_cast<uint8_t>(ptx.vchSigs.size()))};
diff --git a/src/rpc/evo.cpp b/src/rpc/evo.cpp
index 69a14138a5cb..c026b09cbb36 100644
--- a/src/rpc/evo.cpp
+++ b/src/rpc/evo.cpp
@@ -338,6 +338,10 @@ static CMutableTransaction BuildProDisTx(const CDeterministicMN& dmn, uint16_t a
     if (fee <= 0) {
         throw JSONRPCError(RPC_INVALID_PARAMETER, "fee must be positive");
     }
+    if (fee > CProDisTx::MAX_FEE) {
+        throw JSONRPCError(RPC_INVALID_PARAMETER,
+                           strprintf("fee exceeds the consensus ceiling of %d duffs", CProDisTx::MAX_FEE));
+    }
     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");
@@ -1693,7 +1697,7 @@ static RPCHelpMan protx_dissolve()
         {
             {"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."},
+            {"fee", RPCArg::Type::NUM, RPCArg::Default{100000}, "Transaction fee in duffs, paid from the actor's share. At most 1000000 duffs (consensus ceiling)."},
             {"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."},
         },
@@ -2791,7 +2795,7 @@ static RPCHelpMan protx_dissolve_prepare()
         {
             {"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."},
+            {"fee", RPCArg::Type::NUM, RPCArg::Default{100000}, "Transaction fee in duffs, paid from the actor's share. At most 1000000 duffs (consensus ceiling)."},
         },
         RPCResult{RPCResult::Type::OBJ, "", "",
         {
diff --git a/src/test/evo_sharedmn_tests.cpp b/src/test/evo_sharedmn_tests.cpp
index a61138ad4b38..9a5dda748afb 100644
--- a/src/test/evo_sharedmn_tests.cpp
+++ b/src/test/evo_sharedmn_tests.cpp
@@ -681,12 +681,45 @@ BOOST_AUTO_TEST_CASE(prodis_validation)
         const auto tx = t.BuildTx(0, 0, true, ptx);
         t.Check(tx, ptx, IN_EARLY, std::nullopt);
     }
-    // Overpaying the penalty is always valid
+    // Unilateral bonuses above the configured earlyPenalty breach the overpayment ceiling; the
+    // ceiling blocks a stolen key from dumping the actor's share onto the other participants
     {
         CProDisTx ptx;
         const auto tx = t.BuildTx(2, ProDisTestSetup::PENALTY + 12345, false, ptx);
+        t.Check(tx, ptx, IN_EARLY, "bad-prodis-bonus");
+        t.Check(tx, ptx, AFTER_EARLY, "bad-prodis-bonus");
+    }
+    // After the boundary the required penalty is zero, so keeping the full earlyPenalty payment
+    // is an overpayment exactly at the ceiling: valid (this is the early-period standby shape)
+    {
+        CProDisTx ptx;
+        const auto tx = t.BuildTx(2, ProDisTestSetup::PENALTY, false, ptx);
+        t.Check(tx, ptx, AFTER_EARLY, std::nullopt);
+    }
+    // Unanimous dissolutions may distribute bonuses beyond the ceiling: every owner signed the
+    // exact outputs
+    {
+        CProDisTx ptx;
+        const auto tx = t.BuildTx(0, ProDisTestSetup::PENALTY + 12345, true, ptx);
         t.Check(tx, ptx, IN_EARLY, std::nullopt);
     }
+    // Fee above the consensus ceiling
+    {
+        CProDisTx ptx;
+        auto tx = t.BuildTx(0, 0, true, ptx);
+        tx.vout.back().nValue -= CProDisTx::MAX_FEE; // fee becomes FEE + MAX_FEE
+        t.Sign(tx, ptx, true);
+        t.Check(tx, ptx, IN_EARLY, "bad-prodis-fee");
+    }
+    // The theft shape the fee ceiling exists for: omit the actor output so the actor's entire
+    // share becomes fee, capturable by whoever mines the block
+    {
+        CProDisTx ptx;
+        auto tx = t.BuildTx(2, 0, false, ptx);
+        tx.vout.pop_back(); // drop the actor output; its whole share would become fee
+        t.Sign(tx, ptx, false);
+        t.Check(tx, ptx, AFTER_EARLY, "bad-prodis-fee");
+    }
     // Unknown masternode / not-shared handled by callers; unknown hash here
     {
         CProDisTx ptx;
diff --git a/test/functional/feature_masternode_shares.py b/test/functional/feature_masternode_shares.py
index 5dd41ad75b45..ab5e6b181455 100755
--- a/test/functional/feature_masternode_shares.py
+++ b/test/functional/feature_masternode_shares.py
@@ -415,6 +415,10 @@ def submit_with_sigs(sigs):
         payees = self.owner_gbt_payees(node)
         assert_equal([p["payee"] for p in payees], [reward1, refund2])
 
+        self.log.info("The dissolution fee is capped")
+        assert_raises_rpc_error(-8, "fee exceeds the consensus ceiling", node.protx,
+                                "dissolve", protx_hash, 1, 1000001, False)
+
         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 39123ed5cd542e4424ed00bfd6200b06230b3284 Mon Sep 17 00:00:00 2001
From: pasta <pasta@dashboost.org>
Date: Mon, 17 Aug 2026 11:17:11 -0500
Subject: [PATCH 18/21] evo: enforce the ProUpShareTx signature size
 statelessly

Every other signature-bearing payload in the shared-masternode set checks the 65-byte compact size in IsTriviallyValid, but ProUpShareTx only enforced it inside signature verification, which is skipped for assumed-valid blocks. Add the stateless check, matching its siblings and the DIP's payloadSigSize rule. The functional test's pre-activation placeholder gains a real-sized signature so the too-early gate stays the isolated reject reason.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
---
 src/evo/providertx.cpp                       |  3 +++
 src/test/evo_sharedmn_tests.cpp              | 14 ++++++++++++++
 test/functional/feature_masternode_shares.py |  3 ++-
 3 files changed, 19 insertions(+), 1 deletion(-)

diff --git a/src/evo/providertx.cpp b/src/evo/providertx.cpp
index e1a10f5c660d..c853cd9719a1 100644
--- a/src/evo/providertx.cpp
+++ b/src/evo/providertx.cpp
@@ -496,6 +496,9 @@ bool CProUpShareTx::IsTriviallyValid(TxValidationState& state) const
     if (nVersion == 0 || nVersion > CURRENT_VERSION) {
         return state.Invalid(TxValidationResult::TX_CONSENSUS, "bad-proupshare-version");
     }
+    if (vchSig.size() != CPubKey::COMPACT_SIGNATURE_SIZE) {
+        return state.Invalid(TxValidationResult::TX_BAD_SPECIAL, "bad-proupshare-sig-size");
+    }
     if (!scriptReward.empty()) {
         if (sharedcollateral::IsSharedCollateralScript(scriptReward)) {
             return state.Invalid(TxValidationResult::TX_BAD_SPECIAL, "bad-proupshare-payee-template");
diff --git a/src/test/evo_sharedmn_tests.cpp b/src/test/evo_sharedmn_tests.cpp
index 9a5dda748afb..96580f9f841d 100644
--- a/src/test/evo_sharedmn_tests.cpp
+++ b/src/test/evo_sharedmn_tests.cpp
@@ -209,6 +209,20 @@ BOOST_AUTO_TEST_CASE(share_list_validation)
     }
 }
 
+// The 65-byte signature size must hold statelessly, like every other signature-bearing payload
+// in this DIP: contextual verification is skipped for assumed-valid blocks
+BOOST_AUTO_TEST_CASE(proupshare_sig_size)
+{
+    CProUpShareTx ptx;
+    TxValidationState state;
+    BOOST_CHECK(!ptx.IsTriviallyValid(state));
+    BOOST_CHECK_EQUAL(state.GetRejectReason(), "bad-proupshare-sig-size");
+    ptx.vchSig.assign(CPubKey::COMPACT_SIGNATURE_SIZE - 1, 0);
+    BOOST_CHECK(!ptx.IsTriviallyValid(state));
+    ptx.vchSig.assign(CPubKey::COMPACT_SIGNATURE_SIZE, 0);
+    BOOST_CHECK(ptx.IsTriviallyValid(state));
+}
+
 BOOST_AUTO_TEST_CASE(shared_proregtx_serialization)
 {
     CKey refund_keys[8], owner_keys[8], voting_key, collateral_key;
diff --git a/test/functional/feature_masternode_shares.py b/test/functional/feature_masternode_shares.py
index ab5e6b181455..f91117b738ae 100755
--- a/test/functional/feature_masternode_shares.py
+++ b/test/functional/feature_masternode_shares.py
@@ -122,7 +122,8 @@ def run_test(self):
             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")
+            struct.pack("<H", 1) + b"\x00" * 32 + struct.pack("<H", 0) + b"\x00" + b"\x00" * 32 +
+            bytes([65]) + b"\x00" * 65)
         upsharedreg_hex = self.build_lifecycle_tx(
             TRANSACTION_PROVIDER_UPDATE_SHARED_REGISTRAR,
             struct.pack("<H", 1) + b"\x00" * 32 + bytes.fromhex(node.bls("generate")["public"]) +

From da054089f5a05ec85dcc8c066549b2184608e7ad Mon Sep 17 00:00:00 2001
From: pasta <pasta@dashboost.org>
Date: Mon, 17 Aug 2026 11:17:17 -0500
Subject: [PATCH 19/21] miner: recheck the shared-collateral covenant for every
 packaged transaction

The package-level recheck added for special transactions guards against mempool entries invalidated by v24 activating, but the covenant also binds normal transactions: on a node accepting nonstandard transactions (devnets), a template-creating or template-spending normal transaction could sit in the mempool across activation, get selected into every template, and make TestBlockValidity reject each one, leaving the miner unable to produce a block. Run the covenant checks for all packaged transactions; they are exact 7-byte script comparisons per output/input.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
---
 src/node/miner.cpp | 13 +++++++++++++
 1 file changed, 13 insertions(+)

diff --git a/src/node/miner.cpp b/src/node/miner.cpp
index 34225a6d0daa..27a63644555e 100644
--- a/src/node/miner.cpp
+++ b/src/node/miner.cpp
@@ -395,6 +395,19 @@ bool BlockAssembler::TestPackageTransactions(const CTxMemPool::setEntries& packa
             }
         }
 
+        // The shared-collateral covenant applies to every transaction, not only special ones: a
+        // normal transaction creating or spending a template output can sit in the mempool across
+        // v24 activation on a node accepting nonstandard transactions, and would poison every
+        // template through the same TestBlockValidity path described above.
+        if (DeploymentActiveAfter(m_chainstate.m_chain.Tip(), m_chainstate.m_chainman,
+                                  Consensus::DEPLOYMENT_V24)) {
+            TxValidationState tx_state;
+            if (!CheckSharedCollateralSpends(it->GetTx(), m_chainstate.CoinsTip(), tx_state) ||
+                !CheckSharedCollateralTemplateOutputs(it->GetTx(), tx_state)) {
+                return false;
+            }
+        }
+
         const auto& txid = it->GetTx().GetHash();
         if (!m_isman.IsInstantSendEnabled() || m_isman.IsLocked(txid)) {
             continue;

From fe1f531afd87130723b36357278313901470ec48 Mon Sep 17 00:00:00 2001
From: pasta <pasta@dashboost.org>
Date: Mon, 17 Aug 2026 11:17:44 -0500
Subject: [PATCH 20/21] rpc: guard shared_sign against unnoticed dissolution
 time locks

The dissolution digest commits nLockTime and the input sequence, and BIP68 applies to version-3 transactions, so a co-signer's wallet could embed a lock the other signers bake into their signatures without noticing, delaying when the dissolution can confirm. Per the DIP's wallet guidance, shared_sign now refuses a dissolution carrying a lock time or non-final sequence unless the new allowTimeLocks parameter is set.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
---
 doc/release-notes-7437.md                    |  4 +++-
 src/rpc/client.cpp                           |  1 +
 src/rpc/evo.cpp                              | 14 ++++++++++++++
 test/functional/feature_masternode_shares.py |  7 +++++++
 4 files changed, 25 insertions(+), 1 deletion(-)

diff --git a/doc/release-notes-7437.md b/doc/release-notes-7437.md
index d23ea2573390..e12b6e6fd180 100644
--- a/doc/release-notes-7437.md
+++ b/doc/release-notes-7437.md
@@ -48,7 +48,9 @@ together with DIP-0026 multi-party payouts as part of the v24 hard fork
 - `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.
+  registrar update with every share owner key the wallet holds. It refuses a
+  dissolution carrying a lock time or non-final sequence unless
+  `allowTimeLocks` is set.
 - `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).
diff --git a/src/rpc/client.cpp b/src/rpc/client.cpp
index fb7ec84d17dd..68d3cea09b52 100644
--- a/src/rpc/client.cpp
+++ b/src/rpc/client.cpp
@@ -331,6 +331,7 @@ static const CRPCConvertParam vRPCConvertParams[] =
     { "protx dissolve", 5, "payPenalty" },
     { "protx dissolve_prepare", 2, "actorIndex" },
     { "protx dissolve_prepare", 3, "fee" },
+    { "protx shared_sign", 2, "allowTimeLocks" },
     { "protx update_share", 2, "shareIndex" },
     { "protx update_share", 5, "submit" },
     { "protx update_registrar", 4, "payoutAddress", true },
diff --git a/src/rpc/evo.cpp b/src/rpc/evo.cpp
index c026b09cbb36..214d542f3c20 100644
--- a/src/rpc/evo.cpp
+++ b/src/rpc/evo.cpp
@@ -1595,6 +1595,7 @@ static RPCHelpMan protx_shared_sign()
         + HELP_REQUIRING_PASSPHRASE,
         {
             {"tx", RPCArg::Type::STR_HEX, RPCArg::Optional::NO, "The serialized transaction in hex format."},
+            {"allowTimeLocks", RPCArg::Type::BOOL, RPCArg::Default{false}, "Sign a dissolution carrying a lock time or non-final input sequence. The signed digest commits to these fields, so a lock a co-signer failed to notice delays when the dissolution can confirm."},
         },
         RPCResult{RPCResult::Type::ARR, "", "",
         {
@@ -1648,6 +1649,19 @@ static RPCHelpMan protx_shared_sign()
         if (!dmn || !dmn->pdmnState->IsShared()) {
             throw JSONRPCError(RPC_INVALID_PARAMETER, "shared masternode not found");
         }
+        // Consensus permits time-locked dissolutions and the digest commits to the lock fields, so
+        // a lock the signer failed to notice would be silently baked into their signature
+        const bool allow_time_locks{request.params[1].isNull() ? false
+                                                               : ParseBoolV(request.params[1], "allowTimeLocks")};
+        bool has_time_lock{tx.nLockTime != 0};
+        for (const auto& txin : tx.vin) {
+            has_time_lock |= txin.nSequence != CTxIn::SEQUENCE_FINAL;
+        }
+        if (has_time_lock && !allow_time_locks) {
+            throw JSONRPCError(RPC_INVALID_PARAMETER,
+                               "dissolution carries a lock time or non-final input sequence, which delays when "
+                               "it can confirm; pass allowTimeLocks=true to sign it anyway");
+        }
         shares = dmn->pdmnState->shares;
         sign_hash = opt_ptx->MakeSignHash(CTransaction(tx), static_cast<uint8_t>(shares.size()));
     } else if (tx.nType == TRANSACTION_PROVIDER_UPDATE_SHARED_REGISTRAR) {
diff --git a/test/functional/feature_masternode_shares.py b/test/functional/feature_masternode_shares.py
index f91117b738ae..b55478e027db 100755
--- a/test/functional/feature_masternode_shares.py
+++ b/test/functional/feature_masternode_shares.py
@@ -468,6 +468,13 @@ def submit_with_sigs(sigs):
 
         self.log.info("A unanimous dissolution is penalty-free")
         prepared = node.protx("dissolve_prepare", protx_hash2, 0, DISSOLVE_FEE)
+        # The digest commits lock fields, so shared_sign refuses a time-locked dissolution unless
+        # the signer explicitly opts in
+        locked_tx = tx_from_hex(prepared["tx"])
+        locked_tx.nLockTime = 100
+        assert_raises_rpc_error(-8, "pass allowTimeLocks=true", node.protx, "shared_sign",
+                                locked_tx.serialize().hex())
+        assert_equal(len(node.protx("shared_sign", locked_tx.serialize().hex(), True)), 2)
         sigs = node.protx("shared_sign", prepared["tx"])
         assert_equal(len(sigs), 2)
         dissolve_txid2 = node.protx("shared_combine", prepared["tx"], sigs, True)

From 27cb59cf2d71fa3e89e4cfee0a5dde3d4e83778f Mon Sep 17 00:00:00 2001
From: pasta <pasta@dashboost.org>
Date: Mon, 17 Aug 2026 11:18:28 -0500
Subject: [PATCH 21/21] test: backfill DIP test-list coverage for shared
 masternodes

Adds the enumerated vectors the DIP's Test Cases section lists that had no test: the five stateless registration reject shapes (shared Evo, external collateral, non-zero keyIdOwner, non-empty payouts, non-shared payload with non-zero shared fields), consent-digest coverage of mode, type and operator key, a pre-activation template output shown consensus-valid to mine and permanently unspendable after activation, and an end-to-end near-miss script (one tag byte off) that mines and spends freely post-activation.

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

diff --git a/src/test/evo_sharedmn_tests.cpp b/src/test/evo_sharedmn_tests.cpp
index 96580f9f841d..7da37c5222d5 100644
--- a/src/test/evo_sharedmn_tests.cpp
+++ b/src/test/evo_sharedmn_tests.cpp
@@ -209,6 +209,70 @@ BOOST_AUTO_TEST_CASE(share_list_validation)
     }
 }
 
+// Shared-registration shapes rejected in stateless payload validation (DIP Test Cases 2). Every
+// case fails before the later key/netInfo checks, so the payloads only need the fields under test.
+BOOST_AUTO_TEST_CASE(shared_proregtx_shape_validation)
+{
+    const auto check = [](CProRegTx& proTx, const std::string& expected) {
+        TxValidationState state;
+        BOOST_CHECK(!proTx.IsTriviallyValid(state));
+        BOOST_CHECK_EQUAL(state.GetRejectReason(), expected);
+    };
+    const auto base = []() {
+        CProRegTx proTx;
+        proTx.nVersion = ProTxVersion::ExtAddr;
+        proTx.netInfo = NetInfoInterface::MakeNetInfo(proTx.nVersion);
+        CKey r1, r2, o1, o2;
+        proTx.shares = {NewShare(600 * COIN, r1, o1), NewShare(400 * COIN, r2, o2)};
+        proTx.vchJoinSigs = DummyJoinSigs(2);
+        return proTx;
+    };
+
+    {
+        auto proTx = base();
+        proTx.nType = MnType::Evo;
+        check(proTx, "bad-protx-shares-evo");
+    }
+    {
+        auto proTx = base();
+        proTx.collateralOutpoint.hash = GetRandHash();
+        check(proTx, "bad-protx-shares-external");
+    }
+    {
+        auto proTx = base();
+        CKey owner;
+        owner.MakeNewKey(true);
+        proTx.keyIDOwner = owner.GetPubKey().GetID();
+        check(proTx, "bad-protx-shares-owner-key");
+    }
+    {
+        auto proTx = base();
+        CKey payee;
+        proTx.payouts.push_back({NewP2PKHScript(payee), MasternodePayoutShare::MAX_REWARD});
+        check(proTx, "bad-protx-shares-payouts");
+    }
+    // A non-shared payload must serialize zeroed shared fields
+    {
+        auto proTx = base();
+        proTx.shares.clear();
+        check(proTx, "bad-protx-shares-empty-fields"); // joinSigs still present
+    }
+    {
+        auto proTx = base();
+        proTx.shares.clear();
+        proTx.vchJoinSigs.clear();
+        proTx.nEarlyPenalty = 1;
+        check(proTx, "bad-protx-shares-empty-fields");
+    }
+    {
+        auto proTx = base();
+        proTx.shares.clear();
+        proTx.vchJoinSigs.clear();
+        proTx.nEarlyPeriodBlocks = 1;
+        check(proTx, "bad-protx-shares-empty-fields");
+    }
+}
+
 // The 65-byte signature size must hold statelessly, like every other signature-bearing payload
 // in this DIP: contextual verification is skipped for assumed-valid blocks
 BOOST_AUTO_TEST_CASE(proupshare_sig_size)
@@ -442,6 +506,23 @@ BOOST_AUTO_TEST_CASE(shared_reg_consent_hash)
         mtx2.nLockTime += 1;
         BOOST_CHECK(proTx.MakeSharedRegConsentHash(CTransaction(mtx2)) != base);
     }
+    {
+        CProRegTx mutated{proTx};
+        mutated.nMode = 1;
+        BOOST_CHECK(mutated.MakeSharedRegConsentHash(CTransaction(mtx)) != base);
+    }
+    {
+        CProRegTx mutated{proTx};
+        mutated.nType = MnType::Evo;
+        BOOST_CHECK(mutated.MakeSharedRegConsentHash(CTransaction(mtx)) != base);
+    }
+    {
+        CProRegTx mutated{proTx};
+        CBLSSecretKey sk;
+        sk.MakeNewKey();
+        mutated.pubKeyOperator.Set(sk.GetPublicKey(), false);
+        BOOST_CHECK(mutated.MakeSharedRegConsentHash(CTransaction(mtx)) != base);
+    }
 }
 
 BOOST_AUTO_TEST_CASE(split_amount_by_shares)
diff --git a/test/functional/feature_masternode_shares.py b/test/functional/feature_masternode_shares.py
index b55478e027db..035d1053a696 100755
--- a/test/functional/feature_masternode_shares.py
+++ b/test/functional/feature_masternode_shares.py
@@ -134,6 +134,17 @@ def run_test(self):
             assert_raises_rpc_error(-25, reason, self.generateblock, node, pre_miner, [tx_hex],
                                     sync_fun=self.no_op)
 
+        self.log.info("A template output is consensus-valid to mine before activation")
+        pre_tmpl_raw = node.createrawtransaction([], {node.getnewaddress(): 1})
+        pre_tmpl_funded = node.fundrawtransaction(pre_tmpl_raw)["hex"]
+        pre_tmpl_tx = tx_from_hex(pre_tmpl_funded)
+        pre_tmpl_tx.vout[0].scriptPubKey = CScript(bytes.fromhex(SHARED_COLLATERAL_SCRIPT))
+        pre_tmpl_value = pre_tmpl_tx.vout[0].nValue
+        pre_tmpl_signed = node.signrawtransactionwithwallet(pre_tmpl_tx.serialize().hex())
+        assert_equal(pre_tmpl_signed["complete"], True)
+        pre_tmpl_txid = node.decoderawtransaction(pre_tmpl_signed["hex"])["txid"]
+        self.generateblock(node, pre_miner, [pre_tmpl_signed["hex"]], sync_fun=self.no_op)
+
         self.activate_v24()
 
         # The same dissolution now clears the deployment gate and fails at the masternode lookup
@@ -141,6 +152,34 @@ def run_test(self):
         assert_raises_rpc_error(-25, "bad-prodis-hash", self.generateblock, node, pre_miner,
                                 [prodis_hex], sync_fun=self.no_op)
 
+        self.log.info("A template output mined before activation is permanently unspendable after it")
+        # No masternode owns this outpoint, so no ProDisTx can ever exist for it; the covenant
+        # spend rule rejects every other spender, freezing the deliberately created output forever
+        freeze_spend = CTransaction()
+        freeze_spend.vin.append(CTxIn(COutPoint(int(pre_tmpl_txid, 16), 0)))
+        freeze_spend.vout.append(CTxOut(pre_tmpl_value - 100000, CScript(b"\x51")))
+        assert_raises_rpc_error(-25, "bad-shared-collateral-spend", self.generateblock, node, pre_miner,
+                                [freeze_spend.serialize().hex()], sync_fun=self.no_op)
+
+        self.log.info("A near-miss script is unrestricted by the covenant")
+        # One tag byte off the template ('DSHD'): creation and an empty-scriptSig spend both
+        # connect fine post-activation, proving the covenant matches the exact script only
+        near_miss_script = CScript(bytes.fromhex("04445348447551"))
+        near_raw = node.createrawtransaction([], {node.getnewaddress(): 1})
+        near_funded = node.fundrawtransaction(near_raw)["hex"]
+        near_tx = tx_from_hex(near_funded)
+        near_tx.vout[0].scriptPubKey = near_miss_script
+        near_value = near_tx.vout[0].nValue
+        near_signed = node.signrawtransactionwithwallet(near_tx.serialize().hex())
+        assert_equal(near_signed["complete"], True)
+        near_txid = node.decoderawtransaction(near_signed["hex"])["txid"]
+        self.generateblock(node, pre_miner, [near_signed["hex"]], sync_fun=self.no_op)
+        near_spend = CTransaction()
+        near_spend.vin.append(CTxIn(COutPoint(int(near_txid, 16), 0)))
+        near_spend.vout.append(CTxOut(near_value - 100000, CScript(b"\x51")))
+        near_block = self.generateblock(node, pre_miner, [near_spend.serialize().hex()], sync_fun=self.no_op)
+        assert_equal(len(node.getblock(near_block["hash"])["tx"]), 2)
+
         self.log.info("Register a two-participant shared masternode")
         refund1, refund2 = node.getnewaddress(), node.getnewaddress()
         owner1, owner2 = node.getnewaddress(), node.getnewaddress()