diff --git a/doc/release-notes-7437.md b/doc/release-notes-7437.md
new file mode 100644
index 000000000000..7d98d2d42fdb
--- /dev/null
+++ b/doc/release-notes-7437.md
@@ -0,0 +1,53 @@
+# 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 4 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 inside a ProRegTx, 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.
diff --git a/src/Makefile.am b/src/Makefile.am
index 4b446675291e..106b38fb5c9b 100644
--- a/src/Makefile.am
+++ b/src/Makefile.am
@@ -227,6 +227,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/Makefile.test.include b/src/Makefile.test.include
index e2f1782e5d42..521f5167184f 100644
--- a/src/Makefile.test.include
+++ b/src/Makefile.test.include
@@ -114,6 +114,7 @@ BITCOIN_TESTS =\
   test/evo_islock_tests.cpp \
   test/evo_mnhf_tests.cpp \
   test/evo_netinfo_tests.cpp \
+  test/evo_sharedmn_tests.cpp \
   test/evo_simplifiedmns_tests.cpp \
   test/evo_trivialvalidation.cpp \
   test/evo_utils_tests.cpp \
diff --git a/src/common/bloom.cpp b/src/common/bloom.cpp
index 4b0c4c334f19..d2ba500dbb65 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->nVersion, opt_proTx->scriptPayout, opt_proTx->payouts);
             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/core_write.cpp b/src/core_write.cpp
index a7ab773fdc22..7c6d3aee9f3b 100644
--- a/src/core_write.cpp
+++ b/src/core_write.cpp
@@ -324,6 +324,18 @@ void TxToUniv(const CTransaction& tx, const uint256& block_hash, UniValue& entry
         if (const auto opt_assetUnlockTx = GetTxPayload<CAssetUnlockPayload>(tx)) {
             entry.pushKV("assetUnlockTx", opt_assetUnlockTx->ToJson());
         }
+    } else if (tx.nType == TRANSACTION_PROVIDER_DISSOLVE) {
+        if (const auto opt_proTx = GetTxPayload<CProDisTx>(tx)) {
+            entry.pushKV("proDisTx", opt_proTx->ToJson());
+        }
+    } else if (tx.nType == TRANSACTION_PROVIDER_UPDATE_SHARE) {
+        if (const auto opt_proTx = GetTxPayload<CProUpShareTx>(tx)) {
+            entry.pushKV("proUpShareTx", opt_proTx->ToJson());
+        }
+    } else if (tx.nType == TRANSACTION_PROVIDER_UPDATE_SHARED_REGISTRAR) {
+        if (const auto opt_proTx = GetTxPayload<CProUpSharedRegTx>(tx)) {
+            entry.pushKV("proUpSharedRegTx", opt_proTx->ToJson());
+        }
     }
 
     if (have_undo) {
diff --git a/src/evo/assetlocktx.cpp b/src/evo/assetlocktx.cpp
index cba0bdc55534..636488aa26c8 100644
--- a/src/evo/assetlocktx.cpp
+++ b/src/evo/assetlocktx.cpp
@@ -155,6 +155,11 @@ bool CheckAssetUnlockTx(const BlockManager& blockman, const llmq::CQuorumManager
         return state.Invalid(TxValidationResult::TX_BAD_SPECIAL, "bad-assetunlocktx-too-many-outs");
     }
 
+    // A withdrawal paying the shared-collateral template is rejected by the generic template
+    // creation rule (CheckSharedCollateralTemplateOutputs), which is gated on v24. It is
+    // deliberately NOT re-checked here: this function has no v24 activation status available, and
+    // an unconditional rejection would diverge from pre-activation consensus and split the chain.
+
     const auto opt_assetUnlockTx = GetTxPayload<CAssetUnlockPayload>(tx);
     if (!opt_assetUnlockTx) {
         return state.Invalid(TxValidationResult::TX_BAD_SPECIAL, "bad-assetunlocktx-payload");
diff --git a/src/evo/core_write.cpp b/src/evo/core_write.cpp
index 53056d0b9a69..fa41dd74da55 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"),
@@ -229,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),
     }};
@@ -260,7 +278,11 @@ UniValue CDeterministicMNState::ToJson(MnType nType) const
     }
 
     CTxDestination dest;
-    if (nVersion >= ProTxVersion::MultiPayout) {
+    if (IsShared()) {
+        obj.pushKV("shares", ShareListToJson(shares));
+        obj.pushKV("earlyPeriodBlocks", static_cast<int64_t>(nEarlyPeriodBlocks));
+        obj.pushKV("earlyPenalty", nEarlyPenalty);
+    } else if (nVersion >= ProTxVersion::MultiPayout) {
         obj.pushKV("payouts", PayoutListToJson(payouts));
     } else if (ExtractDestination(scriptPayout, dest)) {
         obj.pushKV("payoutAddress", EncodeDestination(dest));
@@ -290,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),
@@ -313,6 +338,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 +363,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::MultiPayout) {
+    if (IsShared()) {
+        ret.pushKV("shares", ShareListToJson(shares));
+        ret.pushKV("earlyPeriodBlocks", static_cast<int64_t>(nEarlyPeriodBlocks));
+        ret.pushKV("earlyPenalty", nEarlyPenalty);
+    } else if (nVersion >= ProTxVersion::MultiPayout) {
         ret.pushKV("payouts", PayoutListToJson(payouts));
     } else if (CTxDestination dest; ExtractDestination(scriptPayout, dest)) {
         ret.pushKV("payoutAddress", EncodeDestination(dest));
@@ -404,6 +436,77 @@ UniValue CProUpRevTx::ToJson() const
     return ret;
 }
 
+RPCResult CProDisTx::GetJsonHelp(const std::string& key, bool optional)
+{
+    return {RPCResult::Type::OBJ, key, optional, key.empty() ? "" : "The shared masternode dissolution special transaction",
+    {
+        GetRpcResult("version"),
+        GetRpcResult("proTxHash"),
+        {RPCResult::Type::NUM, "actorIndex", "Index into the share table of the participant paying the penalty (if any) and the fee"},
+        {RPCResult::Type::NUM, "sigCount", "Number of signatures: 1 = unilateral, one per share = unanimous"},
+    }};
+}
+
+UniValue CProDisTx::ToJson() const
+{
+    UniValue ret(UniValue::VOBJ);
+    ret.pushKV("version", nVersion);
+    ret.pushKV("proTxHash", proTxHash.ToString());
+    ret.pushKV("actorIndex", actorIndex);
+    ret.pushKV("sigCount", static_cast<uint64_t>(vchSigs.size()));
+    return ret;
+}
+
+RPCResult CProUpShareTx::GetJsonHelp(const std::string& key, bool optional)
+{
+    return {RPCResult::Type::OBJ, key, optional, key.empty() ? "" : "The shared masternode share update special transaction",
+    {
+        GetRpcResult("version"),
+        GetRpcResult("proTxHash"),
+        {RPCResult::Type::NUM, "shareIndex", "Index into the share table of the share being updated"},
+        {RPCResult::Type::STR, "rewardAddress", /*optional=*/true, "New Dash address for this share's owner rewards; omitted when reverting to the refund script"},
+        GetRpcResult("inputsHash"),
+    }};
+}
+
+UniValue CProUpShareTx::ToJson() const
+{
+    UniValue ret(UniValue::VOBJ);
+    ret.pushKV("version", nVersion);
+    ret.pushKV("proTxHash", proTxHash.ToString());
+    ret.pushKV("shareIndex", shareIndex);
+    if (CTxDestination dest; !scriptReward.empty() && ExtractDestination(scriptReward, dest)) {
+        ret.pushKV("rewardAddress", EncodeDestination(dest));
+    }
+    ret.pushKV("inputsHash", inputsHash.ToString());
+    return ret;
+}
+
+RPCResult CProUpSharedRegTx::GetJsonHelp(const std::string& key, bool optional)
+{
+    return {RPCResult::Type::OBJ, key, optional, key.empty() ? "" : "The shared masternode registrar update special transaction",
+    {
+        GetRpcResult("version"),
+        GetRpcResult("proTxHash"),
+        GetRpcResult("votingAddress"),
+        GetRpcResult("pubKeyOperator"),
+        GetRpcResult("inputsHash"),
+        {RPCResult::Type::NUM, "sigCount", "Number of signatures; must equal the share count"},
+    }};
+}
+
+UniValue CProUpSharedRegTx::ToJson() const
+{
+    UniValue ret(UniValue::VOBJ);
+    ret.pushKV("version", nVersion);
+    ret.pushKV("proTxHash", proTxHash.ToString());
+    ret.pushKV("votingAddress", EncodeDestination(PKHash(keyIDVoting)));
+    ret.pushKV("pubKeyOperator", pubKeyOperator.ToString());
+    ret.pushKV("inputsHash", inputsHash.ToString());
+    ret.pushKV("sigCount", static_cast<uint64_t>(vchSigs.size()));
+    return ret;
+}
+
 RPCResult CProUpServTx::GetJsonHelp(const std::string& key, bool optional)
 {
     return {RPCResult::Type::OBJ, key, optional, key.empty() ? "" : "The masternode update service special transaction",
diff --git a/src/evo/deterministicmns.cpp b/src/evo/deterministicmns.cpp
index df22b9198362..911ce32822b3 100644
--- a/src/evo/deterministicmns.cpp
+++ b/src/evo/deterministicmns.cpp
@@ -431,7 +431,19 @@ void CDeterministicMNList::AddMN(const CDeterministicMNCPtr& dmn, bool fBumpTota
                 strprintf("%s: Can't add a masternode %s with invalid address", __func__, dmn->proTxHash.ToString()));
         }
     }
-    if (!AddUniqueProperty(*dmn, dmn->pdmnState->keyIDOwner)) {
+    if (dmn->pdmnState->IsShared()) {
+        // A shared masternode has a null keyIDOwner; each share owner key takes its place. Share
+        // owner keys deliberately land in the same uniqueness namespace as keyIDOwner
+        // (GetUniquePropertyHash is an untagged SerializeHash of the value), which is what makes
+        // owner-key reuse between shared and non-shared masternodes impossible in both directions.
+        for (const auto& share : dmn->pdmnState->shares) {
+            if (!AddUniqueProperty(*dmn, share.keyIDOwner)) {
+                mnUniquePropertyMap = mnUniquePropertyMapSaved;
+                throw(std::runtime_error(strprintf("%s: Can't add a masternode %s with a duplicate share ownerKeyID=%s", __func__,
+                        dmn->proTxHash.ToString(), EncodeDestination(PKHash(share.keyIDOwner)))));
+            }
+        }
+    } else if (!AddUniqueProperty(*dmn, dmn->pdmnState->keyIDOwner)) {
         mnUniquePropertyMap = mnUniquePropertyMapSaved;
         throw(std::runtime_error(strprintf("%s: Can't add a masternode %s with a duplicate keyIDOwner=%s", __func__,
                 dmn->proTxHash.ToString(), EncodeDestination(PKHash(dmn->pdmnState->keyIDOwner)))));
@@ -588,7 +600,16 @@ void CDeterministicMNList::RemoveMN(const uint256& proTxHash)
                                                dmn->proTxHash.ToString()));
         }
     }
-    if (!DeleteUniqueProperty(*dmn, dmn->pdmnState->keyIDOwner)) {
+    if (dmn->pdmnState->IsShared()) {
+        // Shared masternodes have a null keyIDOwner; the share owner keys were registered instead
+        for (const auto& share : dmn->pdmnState->shares) {
+            if (!DeleteUniqueProperty(*dmn, share.keyIDOwner)) {
+                mnUniquePropertyMap = mnUniquePropertyMapSaved;
+                throw(std::runtime_error(strprintf("%s: Can't delete a masternode %s with a share ownerKeyID=%s", __func__,
+                        proTxHash.ToString(), EncodeDestination(PKHash(share.keyIDOwner)))));
+            }
+        }
+    } else if (!DeleteUniqueProperty(*dmn, dmn->pdmnState->keyIDOwner)) {
         mnUniquePropertyMap = mnUniquePropertyMapSaved;
         throw(std::runtime_error(strprintf("%s: Can't delete a masternode %s with a keyIDOwner=%s", __func__,
                 proTxHash.ToString(), EncodeDestination(PKHash(dmn->pdmnState->keyIDOwner)))));
diff --git a/src/evo/dmnstate.cpp b/src/evo/dmnstate.cpp
index b384966cb9b7..8afb00406706 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(nVersion, scriptPayout, payouts);
-    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(nVersion, scriptPayout, payouts));
     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 dfab76d1e25b..9b2570c6d32a 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::MultiPayout) {
-            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 d098690fd1ba..fbab424f7282 100644
--- a/src/evo/providertx.cpp
+++ b/src/evo/providertx.cpp
@@ -5,9 +5,11 @@
 #include <evo/providertx.h>
 
 #include <evo/dmn_types.h>
+#include <evo/sharedcollateral.h>
 #include <util/std23.h>
 
 #include <chainparams.h>
+#include <clientversion.h>
 #include <consensus/validation.h>
 #include <deploymentstatus.h>
 #include <hash.h>
@@ -88,6 +90,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)
@@ -148,14 +226,47 @@ bool CProRegTx::IsTriviallyValid(gsl::not_null<const CBlockIndex*> pindexPrev, c
         return state.Invalid(TxValidationResult::TX_CONSENSUS, "bad-protx-mode");
     }
 
-    if (keyIDOwner.IsNull() || !pubKeyOperator.Get().IsValid() || keyIDVoting.IsNull()) {
+    if (IsShared()) {
+        if (nVersion < ProTxVersion::MultiPayout) {
+            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(nVersion, scriptPayout, payouts);
-    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(nVersion, scriptPayout, payouts);
+        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");
     }
@@ -176,6 +287,37 @@ bool CProRegTx::IsTriviallyValid(gsl::not_null<const CBlockIndex*> pindexPrev, c
     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, 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.
+    CHashWriter hw(SER_GETHASH, CLIENT_VERSION);
+    hw << std::string("DashSharedMNReg");
+    hw << nVersion;
+    hw << tx.nVersion;
+    hw << tx.nType;
+    hw << tx.nLockTime;
+    hw << CalcTxInputsHash(tx);
+    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;
@@ -200,7 +342,9 @@ std::string CProRegTx::MakeSignString() const
 
 std::string CProRegTx::ToString() const
 {
-    const std::string payee = PayoutListToString(GetOwnerPayouts(nVersion, scriptPayout, payouts));
+    const std::string payee = IsShared() ? strprintf("shares(%s), earlyPeriodBlocks=%d, earlyPenalty=%d",
+                                                     ShareListToString(shares), nEarlyPeriodBlocks, nEarlyPenalty)
+                                         : PayoutListToString(GetOwnerPayouts(nVersion, scriptPayout, payouts));
 
     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",
@@ -305,3 +449,121 @@ 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(gsl::not_null<const CBlockIndex*> pindexPrev, const ChainstateManager& chainman,
+                                 TxValidationState& state) const
+{
+    if (!DeploymentActiveAfter(pindexPrev, chainman, Consensus::DEPLOYMENT_V24)) {
+        return state.Invalid(TxValidationResult::TX_CONSENSUS, "bad-prodis-too-early");
+    }
+    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(gsl::not_null<const CBlockIndex*> pindexPrev, const ChainstateManager& chainman,
+                                     TxValidationState& state) const
+{
+    if (!DeploymentActiveAfter(pindexPrev, chainman, Consensus::DEPLOYMENT_V24)) {
+        return state.Invalid(TxValidationResult::TX_CONSENSUS, "bad-proupshare-too-early");
+    }
+    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(gsl::not_null<const CBlockIndex*> pindexPrev,
+                                         const ChainstateManager& chainman, TxValidationState& state) const
+{
+    if (!DeploymentActiveAfter(pindexPrev, chainman, Consensus::DEPLOYMENT_V24)) {
+        return state.Invalid(TxValidationResult::TX_CONSENSUS, "bad-proupsharedreg-too-early");
+    }
+    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 a8c24d34b80b..8de436a9e032 100644
--- a/src/evo/providertx.h
+++ b/src/evo/providertx.h
@@ -94,6 +94,62 @@ class CMasternodePayoutShare
 
 using MasternodePayoutShares = std::vector<CMasternodePayoutShare>;
 
+/** Serializes a 65-byte compact recoverable ECDSA signature without a length prefix */
+struct CompactSignatureFormatter {
+    template <typename Stream, typename V>
+    void Ser(Stream& s, const V& v)
+    {
+        if (v.size() != CPubKey::COMPACT_SIGNATURE_SIZE) {
+            throw std::ios_base::failure("compact signature size mismatch");
+        }
+        s.write(AsBytes(Span{v}));
+    }
+    template <typename Stream, typename V>
+    void Unser(Stream& s, V& v)
+    {
+        v.resize(CPubKey::COMPACT_SIGNATURE_SIZE);
+        s.read(AsWritableBytes(Span{v}));
+    }
+};
+
+/** One participant's contribution to a shared masternode collateral */
+class CCollateralShare
+{
+public:
+    static constexpr CAmount MIN_AMOUNT{100 * COIN};
+
+    CAmount amount{0};
+    CScript scriptRefund;
+    CScript scriptReward; //!< empty means "use scriptRefund"
+    CKeyID keyIDOwner;
+
+    CCollateralShare() = default;
+    CCollateralShare(CAmount amount, CScript script_refund, CScript script_reward, CKeyID key_id_owner) :
+        amount(amount),
+        scriptRefund(std::move(script_refund)),
+        scriptReward(std::move(script_reward)),
+        keyIDOwner(key_id_owner)
+    {
+    }
+
+    SERIALIZE_METHODS(CCollateralShare, obj)
+    {
+        READWRITE(obj.amount, obj.scriptRefund, obj.scriptReward, obj.keyIDOwner);
+    }
+
+    /** The script this share's portion of owner rewards is paid to */
+    const CScript& RewardScript() const { return scriptReward.empty() ? scriptRefund : scriptReward; }
+
+    friend bool operator==(const CCollateralShare& a, const CCollateralShare& b)
+    {
+        return a.amount == b.amount && a.scriptRefund == b.scriptRefund && a.scriptReward == b.scriptReward &&
+               a.keyIDOwner == b.keyIDOwner;
+    }
+    friend bool operator!=(const CCollateralShare& a, const CCollateralShare& b) { return !(a == b); }
+};
+
+using CollateralShares = std::vector<CCollateralShare>;
+
 [[nodiscard]] MasternodePayoutShares LegacyPayoutAsList(const CScript& script_payout);
 [[nodiscard]] MasternodePayoutShares GetOwnerPayouts(uint16_t nVersion, const CScript& script_payout,
                                                      const MasternodePayoutShares& payouts);
@@ -105,11 +161,26 @@ using MasternodePayoutShares = std::vector<CMasternodePayoutShare>;
 [[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);
+/** 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:
     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
@@ -124,6 +195,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;
 
@@ -157,6 +232,18 @@ class CProRegTx
             for (auto& payout : obj.payouts) {
                 READWRITE(payout);
             }
+            uint8_t shares_count{0};
+            SER_WRITE(obj, shares_count = static_cast<uint8_t>(obj.shares.size()));
+            READWRITE(shares_count);
+            SER_READ(obj, obj.shares.resize(shares_count));
+            for (auto& share : obj.shares) {
+                READWRITE(share);
+            }
+            SER_READ(obj, obj.vchJoinSigs.resize(shares_count));
+            for (auto& sig : obj.vchJoinSigs) {
+                READWRITE(Using<CompactSignatureFormatter>(sig));
+            }
+            READWRITE(obj.nEarlyPeriodBlocks, obj.nEarlyPenalty);
         } else {
             READWRITE(obj.scriptPayout);
         }
@@ -177,6 +264,14 @@ 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;
@@ -364,6 +459,117 @@ class CProUpRevTx
                           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;
+
+    bool IsTriviallyValid(gsl::not_null<const CBlockIndex*> pindexPrev, const ChainstateManager& chainman,
+                          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;
+
+    bool IsTriviallyValid(gsl::not_null<const CBlockIndex*> pindexPrev, const ChainstateManager& chainman,
+                          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;
+
+    bool IsTriviallyValid(gsl::not_null<const CBlockIndex*> pindexPrev, const ChainstateManager& chainman,
+                          TxValidationState& state) const;
+};
+
 template <typename ProTx>
 static bool CheckInputsHash(const CTransaction& tx, const ProTx& proTx, TxValidationState& state)
 {
diff --git a/src/evo/providertx_util.cpp b/src/evo/providertx_util.cpp
index 0d963b4fb6d6..583930279db1 100644
--- a/src/evo/providertx_util.cpp
+++ b/src/evo/providertx_util.cpp
@@ -4,6 +4,7 @@
 
 #include <evo/providertx.h>
 
+#include <arith_uint256.h>
 #include <key_io.h>
 #include <script/standard.h>
 #include <tinyformat.h>
@@ -54,3 +55,67 @@ 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;
+}
+
+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/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/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/specialtx_filter.cpp b/src/evo/specialtx_filter.cpp
index cd11be7708f6..1ab18129c296 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->nVersion, opt_proTx->scriptPayout, opt_proTx->payouts)) {
                 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/evo/specialtxman.cpp b/src/evo/specialtxman.cpp
index 72ba23ca3206..b93042103f16 100644
--- a/src/evo/specialtxman.cpp
+++ b/src/evo/specialtxman.cpp
@@ -13,6 +13,7 @@
 #include <evo/deterministicmns.h>
 #include <evo/mnhftx.h>
 #include <evo/netinfo.h>
+#include <evo/sharedcollateral.h>
 #include <evo/simplifiedmns.h>
 #include <llmq/blockprocessor.h>
 #include <llmq/commitment.h>
@@ -21,6 +22,7 @@
 #include <messagesigner.h>
 #include <util/helpers.h>
 
+#include <arith_uint256.h>
 #include <chainparams.h>
 #include <consensus/amount.h>
 #include <consensus/validation.h>
@@ -174,8 +176,8 @@ bool CheckCbTxBestChainlock(const CCbTx& cbTx, const CBlockIndex* pindex, const
 static bool CheckSpecialTxInner(CDeterministicMNManager& dmnman, llmq::CQuorumSnapshotManager& qsnapman,
                                 const ChainstateManager& chainman, const llmq::CQuorumManager& qman,
                                 const CTransaction& tx, const CBlockIndex* pindexPrev, const CCoinsViewCache& view,
-                                const std::optional<CRangesSet>& indexes, bool check_sigs, TxValidationState& state)
-    EXCLUSIVE_LOCKS_REQUIRED(::cs_main)
+                                const std::optional<CRangesSet>& indexes, bool check_sigs, SpecialTxContext context,
+                                TxValidationState& state) EXCLUSIVE_LOCKS_REQUIRED(::cs_main)
 {
     AssertLockHeld(::cs_main);
 
@@ -196,6 +198,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");
@@ -227,7 +235,7 @@ bool CSpecialTxProcessor::CheckSpecialTx(const CTransaction& tx, const CBlockInd
 {
     AssertLockHeld(::cs_main);
     return CheckSpecialTxInner(m_dmnman, m_qsnapman, m_chainman, m_qman, tx, pindexPrev, view, std::nullopt, check_sigs,
-                               state);
+                               SpecialTxContext::Mempool, state);
 }
 
 static void HandleQuorumCommitment(const llmq::CFinalCommitment& qc, const std::vector<CDeterministicMNCPtr>& members,
@@ -364,7 +372,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");
             }
 
@@ -445,9 +462,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);
@@ -470,6 +488,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};
@@ -529,6 +551,90 @@ bool CSpecialTxProcessor::RebuildListFromBlock(const CBlock& block, gsl::not_nul
                 LogPrintf("%s -- MN %s revoked operator key at height %d: %s\n", __func__,
                           opt_proTx->proTxHash.ToString(), nHeight, opt_proTx->ToString());
             }
+        } else if (tx.nType == TRANSACTION_PROVIDER_DISSOLVE) {
+            const auto opt_proTx = GetTxPayload<CProDisTx>(tx);
+            if (!opt_proTx) {
+                return state.Invalid(BlockValidationResult::BLOCK_CONSENSUS, "bad-protx-payload");
+            }
+
+            // Authoritative validation: newList at this position equals the previous block's list
+            // plus earlier transactions in this block, so a masternode registered and dissolved
+            // within one block is handled per the DIP.
+            //
+            // 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;
+
+            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 MultiPayout or later; restore the state version that
+            // ResetOperatorFields() cleared
+            if (!SetStateVersion(*newState, old_version, dmn->nType, state)) {
+                return false;
+            }
+            if (operator_changed) {
+                newState->pubKeyOperator.SetLegacy(false);
+            }
+
+            newList.UpdateMN(opt_proTx->proTxHash, newState);
+
+            if (debugLogs) {
+                LogPrintf("%s -- MN %s updated shared registrar at height %d: %s\n", __func__,
+                          opt_proTx->proTxHash.ToString(), nHeight, opt_proTx->ToString());
+            }
         } else if (tx.nType == TRANSACTION_QUORUM_COMMITMENT) {
             const auto opt_qc = GetTxPayload<llmq::CFinalCommitmentTxPayload>(tx);
             if (!opt_qc) {
@@ -566,6 +672,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) {
@@ -672,7 +786,18 @@ bool CSpecialTxProcessor::ProcessSpecialTxsInBlock(const CBlock& block, const CB
             indexes = std::move(creditPool.indexes);
         }
 
+        const bool is_v24_active{DeploymentActiveAt(*pindex, m_chainman, Consensus::DEPLOYMENT_V24)};
         for (size_t i = 0; i < block.vtx.size(); ++i) {
+            // The shared-collateral creation rule applies to every transaction, including the
+            // coinbase and non-special transactions, which CheckSpecialTxInner never sees
+            if (is_v24_active) {
+                if (TxValidationState tx_state; !CheckSharedCollateralTemplateOutputs(*block.vtx[i], tx_state)) {
+                    return state.Invalid(BlockValidationResult::BLOCK_CONSENSUS, tx_state.GetRejectReason(),
+                                         strprintf("Shared collateral check failed (tx hash %s) %s",
+                                                   block.vtx[i]->GetHash().ToString(), tx_state.GetDebugMessage()));
+                }
+            }
+
             // we validated CCbTx above, starts from the 2nd transaction
             if (i == 0 && block.vtx[i]->nType == TRANSACTION_COINBASE) continue;
 
@@ -681,7 +806,7 @@ bool CSpecialTxProcessor::ProcessSpecialTxsInBlock(const CBlock& block, const CB
             // At this moment CheckSpecialTx() may fail by 2 possible ways:
             // consensus failures and "TX_BAD_SPECIAL"
             if (!CheckSpecialTxInner(m_dmnman, m_qsnapman, m_chainman, m_qman, *ptr_tx, pindex->pprev, view, indexes,
-                                     fCheckCbTxMerkleRoots, tx_state)) {
+                                     fCheckCbTxMerkleRoots, SpecialTxContext::Block, tx_state)) {
                 assert(tx_state.GetResult() == TxValidationResult::TX_CONSENSUS || tx_state.GetResult() == TxValidationResult::TX_BAD_SPECIAL);
                 return state.Invalid(BlockValidationResult::BLOCK_CONSENSUS, tx_state.GetRejectReason(),
                                  strprintf("Special Transaction check failed (tx hash %s) %s", ptr_tx->GetHash().ToString(), tx_state.GetDebugMessage()));
@@ -1086,7 +1211,12 @@ bool CheckProRegTx(const CTransaction& tx, gsl::not_null<const CBlockIndex*> pin
             return state.Invalid(TxValidationResult::TX_BAD_SPECIAL, "bad-protx-collateral");
         }
 
-        if (!ExtractDestination(tx.vout[opt_ptx->collateralOutpoint.n].scriptPubKey, collateralTxDest)) {
+        if (opt_ptx->IsShared()) {
+            // Shared collateral must use exactly the template script; there is no destination to extract
+            if (!sharedcollateral::IsSharedCollateralScript(tx.vout[opt_ptx->collateralOutpoint.n].scriptPubKey)) {
+                return state.Invalid(TxValidationResult::TX_BAD_SPECIAL, "bad-protx-shares-collateral-script");
+            }
+        } else if (!ExtractDestination(tx.vout[opt_ptx->collateralOutpoint.n].scriptPubKey, collateralTxDest)) {
             return state.Invalid(TxValidationResult::TX_BAD_SPECIAL, "bad-protx-collateral-dest");
         }
 
@@ -1095,7 +1225,9 @@ bool CheckProRegTx(const CTransaction& tx, gsl::not_null<const CBlockIndex*> pin
 
     // don't allow reuse of collateral key for other keys (don't allow people to put the collateral key onto an online server)
     // this check applies to internal and external collateral, but internal collaterals are not necessarily a P2PKH
-    if (!IsPayoutListKeySafe(GetOwnerPayouts(opt_ptx->nVersion, opt_ptx->scriptPayout, opt_ptx->payouts),
+    // (shared collateral has no destination at all; refund/reward key reuse is checked in IsShareListTriviallyValid)
+    if (!opt_ptx->IsShared() &&
+        !IsPayoutListKeySafe(GetOwnerPayouts(opt_ptx->nVersion, opt_ptx->scriptPayout, opt_ptx->payouts),
                              collateralTxDest, opt_ptx->keyIDOwner, opt_ptx->keyIDVoting,
                              opt_ptx->nVersion >= ProTxVersion::MultiPayout, state)) return false;
 
@@ -1119,8 +1251,19 @@ bool CheckProRegTx(const CTransaction& tx, gsl::not_null<const CBlockIndex*> pin
             }
         }
 
-        // never allow duplicate keys, even if this ProTx would replace an existing MN
-        if (mnList.HasUniqueProperty(opt_ptx->keyIDOwner) || mnList.HasUniqueProperty(opt_ptx->pubKeyOperator)) {
+        // never allow duplicate keys, even if this ProTx would replace an existing MN. Share owner
+        // keys live in the same uniqueness namespace as keyIDOwner, so reuse is blocked in both
+        // directions between shared and non-shared masternodes.
+        if (opt_ptx->IsShared()) {
+            for (const auto& share : opt_ptx->shares) {
+                if (mnList.HasUniqueProperty(share.keyIDOwner)) {
+                    return state.Invalid(TxValidationResult::TX_BAD_SPECIAL, "bad-protx-dup-key");
+                }
+            }
+            if (mnList.HasUniqueProperty(opt_ptx->pubKeyOperator)) {
+                return state.Invalid(TxValidationResult::TX_BAD_SPECIAL, "bad-protx-dup-key");
+            }
+        } else if (mnList.HasUniqueProperty(opt_ptx->keyIDOwner) || mnList.HasUniqueProperty(opt_ptx->pubKeyOperator)) {
             return state.Invalid(TxValidationResult::TX_BAD_SPECIAL, "bad-protx-dup-key");
         }
 
@@ -1154,6 +1297,18 @@ bool CheckProRegTx(const CTransaction& tx, gsl::not_null<const CBlockIndex*> pin
         if (!opt_ptx->vchSig.empty()) {
             return state.Invalid(TxValidationResult::TX_CONSENSUS, "bad-protx-sig");
         }
+        if (opt_ptx->IsShared() && check_sigs) {
+            // every participant must consent to the exact funding inputs, outputs, share table,
+            // penalty terms and registrar configuration
+            const uint256 consent_hash = opt_ptx->MakeSharedRegConsentHash(tx);
+            for (size_t i = 0; i < opt_ptx->shares.size(); i++) {
+                if (std::string strError;
+                    !CHashSigner::VerifyHashCanonical(consent_hash, opt_ptx->shares[i].keyIDOwner,
+                                                      opt_ptx->vchJoinSigs[i], strError)) {
+                    return state.Invalid(TxValidationResult::TX_BAD_SPECIAL, "bad-protx-shares-sig");
+                }
+            }
+        }
     }
 
     return true;
@@ -1254,6 +1409,12 @@ bool CheckProUpRegTx(const CTransaction& tx, gsl::not_null<const CBlockIndex*> p
         return state.Invalid(TxValidationResult::TX_CONSENSUS, "bad-protx-hash");
     }
 
+    // Shared masternodes have no registrar owner key; they are updated via ProUpShareTx and
+    // ProUpSharedRegTx exclusively
+    if (dmn->pdmnState->IsShared()) {
+        return state.Invalid(TxValidationResult::TX_BAD_SPECIAL, "bad-protx-shared-mn");
+    }
+
     if (!IsVersionChangeValid(pindexPrev, tx.nType, dmn->pdmnState->nVersion, opt_ptx->nVersion, chainman, state)) {
         // pass the state returned by the function above
         return false;
@@ -1335,6 +1496,275 @@ 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;
+    }
+
+    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;
+    }
+
+    const auto mnList = dmnman.GetListForBlock(pindexPrev);
+    const auto dmn = mnList.GetMN(opt_ptx->proTxHash);
+    if (!dmn) {
+        return state.Invalid(TxValidationResult::TX_BAD_SPECIAL, "bad-proupsharedreg-hash");
+    }
+    const auto& mnState = *dmn->pdmnState;
+    if (!mnState.IsShared()) {
+        return state.Invalid(TxValidationResult::TX_BAD_SPECIAL, "bad-proupsharedreg-not-shared");
+    }
+
+    // A shared registrar update requires unanimity: one signature per share, in share order
+    if (opt_ptx->vchSigs.size() != mnState.shares.size()) {
+        return state.Invalid(TxValidationResult::TX_BAD_SPECIAL, "bad-proupsharedreg-sig-count");
+    }
+
+    if (mnList.HasUniqueProperty(opt_ptx->pubKeyOperator)) {
+        auto otherDmn = mnList.GetUniquePropertyMN(opt_ptx->pubKeyOperator);
+        if (opt_ptx->proTxHash != otherDmn->proTxHash) {
+            return state.Invalid(TxValidationResult::TX_BAD_SPECIAL, "bad-protx-dup-key");
+        }
+    }
+
+    if (!CheckInputsHash(tx, *opt_ptx, state)) {
+        // pass the state returned by the function above
+        return false;
+    }
+    if (check_sigs) {
+        const uint256 payload_hash = ::SerializeHash(*opt_ptx);
+        for (size_t i = 0; i < mnState.shares.size(); i++) {
+            if (std::string strError; !CHashSigner::VerifyHashCanonical(payload_hash, mnState.shares[i].keyIDOwner,
+                                                                        opt_ptx->vchSigs[i], strError)) {
+                return state.Invalid(TxValidationResult::TX_BAD_SPECIAL, "bad-proupsharedreg-sig");
+            }
+        }
+    }
+
+    return true;
+}
+
+bool CheckProDisTxForList(const CTransaction& tx, const CProDisTx& ptx, const CDeterministicMNList& mnList,
+                          int nSpendHeight, TxValidationState& state, bool check_sigs)
+{
+    const auto dmn = mnList.GetMN(ptx.proTxHash);
+    if (!dmn) {
+        return state.Invalid(TxValidationResult::TX_BAD_SPECIAL, "bad-prodis-hash");
+    }
+    const auto& mnState = *dmn->pdmnState;
+    if (!mnState.IsShared()) {
+        return state.Invalid(TxValidationResult::TX_BAD_SPECIAL, "bad-prodis-not-shared");
+    }
+    const auto& shares = mnState.shares;
+
+    // Exactly one input: the masternode's collateral outpoint, with an empty scriptSig (the
+    // empty-scriptSig rule keeps the txid non-malleable; the template script needs no witness)
+    if (tx.vin.size() != 1 || tx.vin[0].prevout != dmn->collateralOutpoint || !tx.vin[0].scriptSig.empty()) {
+        return state.Invalid(TxValidationResult::TX_BAD_SPECIAL, "bad-prodis-input");
+    }
+    if (ptx.actorIndex >= shares.size()) {
+        return state.Invalid(TxValidationResult::TX_BAD_SPECIAL, "bad-prodis-actor");
+    }
+
+    // The signature count defines the mode: exactly one (unilateral, by the actor) or exactly one
+    // per share in share order (unanimous). shares.size() >= 2, so the two cannot coincide.
+    if (ptx.vchSigs.size() != 1 && ptx.vchSigs.size() != shares.size()) {
+        return state.Invalid(TxValidationResult::TX_BAD_SPECIAL, "bad-prodis-sig-count");
+    }
+    const bool unanimous{ptx.vchSigs.size() == shares.size()};
+
+    // requiredPenalty is non-increasing in nSpendHeight, which makes ProDisTx validity monotone:
+    // once valid, always valid (see the DIP's "Output rules" section)
+    const bool early{nSpendHeight - mnState.nRegisteredHeight < static_cast<int64_t>(mnState.nEarlyPeriodBlocks)};
+    const CAmount required_penalty{(unanimous || !early) ? 0 : mnState.nEarlyPenalty};
+
+    // One output per non-actor share, paying its refund script, in share order, plus optionally
+    // one final actor output. A zero-value actor output must be omitted. No other outputs.
+    const size_t non_actor_count{shares.size() - 1};
+    if (tx.vout.size() != non_actor_count && tx.vout.size() != non_actor_count + 1) {
+        return state.Invalid(TxValidationResult::TX_BAD_SPECIAL, "bad-prodis-payee-count");
+    }
+
+    CAmount non_actor_total{0};
+    for (size_t i = 0; i < shares.size(); i++) {
+        if (i != ptx.actorIndex) non_actor_total += shares[i].amount;
+    }
+
+    size_t out_idx{0};
+    CAmount bonus_total{0};
+    for (size_t i = 0; i < shares.size(); i++) {
+        if (i == ptx.actorIndex) continue;
+        const auto& out = tx.vout[out_idx++];
+        if (out.scriptPubKey != shares[i].scriptRefund) {
+            return state.Invalid(TxValidationResult::TX_BAD_SPECIAL, "bad-prodis-payee");
+        }
+        // Minimum-based rules: bonus[i] >= floor(P * amount[i] / W). The floor is element-wise
+        // monotone in P, which is what preserves monotone validity; overpaying is always valid.
+        const CAmount bonus{out.nValue - shares[i].amount};
+        const CAmount min_bonus{[&]() {
+            if (required_penalty == 0) return CAmount{0};
+            // 128-bit intermediate: penalty and amount can each approach the full collateral
+            arith_uint256 v{static_cast<uint64_t>(required_penalty)};
+            v *= arith_uint256{static_cast<uint64_t>(shares[i].amount)};
+            v /= arith_uint256{static_cast<uint64_t>(non_actor_total)};
+            return static_cast<CAmount>(v.GetLow64());
+        }()};
+        if (bonus < min_bonus) {
+            return state.Invalid(TxValidationResult::TX_BAD_SPECIAL, "bad-prodis-penalty-floor");
+        }
+        bonus_total += bonus;
+    }
+    if (tx.vout.size() == non_actor_count + 1) {
+        const auto& actor_out = tx.vout.back();
+        if (actor_out.scriptPubKey != shares[ptx.actorIndex].scriptRefund) {
+            return state.Invalid(TxValidationResult::TX_BAD_SPECIAL, "bad-prodis-payee");
+        }
+        if (actor_out.nValue == 0) {
+            return state.Invalid(TxValidationResult::TX_BAD_SPECIAL, "bad-prodis-actor-output-zero");
+        }
+    }
+    // The per-recipient floors discard sub-duff remainders; the bonus sum rule forces the
+    // remainder onto some non-actor output
+    if (bonus_total < required_penalty) {
+        return state.Invalid(TxValidationResult::TX_BAD_SPECIAL, "bad-prodis-penalty-sum");
+    }
+
+    if (check_sigs) {
+        const uint256 sign_hash{ptx.MakeSignHash(tx, 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;
+    }
+
+    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 013fbfa5f1b7..809692a3a7d2 100644
--- a/src/evo/specialtxman.h
+++ b/src/evo/specialtxman.h
@@ -20,12 +20,21 @@ class CCoinsViewCache;
 class CCreditPoolManager;
 class CDeterministicMNList;
 class CDeterministicMNManager;
+class CProDisTx;
 class CTransaction;
 class ChainstateManager;
 class CMNHFManager;
 class TxValidationState;
 struct MNListUpdates;
 
+/** Where a special transaction is being validated. Some checks (currently only ProDisTx) must
+ *  defer to RebuildListFromBlock in block context because the referenced masternode may have been
+ *  registered earlier in the same block. */
+enum class SpecialTxContext : uint8_t {
+    Mempool,
+    Block,
+};
+
 namespace chainlock {
 class Chainlocks;
 }
@@ -109,6 +118,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/masternode/payments.cpp b/src/masternode/payments.cpp
index 030b67a64a30..04dafdd4eb22 100644
--- a/src/masternode/payments.cpp
+++ b/src/masternode/payments.cpp
@@ -168,16 +168,28 @@ CAmount GetMasternodePayment(int nHeight, CAmount blockValue, const Consensus::P
         masternodeReward -= operatorReward;
     }
 
-    const auto owner_payouts = GetOwnerPayouts(dmnPayee->pdmnState->nVersion, dmnPayee->pdmnState->scriptPayout,
-                                               dmnPayee->pdmnState->payouts);
-    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) / CMasternodePayoutShare::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->nVersion, dmnPayee->pdmnState->scriptPayout,
+                                                   dmnPayee->pdmnState->payouts);
+        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) / CMasternodePayoutShare::MAX_REWARD;
+            paid_owner_reward += payout_amount;
+            if (payout_amount > 0) {
+                voutMasternodePaymentsRet.emplace_back(payout_amount, owner_payouts[i].scriptPayout);
+            }
         }
     }
     if (operatorReward > 0) {
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/policy/policy.cpp b/src/policy/policy.cpp
index c91471f8d959..ce883cbd5c46 100644
--- a/src/policy/policy.cpp
+++ b/src/policy/policy.cpp
@@ -11,6 +11,7 @@
 #include <consensus/amount.h>
 #include <consensus/consensus.h>
 #include <consensus/validation.h>
+#include <evo/sharedcollateral.h>
 #include <policy/feerate.h>
 #include <primitives/transaction.h>
 #include <script/interpreter.h>
@@ -110,6 +111,13 @@ bool IsStandardTx(const CTransaction& tx, bool permit_bare_multisig, const CFeeR
     TxoutType whichType;
     for (const CTxOut& txout : tx.vout) {
         if (!::IsStandard(txout.scriptPubKey, whichType)) {
+            // The shared-collateral template is intentionally nonstandard everywhere except as an
+            // output of a ProRegTx (consensus restricts it to the collateral slot of a valid
+            // shared registration; policy only needs to let well-formed registrations relay)
+            if (tx.IsSpecialTxVersion() && tx.nType == TRANSACTION_PROVIDER_REGISTER &&
+                sharedcollateral::IsSharedCollateralScript(txout.scriptPubKey)) {
+                continue;
+            }
             reason = "scriptpubkey";
             return false;
         }
@@ -162,6 +170,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;
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/rpc/client.cpp b/src/rpc/client.cpp
index 4440f5cba1ff..e6bf22d287bd 100644
--- a/src/rpc/client.cpp
+++ b/src/rpc/client.cpp
@@ -313,8 +313,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 59ff1c0e7cc4..e71ccb5f5451 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>
@@ -266,6 +268,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)
 {
@@ -1241,6 +1366,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");
+    }
     if (dmn->pdmnState->nVersion == ProTxVersion::LegacyBLS && ptx.nVersion > ProTxVersion::BasicBLS) {
         ptx.nVersion = ProTxVersion::BasicBLS;
     }
@@ -1427,6 +1556,455 @@ static RPCHelpMan protx_revoke()
     };
 }
 
+static RPCHelpMan protx_shared_sign()
+{
+    return RPCHelpMan{"protx shared_sign",
+        "\nSigns a shared masternode transaction (shared ProRegTx, ProDisTx or ProUpSharedRegTx) with every\n"
+        "share owner key this wallet holds and returns the produced signatures. The transaction itself is\n"
+        "not modified; pass the signatures to \"protx shared_combine\".\n"
+        + HELP_REQUIRING_PASSPHRASE,
+        {
+            {"tx", RPCArg::Type::STR_HEX, RPCArg::Optional::NO, "The serialized transaction in hex format."},
+        },
+        RPCResult{RPCResult::Type::ARR, "", "",
+        {
+            {RPCResult::Type::OBJ, "", "",
+            {
+                {RPCResult::Type::NUM, "shareIndex", "Index into the share table"},
+                {RPCResult::Type::STR, "signature", "Base64-encoded signature by this share's owner key"},
+            }},
+        }},
+        RPCExamples{HelpExampleCli("protx", "shared_sign \"tx\"")},
+        [&](const RPCHelpMan& self, const JSONRPCRequest& request) -> UniValue
+{
+    const NodeContext& node = EnsureAnyNodeContext(request.context);
+    CDeterministicMNManager& dmnman = *CHECK_NONFATAL(node.dmnman);
+
+    std::shared_ptr<CWallet> const pwallet = GetWalletForJSONRPCRequest(request);
+    if (!pwallet) return UniValue::VNULL;
+    EnsureWalletIsUnlocked(*pwallet);
+
+    CMutableTransaction tx;
+    if (!DecodeHexTx(tx, request.params[0].get_str())) {
+        throw JSONRPCError(RPC_INVALID_PARAMETER, "transaction not deserializable");
+    }
+
+    // Resolve the share table and the digest to sign from the transaction type
+    CollateralShares shares;
+    uint256 sign_hash;
+    if (tx.nType == TRANSACTION_PROVIDER_REGISTER) {
+        const auto opt_ptx = GetTxPayload<CProRegTx>(tx);
+        if (!opt_ptx || !opt_ptx->IsShared()) {
+            throw JSONRPCError(RPC_INVALID_PARAMETER, "transaction is not a shared masternode registration");
+        }
+        shares = opt_ptx->shares;
+        sign_hash = opt_ptx->MakeSharedRegConsentHash(CTransaction(tx));
+    } else if (tx.nType == TRANSACTION_PROVIDER_DISSOLVE) {
+        const auto opt_ptx = GetTxPayload<CProDisTx>(tx);
+        if (!opt_ptx) {
+            throw JSONRPCError(RPC_INVALID_PARAMETER, "transaction payload not deserializable");
+        }
+        const auto dmn = dmnman.GetListAtChainTip().GetMN(opt_ptx->proTxHash);
+        if (!dmn || !dmn->pdmnState->IsShared()) {
+            throw JSONRPCError(RPC_INVALID_PARAMETER, "shared masternode not found");
+        }
+        shares = dmn->pdmnState->shares;
+        // shared_sign only ever signs unanimous dissolutions (built by dissolve_prepare); a
+        // unilateral dissolution is signed inline by "protx dissolve"
+        sign_hash = opt_ptx->MakeSignHash(CTransaction(tx), static_cast<uint8_t>(shares.size()));
+    } else if (tx.nType == TRANSACTION_PROVIDER_UPDATE_SHARED_REGISTRAR) {
+        const auto opt_ptx = GetTxPayload<CProUpSharedRegTx>(tx);
+        if (!opt_ptx) {
+            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{RPCResult::Type::STR_HEX, "txid", "The transaction id"},
+        RPCExamples{HelpExampleCli("protx", "update_share \"proTxHash\" 0 \"" + EXAMPLE_ADDRESS[1] + "\" \"" + EXAMPLE_ADDRESS[0] + "\"")},
+        [&](const RPCHelpMan& self, const JSONRPCRequest& request) -> UniValue
+{
+    const NodeContext& node = EnsureAnyNodeContext(request.context);
+    const ChainstateManager& chainman = EnsureChainman(node);
+    CDeterministicMNManager& dmnman = *CHECK_NONFATAL(node.dmnman);
+    CChainstateHelper& chain_helper = *CHECK_NONFATAL(node.chain_helper);
+
+    std::shared_ptr<CWallet> const pwallet = GetWalletForJSONRPCRequest(request);
+    if (!pwallet) return UniValue::VNULL;
+    EnsureWalletIsUnlocked(*pwallet);
+
+    CProUpShareTx ptx;
+    ptx.proTxHash = ParseHashV(request.params[0], "proTxHash");
+    const int shareIndex{request.params[1].getInt<int>()};
+    if (shareIndex < 0 || shareIndex > std::numeric_limits<uint16_t>::max()) {
+        throw JSONRPCError(RPC_INVALID_PARAMETER, "shareIndex out of range");
+    }
+    ptx.shareIndex = static_cast<uint16_t>(shareIndex);
+
+    const auto dmn = dmnman.GetListAtChainTip().GetMN(ptx.proTxHash);
+    if (!dmn || !dmn->pdmnState->IsShared()) {
+        throw JSONRPCError(RPC_INVALID_PARAMETER, "shared masternode not found");
+    }
+    if (ptx.shareIndex >= dmn->pdmnState->shares.size()) {
+        throw JSONRPCError(RPC_INVALID_PARAMETER, "shareIndex out of range");
+    }
+
+    if (!request.params[2].get_str().empty()) {
+        CTxDestination rewardDest = DecodeDestination(request.params[2].get_str());
+        if (!IsValidDestination(rewardDest)) {
+            throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, strprintf("invalid reward address: %s", request.params[2].get_str()));
+        }
+        ptx.scriptReward = GetScriptForDestination(rewardDest);
+    }
+
+    CTxDestination feeSourceDest = DecodeDestination(request.params[3].get_str());
+    if (!IsValidDestination(feeSourceDest)) {
+        throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, std::string("Invalid Dash address: ") + request.params[3].get_str());
+    }
+
+    bool fSubmit{true};
+    if (!request.params[4].isNull()) {
+        fSubmit = ParseBoolV(request.params[4], "submit");
+    }
+
+    CMutableTransaction tx;
+    tx.nVersion = 3;
+    tx.nType = TRANSACTION_PROVIDER_UPDATE_SHARE;
+
+    // make sure we get enough fees added
+    ptx.vchSig.resize(65);
+
+    FundSpecialTx(*pwallet, tx, ptx, feeSourceDest);
+    SignSpecialTxPayloadByHash(tx, ptx, dmn->pdmnState->shares[ptx.shareIndex].keyIDOwner, *pwallet);
+    SetTxPayload(tx, ptx);
+
+    return SignAndSendSpecialTx(request, chain_helper, chainman, tx, fSubmit);
+},
+    };
+}
+
+static RPCHelpMan protx_update_shared_registrar_prepare()
+{
+    return RPCHelpMan{"protx update_shared_registrar_prepare",
+        "\nCreates an unsigned ProUpSharedRegTx updating a shared masternode's operator key and/or voting\n"
+        "key. Fee inputs from this wallet are added and signed. Every share owner must then sign the\n"
+        "returned transaction with \"protx shared_sign\"; combine the signatures with \"protx shared_combine\".\n"
+        + HELP_REQUIRING_PASSPHRASE,
+        {
+            {"proTxHash", RPCArg::Type::STR_HEX, RPCArg::Optional::NO, "The hash of the initial ProRegTx."},
+            {"operatorPubKey", RPCArg::Type::STR, RPCArg::Optional::NO, "The new operator BLS public key, or an empty string to keep the current key."},
+            {"votingAddress", RPCArg::Type::STR, RPCArg::Optional::NO, "The new voting address, or an empty string to keep the current address."},
+            {"feeSourceAddress", RPCArg::Type::STR, RPCArg::Optional::NO, "Wallet address to pay the transaction fee from."},
+        },
+        RPCResult{RPCResult::Type::OBJ, "", "",
+        {
+            {RPCResult::Type::STR_HEX, "tx", "The serialized unsigned ProUpSharedRegTx"},
+            {RPCResult::Type::STR_HEX, "signHash", "The payload hash every share owner must sign"},
+        }},
+        RPCExamples{HelpExampleCli("protx", "update_shared_registrar_prepare \"proTxHash\" \"operatorPubKey\" \"\" \"" + EXAMPLE_ADDRESS[0] + "\"")},
+        [&](const RPCHelpMan& self, const JSONRPCRequest& request) -> UniValue
+{
+    const NodeContext& node = EnsureAnyNodeContext(request.context);
+    CDeterministicMNManager& dmnman = *CHECK_NONFATAL(node.dmnman);
+
+    std::shared_ptr<CWallet> const pwallet = GetWalletForJSONRPCRequest(request);
+    if (!pwallet) return UniValue::VNULL;
+    EnsureWalletIsUnlocked(*pwallet);
+
+    CProUpSharedRegTx ptx;
+    ptx.proTxHash = ParseHashV(request.params[0], "proTxHash");
+
+    const auto dmn = dmnman.GetListAtChainTip().GetMN(ptx.proTxHash);
+    if (!dmn || !dmn->pdmnState->IsShared()) {
+        throw JSONRPCError(RPC_INVALID_PARAMETER, "shared masternode not found");
+    }
+
+    if (!request.params[1].get_str().empty()) {
+        ptx.pubKeyOperator.Set(ParseBLSPubKey(request.params[1].get_str(), "operator BLS address", /*specific_legacy_bls_scheme=*/false),
+                               /*specificLegacyScheme=*/false);
+    } else {
+        ptx.pubKeyOperator = dmn->pdmnState->pubKeyOperator;
+    }
+    if (!request.params[2].get_str().empty()) {
+        ptx.keyIDVoting = ParsePubKeyIDFromAddress(request.params[2].get_str(), "voting address");
+    } else {
+        ptx.keyIDVoting = dmn->pdmnState->keyIDVoting;
+    }
+
+    CTxDestination feeSourceDest = DecodeDestination(request.params[3].get_str());
+    if (!IsValidDestination(feeSourceDest)) {
+        throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, std::string("Invalid Dash address: ") + request.params[3].get_str());
+    }
+
+    CMutableTransaction tx;
+    tx.nVersion = 3;
+    tx.nType = TRANSACTION_PROVIDER_UPDATE_SHARED_REGISTRAR;
+
+    // make sure we get enough fees added: one signature per share
+    ptx.vchSigs.assign(dmn->pdmnState->shares.size(), std::vector<unsigned char>(CPubKey::COMPACT_SIGNATURE_SIZE, 0));
+
+    FundSpecialTx(*pwallet, tx, ptx, feeSourceDest);
+    UpdateSpecialTxInputsHash(tx, ptx);
+    SetTxPayload(tx, ptx);
+
+    UniValue ret(UniValue::VOBJ);
+    ret.pushKV("tx", EncodeHexTx(CTransaction(tx)));
+    ret.pushKV("signHash", ::SerializeHash(ptx).ToString());
+    return ret;
+},
+    };
+}
+
+static RPCHelpMan protx_shared_combine()
+{
+    return RPCHelpMan{"protx shared_combine",
+        "\nCombines share owner signatures produced by \"protx shared_sign\" into a shared masternode\n"
+        "transaction. For a shared ProRegTx the completed transaction hex is returned and the funding\n"
+        "inputs still have to be signed (e.g. by passing the result around signrawtransactionwithwallet).\n"
+        "For a ProDisTx or ProUpSharedRegTx the transaction can be submitted directly.\n",
+        {
+            {"tx", RPCArg::Type::STR_HEX, RPCArg::Optional::NO, "The serialized transaction in hex format."},
+            {"signatures", RPCArg::Type::ARR, RPCArg::Optional::NO, "Signature entries collected from \"protx shared_sign\".",
+            {
+                {"", RPCArg::Type::OBJ, RPCArg::Optional::OMITTED, "",
+                {
+                    {"shareIndex", RPCArg::Type::NUM, RPCArg::Optional::NO, "Index into the share table"},
+                    {"signature", RPCArg::Type::STR, RPCArg::Optional::NO, "Base64-encoded signature"},
+                }},
+            }},
+            {"submit", RPCArg::Type::BOOL, RPCArg::Default{false}, "Submit the transaction to the network (not available for registrations, whose funding inputs still need signing)."},
+        },
+        RPCResult{RPCResult::Type::STR_HEX, "result", "The transaction id if submitted, otherwise the combined transaction hex"},
+        RPCExamples{HelpExampleCli("protx", "shared_combine \"tx\" \"[{\\\"shareIndex\\\":0,\\\"signature\\\":\\\"...\\\"}]\"")},
+        [&](const RPCHelpMan& self, const JSONRPCRequest& request) -> UniValue
+{
+    const NodeContext& node = EnsureAnyNodeContext(request.context);
+    const ChainstateManager& chainman = EnsureChainman(node);
+    CDeterministicMNManager& dmnman = *CHECK_NONFATAL(node.dmnman);
+    CChainstateHelper& chain_helper = *CHECK_NONFATAL(node.chain_helper);
+
+    CMutableTransaction tx;
+    if (!DecodeHexTx(tx, request.params[0].get_str())) {
+        throw JSONRPCError(RPC_INVALID_PARAMETER, "transaction not deserializable");
+    }
+
+    // Collect (shareIndex, signature) pairs
+    std::map<size_t, std::vector<unsigned char>> sigs;
+    for (const auto& entry : request.params[1].get_array().getValues()) {
+        const int64_t index{entry.find_value("shareIndex").getInt<int64_t>()};
+        auto opt_sig = DecodeBase64(entry.find_value("signature").get_str());
+        if (index < 0 || !opt_sig.has_value() || opt_sig->size() != CPubKey::COMPACT_SIGNATURE_SIZE) {
+            throw JSONRPCError(RPC_INVALID_PARAMETER, "invalid signature entry");
+        }
+        if (!sigs.emplace(static_cast<size_t>(index), *opt_sig).second) {
+            throw JSONRPCError(RPC_INVALID_PARAMETER, "duplicate shareIndex");
+        }
+    }
+
+    const bool fSubmit{request.params[2].isNull() ? false : ParseBoolV(request.params[2], "submit")};
+
+    if (tx.nType == TRANSACTION_PROVIDER_REGISTER) {
+        auto opt_ptx = GetTxPayload<CProRegTx>(tx);
+        if (!opt_ptx || !opt_ptx->IsShared()) {
+            throw JSONRPCError(RPC_INVALID_PARAMETER, "transaction is not a shared masternode registration");
+        }
+        if (fSubmit) {
+            throw JSONRPCError(RPC_INVALID_PARAMETER, "a combined registration still needs its funding inputs signed; submit it with sendrawtransaction afterwards");
+        }
+        if (sigs.size() != opt_ptx->shares.size()) {
+            throw JSONRPCError(RPC_INVALID_PARAMETER, "a registration requires a signature from every share");
+        }
+        for (const auto& [index, sig] : sigs) {
+            if (index >= opt_ptx->shares.size()) {
+                throw JSONRPCError(RPC_INVALID_PARAMETER, "shareIndex out of range");
+            }
+            opt_ptx->vchJoinSigs[index] = sig;
+        }
+        SetTxPayload(tx, *opt_ptx);
+        return EncodeHexTx(CTransaction(tx));
+    } else if (tx.nType == TRANSACTION_PROVIDER_DISSOLVE) {
+        auto opt_ptx = GetTxPayload<CProDisTx>(tx);
+        if (!opt_ptx) {
+            throw JSONRPCError(RPC_INVALID_PARAMETER, "transaction payload not deserializable");
+        }
+        const auto dmn = dmnman.GetListAtChainTip().GetMN(opt_ptx->proTxHash);
+        if (!dmn || !dmn->pdmnState->IsShared()) {
+            throw JSONRPCError(RPC_INVALID_PARAMETER, "shared masternode not found");
+        }
+        const size_t share_count{dmn->pdmnState->shares.size()};
+        opt_ptx->vchSigs.clear();
+        if (sigs.size() == 1) {
+            // unilateral: the single signature must be the actor's
+            if (sigs.begin()->first != opt_ptx->actorIndex) {
+                throw JSONRPCError(RPC_INVALID_PARAMETER, "a single signature must be by the actor share");
+            }
+            opt_ptx->vchSigs.push_back(sigs.begin()->second);
+        } else if (sigs.size() == share_count) {
+            for (size_t i = 0; i < share_count; i++) {
+                const auto it = sigs.find(i);
+                if (it == sigs.end()) {
+                    throw JSONRPCError(RPC_INVALID_PARAMETER, strprintf("missing signature for share %d", i));
+                }
+                opt_ptx->vchSigs.push_back(it->second);
+            }
+        } else {
+            throw JSONRPCError(RPC_INVALID_PARAMETER, "a dissolution requires exactly one signature or one per share");
+        }
+        SetTxPayload(tx, *opt_ptx);
+        if (!fSubmit) {
+            return EncodeHexTx(CTransaction(tx));
+        }
+        return SubmitSpecialTx(request, chain_helper, chainman, tx);
+    } else if (tx.nType == TRANSACTION_PROVIDER_UPDATE_SHARED_REGISTRAR) {
+        auto opt_ptx = GetTxPayload<CProUpSharedRegTx>(tx);
+        if (!opt_ptx) {
+            throw JSONRPCError(RPC_INVALID_PARAMETER, "transaction payload not deserializable");
+        }
+        const auto dmn = dmnman.GetListAtChainTip().GetMN(opt_ptx->proTxHash);
+        if (!dmn || !dmn->pdmnState->IsShared()) {
+            throw JSONRPCError(RPC_INVALID_PARAMETER, "shared masternode not found");
+        }
+        const size_t share_count{dmn->pdmnState->shares.size()};
+        if (sigs.size() != share_count) {
+            throw JSONRPCError(RPC_INVALID_PARAMETER, "a shared registrar update requires a signature from every share");
+        }
+        opt_ptx->vchSigs.clear();
+        for (size_t i = 0; i < share_count; i++) {
+            const auto it = sigs.find(i);
+            if (it == sigs.end()) {
+                throw JSONRPCError(RPC_INVALID_PARAMETER, strprintf("missing signature for share %d", i));
+            }
+            opt_ptx->vchSigs.push_back(it->second);
+        }
+        SetTxPayload(tx, *opt_ptx);
+        // Inserting the signatures changed the payload, so the fee inputs signed at prepare time
+        // are stale; SignAndSendSpecialTx re-signs them with this wallet before submitting
+        return SignAndSendSpecialTx(request, chain_helper, chainman, tx, fSubmit);
+    }
+    throw JSONRPCError(RPC_INVALID_PARAMETER, "transaction is not a shared masternode transaction");
+},
+    };
+}
+
 #endif//ENABLE_WALLET
 
 #ifdef ENABLE_WALLET
@@ -2023,6 +2601,181 @@ 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 4 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"
+        "\nIMPORTANT: once the registration confirms, every participant should create a standby dissolution\n"
+        "(\"protx dissolve <proTxHash> <shareIndex> <fee> false\") and store the returned hex with their\n"
+        "refund-key backup, separately from the share owner key. Dissolution validity is monotone, so a\n"
+        "standby never expires; if the owner key is later lost, broadcasting the standby recovers the\n"
+        "participant's principal without any other party's cooperation.\n",
+        {
+            {"fundingTx", RPCArg::Type::STR_HEX, RPCArg::Optional::NO, "The serialized funding transaction with all participants' inputs and change outputs."},
+            {"shares", RPCArg::Type::ARR, RPCArg::Optional::NO, "The collateral share table, in consensus-significant order. Amounts must sum to the collateral.",
+            {
+                {"", 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 = ProTxVersion::GetMaxFromDeployment<CProRegTx>(
+        WITH_LOCK(::cs_main, return chainman.ActiveChain().Tip()), chainman);
+    if (ptx.nVersion < ProTxVersion::MultiPayout) {
+        throw JSONRPCError(RPC_INVALID_PARAMETER, "shared masternode registration requires provider transaction version 4");
+    }
+    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);
+
+    // 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
+    {
+        LOCK(::cs_main);
+        if (TxValidationState state;
+            !ptx.IsTriviallyValid(chainman.ActiveChain().Tip(), chainman, state)) {
+            throw JSONRPCError(RPC_INVALID_PARAMETER,
+                               strprintf("invalid shared registration terms: %s", state.GetRejectReason()));
+        }
+    }
+
+    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{
@@ -2041,6 +2794,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"
@@ -2050,6 +2804,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",
@@ -2172,6 +2932,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},
diff --git a/src/rpc/rawtransaction.cpp b/src/rpc/rawtransaction.cpp
index 3efd753d2ac0..a344e26f30a6 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/test/evo_sharedmn_tests.cpp b/src/test/evo_sharedmn_tests.cpp
new file mode 100644
index 000000000000..5188aa66fceb
--- /dev/null
+++ b/src/test/evo_sharedmn_tests.cpp
@@ -0,0 +1,770 @@
+// 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::MultiPayout;
+        proTx.netInfo = NetInfoInterface::MakeNetInfo(proTx.nVersion);
+        proTx.keyIDVoting = voting_key.GetPubKey().GetID();
+        proTx.collateralOutpoint = COutPoint(uint256(), 0);
+        for (size_t i = 0; i < count; i++) {
+            proTx.shares.push_back(NewShare(dmn_types::Regular.collat_amount / count, refund_keys[i], owner_keys[i]));
+        }
+        proTx.vchJoinSigs = DummyJoinSigs(count);
+        proTx.nEarlyPeriodBlocks = 1000;
+        proTx.nEarlyPenalty = 50 * COIN;
+
+        CDataStream ss(SER_NETWORK, CLIENT_VERSION);
+        ss << proTx;
+        CProRegTx proTx2;
+        ss >> proTx2;
+
+        BOOST_CHECK(proTx2.IsShared());
+        BOOST_CHECK_EQUAL(proTx2.shares.size(), count);
+        BOOST_CHECK(proTx2.shares == proTx.shares);
+        BOOST_CHECK(proTx2.vchJoinSigs == proTx.vchJoinSigs);
+        BOOST_CHECK_EQUAL(proTx2.nEarlyPeriodBlocks, proTx.nEarlyPeriodBlocks);
+        BOOST_CHECK_EQUAL(proTx2.nEarlyPenalty, proTx.nEarlyPenalty);
+
+        // Serialization must be deterministic and round-trip byte-identically
+        CDataStream ss2(SER_NETWORK, CLIENT_VERSION);
+        ss2 << proTx2;
+        CDataStream ss3(SER_NETWORK, CLIENT_VERSION);
+        ss3 << proTx;
+        BOOST_CHECK(ss2.str() == ss3.str());
+    }
+
+    // A non-shared v4 payload serializes an empty share list and zeroed penalty fields
+    CProRegTx nonShared;
+    nonShared.nVersion = ProTxVersion::MultiPayout;
+    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::MultiPayout;
+    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);
+    }
+    {
+        // Sequences are not covered by the consent digest (inputsHash covers prevouts only), but
+        // nLockTime is
+        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::MultiPayout;
+    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::MultiPayout;
+    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::MultiPayout;
+        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/txmempool.cpp b/src/txmempool.cpp
index 8524d6a07e71..f72834b7a89e 100644
--- a/src/txmempool.cpp
+++ b/src/txmempool.cpp
@@ -673,7 +673,15 @@ void CTxMemPool::addUncheckedProTx(CDeterministicMNManager& dmnman, indexed_tran
         for (const auto& entry : proTx.netInfo->GetEntries()) {
             mapProTxAddresses.emplace(entry, tx_hash);
         }
-        mapProTxPubKeyIDs.emplace(proTx.keyIDOwner, tx_hash);
+        if (proTx.IsShared()) {
+            // A shared registration has a null keyIDOwner (which must never enter the map, or two
+            // shared registrations would collide on it); the share owner keys take its place
+            for (const auto& share : proTx.shares) {
+                mapProTxPubKeyIDs.emplace(share.keyIDOwner, tx_hash);
+            }
+        } else {
+            mapProTxPubKeyIDs.emplace(proTx.keyIDOwner, tx_hash);
+        }
         mapProTxBlsPubKeyHashes.emplace(proTx.pubKeyOperator.GetHash(), tx_hash);
         if (proTx.nType == MnType::Evo && !proTx.platformNodeID.IsNull()) {
             mapProTxPlatformNodeIDs.emplace(proTx.platformNodeID, tx_hash);
@@ -714,6 +722,23 @@ void CTxMemPool::addUncheckedProTx(CDeterministicMNManager& dmnman, indexed_tran
         mapAssetUnlockExpiry.insert({tx_hash, assetUnlockTx.getHeightToExpiry()});
     } else if (tx.nType == TRANSACTION_MNHF_SIGNAL) {
         PrioritiseTransaction(tx_hash, 0.1 * COIN);
+    } else if (tx.nType == TRANSACTION_PROVIDER_DISSOLVE) {
+        // Registering in mapProTxRefs makes removeProTxSpentCollateralConflicts evict pending
+        // updates for the masternode (and any competing dissolution) when a ProDisTx confirms
+        auto proTx = *Assert(GetTxPayload<CProDisTx>(tx));
+        mapProTxRefs.emplace(proTx.proTxHash, tx_hash);
+    } else if (tx.nType == TRANSACTION_PROVIDER_UPDATE_SHARE) {
+        auto proTx = *Assert(GetTxPayload<CProUpShareTx>(tx));
+        mapProTxRefs.emplace(proTx.proTxHash, tx_hash);
+    } else if (tx.nType == TRANSACTION_PROVIDER_UPDATE_SHARED_REGISTRAR) {
+        auto proTx = *Assert(GetTxPayload<CProUpSharedRegTx>(tx));
+        mapProTxRefs.emplace(proTx.proTxHash, tx_hash);
+        mapProTxBlsPubKeyHashes.emplace(proTx.pubKeyOperator.GetHash(), tx_hash);
+        auto dmn = Assert(dmnman.GetListAtChainTip().GetMN(proTx.proTxHash));
+        newit->validForProTxKey = ::SerializeHash(dmn->pdmnState->pubKeyOperator);
+        if (dmn->pdmnState->pubKeyOperator != proTx.pubKeyOperator) {
+            newit->isKeyChangeProTx = true;
+        }
     }
 }
 
@@ -783,7 +808,13 @@ void CTxMemPool::removeUncheckedProTx(const CTransaction& tx)
         for (const auto& entry : proTx.netInfo->GetEntries()) {
             mapProTxAddresses.erase(entry);
         }
-        mapProTxPubKeyIDs.erase(proTx.keyIDOwner);
+        if (proTx.IsShared()) {
+            for (const auto& share : proTx.shares) {
+                mapProTxPubKeyIDs.erase(share.keyIDOwner);
+            }
+        } else {
+            mapProTxPubKeyIDs.erase(proTx.keyIDOwner);
+        }
         mapProTxBlsPubKeyHashes.erase(proTx.pubKeyOperator.GetHash());
         if (proTx.nType == MnType::Evo && !proTx.platformNodeID.IsNull()) {
             mapProTxPlatformNodeIDs.erase(proTx.platformNodeID);
@@ -808,6 +839,16 @@ void CTxMemPool::removeUncheckedProTx(const CTransaction& tx)
         eraseProTxRef(proTx.proTxHash, tx_hash);
     } else if (tx.nType == TRANSACTION_ASSET_UNLOCK) {
         mapAssetUnlockExpiry.erase(tx_hash);
+    } else if (tx.nType == TRANSACTION_PROVIDER_DISSOLVE) {
+        auto proTx = *Assert(GetTxPayload<CProDisTx>(tx));
+        eraseProTxRef(proTx.proTxHash, tx_hash);
+    } else if (tx.nType == TRANSACTION_PROVIDER_UPDATE_SHARE) {
+        auto proTx = *Assert(GetTxPayload<CProUpShareTx>(tx));
+        eraseProTxRef(proTx.proTxHash, tx_hash);
+    } else if (tx.nType == TRANSACTION_PROVIDER_UPDATE_SHARED_REGISTRAR) {
+        auto proTx = *Assert(GetTxPayload<CProUpSharedRegTx>(tx));
+        eraseProTxRef(proTx.proTxHash, tx_hash);
+        mapProTxBlsPubKeyHashes.erase(proTx.pubKeyOperator.GetHash());
     }
 }
 
@@ -1012,13 +1053,26 @@ 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());
         }
     }
     for (const auto& txHash : conflictingTxs) {
-        auto& tx = mapTx.find(txHash)->GetTx();
-        removeRecursive(tx, MemPoolRemovalReason::CONFLICT);
+        // An earlier removeRecursive() may have already evicted this entry as a descendant of a
+        // previously-processed conflict, so it can be absent here; dereferencing mapTx.end() would
+        // crash. (Pre-existing hazard; guarded here to be safe.)
+        auto it = mapTx.find(txHash);
+        if (it == mapTx.end()) {
+            continue;
+        }
+        removeRecursive(it->GetTx(), MemPoolRemovalReason::CONFLICT);
     }
 }
 
@@ -1043,7 +1097,13 @@ void CTxMemPool::removeProTxConflicts(const CTransaction &tx)
                 }
             }
         }
-        removeProTxPubKeyConflicts(tx, proTx.keyIDOwner);
+        if (proTx.IsShared()) {
+            for (const auto& share : proTx.shares) {
+                removeProTxPubKeyConflicts(tx, share.keyIDOwner);
+            }
+        } else {
+            removeProTxPubKeyConflicts(tx, proTx.keyIDOwner);
+        }
         removeProTxPubKeyConflicts(tx, proTx.pubKeyOperator);
         if (proTx.nType == MnType::Evo && !proTx.platformNodeID.IsNull()) {
             removeProTxPlatformNodeIDConflicts(tx, proTx.platformNodeID);
@@ -1088,6 +1148,15 @@ void CTxMemPool::removeProTxConflicts(const CTransaction &tx)
         }
 
         removeProTxKeyChangedConflicts(tx, opt_proTx->proTxHash, ::SerializeHash(CBLSPublicKey()));
+    } else if (tx.nType == TRANSACTION_PROVIDER_UPDATE_SHARED_REGISTRAR) {
+        const auto opt_proTx = GetTxPayload<CProUpSharedRegTx>(tx);
+        if (!opt_proTx) {
+            LogPrint(BCLog::MEMPOOL, "%s: ERROR: Invalid transaction payload, tx: %s\n", __func__, tx_hash.ToString());
+            return;
+        }
+
+        removeProTxPubKeyConflicts(tx, opt_proTx->pubKeyOperator);
+        removeProTxKeyChangedConflicts(tx, opt_proTx->proTxHash, ::SerializeHash(opt_proTx->pubKeyOperator));
     }
 }
 
@@ -1407,7 +1476,18 @@ bool CTxMemPool::existsProviderTxConflict(const CTransaction &tx) const {
                 return true;
             }
         }
-        if (mapProTxPubKeyIDs.count(proTx.keyIDOwner) || mapProTxBlsPubKeyHashes.count(proTx.pubKeyOperator.GetHash())) {
+        if (proTx.IsShared()) {
+            // share owner keys occupy the same conflict namespace as keyIDOwner, in both
+            // directions between pending shared and non-shared registrations
+            for (const auto& share : proTx.shares) {
+                if (mapProTxPubKeyIDs.count(share.keyIDOwner)) {
+                    return true;
+                }
+            }
+            if (mapProTxBlsPubKeyHashes.count(proTx.pubKeyOperator.GetHash())) {
+                return true;
+            }
+        } else if (mapProTxPubKeyIDs.count(proTx.keyIDOwner) || mapProTxBlsPubKeyHashes.count(proTx.pubKeyOperator.GetHash())) {
             return true;
         }
         if (proTx.nType == MnType::Evo && !proTx.platformNodeID.IsNull() && mapProTxPlatformNodeIDs.count(proTx.platformNodeID)) {
@@ -1484,6 +1564,29 @@ bool CTxMemPool::existsProviderTxConflict(const CTransaction &tx) const {
                 return true;
             }
         }
+    } else if (tx.nType == TRANSACTION_PROVIDER_UPDATE_SHARED_REGISTRAR) {
+        const auto opt_proTx = GetTxPayload<CProUpSharedRegTx>(tx);
+        if (!opt_proTx) {
+            LogPrint(BCLog::MEMPOOL, "%s: ERROR: Invalid transaction payload, tx: %s\n", __func__, tx_hash.ToString());
+            return true; // i.e. can't decode payload == conflict
+        }
+        auto& proTx = *opt_proTx;
+
+        // this method should only be called with validated ProTxs
+        auto dmn = dmnman->GetListAtChainTip().GetMN(proTx.proTxHash);
+        if (!dmn) {
+            LogPrint(BCLog::MEMPOOL, "%s: ERROR: Masternode is not in the list, proTxHash: %s\n", __func__, proTx.proTxHash.ToString());
+            return true; // i.e. failed to find validated ProTx == conflict
+        }
+        // only allow one operator key change in the mempool
+        if (dmn->pdmnState->pubKeyOperator != proTx.pubKeyOperator) {
+            if (hasKeyChangeInMempool(proTx.proTxHash)) {
+                return true;
+            }
+        }
+
+        auto it = mapProTxBlsPubKeyHashes.find(proTx.pubKeyOperator.GetHash());
+        return it != mapProTxBlsPubKeyHashes.end() && it->second != proTx.proTxHash;
     }
     return false;
 }
diff --git a/src/validation.cpp b/src/validation.cpp
index 012783385685..9fe0ee435503 100644
--- a/src/validation.cpp
+++ b/src/validation.cpp
@@ -362,7 +362,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)
@@ -912,6 +915,18 @@ bool MemPoolAccept::PreChecks(ATMPArgs& args, Workspace& ws)
         return false; // state filled in by CheckTxInputs
     }
 
+    // Shared-collateral covenant rules apply to every transaction, including normal transactions
+    // that never reach CheckSpecialTx below
+    if (DeploymentActiveAfter(m_active_chainstate.m_chain.Tip(), m_active_chainstate.m_chainman,
+                              Consensus::DEPLOYMENT_V24)) {
+        if (!CheckSharedCollateralSpends(tx, m_view, state)) {
+            return false; // state filled in by CheckSharedCollateralSpends
+        }
+        if (!CheckSharedCollateralTemplateOutputs(tx, state)) {
+            return false; // state filled in by CheckSharedCollateralTemplateOutputs
+        }
+    }
+
     if (fRequireStandard && !AreInputsStandard(tx, m_view)) {
         return state.Invalid(TxValidationResult::TX_INPUTS_NOT_STANDARD, "bad-txns-nonstandard-inputs");
     }
@@ -2325,6 +2340,7 @@ bool CChainState::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]);
@@ -2341,6 +2357,19 @@ bool CChainState::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__);
diff --git a/test/functional/feature_masternode_shares.py b/test/functional/feature_masternode_shares.py
new file mode 100755
index 000000000000..ae4c238fdad2
--- /dev/null
+++ b/test/functional/feature_masternode_shares.py
@@ -0,0 +1,294 @@
+#!/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)."""
+
+from decimal import Decimal
+
+from test_framework.messages import COIN, 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},
+        ]
+
+        # 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)
+        assert_equal(raw["proRegTx"]["version"], 4)
+        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"], 4)
+        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("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 zero-penalty unilateral dissolution is invalid during the early period")
+        assert_raises_rpc_error(-8, "must pay the penalty", node.protx,
+                                "dissolve", protx_hash, 1, DISSOLVE_FEE, True, False)
+        standby_hex = node.protx("dissolve", protx_hash, 1, DISSOLVE_FEE, False, False)
+        standby_res = node.testmempoolaccept([standby_hex])[0]
+        assert_equal(standby_res["allowed"], False)
+        assert_equal(standby_res["reject-reason"], "bad-prodis-penalty-floor")
+
+        self.log.info("A penalty-paying unilateral dissolution succeeds during the early period")
+        registered_height = node.protx("info", protx_hash)["state"]["registeredHeight"]
+        assert_greater_than(registered_height + EARLY_PERIOD_BLOCKS, node.getblockcount() + 1)
+        dissolve_txid = node.protx("dissolve", protx_hash, 1, DISSOLVE_FEE)
+        dissolve_tx = node.getrawtransaction(dissolve_txid, 1)
+        assert_equal(dissolve_tx["proDisTx"]["proTxHash"], protx_hash)
+        assert_equal(dissolve_tx["proDisTx"]["actorIndex"], 1)
+        assert_equal(dissolve_tx["proDisTx"]["sigCount"], 1)
+        # non-actor share is refunded principal plus the entire penalty, the actor absorbs it
+        assert_equal(dissolve_tx["vout"][0]["scriptPubKey"]["address"], refund1)
+        assert_equal(int(dissolve_tx["vout"][0]["value"] * COIN), 600 * COIN + EARLY_PENALTY)
+        assert_equal(dissolve_tx["vout"][1]["scriptPubKey"]["address"], refund2)
+        assert_equal(int(dissolve_tx["vout"][1]["value"] * COIN), 400 * COIN - EARLY_PENALTY - DISSOLVE_FEE)
+        self.bump_mocktime(10 * 60 + 1)
+        self.generate(node, 1, sync_fun=self.no_op)
+        assert_raises_rpc_error(None, None, node.protx, "info", protx_hash)
+        assert_equal(node.masternodelist(), {})
+
+        self.log.info("A standby dissolution signed inside the early period is valid after it ends")
+        refund3, refund4 = node.getnewaddress(), node.getnewaddress()
+        owner3, owner4 = node.getnewaddress(), node.getnewaddress()
+        shares2 = [
+            {"amount": 500 * COIN, "refundAddress": refund3, "ownerAddress": owner3},
+            {"amount": 500 * COIN, "refundAddress": refund4, "rewardAddress": node.getnewaddress(),
+             "ownerAddress": owner4},
+        ]
+        protx_hash2, _ = self.register_shared(node, shares2, port_offset=2)
+        standby_hex = node.protx("dissolve", protx_hash2, 0, DISSOLVE_FEE, False, False)
+        assert_equal(node.testmempoolaccept([standby_hex])[0]["allowed"], False)
+        # mine past the early-period boundary; the same signed hex becomes and stays valid
+        self.bump_mocktime(10 * 60 + 1)
+        self.generate(node, EARLY_PERIOD_BLOCKS + 1, sync_fun=self.no_op)
+        assert_equal(node.testmempoolaccept([standby_hex])[0]["allowed"], True)
+
+        self.log.info("A unanimous dissolution is penalty-free")
+        prepared = node.protx("dissolve_prepare", protx_hash2, 0, DISSOLVE_FEE)
+        sigs = node.protx("shared_sign", prepared["tx"])
+        assert_equal(len(sigs), 2)
+        dissolve_txid2 = node.protx("shared_combine", prepared["tx"], sigs, True)
+        dissolve_tx2 = node.getrawtransaction(dissolve_txid2, 1)
+        assert_equal(dissolve_tx2["proDisTx"]["sigCount"], 2)
+        assert_equal(int(dissolve_tx2["vout"][0]["value"] * COIN), 500 * COIN)
+        self.bump_mocktime(10 * 60 + 1)
+        self.generate(node, 1, sync_fun=self.no_op)
+        assert_equal(node.masternodelist(), {})
+
+        self.log.info("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 e303013a6b75..14557277834c 100755
--- a/test/functional/test_runner.py
+++ b/test/functional/test_runner.py
@@ -133,6 +133,7 @@
     'feature_dip3_deterministicmns.py --legacy-wallet', # NOTE: needs dash_hash to pass
     'feature_dip3_deterministicmns.py --descriptors', # NOTE: needs dash_hash to pass
     'feature_masternode_payout_shares.py',
+    'feature_masternode_shares.py',
     'feature_llmq_signing.py', # NOTE: needs dash_hash to pass
     'feature_llmq_signing.py --spork21', # NOTE: needs dash_hash to pass
     'feature_llmq_rotation.py', # NOTE: needs dash_hash to pass