From 89089ed281f0b8a60f7585bc2dffafe2674976c4 Mon Sep 17 00:00:00 2001
From: Hilawe Semunegus <hilawe@gmail.com>
Date: Sat, 6 Jun 2026 01:01:01 -0400
Subject: [PATCH 01/15] DIP-0026 P1: add ProTx v4 (MultiPayout) +
 DEPLOYMENT_V25 activation gate

Scaffolding for DIP-0026 multi-party masternode payouts. Introduces a new
special-transaction version ProTxVersion::MultiPayout (v4) for CProRegTx and
CProUpRegTx, gated behind a new EHF-style hard-fork deployment DEPLOYMENT_V25.
No payout-share fields or payout logic yet: a v4 ProTx is rejected until the
fork activates, so there is no behavior change on existing networks.

- consensus/params.h, deploymentinfo.cpp: register DEPLOYMENT_V25 ("v25").
- chainparams.cpp: V25 params for all four networks (bit 13, EHF); NEVER_ACTIVE
  on main/testnet/devnet, activatable on regtest.
- evo/providertx.h: ProTxVersion::MultiPayout=4; extend GetMax() with an
  is_multi_payout axis; compile-time static_asserts pin the version tiers.
- evo/providertx.cpp: GetMaxFromDeployment gates v4 on DEPLOYMENT_V25 for
  ProRegTx/ProUpRegTx only, and enforces V24-before-V25 for ProRegTx so a v4
  reg-tx can never outrun extended-address support. Fix the CanStorePlatform
  netinfo-version gate (== ExtAddr -> >= ExtAddr) so v4 keeps extended netInfo.
- rpc/blockchain.cpp: report v25 in getblockchaininfo EHF softforks.
- test: update GetMax call sites; add v25 to rpc_blockchain.py expected softforks.
---
 src/chainparams.cpp                          | 36 +++++++++++++++++
 src/consensus/params.h                       |  1 +
 src/deploymentinfo.cpp                       |  4 ++
 src/evo/providertx.cpp                       | 25 +++++++++---
 src/evo/providertx.h                         | 42 +++++++++++++++-----
 src/rpc/blockchain.cpp                       |  1 +
 src/test/block_reward_reallocation_tests.cpp |  2 +-
 src/test/evo_deterministicmns_tests.cpp      | 16 ++++----
 src/test/evo_simplifiedmns_tests.cpp         |  2 +-
 test/functional/rpc_blockchain.py            | 11 +++++
 10 files changed, 113 insertions(+), 27 deletions(-)

diff --git a/src/chainparams.cpp b/src/chainparams.cpp
index d7d491ba83e0..e37a92905ec6 100644
--- a/src/chainparams.cpp
+++ b/src/chainparams.cpp
@@ -218,6 +218,15 @@ class CMainParams : public CChainParams {
         consensus.vDeployments[Consensus::DEPLOYMENT_V24].nFalloffCoeff = 5;          // this corresponds to 10 periods
         consensus.vDeployments[Consensus::DEPLOYMENT_V24].useEHF = true;
 
+        consensus.vDeployments[Consensus::DEPLOYMENT_V25].bit = 13;
+        consensus.vDeployments[Consensus::DEPLOYMENT_V25].nStartTime = Consensus::BIP9Deployment::NEVER_ACTIVE; // TODO
+        consensus.vDeployments[Consensus::DEPLOYMENT_V25].nTimeout = Consensus::BIP9Deployment::NO_TIMEOUT; // TODO
+        consensus.vDeployments[Consensus::DEPLOYMENT_V25].nWindowSize = 4032;
+        consensus.vDeployments[Consensus::DEPLOYMENT_V25].nThresholdStart = 3226;     // 80% of 4032
+        consensus.vDeployments[Consensus::DEPLOYMENT_V25].nThresholdMin = 2420;       // 60% of 4032
+        consensus.vDeployments[Consensus::DEPLOYMENT_V25].nFalloffCoeff = 5;          // this corresponds to 10 periods
+        consensus.vDeployments[Consensus::DEPLOYMENT_V25].useEHF = true;
+
         consensus.nMinimumChainWork = uint256S("0x00000000000000000000000000000000000000000000b9040746437784aaec47"); // 2471728
         consensus.defaultAssumeValid = uint256S("0x000000000000001a19ad7270422a00f86123ea94e0b295a3a796d6861bd7b032"); // 2471728
 
@@ -419,6 +428,15 @@ class CTestNetParams : public CChainParams {
         consensus.vDeployments[Consensus::DEPLOYMENT_V24].nFalloffCoeff = 5;          // this corresponds to 10 periods
         consensus.vDeployments[Consensus::DEPLOYMENT_V24].useEHF = true;
 
+        consensus.vDeployments[Consensus::DEPLOYMENT_V25].bit = 13;
+        consensus.vDeployments[Consensus::DEPLOYMENT_V25].nStartTime = Consensus::BIP9Deployment::NEVER_ACTIVE; // TODO
+        consensus.vDeployments[Consensus::DEPLOYMENT_V25].nTimeout = Consensus::BIP9Deployment::NO_TIMEOUT;
+        consensus.vDeployments[Consensus::DEPLOYMENT_V25].nWindowSize = 100;
+        consensus.vDeployments[Consensus::DEPLOYMENT_V25].nThresholdStart = 80;       // 80% of 100
+        consensus.vDeployments[Consensus::DEPLOYMENT_V25].nThresholdMin = 60;         // 60% of 100
+        consensus.vDeployments[Consensus::DEPLOYMENT_V25].nFalloffCoeff = 5;          // this corresponds to 10 periods
+        consensus.vDeployments[Consensus::DEPLOYMENT_V25].useEHF = true;
+
         consensus.nMinimumChainWork = uint256S("0x000000000000000000000000000000000000000000000000036c8f738da818d2"); // 1400000
         consensus.defaultAssumeValid = uint256S("0x000000541a23f9db7411cddbe50f9f1ebd4aa7108ebdcad62214753f648c0239"); // 1400000
 
@@ -594,6 +612,15 @@ class CDevNetParams : public CChainParams {
         consensus.vDeployments[Consensus::DEPLOYMENT_V24].nFalloffCoeff = 5;          // this corresponds to 10 periods
         consensus.vDeployments[Consensus::DEPLOYMENT_V24].useEHF = true;
 
+        consensus.vDeployments[Consensus::DEPLOYMENT_V25].bit = 13;
+        consensus.vDeployments[Consensus::DEPLOYMENT_V25].nStartTime = Consensus::BIP9Deployment::NEVER_ACTIVE; // TODO
+        consensus.vDeployments[Consensus::DEPLOYMENT_V25].nTimeout = Consensus::BIP9Deployment::NO_TIMEOUT;
+        consensus.vDeployments[Consensus::DEPLOYMENT_V25].nWindowSize = 120;
+        consensus.vDeployments[Consensus::DEPLOYMENT_V25].nThresholdStart = 96;       // 80% of 120
+        consensus.vDeployments[Consensus::DEPLOYMENT_V25].nThresholdMin = 72;         // 60% of 120
+        consensus.vDeployments[Consensus::DEPLOYMENT_V25].nFalloffCoeff = 5;          // this corresponds to 10 periods
+        consensus.vDeployments[Consensus::DEPLOYMENT_V25].useEHF = true;
+
         consensus.nMinimumChainWork = uint256{};
         consensus.defaultAssumeValid = uint256{};
 
@@ -831,6 +858,15 @@ class CRegTestParams : public CChainParams {
         consensus.vDeployments[Consensus::DEPLOYMENT_V24].nFalloffCoeff = 5;                 // this corresponds to 10 periods
         consensus.vDeployments[Consensus::DEPLOYMENT_V24].useEHF = true;
 
+        consensus.vDeployments[Consensus::DEPLOYMENT_V25].bit = 13;
+        consensus.vDeployments[Consensus::DEPLOYMENT_V25].nStartTime = 0;
+        consensus.vDeployments[Consensus::DEPLOYMENT_V25].nTimeout = Consensus::BIP9Deployment::NO_TIMEOUT;
+        consensus.vDeployments[Consensus::DEPLOYMENT_V25].nWindowSize = 250;
+        consensus.vDeployments[Consensus::DEPLOYMENT_V25].nThresholdStart = 250 / 5 * 4;     // 80% of window size
+        consensus.vDeployments[Consensus::DEPLOYMENT_V25].nThresholdMin = 250 / 5 * 3;       // 60% of window size
+        consensus.vDeployments[Consensus::DEPLOYMENT_V25].nFalloffCoeff = 5;                 // this corresponds to 10 periods
+        consensus.vDeployments[Consensus::DEPLOYMENT_V25].useEHF = true;
+
         consensus.nMinimumChainWork = uint256{};
         consensus.defaultAssumeValid = uint256{};
 
diff --git a/src/consensus/params.h b/src/consensus/params.h
index 37b5c75f2896..06ee9a09ce3d 100644
--- a/src/consensus/params.h
+++ b/src/consensus/params.h
@@ -41,6 +41,7 @@ constexpr bool ValidDeployment(BuriedDeployment dep) { return dep <= DEPLOYMENT_
 enum DeploymentPos : uint16_t {
     DEPLOYMENT_TESTDUMMY,
     DEPLOYMENT_V24,         // Deployment of doubling withdrawal limit, extended addresses
+    DEPLOYMENT_V25,         // Deployment of DIP0026 multi-party masternode payouts
     // NOTE: Also add new deployments to VersionBitsDeploymentInfo in deploymentinfo.cpp
     MAX_VERSION_BITS_DEPLOYMENTS
 };
diff --git a/src/deploymentinfo.cpp b/src/deploymentinfo.cpp
index 856403e32889..0ce08a6e7186 100644
--- a/src/deploymentinfo.cpp
+++ b/src/deploymentinfo.cpp
@@ -15,6 +15,10 @@ const struct VBDeploymentInfo VersionBitsDeploymentInfo[Consensus::MAX_VERSION_B
         /*.name =*/"v24",
         /*.gbt_force =*/true,
     },
+    {
+        /*.name =*/"v25",
+        /*.gbt_force =*/true,
+    },
 };
 
 std::string DeploymentName(Consensus::BuriedDeployment dep)
diff --git a/src/evo/providertx.cpp b/src/evo/providertx.cpp
index b2c3691aa4f5..bf23da96b842 100644
--- a/src/evo/providertx.cpp
+++ b/src/evo/providertx.cpp
@@ -21,10 +21,23 @@ template <typename T>
                                             const ChainstateManager& chainman, std::optional<bool> is_basic_override)
 {
     constexpr bool is_extaddr_eligible{std::is_same_v<std::decay_t<T>, CProRegTx> || std::is_same_v<std::decay_t<T>, CProUpServTx>};
-    return ProTxVersion::GetMax(
-        is_basic_override ? *is_basic_override
-                          : DeploymentActiveAfter(pindexPrev, chainman.GetConsensus(), Consensus::DEPLOYMENT_V19),
-        is_extaddr_eligible ? DeploymentActiveAfter(pindexPrev, chainman, Consensus::DEPLOYMENT_V24) : false);
+    // DIP0026 multi-party payouts apply to the owner-side payout, which is only carried by
+    // ProRegTx and ProUpRegTx. ProUpServTx (operator payout) and ProUpRevTx are not eligible.
+    constexpr bool is_multipayout_eligible{std::is_same_v<std::decay_t<T>, CProRegTx> || std::is_same_v<std::decay_t<T>, CProUpRegTx>};
+
+    const bool is_basic{is_basic_override ? *is_basic_override
+                                          : DeploymentActiveAfter(pindexPrev, chainman.GetConsensus(), Consensus::DEPLOYMENT_V19)};
+    const bool is_extaddr{is_extaddr_eligible && DeploymentActiveAfter(pindexPrev, chainman, Consensus::DEPLOYMENT_V24)};
+    bool is_multipayout{is_multipayout_eligible && DeploymentActiveAfter(pindexPrev, chainman, Consensus::DEPLOYMENT_V25)};
+
+    // A v4 CProRegTx (MultiPayout > ExtAddr) implies extended-address netInfo, so multi-payout
+    // must never outrun the extended-address fork for an extaddr-eligible type. We enforce this
+    // in code rather than relying on chainparams ordering of V24/V25. CProUpRegTx carries no
+    // netInfo and is not extaddr-eligible, so it may reach v4 on DEPLOYMENT_V25 alone.
+    if (is_extaddr_eligible && is_multipayout && !is_extaddr) {
+        is_multipayout = false;
+    }
+    return ProTxVersion::GetMax(is_basic, is_extaddr, is_multipayout);
 }
 template uint16_t GetMaxFromDeployment<CProRegTx>(gsl::not_null<const CBlockIndex*> pindexPrev,
                                                   const ChainstateManager& chainman,
@@ -89,7 +102,7 @@ bool CProRegTx::IsTriviallyValid(gsl::not_null<const CBlockIndex*> pindexPrev, c
     if (!scriptPayout.IsPayToPublicKeyHash() && !scriptPayout.IsPayToScriptHash()) {
         return state.Invalid(TxValidationResult::TX_BAD_SPECIAL, "bad-protx-payee");
     }
-    if (netInfo->CanStorePlatform() != (nVersion == ProTxVersion::ExtAddr)) {
+    if (netInfo->CanStorePlatform() != (nVersion >= ProTxVersion::ExtAddr)) {
         return state.Invalid(TxValidationResult::TX_CONSENSUS, "bad-protx-netinfo-version");
     }
     if (!netInfo->IsEmpty() && !IsNetInfoTriviallyValid(*this, state)) {
@@ -171,7 +184,7 @@ bool CProUpServTx::IsTriviallyValid(gsl::not_null<const CBlockIndex*> pindexPrev
     if (nVersion < ProTxVersion::BasicBLS && nType == MnType::Evo) {
         return state.Invalid(TxValidationResult::TX_CONSENSUS, "bad-protx-evo-version");
     }
-    if (netInfo->CanStorePlatform() != (nVersion == ProTxVersion::ExtAddr)) {
+    if (netInfo->CanStorePlatform() != (nVersion >= ProTxVersion::ExtAddr)) {
         return state.Invalid(TxValidationResult::TX_CONSENSUS, "bad-protx-netinfo-version");
     }
     if (netInfo->IsEmpty()) {
diff --git a/src/evo/providertx.h b/src/evo/providertx.h
index 68c6fe3c7aa2..304908c0b324 100644
--- a/src/evo/providertx.h
+++ b/src/evo/providertx.h
@@ -27,19 +27,28 @@ struct RPCResult;
 
 namespace ProTxVersion {
 enum : uint16_t {
-    LegacyBLS = 1,
-    BasicBLS  = 2,
-    ExtAddr   = 3,
+    LegacyBLS   = 1,
+    BasicBLS    = 2,
+    ExtAddr     = 3,
+    MultiPayout = 4, // DIP0026 multi-party payouts (gated by DEPLOYMENT_V25)
 };
 
 /** Get highest permissible ProTx version based on flags set. */
-[[nodiscard]] constexpr uint16_t GetMax(const bool is_basic_scheme_active, const bool is_extended_addr)
+[[nodiscard]] constexpr uint16_t GetMax(const bool is_basic_scheme_active, const bool is_extended_addr,
+                                        const bool is_multi_payout)
 {
     if (is_basic_scheme_active) {
+        // DIP0026 multi-party payouts (v4) build on top of basic BLS and are the highest
+        // version. For CProRegTx the extended-address (v3) features are implied because
+        // DEPLOYMENT_V25 only activates after DEPLOYMENT_V24; CProUpRegTx carries no netInfo
+        // and so transitions straight from v2 to v4. is_basic_scheme_active could be set to
+        // false due to RPC specialization, so it gates the whole block to avoid accidentally
+        // upgrading a legacy BLS node due to a later fork activation.
+        if (is_multi_payout) {
+            return ProTxVersion::MultiPayout;
+        }
         if (is_extended_addr) {
-            // Requires *both* forks to be active to use extended addresses. is_basic_scheme_active could
-            // be set to false due to RPC specialization, so we must evaluate is_extended_addr *last* to
-            // avoid accidentally upgrading a legacy BLS node to basic BLS due to v24 activation.
+            // Requires *both* forks to be active to use extended addresses.
             return ProTxVersion::ExtAddr;
         }
         return ProTxVersion::BasicBLS;
@@ -47,6 +56,17 @@ enum : uint16_t {
     return ProTxVersion::LegacyBLS;
 }
 
+// Compile-time verification of the version-tier logic (DIP0026). These guarantee the gating
+// can never silently regress: basic-BLS gates everything, and multi-payout (v4) is the highest
+// version, reachable with or without extended addresses (CProUpRegTx carries no netInfo so it
+// goes v2 -> v4 directly; for CProRegTx, DEPLOYMENT_V25 only activates after DEPLOYMENT_V24).
+static_assert(GetMax(/*basic=*/false, /*extaddr=*/false, /*multipayout=*/false) == LegacyBLS);
+static_assert(GetMax(/*basic=*/false, /*extaddr=*/true,  /*multipayout=*/true ) == LegacyBLS);
+static_assert(GetMax(/*basic=*/true,  /*extaddr=*/false, /*multipayout=*/false) == BasicBLS);
+static_assert(GetMax(/*basic=*/true,  /*extaddr=*/true,  /*multipayout=*/false) == ExtAddr);
+static_assert(GetMax(/*basic=*/true,  /*extaddr=*/false, /*multipayout=*/true ) == MultiPayout);
+static_assert(GetMax(/*basic=*/true,  /*extaddr=*/true,  /*multipayout=*/true ) == MultiPayout);
+
 /** Get highest permissible ProTx version based on deployment status
  *  Note: The override is needed because some RPCs need to use deployment status information for everything *except*
  *        the BLS version upgrade since they are specializations for a specific BLS version. This is a one-off.
@@ -84,7 +104,7 @@ class CProRegTx
                 obj.nVersion
         );
         if (obj.nVersion == 0 ||
-            obj.nVersion > ProTxVersion::GetMax(/*is_basic_scheme_active=*/true, /*is_extended_addr=*/true)) {
+            obj.nVersion > ProTxVersion::GetMax(/*is_basic_scheme_active=*/true, /*is_extended_addr=*/true, /*is_multi_payout=*/true)) {
             // unknown version, bail out early
             return;
         }
@@ -151,7 +171,7 @@ class CProUpServTx
                 obj.nVersion
         );
         if (obj.nVersion == 0 ||
-            obj.nVersion > ProTxVersion::GetMax(/*is_basic_scheme_active=*/true, /*is_extended_addr=*/true)) {
+            obj.nVersion > ProTxVersion::GetMax(/*is_basic_scheme_active=*/true, /*is_extended_addr=*/true, /*is_multi_payout=*/true)) {
             // unknown version, bail out early
             return;
         }
@@ -211,7 +231,7 @@ class CProUpRegTx
                 obj.nVersion
         );
         if (obj.nVersion == 0 ||
-            obj.nVersion > ProTxVersion::GetMax(/*is_basic_scheme_active=*/true, /*is_extended_addr=*/true)) {
+            obj.nVersion > ProTxVersion::GetMax(/*is_basic_scheme_active=*/true, /*is_extended_addr=*/true, /*is_multi_payout=*/true)) {
             // unknown version, bail out early
             return;
         }
@@ -265,7 +285,7 @@ class CProUpRevTx
                 obj.nVersion
         );
         if (obj.nVersion == 0 ||
-            obj.nVersion > ProTxVersion::GetMax(/*is_basic_scheme_active=*/true, /*is_extended_addr=*/true)) {
+            obj.nVersion > ProTxVersion::GetMax(/*is_basic_scheme_active=*/true, /*is_extended_addr=*/true, /*is_multi_payout=*/true)) {
             // unknown version, bail out early
             return;
         }
diff --git a/src/rpc/blockchain.cpp b/src/rpc/blockchain.cpp
index eca003933174..05eee0e5964a 100644
--- a/src/rpc/blockchain.cpp
+++ b/src/rpc/blockchain.cpp
@@ -1609,6 +1609,7 @@ RPCHelpMan getblockchaininfo()
     }
     for (auto ehf_deploy : { /* sorted by activation block */
                              Consensus::DEPLOYMENT_V24,
+                             Consensus::DEPLOYMENT_V25,
                              Consensus::DEPLOYMENT_TESTDUMMY }) {
         SoftForkDescPushBack(&tip, ehfSignals, softforks, chainman, ehf_deploy);
     }
diff --git a/src/test/block_reward_reallocation_tests.cpp b/src/test/block_reward_reallocation_tests.cpp
index 97c29c62c9d0..dca62e913e89 100644
--- a/src/test/block_reward_reallocation_tests.cpp
+++ b/src/test/block_reward_reallocation_tests.cpp
@@ -115,7 +115,7 @@ static CMutableTransaction CreateProRegTx(const CChain& active_chain, const CTxM
     operatorKeyRet.MakeNewKey();
 
     CProRegTx proTx;
-    proTx.nVersion = ProTxVersion::GetMax(!bls::bls_legacy_scheme, /*is_extended_addr=*/false);
+    proTx.nVersion = ProTxVersion::GetMax(!bls::bls_legacy_scheme, /*is_extended_addr=*/false, /*is_multi_payout=*/false);
     proTx.netInfo = NetInfoInterface::MakeNetInfo(proTx.nVersion);
     proTx.collateralOutpoint.n = 0;
     BOOST_CHECK_EQUAL(proTx.netInfo->AddEntry(NetInfoPurpose::CORE_P2P, strprintf("1.1.1.1:%d", port)),
diff --git a/src/test/evo_deterministicmns_tests.cpp b/src/test/evo_deterministicmns_tests.cpp
index af286a51f148..bde861d511b1 100644
--- a/src/test/evo_deterministicmns_tests.cpp
+++ b/src/test/evo_deterministicmns_tests.cpp
@@ -106,7 +106,7 @@ static CMutableTransaction CreateProRegTx(const CChain& active_chain, const CTxM
     operatorKeyRet.MakeNewKey();
 
     CProRegTx proTx;
-    proTx.nVersion = ProTxVersion::GetMax(!bls::bls_legacy_scheme, /*is_extended_addr=*/false);
+    proTx.nVersion = ProTxVersion::GetMax(!bls::bls_legacy_scheme, /*is_extended_addr=*/false, /*is_multi_payout=*/false);
     proTx.netInfo = NetInfoInterface::MakeNetInfo(proTx.nVersion);
     proTx.collateralOutpoint.n = 0;
     BOOST_CHECK_EQUAL(proTx.netInfo->AddEntry(NetInfoPurpose::CORE_P2P, strprintf("1.1.1.1:%d", port)),
@@ -130,7 +130,7 @@ static CMutableTransaction CreateProRegTx(const CChain& active_chain, const CTxM
 static CMutableTransaction CreateProUpServTx(const CChain& active_chain, const CTxMemPool& mempool, SimpleUTXOMap& utxos, const uint256& proTxHash, const CBLSSecretKey& operatorKey, int port, const CScript& scriptOperatorPayout, const CKey& coinbaseKey)
 {
     CProUpServTx proTx;
-    proTx.nVersion = ProTxVersion::GetMax(!bls::bls_legacy_scheme, /*is_extended_addr=*/false);
+    proTx.nVersion = ProTxVersion::GetMax(!bls::bls_legacy_scheme, /*is_extended_addr=*/false, /*is_multi_payout=*/false);
     proTx.netInfo = NetInfoInterface::MakeNetInfo(proTx.nVersion);
     proTx.proTxHash = proTxHash;
     BOOST_CHECK_EQUAL(proTx.netInfo->AddEntry(NetInfoPurpose::CORE_P2P, strprintf("1.1.1.1:%d", port)),
@@ -152,7 +152,7 @@ static CMutableTransaction CreateProUpServTx(const CChain& active_chain, const C
 static CMutableTransaction CreateProUpRegTx(const CChain& active_chain, const CTxMemPool& mempool, SimpleUTXOMap& utxos, const uint256& proTxHash, const CKey& mnKey, const CBLSPublicKey& pubKeyOperator, const CKeyID& keyIDVoting, const CScript& scriptPayout, const CKey& coinbaseKey)
 {
     CProUpRegTx proTx;
-    proTx.nVersion = ProTxVersion::GetMax(!bls::bls_legacy_scheme, /*is_extended_addr=*/false);
+    proTx.nVersion = ProTxVersion::GetMax(!bls::bls_legacy_scheme, /*is_extended_addr=*/false, /*is_multi_payout=*/false);
     proTx.proTxHash = proTxHash;
     proTx.pubKeyOperator.Set(pubKeyOperator, bls::bls_legacy_scheme.load());
     proTx.keyIDVoting = keyIDVoting;
@@ -173,7 +173,7 @@ static CMutableTransaction CreateProUpRegTx(const CChain& active_chain, const CT
 static CMutableTransaction CreateProUpRevTx(const CChain& active_chain, const CTxMemPool& mempool, SimpleUTXOMap& utxos, const uint256& proTxHash, const CBLSSecretKey& operatorKey, const CKey& coinbaseKey)
 {
     CProUpRevTx proTx;
-    proTx.nVersion = ProTxVersion::GetMax(!bls::bls_legacy_scheme, /*is_extended_addr=*/false);
+    proTx.nVersion = ProTxVersion::GetMax(!bls::bls_legacy_scheme, /*is_extended_addr=*/false, /*is_multi_payout=*/false);
     proTx.proTxHash = proTxHash;
 
     CMutableTransaction tx;
@@ -641,7 +641,7 @@ void FuncTestMempoolReorg(TestChainSetup& setup)
     BOOST_CHECK_EQUAL(block->GetHash(), chainman.ActiveChain().Tip()->GetBlockHash());
 
     CProRegTx payload;
-    payload.nVersion = ProTxVersion::GetMax(!bls::bls_legacy_scheme, /*is_extended_addr=*/false);
+    payload.nVersion = ProTxVersion::GetMax(!bls::bls_legacy_scheme, /*is_extended_addr=*/false, /*is_multi_payout=*/false);
     payload.netInfo = NetInfoInterface::MakeNetInfo(payload.nVersion);
     BOOST_CHECK_EQUAL(payload.netInfo->AddEntry(NetInfoPurpose::CORE_P2P, "1.1.1.1:1"), NetInfoStatus::Success);
     payload.keyIDOwner = ownerKey.GetPubKey().GetID();
@@ -717,7 +717,7 @@ void FuncTestMempoolDualProregtx(TestChainSetup& setup)
     auto scriptPayout = GetScriptForDestination(PKHash(payoutKey.GetPubKey()));
 
     CProRegTx payload;
-    payload.nVersion = ProTxVersion::GetMax(!bls::bls_legacy_scheme, /*is_extended_addr=*/false);
+    payload.nVersion = ProTxVersion::GetMax(!bls::bls_legacy_scheme, /*is_extended_addr=*/false, /*is_multi_payout=*/false);
     payload.netInfo = NetInfoInterface::MakeNetInfo(payload.nVersion);
     BOOST_CHECK_EQUAL(payload.netInfo->AddEntry(NetInfoPurpose::CORE_P2P, "1.1.1.1:2"), NetInfoStatus::Success);
     payload.keyIDOwner = ownerKey.GetPubKey().GetID();
@@ -787,7 +787,7 @@ void FuncVerifyDB(TestChainSetup& setup)
     BOOST_CHECK_EQUAL(block->GetHash(), chainman.ActiveChain().Tip()->GetBlockHash());
 
     CProRegTx payload;
-    payload.nVersion = ProTxVersion::GetMax(!bls::bls_legacy_scheme, /*is_extended_addr=*/false);
+    payload.nVersion = ProTxVersion::GetMax(!bls::bls_legacy_scheme, /*is_extended_addr=*/false, /*is_multi_payout=*/false);
     payload.netInfo = NetInfoInterface::MakeNetInfo(payload.nVersion);
     BOOST_CHECK_EQUAL(payload.netInfo->AddEntry(NetInfoPurpose::CORE_P2P, "1.1.1.1:1"), NetInfoStatus::Success);
     payload.keyIDOwner = ownerKey.GetPubKey().GetID();
@@ -852,7 +852,7 @@ static CDeterministicMNCPtr create_mock_mn(uint64_t internal_id)
     dmnState->pubKeyOperator.Set(operatorKey.GetPublicKey(), bls::bls_legacy_scheme.load());
     dmnState->keyIDVoting = ownerKey.GetPubKey().GetID();
     dmnState->netInfo = NetInfoInterface::MakeNetInfo(
-        ProTxVersion::GetMax(!bls::bls_legacy_scheme, /*is_extended_addr=*/false));
+        ProTxVersion::GetMax(!bls::bls_legacy_scheme, /*is_extended_addr=*/false, /*is_multi_payout=*/false));
     BOOST_CHECK_EQUAL(dmnState->netInfo->AddEntry(NetInfoPurpose::CORE_P2P, "1.1.1.1:1"), NetInfoStatus::Success);
 
     auto dmn = std::make_shared<CDeterministicMN>(internal_id, MnType::Regular);
diff --git a/src/test/evo_simplifiedmns_tests.cpp b/src/test/evo_simplifiedmns_tests.cpp
index 1122ad6aef19..95770457e016 100644
--- a/src/test/evo_simplifiedmns_tests.cpp
+++ b/src/test/evo_simplifiedmns_tests.cpp
@@ -19,7 +19,7 @@ BOOST_AUTO_TEST_CASE(simplifiedmns_merkleroots)
     std::vector<std::unique_ptr<CSimplifiedMNListEntry>> entries;
     for (size_t i = 1; i < 16; i++) {
         CSimplifiedMNListEntry smle;
-        smle.nVersion = ProTxVersion::GetMax(!bls::bls_legacy_scheme, /*is_extended_addr=*/false);
+        smle.nVersion = ProTxVersion::GetMax(!bls::bls_legacy_scheme, /*is_extended_addr=*/false, /*is_multi_payout=*/false);
         smle.netInfo = NetInfoInterface::MakeNetInfo(smle.nVersion);
         smle.proRegTxHash.SetHex(strprintf("%064x", i));
         smle.confirmedHash.SetHex(strprintf("%064x", i));
diff --git a/test/functional/rpc_blockchain.py b/test/functional/rpc_blockchain.py
index 2f74a60003ba..81c4c04ffc8d 100755
--- a/test/functional/rpc_blockchain.py
+++ b/test/functional/rpc_blockchain.py
@@ -229,6 +229,17 @@ def _test_getblockchaininfo(self):
                     'ehf': True
                 },
                 'active': False},
+            'v25': {
+                'type': 'bip9',
+                'bip9': {
+                    'status': 'defined',
+                    'start_time': 0,
+                    'timeout': 9223372036854775807,  # "v25" does not have a timeout so is set to the max int64 value
+                    'since': 0,
+                    'min_activation_height': 0,
+                    'ehf': True
+                },
+                'active': False},
             'testdummy': {
                 'type': 'bip9',
                 'bip9': {

From fa889ac7b3c2f23bd4c72e8f853877678f8065c4 Mon Sep 17 00:00:00 2001
From: Hilawe Semunegus <hilawe@gmail.com>
Date: Sat, 6 Jun 2026 01:16:03 -0400
Subject: [PATCH 02/15] DIP-0026 P2: PayoutShare data model + version-gated
 serialization

Add the multi-party payout data model and wire its serialization into v4
ProRegTx/ProUpRegTx, with no validation or payout logic yet.

- evo/providertx.h: new PayoutShare {CScript scriptPayout; uint16_t
  payoutShareReward;} with the DIP0026 wire format (CompactSize scriptlen +
  script bytes + uint16 reward); TOTAL_BASIS_POINTS=10000. Add
  std::vector<PayoutShare> payoutShares to CProRegTx and CProUpRegTx,
  serialized at the same wire position as scriptPayout but only for
  nVersion >= MultiPayout; pre-v4 serialization is byte-for-byte unchanged.
  Add GetPayoutShares() for a uniform view (synthesizes a single full share
  from scriptPayout for older versions).
- evo/providertx.cpp: PayoutShare::ToString().
- test: new evo_providertx_tests (round-trip + wire-format + accessor
  coverage for PayoutShare, the share vector, and v2/v3/v4 ProReg/ProUpReg).

Verified on macOS: 6 new tests pass; evo_dip3_activation_tests and the other
evo serialization suites pass unchanged (no v<4 regression).
---
 src/Makefile.test.include         |   1 +
 src/evo/providertx.cpp            |   8 ++
 src/evo/providertx.h              |  80 ++++++++++++++--
 src/test/evo_providertx_tests.cpp | 148 ++++++++++++++++++++++++++++++
 4 files changed, 229 insertions(+), 8 deletions(-)
 create mode 100644 src/test/evo_providertx_tests.cpp

diff --git a/src/Makefile.test.include b/src/Makefile.test.include
index 375c9940d059..d76789b37321 100644
--- a/src/Makefile.test.include
+++ b/src/Makefile.test.include
@@ -113,6 +113,7 @@ BITCOIN_TESTS =\
   test/evo_islock_tests.cpp \
   test/evo_mnhf_tests.cpp \
   test/evo_netinfo_tests.cpp \
+  test/evo_providertx_tests.cpp \
   test/evo_simplifiedmns_tests.cpp \
   test/evo_trivialvalidation.cpp \
   test/evo_utils_tests.cpp \
diff --git a/src/evo/providertx.cpp b/src/evo/providertx.cpp
index bf23da96b842..207285d651c8 100644
--- a/src/evo/providertx.cpp
+++ b/src/evo/providertx.cpp
@@ -53,6 +53,14 @@ template uint16_t GetMaxFromDeployment<CProUpRevTx>(gsl::not_null<const CBlockIn
                                                     std::optional<bool> is_basic_override);
 } // namespace ProTxVersion
 
+std::string PayoutShare::ToString() const
+{
+    CTxDestination dest;
+    const std::string payee{ExtractDestination(scriptPayout, dest) ? EncodeDestination(dest)
+                                                                   : HexStr(scriptPayout)};
+    return strprintf("%s:%d", payee, payoutShareReward);
+}
+
 template <typename ProTx>
 bool IsNetInfoTriviallyValid(const ProTx& proTx, TxValidationState& state)
 {
diff --git a/src/evo/providertx.h b/src/evo/providertx.h
index 304908c0b324..fa2266adcd3d 100644
--- a/src/evo/providertx.h
+++ b/src/evo/providertx.h
@@ -77,6 +77,40 @@ template <typename T>
                                             std::optional<bool> is_basic_override = std::nullopt);
 } // namespace ProTxVersion
 
+/**
+ * DIP0026: a single multi-party payout share. The owner-side masternode block reward is split
+ * across a set of these. `payoutShareReward` is expressed in basis points (0..10000); the full
+ * set carried by a v4 ProRegTx/ProUpRegTx must sum to exactly TOTAL_BASIS_POINTS.
+ *
+ * Wire format (matches DIP0026): CompactSize scriptPayout length, scriptPayout bytes, uint16
+ * payoutShareReward. A std::vector<PayoutShare> therefore serializes as a CompactSize count
+ * followed by that many encoded shares, which is exactly the DIP `payoutSharesSize` +
+ * `payoutShares[]` layout.
+ */
+class PayoutShare
+{
+public:
+    static constexpr uint16_t TOTAL_BASIS_POINTS{10000};
+
+    CScript scriptPayout;
+    uint16_t payoutShareReward{0};
+
+    PayoutShare() = default;
+    PayoutShare(CScript script, uint16_t reward) : scriptPayout(std::move(script)), payoutShareReward(reward) {}
+
+    SERIALIZE_METHODS(PayoutShare, obj)
+    {
+        READWRITE(obj.scriptPayout, obj.payoutShareReward);
+    }
+
+    friend bool operator==(const PayoutShare& a, const PayoutShare& b)
+    {
+        return a.scriptPayout == b.scriptPayout && a.payoutShareReward == b.payoutShareReward;
+    }
+
+    std::string ToString() const;
+};
+
 class CProRegTx
 {
 public:
@@ -94,7 +128,8 @@ class CProRegTx
     CBLSLazyPublicKey pubKeyOperator;
     CKeyID keyIDVoting;
     uint16_t nOperatorReward{0};
-    CScript scriptPayout;
+    CScript scriptPayout;                  // used for nVersion < MultiPayout
+    std::vector<PayoutShare> payoutShares; // DIP0026, used for nVersion >= MultiPayout
     uint256 inputsHash; // replay protection
     std::vector<unsigned char> vchSig;
 
@@ -118,10 +153,16 @@ class CProRegTx
                 obj.keyIDOwner,
                 CBLSLazyPublicKeyVersionWrapper(const_cast<CBLSLazyPublicKey&>(obj.pubKeyOperator), (obj.nVersion == ProTxVersion::LegacyBLS)),
                 obj.keyIDVoting,
-                obj.nOperatorReward,
-                obj.scriptPayout,
-                obj.inputsHash
+                obj.nOperatorReward
         );
+        // DIP0026: v4+ replaces the single scriptPayout with an array of payout shares at the
+        // same wire position. Pre-v4 serialization is byte-for-byte unchanged.
+        if (obj.nVersion < ProTxVersion::MultiPayout) {
+            READWRITE(obj.scriptPayout);
+        } else {
+            READWRITE(obj.payoutShares);
+        }
+        READWRITE(obj.inputsHash);
         if (obj.nType == MnType::Evo) {
             READWRITE(
                 obj.platformNodeID);
@@ -136,6 +177,15 @@ class CProRegTx
         }
     }
 
+    // Uniform view of the owner-side payout regardless of version: for nVersion >= MultiPayout
+    // returns the stored shares; for older versions synthesizes a single full share from
+    // scriptPayout. Lets downstream payout/validation code have a single code path.
+    [[nodiscard]] std::vector<PayoutShare> GetPayoutShares() const
+    {
+        if (nVersion >= ProTxVersion::MultiPayout) return payoutShares;
+        return {PayoutShare{scriptPayout, PayoutShare::TOTAL_BASIS_POINTS}};
+    }
+
     // 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;
@@ -221,7 +271,8 @@ class CProUpRegTx
     uint16_t nMode{0}; // only 0 supported for now
     CBLSLazyPublicKey pubKeyOperator;
     CKeyID keyIDVoting;
-    CScript scriptPayout;
+    CScript scriptPayout;                  // used for nVersion < MultiPayout
+    std::vector<PayoutShare> payoutShares; // DIP0026, used for nVersion >= MultiPayout
     uint256 inputsHash; // replay protection
     std::vector<unsigned char> vchSig;
 
@@ -239,10 +290,16 @@ class CProUpRegTx
                 obj.proTxHash,
                 obj.nMode,
                 CBLSLazyPublicKeyVersionWrapper(const_cast<CBLSLazyPublicKey&>(obj.pubKeyOperator), (obj.nVersion == ProTxVersion::LegacyBLS)),
-                obj.keyIDVoting,
-                obj.scriptPayout,
-                obj.inputsHash
+                obj.keyIDVoting
         );
+        // DIP0026: v4+ replaces the single scriptPayout with an array of payout shares at the
+        // same wire position. Pre-v4 serialization is byte-for-byte unchanged.
+        if (obj.nVersion < ProTxVersion::MultiPayout) {
+            READWRITE(obj.scriptPayout);
+        } else {
+            READWRITE(obj.payoutShares);
+        }
+        READWRITE(obj.inputsHash);
         if (!(s.GetType() & SER_GETHASH)) {
             READWRITE(
                     obj.vchSig
@@ -250,6 +307,13 @@ class CProUpRegTx
         }
     }
 
+    // Uniform view of the owner-side payout regardless of version (see CProRegTx::GetPayoutShares).
+    [[nodiscard]] std::vector<PayoutShare> GetPayoutShares() const
+    {
+        if (nVersion >= ProTxVersion::MultiPayout) return payoutShares;
+        return {PayoutShare{scriptPayout, PayoutShare::TOTAL_BASIS_POINTS}};
+    }
+
     std::string ToString() const;
 
     [[nodiscard]] static RPCResult GetJsonHelp(const std::string& key, bool optional);
diff --git a/src/test/evo_providertx_tests.cpp b/src/test/evo_providertx_tests.cpp
new file mode 100644
index 000000000000..89d754437927
--- /dev/null
+++ b/src/test/evo_providertx_tests.cpp
@@ -0,0 +1,148 @@
+// Copyright (c) 2025 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 <evo/providertx.h>
+
+#include <bls/bls.h>
+#include <evo/dmn_types.h>
+#include <evo/netinfo.h>
+#include <key.h>
+#include <script/script.h>
+#include <streams.h>
+#include <uint256.h>
+
+#include <test/util/setup_common.h>
+
+#include <boost/test/unit_test.hpp>
+
+// DIP0026 multi-party payout data-model / serialization tests.
+BOOST_FIXTURE_TEST_SUITE(evo_providertx_tests, BasicTestingSetup)
+
+static CScript P2PKHScript(uint8_t fill)
+{
+    return CScript() << OP_DUP << OP_HASH160 << std::vector<unsigned char>(20, fill) << OP_EQUALVERIFY << OP_CHECKSIG;
+}
+
+template <typename T>
+static T SerRoundtrip(const T& in)
+{
+    CDataStream ss(SER_NETWORK, PROTOCOL_VERSION);
+    ss << in;
+    T out;
+    ss >> out;
+    return out;
+}
+
+BOOST_AUTO_TEST_CASE(payoutshare_roundtrip)
+{
+    const PayoutShare in{P2PKHScript(0x11), 6000};
+    const PayoutShare out = SerRoundtrip(in);
+    BOOST_CHECK(in == out);
+    BOOST_CHECK(out.scriptPayout == in.scriptPayout);
+    BOOST_CHECK_EQUAL(out.payoutShareReward, 6000);
+}
+
+BOOST_AUTO_TEST_CASE(payoutshares_vector_wireformat)
+{
+    // The DIP0026 wire layout is a CompactSize count followed by that many shares.
+    const std::vector<PayoutShare> shares{{P2PKHScript(0x11), 6000}, {P2PKHScript(0x22), 4000}};
+    CDataStream ss(SER_NETWORK, PROTOCOL_VERSION);
+    ss << shares;
+    BOOST_CHECK_EQUAL(static_cast<uint8_t>(ss[0]), 0x02); // CompactSize count == 2
+
+    std::vector<PayoutShare> out;
+    ss >> out;
+    BOOST_CHECK_EQUAL(out.size(), 2U);
+    BOOST_CHECK(out == shares);
+}
+
+// Build a minimal but serializable ProRegTx at the requested version.
+static CProRegTx MakeProReg(uint16_t version)
+{
+    CProRegTx p;
+    p.nVersion = version;
+    p.nType = MnType::Regular;
+    p.netInfo = NetInfoInterface::MakeNetInfo(version);
+    BOOST_CHECK_EQUAL(p.netInfo->AddEntry(NetInfoPurpose::CORE_P2P, "1.2.3.4:9999"), NetInfoStatus::Success);
+    CBLSSecretKey sk;
+    sk.MakeNewKey();
+    p.pubKeyOperator.Set(sk.GetPublicKey(), /*specificLegacyScheme=*/version == ProTxVersion::LegacyBLS);
+    CKey owner;
+    owner.MakeNewKey(true);
+    p.keyIDOwner = owner.GetPubKey().GetID();
+    p.keyIDVoting = owner.GetPubKey().GetID();
+    p.inputsHash = uint256S("aa");
+    return p;
+}
+
+BOOST_AUTO_TEST_CASE(proregtx_v3_uses_scriptpayout)
+{
+    CProRegTx in = MakeProReg(ProTxVersion::ExtAddr);
+    in.scriptPayout = P2PKHScript(0x33);
+
+    const CProRegTx out = SerRoundtrip(in);
+    BOOST_CHECK_EQUAL(out.nVersion, ProTxVersion::ExtAddr);
+    BOOST_CHECK(out.scriptPayout == in.scriptPayout);
+    BOOST_CHECK(out.payoutShares.empty());
+    // Uniform accessor synthesizes a single full share from the legacy field.
+    const auto shares = out.GetPayoutShares();
+    BOOST_CHECK_EQUAL(shares.size(), 1U);
+    BOOST_CHECK(shares[0].scriptPayout == in.scriptPayout);
+    BOOST_CHECK_EQUAL(shares[0].payoutShareReward, PayoutShare::TOTAL_BASIS_POINTS);
+}
+
+BOOST_AUTO_TEST_CASE(proregtx_v4_uses_payoutshares)
+{
+    CProRegTx in = MakeProReg(ProTxVersion::MultiPayout);
+    in.payoutShares = {{P2PKHScript(0x44), 7000}, {P2PKHScript(0x55), 3000}};
+
+    const CProRegTx out = SerRoundtrip(in);
+    BOOST_CHECK_EQUAL(out.nVersion, ProTxVersion::MultiPayout);
+    BOOST_CHECK(out.scriptPayout.empty());
+    BOOST_CHECK_EQUAL(out.payoutShares.size(), 2U);
+    BOOST_CHECK(out.payoutShares == in.payoutShares);
+    // Uniform accessor returns the stored shares verbatim for v4.
+    BOOST_CHECK(out.GetPayoutShares() == in.payoutShares);
+}
+
+// Build a minimal but serializable ProUpRegTx at the requested version.
+static CProUpRegTx MakeProUpReg(uint16_t version)
+{
+    CProUpRegTx p;
+    p.nVersion = version;
+    p.proTxHash = uint256S("bb");
+    CBLSSecretKey sk;
+    sk.MakeNewKey();
+    p.pubKeyOperator.Set(sk.GetPublicKey(), /*specificLegacyScheme=*/version == ProTxVersion::LegacyBLS);
+    CKey voting;
+    voting.MakeNewKey(true);
+    p.keyIDVoting = voting.GetPubKey().GetID();
+    p.inputsHash = uint256S("cc");
+    return p;
+}
+
+BOOST_AUTO_TEST_CASE(proupregtx_v2_uses_scriptpayout)
+{
+    CProUpRegTx in = MakeProUpReg(ProTxVersion::BasicBLS);
+    in.scriptPayout = P2PKHScript(0x66);
+
+    const CProUpRegTx out = SerRoundtrip(in);
+    BOOST_CHECK_EQUAL(out.nVersion, ProTxVersion::BasicBLS);
+    BOOST_CHECK(out.scriptPayout == in.scriptPayout);
+    BOOST_CHECK(out.payoutShares.empty());
+}
+
+BOOST_AUTO_TEST_CASE(proupregtx_v4_uses_payoutshares)
+{
+    CProUpRegTx in = MakeProUpReg(ProTxVersion::MultiPayout);
+    in.payoutShares = {{P2PKHScript(0x77), 5000}, {P2PKHScript(0x88), 2500}, {P2PKHScript(0x99), 2500}};
+
+    const CProUpRegTx out = SerRoundtrip(in);
+    BOOST_CHECK_EQUAL(out.nVersion, ProTxVersion::MultiPayout);
+    BOOST_CHECK(out.scriptPayout.empty());
+    BOOST_CHECK_EQUAL(out.payoutShares.size(), 3U);
+    BOOST_CHECK(out.payoutShares == in.payoutShares);
+}
+
+BOOST_AUTO_TEST_SUITE_END()

From 3c21bfa09e990be9921bd8b4c2c282f0d3c6a75e Mon Sep 17 00:00:00 2001
From: Hilawe Semunegus <hilawe@gmail.com>
Date: Sat, 6 Jun 2026 01:27:54 -0400
Subject: [PATCH 03/15] DIP-0026 P3: carry payout shares in the deterministic
 MN-list state

Extend CDeterministicMNState with the multi-party payout representation and
apply it through the ProUpRegTx path; no payout or validation logic yet.

- evo/dmnstate.h: add std::vector<PayoutShare> payoutShares to
  CDeterministicMNState; serialize it in place of scriptPayout only for
  nVersion >= MultiPayout (pre-v4 byte-for-byte unchanged); init from
  CProRegTx; add GetPayoutShares() for a uniform view. Add a new last diff
  field bit Field_payoutShares (+ member-tuple entry) so existing diff bits
  are stable. Legacy diff format left untouched.
- evo/specialtxman.cpp: ProUpRegTx apply keeps the payout representation
  consistent with the state version - a v4 update stores payoutShares, clears
  the single scriptPayout, and bumps nVersion so shares persist; older updates
  keep the single-payout path. (Version-transition validation guarding this -
  v4 only targets v3+ MNs, no v4 downgrade - lands in P4.)
- test: state v3/v4 round-trips and a diff round-trip exercising the new
  Field_payoutShares bit.

Verified on macOS: 9 evo_providertx_tests pass; full evo regression (26 cases
incl. evo_dip3_activation_tests) green - no v<4 MN-state serialization regression.
---
 src/evo/dmnstate.h                | 28 ++++++++++--
 src/evo/specialtxman.cpp          | 16 ++++++-
 src/test/evo_providertx_tests.cpp | 71 +++++++++++++++++++++++++++++++
 3 files changed, 110 insertions(+), 5 deletions(-)

diff --git a/src/evo/dmnstate.h b/src/evo/dmnstate.h
index bb1a23f2074c..448006051999 100644
--- a/src/evo/dmnstate.h
+++ b/src/evo/dmnstate.h
@@ -56,7 +56,8 @@ class CDeterministicMNState
     CBLSLazyPublicKey pubKeyOperator;
     CKeyID keyIDVoting;
     std::shared_ptr<NetInfoInterface> netInfo{nullptr};
-    CScript scriptPayout;
+    CScript scriptPayout;                  // used for nVersion < MultiPayout
+    std::vector<PayoutShare> payoutShares; // DIP0026, used for nVersion >= MultiPayout
     CScript scriptOperatorPayout;
 
     uint160 platformNodeID{};
@@ -72,6 +73,7 @@ class CDeterministicMNState
         keyIDVoting(proTx.keyIDVoting),
         netInfo(proTx.netInfo),
         scriptPayout(proTx.scriptPayout),
+        payoutShares(proTx.payoutShares),
         platformNodeID(proTx.platformNodeID),
         platformP2PPort(proTx.platformP2PPort),
         platformHTTPPort(proTx.platformHTTPPort)
@@ -98,8 +100,15 @@ class CDeterministicMNState
         READWRITE(
             obj.keyIDVoting,
             NetInfoSerWrapper(const_cast<std::shared_ptr<NetInfoInterface>&>(obj.netInfo),
-                              obj.nVersion >= ProTxVersion::ExtAddr),
-            obj.scriptPayout,
+                              obj.nVersion >= ProTxVersion::ExtAddr));
+        // DIP0026: v4+ stores an array of payout shares in place of the single scriptPayout.
+        // Pre-v4 serialization is byte-for-byte unchanged.
+        if (obj.nVersion < ProTxVersion::MultiPayout) {
+            READWRITE(obj.scriptPayout);
+        } else {
+            READWRITE(obj.payoutShares);
+        }
+        READWRITE(
             obj.scriptOperatorPayout,
             obj.platformNodeID);
         if (obj.nVersion < ProTxVersion::ExtAddr) {
@@ -147,6 +156,15 @@ class CDeterministicMNState
         h.Finalize(confirmedHashWithProRegTxHash.begin());
     }
 
+    // Uniform view of the owner-side payout regardless of version: for nVersion >= MultiPayout
+    // returns the stored shares; for older versions synthesizes a single full share from
+    // scriptPayout. Downstream payout code (masternode/payments) uses this for one code path.
+    [[nodiscard]] std::vector<PayoutShare> GetPayoutShares() const
+    {
+        if (nVersion >= ProTxVersion::MultiPayout) return payoutShares;
+        return {PayoutShare{scriptPayout, PayoutShare::TOTAL_BASIS_POINTS}};
+    }
+
 public:
     std::string ToString() const;
     [[nodiscard]] static RPCResult GetJsonHelp(const std::string& key, bool optional);
@@ -176,6 +194,7 @@ class CDeterministicMNStateDiff
         Field_platformNodeID = 0x10000,
         Field_platformP2PPort = 0x20000,
         Field_platformHTTPPort = 0x40000,
+        Field_payoutShares = 0x80000, // DIP0026; appended last to keep existing diff bits stable
     };
 
 private:
@@ -207,7 +226,8 @@ class CDeterministicMNStateDiff
         DMN_STATE_MEMBER(nConsecutivePayments),
         DMN_STATE_MEMBER(platformNodeID),
         DMN_STATE_MEMBER(platformP2PPort),
-        DMN_STATE_MEMBER(platformHTTPPort)
+        DMN_STATE_MEMBER(platformHTTPPort),
+        DMN_STATE_MEMBER(payoutShares)
     );
 #undef DMN_STATE_MEMBER
 
diff --git a/src/evo/specialtxman.cpp b/src/evo/specialtxman.cpp
index 65b1e6c4e2c6..89d1d4f6f248 100644
--- a/src/evo/specialtxman.cpp
+++ b/src/evo/specialtxman.cpp
@@ -396,7 +396,21 @@ bool CSpecialTxProcessor::RebuildListFromBlock(const CBlock& block, gsl::not_nul
                 newState->pubKeyOperator = opt_proTx->pubKeyOperator;
             }
             newState->keyIDVoting = opt_proTx->keyIDVoting;
-            newState->scriptPayout = opt_proTx->scriptPayout;
+            // DIP0026: keep the state's payout representation consistent with its version. A v4
+            // ProUpRegTx carries payoutShares (and an empty scriptPayout); applying it stores the
+            // shares, clears the single-payout field, and bumps the state version so the shares
+            // persist (state serialization gates payoutShares on nVersion >= MultiPayout).
+            // Validation (CheckProUpRegTx) guarantees a v4 ProUpRegTx only targets a v3+ MN and
+            // that a v4 MN is never downgraded, so the version bump cannot corrupt netInfo or
+            // silently drop a payout.
+            if (opt_proTx->nVersion >= ProTxVersion::MultiPayout) {
+                newState->payoutShares = opt_proTx->payoutShares;
+                newState->scriptPayout = CScript();
+                newState->nVersion = std::max<uint16_t>(newState->nVersion, opt_proTx->nVersion);
+            } else {
+                newState->scriptPayout = opt_proTx->scriptPayout;
+                newState->payoutShares.clear();
+            }
 
             newList.UpdateMN(opt_proTx->proTxHash, newState);
 
diff --git a/src/test/evo_providertx_tests.cpp b/src/test/evo_providertx_tests.cpp
index 89d754437927..61d2146b2be6 100644
--- a/src/test/evo_providertx_tests.cpp
+++ b/src/test/evo_providertx_tests.cpp
@@ -5,7 +5,9 @@
 #include <evo/providertx.h>
 
 #include <bls/bls.h>
+#include <clientversion.h>
 #include <evo/dmn_types.h>
+#include <evo/dmnstate.h>
 #include <evo/netinfo.h>
 #include <key.h>
 #include <script/script.h>
@@ -145,4 +147,73 @@ BOOST_AUTO_TEST_CASE(proupregtx_v4_uses_payoutshares)
     BOOST_CHECK(out.payoutShares == in.payoutShares);
 }
 
+// ---- DIP0026 deterministic MN state (P3) ----
+
+static CDeterministicMNState MakeMNState(uint16_t version)
+{
+    CDeterministicMNState s;
+    s.nVersion = version;
+    s.netInfo = NetInfoInterface::MakeNetInfo(version);
+    BOOST_CHECK_EQUAL(s.netInfo->AddEntry(NetInfoPurpose::CORE_P2P, "1.2.3.4:9999"), NetInfoStatus::Success);
+    CBLSSecretKey sk;
+    sk.MakeNewKey();
+    s.pubKeyOperator.Set(sk.GetPublicKey(), /*specificLegacyScheme=*/version == ProTxVersion::LegacyBLS);
+    CKey k;
+    k.MakeNewKey(true);
+    s.keyIDOwner = k.GetPubKey().GetID();
+    s.keyIDVoting = k.GetPubKey().GetID();
+    return s;
+}
+
+BOOST_AUTO_TEST_CASE(mnstate_v4_payoutshares_roundtrip)
+{
+    CDeterministicMNState in = MakeMNState(ProTxVersion::MultiPayout);
+    in.payoutShares = {{P2PKHScript(0xa1), 5000}, {P2PKHScript(0xa2), 5000}};
+
+    CDataStream ss(SER_DISK, CLIENT_VERSION);
+    ss << in;
+    CDeterministicMNState out;
+    ss >> out;
+
+    BOOST_CHECK_EQUAL(out.nVersion, ProTxVersion::MultiPayout);
+    BOOST_CHECK(out.payoutShares == in.payoutShares);
+    BOOST_CHECK(out.scriptPayout.empty());
+    BOOST_CHECK(out.GetPayoutShares() == in.payoutShares);
+}
+
+BOOST_AUTO_TEST_CASE(mnstate_v3_scriptpayout_roundtrip)
+{
+    CDeterministicMNState in = MakeMNState(ProTxVersion::ExtAddr);
+    in.scriptPayout = P2PKHScript(0xa3);
+
+    CDataStream ss(SER_DISK, CLIENT_VERSION);
+    ss << in;
+    CDeterministicMNState out;
+    ss >> out;
+
+    BOOST_CHECK_EQUAL(out.nVersion, ProTxVersion::ExtAddr);
+    BOOST_CHECK(out.scriptPayout == in.scriptPayout);
+    BOOST_CHECK(out.payoutShares.empty());
+}
+
+BOOST_AUTO_TEST_CASE(mnstatediff_tracks_payoutshares)
+{
+    CDeterministicMNState a = MakeMNState(ProTxVersion::MultiPayout);
+    a.payoutShares = {{P2PKHScript(0xb1), PayoutShare::TOTAL_BASIS_POINTS}};
+    CDeterministicMNState b = a;
+    b.payoutShares = {{P2PKHScript(0xb2), 6000}, {P2PKHScript(0xb3), 4000}};
+
+    CDeterministicMNStateDiff diff(a, b);
+    BOOST_CHECK(diff.fields & CDeterministicMNStateDiff::Field_payoutShares);
+
+    CDataStream ss(SER_DISK, CLIENT_VERSION);
+    ss << diff;
+    CDeterministicMNStateDiff out;
+    ss >> out;
+
+    CDeterministicMNState applied = a;
+    out.ApplyToState(applied);
+    BOOST_CHECK(applied.payoutShares == b.payoutShares);
+}
+
 BOOST_AUTO_TEST_SUITE_END()

From 10e619bc34e57deeb5d7c9aa5ffc97b70a00ba8c Mon Sep 17 00:00:00 2001
From: Hilawe Semunegus <hilawe@gmail.com>
Date: Sat, 6 Jun 2026 01:37:59 -0400
Subject: [PATCH 04/15] DIP-0026 P4: payout-share validation rules +
 version-transition guards

Validate the multi-party payout structure and the v4 version transitions, and
keep payout shares safe across operator service updates and revocations.

- evo/providertx.{h,cpp}: CheckPayoutShares() enforces, for v4 ProRegTx/
  ProUpRegTx, that payoutShares is non-empty and <= MAX_PAYOUT_SHARES (32),
  every share is p2pkh/p2sh with a nonzero reward <= 10000 bp, scripts are
  unique, and rewards sum to exactly 10000. Wired into both IsTriviallyValid
  (replacing the single scriptPayout check); the payout-key-reuse check now
  iterates every share via GetPayoutShares(). Uniqueness and the nonzero-reward
  rule are stricter than the three DIP0026 conditions (companion dips PR to come).
- evo/specialtxman.cpp: IsVersionChangeValid now (1) requires a v4 ProUpRegTx to
  target an MN already at >= ExtAddr so the version bump can't reinterpret a
  non-extended netInfo, and (2) forbids a ProUpRegTx downgrading a v4 MN back to
  single-payout. The ProUpServTx apply keeps a multi-payout MN at >= MultiPayout
  so a service update can't drop its shares.
- evo/dmnstate.h: ResetOperatorFields (operator revocation) preserves MultiPayout
  when shares are present (payout is an owner-side property surviving operator
  changes).
- test: reject-matrix covering all eight failure modes plus valid v<4 and v4
  cases (including exactly 32 shares).

Verified on macOS: 11 evo_providertx_tests pass; evo_dip3_activation_tests +
evo_trivialvalidation + SML/reallocation suites (17 cases) green.
---
 src/evo/dmnstate.h                |  6 ++-
 src/evo/providertx.cpp            | 69 +++++++++++++++++++++++++------
 src/evo/providertx.h              | 11 +++++
 src/evo/specialtxman.cpp          | 23 +++++++++++
 src/test/evo_providertx_tests.cpp | 64 ++++++++++++++++++++++++++++
 5 files changed, 160 insertions(+), 13 deletions(-)

diff --git a/src/evo/dmnstate.h b/src/evo/dmnstate.h
index 448006051999..ff6832a61b7d 100644
--- a/src/evo/dmnstate.h
+++ b/src/evo/dmnstate.h
@@ -120,7 +120,11 @@ class CDeterministicMNState
 
     void ResetOperatorFields()
     {
-        nVersion = ProTxVersion::LegacyBLS;
+        // DIP0026: the multi-party payout is an owner-side property and must survive an operator
+        // revocation. Keep nVersion at MultiPayout when payout shares are present so they are
+        // still serialized; the (empty) netInfo is rebuilt as the matching extended type. Reset
+        // to LegacyBLS as before when there are no shares.
+        nVersion = payoutShares.empty() ? ProTxVersion::LegacyBLS : ProTxVersion::MultiPayout;
         pubKeyOperator = CBLSLazyPublicKey();
         netInfo = NetInfoInterface::MakeNetInfo(nVersion);
         scriptOperatorPayout = CScript();
diff --git a/src/evo/providertx.cpp b/src/evo/providertx.cpp
index 207285d651c8..038f7f67ad3c 100644
--- a/src/evo/providertx.cpp
+++ b/src/evo/providertx.cpp
@@ -7,6 +7,8 @@
 #include <evo/dmn_types.h>
 #include <util/std23.h>
 
+#include <set>
+
 #include <chainparams.h>
 #include <consensus/validation.h>
 #include <deploymentstatus.h>
@@ -85,6 +87,44 @@ bool IsNetInfoTriviallyValid(const ProTx& proTx, TxValidationState& state)
     return true;
 }
 
+// DIP0026: validate the owner-side payout for a ProRegTx/ProUpRegTx. For nVersion < MultiPayout
+// this is the single scriptPayout (must be p2pkh or p2sh). For nVersion >= MultiPayout it is the
+// payoutShares set, which must be non-empty and at most MAX_PAYOUT_SHARES, each share a p2pkh/p2sh
+// payee with a nonzero reward not exceeding TOTAL_BASIS_POINTS, with no duplicate scripts, summing
+// to exactly TOTAL_BASIS_POINTS. (Uniqueness and the nonzero-reward rule are stricter than the
+// three DIP0026 conditions; see the implementation notes / companion dips PR.)
+bool CheckPayoutShares(uint16_t nVersion, const CScript& scriptPayout,
+                       const std::vector<PayoutShare>& payoutShares, TxValidationState& state)
+{
+    if (nVersion < ProTxVersion::MultiPayout) {
+        if (!scriptPayout.IsPayToPublicKeyHash() && !scriptPayout.IsPayToScriptHash()) {
+            return state.Invalid(TxValidationResult::TX_BAD_SPECIAL, "bad-protx-payee");
+        }
+        return true;
+    }
+    if (payoutShares.empty() || payoutShares.size() > PayoutShare::MAX_PAYOUT_SHARES) {
+        return state.Invalid(TxValidationResult::TX_BAD_SPECIAL, "bad-protx-payout-shares-count");
+    }
+    int64_t total{0};
+    std::set<CScript> seen;
+    for (const auto& share : payoutShares) {
+        if (!share.scriptPayout.IsPayToPublicKeyHash() && !share.scriptPayout.IsPayToScriptHash()) {
+            return state.Invalid(TxValidationResult::TX_BAD_SPECIAL, "bad-protx-payee");
+        }
+        if (share.payoutShareReward == 0 || share.payoutShareReward > PayoutShare::TOTAL_BASIS_POINTS) {
+            return state.Invalid(TxValidationResult::TX_BAD_SPECIAL, "bad-protx-payout-share-reward");
+        }
+        if (!seen.insert(share.scriptPayout).second) {
+            return state.Invalid(TxValidationResult::TX_BAD_SPECIAL, "bad-protx-payout-share-duplicate");
+        }
+        total += share.payoutShareReward;
+    }
+    if (total != PayoutShare::TOTAL_BASIS_POINTS) {
+        return state.Invalid(TxValidationResult::TX_BAD_SPECIAL, "bad-protx-payout-shares-sum");
+    }
+    return true;
+}
+
 bool CProRegTx::IsTriviallyValid(gsl::not_null<const CBlockIndex*> pindexPrev, const ChainstateManager& chainman,
                                  TxValidationState& state) const
 {
@@ -107,8 +147,9 @@ bool CProRegTx::IsTriviallyValid(gsl::not_null<const CBlockIndex*> pindexPrev, c
     if (pubKeyOperator.IsLegacy() != (nVersion == ProTxVersion::LegacyBLS)) {
         return state.Invalid(TxValidationResult::TX_BAD_SPECIAL, "bad-protx-operator-pubkey");
     }
-    if (!scriptPayout.IsPayToPublicKeyHash() && !scriptPayout.IsPayToScriptHash()) {
-        return state.Invalid(TxValidationResult::TX_BAD_SPECIAL, "bad-protx-payee");
+    if (!CheckPayoutShares(nVersion, scriptPayout, payoutShares, state)) {
+        // pass the state returned by the helper above
+        return false;
     }
     if (netInfo->CanStorePlatform() != (nVersion >= ProTxVersion::ExtAddr)) {
         return state.Invalid(TxValidationResult::TX_CONSENSUS, "bad-protx-netinfo-version");
@@ -123,14 +164,17 @@ bool CProRegTx::IsTriviallyValid(gsl::not_null<const CBlockIndex*> pindexPrev, c
         }
     }
 
-    CTxDestination payoutDest;
-    if (!ExtractDestination(scriptPayout, payoutDest)) {
-        // should not happen as we checked script types before
-        return state.Invalid(TxValidationResult::TX_BAD_SPECIAL, "bad-protx-payee-dest");
-    }
-    // don't allow reuse of payout key for other keys (don't allow people to put the payee key onto an online server)
-    if (payoutDest == CTxDestination(PKHash(keyIDOwner)) || payoutDest == CTxDestination(PKHash(keyIDVoting))) {
-        return state.Invalid(TxValidationResult::TX_BAD_SPECIAL, "bad-protx-payee-reuse");
+    // don't allow reuse of a payout key for the owner/voting keys (don't allow people to put the
+    // payee key onto an online server). For v4 this applies to every payout share.
+    for (const auto& share : GetPayoutShares()) {
+        CTxDestination payoutDest;
+        if (!ExtractDestination(share.scriptPayout, payoutDest)) {
+            // should not happen as we checked script types before
+            return state.Invalid(TxValidationResult::TX_BAD_SPECIAL, "bad-protx-payee-dest");
+        }
+        if (payoutDest == CTxDestination(PKHash(keyIDOwner)) || payoutDest == CTxDestination(PKHash(keyIDVoting))) {
+            return state.Invalid(TxValidationResult::TX_BAD_SPECIAL, "bad-protx-payee-reuse");
+        }
     }
 
     if (nOperatorReward > 10000) {
@@ -244,8 +288,9 @@ bool CProUpRegTx::IsTriviallyValid(gsl::not_null<const CBlockIndex*> pindexPrev,
     if (pubKeyOperator.IsLegacy() != (nVersion == ProTxVersion::LegacyBLS)) {
         return state.Invalid(TxValidationResult::TX_BAD_SPECIAL, "bad-protx-operator-pubkey");
     }
-    if (!scriptPayout.IsPayToPublicKeyHash() && !scriptPayout.IsPayToScriptHash()) {
-        return state.Invalid(TxValidationResult::TX_BAD_SPECIAL, "bad-protx-payee");
+    if (!CheckPayoutShares(nVersion, scriptPayout, payoutShares, state)) {
+        // pass the state returned by the helper above
+        return false;
     }
     return true;
 }
diff --git a/src/evo/providertx.h b/src/evo/providertx.h
index fa2266adcd3d..07e29fd8be59 100644
--- a/src/evo/providertx.h
+++ b/src/evo/providertx.h
@@ -91,6 +91,7 @@ class PayoutShare
 {
 public:
     static constexpr uint16_t TOTAL_BASIS_POINTS{10000};
+    static constexpr size_t MAX_PAYOUT_SHARES{32}; // DIP0026: at most 32 shares per ProRegTx/ProUpRegTx
 
     CScript scriptPayout;
     uint16_t payoutShareReward{0};
@@ -111,6 +112,16 @@ class PayoutShare
     std::string ToString() const;
 };
 
+/**
+ * DIP0026: validate the owner-side payout for a ProRegTx/ProUpRegTx. For nVersion < MultiPayout
+ * this is the single scriptPayout (must be p2pkh/p2sh). For nVersion >= MultiPayout it is the
+ * payoutShares set: non-empty and at most PayoutShare::MAX_PAYOUT_SHARES, each a p2pkh/p2sh payee
+ * with a nonzero reward not exceeding TOTAL_BASIS_POINTS, no duplicate scripts, summing to exactly
+ * TOTAL_BASIS_POINTS. Sets `state` and returns false on the first violation.
+ */
+bool CheckPayoutShares(uint16_t nVersion, const CScript& scriptPayout,
+                       const std::vector<PayoutShare>& payoutShares, TxValidationState& state);
+
 class CProRegTx
 {
 public:
diff --git a/src/evo/specialtxman.cpp b/src/evo/specialtxman.cpp
index 89d1d4f6f248..b3ccd32b4f19 100644
--- a/src/evo/specialtxman.cpp
+++ b/src/evo/specialtxman.cpp
@@ -349,6 +349,13 @@ bool CSpecialTxProcessor::RebuildListFromBlock(const CBlock& block, gsl::not_nul
                 // Extended addresses support in v24 means that the version can be updated
                 newState->nVersion = opt_proTx->nVersion;
             }
+            // DIP0026: a ProUpServTx (max ExtAddr) must not downgrade a multi-party-payout MN
+            // below MultiPayout, which would silently drop its payout shares on serialization.
+            // ExtAddr and MultiPayout both imply extended netInfo, so keeping the higher version
+            // is consistent with the ProUpServTx's (extended) netInfo set just below.
+            if (!newState->payoutShares.empty()) {
+                newState->nVersion = std::max<uint16_t>(newState->nVersion, ProTxVersion::MultiPayout);
+            }
             newState->netInfo = opt_proTx->netInfo;
             newState->scriptOperatorPayout = opt_proTx->scriptOperatorPayout;
             if (opt_proTx->nType == MnType::Evo) {
@@ -926,6 +933,22 @@ static bool IsVersionChangeValid(gsl::not_null<const CBlockIndex*> pindexPrev, c
         return state.Invalid(TxValidationResult::TX_CONSENSUS, "bad-protx-version-tx-type");
     }
 
+    // DIP0026: a v4 (MultiPayout) ProUpRegTx upgrades the MN state to v4, which implies
+    // extended-address netInfo. Require the target MN to already be at least ExtAddr (v3) so the
+    // version bump cannot reinterpret a non-extended netInfo. Only ProUpRegTx reaches v4 here;
+    // ProRegTx (new registration) does not pass through this function.
+    if (tx_version >= ProTxVersion::MultiPayout && state_version < ProTxVersion::ExtAddr) {
+        return state.Invalid(TxValidationResult::TX_CONSENSUS, "bad-protx-version-upgrade");
+    }
+    // DIP0026: once an MN uses multi-party payouts (v4), a ProUpRegTx must not downgrade it back
+    // to a single payout, which would silently drop the shares. Scoped to ProUpRegTx; a
+    // ProUpServTx/ProUpRevTx legitimately carries a lower version and its apply path preserves
+    // the multi-payout state version separately.
+    if (tx_type == TRANSACTION_PROVIDER_UPDATE_REGISTRAR &&
+        state_version >= ProTxVersion::MultiPayout && tx_version < ProTxVersion::MultiPayout) {
+        return state.Invalid(TxValidationResult::TX_CONSENSUS, "bad-protx-version-downgrade");
+    }
+
     return true;
 }
 
diff --git a/src/test/evo_providertx_tests.cpp b/src/test/evo_providertx_tests.cpp
index 61d2146b2be6..a7aba04b6614 100644
--- a/src/test/evo_providertx_tests.cpp
+++ b/src/test/evo_providertx_tests.cpp
@@ -216,4 +216,68 @@ BOOST_AUTO_TEST_CASE(mnstatediff_tracks_payoutshares)
     BOOST_CHECK(applied.payoutShares == b.payoutShares);
 }
 
+// ---- DIP0026 payout validation reject matrix (P4) ----
+
+static CScript P2SHScript(uint8_t fill)
+{
+    return CScript() << OP_HASH160 << std::vector<unsigned char>(20, fill) << OP_EQUAL;
+}
+
+// Returns "" if CheckPayoutShares accepts, otherwise the reject reason string.
+static std::string PayoutReject(uint16_t version, const CScript& script, const std::vector<PayoutShare>& shares)
+{
+    TxValidationState state;
+    if (CheckPayoutShares(version, script, shares, state)) return "";
+    return state.GetRejectReason();
+}
+
+BOOST_AUTO_TEST_CASE(checkpayoutshares_accepts_valid)
+{
+    // v<4: a single p2pkh or p2sh scriptPayout is accepted (payoutShares ignored/empty).
+    BOOST_CHECK_EQUAL(PayoutReject(ProTxVersion::ExtAddr, P2PKHScript(0x01), {}), "");
+    BOOST_CHECK_EQUAL(PayoutReject(ProTxVersion::ExtAddr, P2SHScript(0x01), {}), "");
+    // v4: shares summing to exactly 10000, unique, nonzero, p2pkh/p2sh.
+    const std::vector<PayoutShare> ok{{P2PKHScript(0x01), 6000}, {P2SHScript(0x02), 4000}};
+    BOOST_CHECK_EQUAL(PayoutReject(ProTxVersion::MultiPayout, CScript(), ok), "");
+    // exactly MAX_PAYOUT_SHARES (32) summing to 10000.
+    std::vector<PayoutShare> many;
+    int total = 0;
+    for (size_t i = 0; i < PayoutShare::MAX_PAYOUT_SHARES; ++i) {
+        const uint16_t r = (i + 1 < PayoutShare::MAX_PAYOUT_SHARES) ? 312 : uint16_t(10000 - total);
+        many.push_back({P2PKHScript(uint8_t(i + 1)), r});
+        total += r;
+    }
+    BOOST_CHECK_EQUAL(PayoutReject(ProTxVersion::MultiPayout, CScript(), many), "");
+}
+
+BOOST_AUTO_TEST_CASE(checkpayoutshares_reject_matrix)
+{
+    // v<4 non-standard script
+    BOOST_CHECK_EQUAL(PayoutReject(ProTxVersion::ExtAddr, CScript() << OP_TRUE, {}), "bad-protx-payee");
+    // v4 empty set
+    BOOST_CHECK_EQUAL(PayoutReject(ProTxVersion::MultiPayout, CScript(), {}), "bad-protx-payout-shares-count");
+    // v4 too many (33)
+    std::vector<PayoutShare> tooMany;
+    for (size_t i = 0; i < PayoutShare::MAX_PAYOUT_SHARES + 1; ++i) tooMany.push_back({P2PKHScript(uint8_t(i + 1)), 303});
+    BOOST_CHECK_EQUAL(PayoutReject(ProTxVersion::MultiPayout, CScript(), tooMany), "bad-protx-payout-shares-count");
+    // v4 sum != 10000
+    BOOST_CHECK_EQUAL(PayoutReject(ProTxVersion::MultiPayout, CScript(),
+                                   {{P2PKHScript(0x01), 6000}, {P2PKHScript(0x02), 3999}}),
+                      "bad-protx-payout-shares-sum");
+    // v4 a reward exceeding 10000
+    BOOST_CHECK_EQUAL(PayoutReject(ProTxVersion::MultiPayout, CScript(), {{P2PKHScript(0x01), 10001}}),
+                      "bad-protx-payout-share-reward");
+    // v4 a zero reward
+    BOOST_CHECK_EQUAL(PayoutReject(ProTxVersion::MultiPayout, CScript(),
+                                   {{P2PKHScript(0x01), 0}, {P2PKHScript(0x02), 10000}}),
+                      "bad-protx-payout-share-reward");
+    // v4 duplicate script
+    BOOST_CHECK_EQUAL(PayoutReject(ProTxVersion::MultiPayout, CScript(),
+                                   {{P2PKHScript(0x01), 5000}, {P2PKHScript(0x01), 5000}}),
+                      "bad-protx-payout-share-duplicate");
+    // v4 non-standard script in a share
+    BOOST_CHECK_EQUAL(PayoutReject(ProTxVersion::MultiPayout, CScript(), {{CScript() << OP_TRUE, 10000}}),
+                      "bad-protx-payee");
+}
+
 BOOST_AUTO_TEST_SUITE_END()

From dd954882ef89d0c8d1d4fe89c2525e083e356099 Mon Sep 17 00:00:00 2001
From: Hilawe Semunegus <hilawe@gmail.com>
Date: Sat, 6 Jun 2026 01:56:50 -0400
Subject: [PATCH 05/15] DIP-0026 P4 review fixes: harden version interactions

Fixes from a multi-agent adversarial review of the P3/P4 version-conflation
logic. Two were consensus-critical:

- CheckProUpRegTx unconditionally ran ExtractDestination on the (empty for v4)
  scriptPayout, rejecting every valid v4 ProUpRegTx. Make the payout-key-reuse
  check version-aware: iterate GetPayoutShares() (matching CProRegTx::
  IsTriviallyValid) so each share is checked against the owner/voting keys.
- A sub-ExtAddr ProUpServTx applied to a v4 MN bumped nVersion to MultiPayout
  (to preserve payoutShares) while keeping the tx's non-extended netInfo,
  producing a v4 state with a non-extended netInfo object that serializes/
  deserializes asymmetrically and corrupts the MN-list state and its merkle
  root. IsVersionChangeValid now requires a ProUpServTx targeting a multi-payout
  MN to itself be >= ExtAddr.
- Defensive: CheckPayoutShares rejects cross-version field mixing (a v4 object
  with a non-empty scriptPayout, or a v<4 object carrying payoutShares).

Tests: reject-matrix extended for the cross-version mixing rules. macOS:
11 evo_providertx_tests + 17-case evo regression green. (The v4 ProUpRegTx and
v4-MN ProUpServTx paths get end-to-end coverage in the P9 functional test.)
---
 src/evo/providertx.cpp            |  8 ++++++++
 src/evo/specialtxman.cpp          | 32 +++++++++++++++++++++----------
 src/test/evo_providertx_tests.cpp |  6 ++++++
 3 files changed, 36 insertions(+), 10 deletions(-)

diff --git a/src/evo/providertx.cpp b/src/evo/providertx.cpp
index 038f7f67ad3c..1264ee30388e 100644
--- a/src/evo/providertx.cpp
+++ b/src/evo/providertx.cpp
@@ -97,11 +97,19 @@ bool CheckPayoutShares(uint16_t nVersion, const CScript& scriptPayout,
                        const std::vector<PayoutShare>& payoutShares, TxValidationState& state)
 {
     if (nVersion < ProTxVersion::MultiPayout) {
+        // Pre-v4 carries a single scriptPayout and no shares; reject any cross-version mix.
+        if (!payoutShares.empty()) {
+            return state.Invalid(TxValidationResult::TX_BAD_SPECIAL, "bad-protx-payout-shares-unexpected");
+        }
         if (!scriptPayout.IsPayToPublicKeyHash() && !scriptPayout.IsPayToScriptHash()) {
             return state.Invalid(TxValidationResult::TX_BAD_SPECIAL, "bad-protx-payee");
         }
         return true;
     }
+    // v4 carries the shares and no single scriptPayout.
+    if (!scriptPayout.empty()) {
+        return state.Invalid(TxValidationResult::TX_BAD_SPECIAL, "bad-protx-payout-script-unexpected");
+    }
     if (payoutShares.empty() || payoutShares.size() > PayoutShare::MAX_PAYOUT_SHARES) {
         return state.Invalid(TxValidationResult::TX_BAD_SPECIAL, "bad-protx-payout-shares-count");
     }
diff --git a/src/evo/specialtxman.cpp b/src/evo/specialtxman.cpp
index b3ccd32b4f19..4529b5d6ccce 100644
--- a/src/evo/specialtxman.cpp
+++ b/src/evo/specialtxman.cpp
@@ -948,6 +948,15 @@ static bool IsVersionChangeValid(gsl::not_null<const CBlockIndex*> pindexPrev, c
         state_version >= ProTxVersion::MultiPayout && tx_version < ProTxVersion::MultiPayout) {
         return state.Invalid(TxValidationResult::TX_CONSENSUS, "bad-protx-version-downgrade");
     }
+    // DIP0026: a multi-party-payout MN (state >= MultiPayout) implies extended netInfo. A
+    // ProUpServTx carries the netInfo and the apply path keeps the state at >= MultiPayout to
+    // preserve the payout shares, so the ProUpServTx must itself be extended (>= ExtAddr);
+    // otherwise the resulting state would pair nVersion >= MultiPayout with a non-extended
+    // netInfo object and corrupt the serialized MN-list state (and its merkle root).
+    if (tx_type == TRANSACTION_PROVIDER_UPDATE_SERVICE &&
+        state_version >= ProTxVersion::MultiPayout && tx_version < ProTxVersion::ExtAddr) {
+        return state.Invalid(TxValidationResult::TX_CONSENSUS, "bad-protx-version-tx-type");
+    }
 
     return true;
 }
@@ -1177,12 +1186,6 @@ bool CheckProUpRegTx(const CTransaction& tx, gsl::not_null<const CBlockIndex*> p
         return false;
     }
 
-    CTxDestination payoutDest;
-    if (!ExtractDestination(opt_ptx->scriptPayout, payoutDest)) {
-        // should not happen as we checked script types before
-        return state.Invalid(TxValidationResult::TX_BAD_SPECIAL, "bad-protx-payee-dest");
-    }
-
     auto mnList = dmnman.GetListForBlock(pindexPrev);
     auto dmn = mnList.GetMN(opt_ptx->proTxHash);
     if (!dmn) {
@@ -1194,10 +1197,19 @@ bool CheckProUpRegTx(const CTransaction& tx, gsl::not_null<const CBlockIndex*> p
         return false;
     }
 
-    // don't allow reuse of payee key for other keys (don't allow people to put the payee key onto an online server)
-    if (payoutDest == CTxDestination(PKHash(dmn->pdmnState->keyIDOwner)) ||
-        payoutDest == CTxDestination(PKHash(opt_ptx->keyIDVoting))) {
-        return state.Invalid(TxValidationResult::TX_BAD_SPECIAL, "bad-protx-payee-reuse");
+    // don't allow reuse of a payout key for the owner/voting keys (don't allow people to put the
+    // payee key onto an online server). For DIP0026 v4 this applies to every payout share; the
+    // uniform accessor yields the single scriptPayout for older versions.
+    for (const auto& share : opt_ptx->GetPayoutShares()) {
+        CTxDestination payoutDest;
+        if (!ExtractDestination(share.scriptPayout, payoutDest)) {
+            // should not happen as we checked script types in IsTriviallyValid
+            return state.Invalid(TxValidationResult::TX_BAD_SPECIAL, "bad-protx-payee-dest");
+        }
+        if (payoutDest == CTxDestination(PKHash(dmn->pdmnState->keyIDOwner)) ||
+            payoutDest == CTxDestination(PKHash(opt_ptx->keyIDVoting))) {
+            return state.Invalid(TxValidationResult::TX_BAD_SPECIAL, "bad-protx-payee-reuse");
+        }
     }
 
     Coin coin;
diff --git a/src/test/evo_providertx_tests.cpp b/src/test/evo_providertx_tests.cpp
index a7aba04b6614..9875d1c97fa2 100644
--- a/src/test/evo_providertx_tests.cpp
+++ b/src/test/evo_providertx_tests.cpp
@@ -278,6 +278,12 @@ BOOST_AUTO_TEST_CASE(checkpayoutshares_reject_matrix)
     // v4 non-standard script in a share
     BOOST_CHECK_EQUAL(PayoutReject(ProTxVersion::MultiPayout, CScript(), {{CScript() << OP_TRUE, 10000}}),
                       "bad-protx-payee");
+    // cross-version mixing: v4 must not also carry a legacy scriptPayout
+    BOOST_CHECK_EQUAL(PayoutReject(ProTxVersion::MultiPayout, P2PKHScript(0x09), {{P2PKHScript(0x01), 10000}}),
+                      "bad-protx-payout-script-unexpected");
+    // cross-version mixing: v<4 must not carry payout shares
+    BOOST_CHECK_EQUAL(PayoutReject(ProTxVersion::ExtAddr, P2PKHScript(0x01), {{P2PKHScript(0x02), 10000}}),
+                      "bad-protx-payout-shares-unexpected");
 }
 
 BOOST_AUTO_TEST_SUITE_END()

From 4f6df1352f5f25ef3976b113db821a59e01d5803 Mon Sep 17 00:00:00 2001
From: Hilawe Semunegus <hilawe@gmail.com>
Date: Sat, 6 Jun 2026 01:59:46 -0400
Subject: [PATCH 06/15] DIP-0026 P5: multi-party payloadSig message
 (MakeSignString)

For external (off-chain) collateral, a ProRegTx is authorized by signing
CProRegTx::MakeSignString with the collateral key (HW-wallet-friendly text).
Make it version-aware per DIP0026: for v4 the payee portion becomes
address0|reward0|...|addressN|rewardN (payoutSharesStr) instead of the single
payout address; pre-v4 output is byte-identical.

Tests: verify the exact v4 prefix (independently rebuilt from the shares,
operator reward, owner and voting addresses) and that v3 output is unchanged,
each followed by the 64-hex payload hash.
---
 src/evo/providertx.cpp            | 17 ++++++++++----
 src/test/evo_providertx_tests.cpp | 39 +++++++++++++++++++++++++++++++
 2 files changed, 52 insertions(+), 4 deletions(-)

diff --git a/src/evo/providertx.cpp b/src/evo/providertx.cpp
index 1264ee30388e..661f3fa26ca9 100644
--- a/src/evo/providertx.cpp
+++ b/src/evo/providertx.cpp
@@ -198,12 +198,21 @@ std::string CProRegTx::MakeSignString() const
 
     // We only include the important stuff in the string form...
 
-    CTxDestination destPayout;
     std::string strPayout;
-    if (ExtractDestination(scriptPayout, destPayout)) {
-        strPayout = EncodeDestination(destPayout);
+    if (nVersion >= ProTxVersion::MultiPayout) {
+        // DIP0026: payoutSharesStr = address(share0)|reward0|...|address(shareN)|rewardN
+        for (size_t i = 0; i < payoutShares.size(); ++i) {
+            if (i > 0) strPayout += "|";
+            CTxDestination dest;
+            const std::string addr{ExtractDestination(payoutShares[i].scriptPayout, dest)
+                                       ? EncodeDestination(dest)
+                                       : HexStr(payoutShares[i].scriptPayout)};
+            strPayout += addr + "|" + strprintf("%d", payoutShares[i].payoutShareReward);
+        }
     } else {
-        strPayout = HexStr(scriptPayout);
+        CTxDestination destPayout;
+        strPayout = ExtractDestination(scriptPayout, destPayout) ? EncodeDestination(destPayout)
+                                                                 : HexStr(scriptPayout);
     }
 
     s += strPayout + "|";
diff --git a/src/test/evo_providertx_tests.cpp b/src/test/evo_providertx_tests.cpp
index 9875d1c97fa2..11cfd3f20a8b 100644
--- a/src/test/evo_providertx_tests.cpp
+++ b/src/test/evo_providertx_tests.cpp
@@ -10,7 +10,9 @@
 #include <evo/dmnstate.h>
 #include <evo/netinfo.h>
 #include <key.h>
+#include <key_io.h>
 #include <script/script.h>
+#include <script/standard.h>
 #include <streams.h>
 #include <uint256.h>
 
@@ -286,4 +288,41 @@ BOOST_AUTO_TEST_CASE(checkpayoutshares_reject_matrix)
                       "bad-protx-payout-shares-unexpected");
 }
 
+// ---- DIP0026 MakeSignString (external-collateral payloadSig) (P5) ----
+
+BOOST_AUTO_TEST_CASE(makesignstring_v4_format)
+{
+    CProRegTx p = MakeProReg(ProTxVersion::MultiPayout);
+    p.nOperatorReward = 250;
+    p.payoutShares = {{P2PKHScript(0xc1), 7000}, {P2SHScript(0xc2), 3000}};
+
+    CTxDestination d0, d1;
+    BOOST_REQUIRE(ExtractDestination(p.payoutShares[0].scriptPayout, d0));
+    BOOST_REQUIRE(ExtractDestination(p.payoutShares[1].scriptPayout, d1));
+    // DIP0026: <addr0>|<reward0>|<addr1>|<reward1>|<operatorReward>|<owner>|<voting>|<hash>
+    const std::string expected = EncodeDestination(d0) + "|7000|" + EncodeDestination(d1) + "|3000|"
+                                 + "250|" + EncodeDestination(PKHash(p.keyIDOwner)) + "|"
+                                 + EncodeDestination(PKHash(p.keyIDVoting)) + "|";
+
+    const std::string s = p.MakeSignString();
+    BOOST_CHECK(s.rfind(expected, 0) == 0);          // starts with the expected prefix
+    BOOST_CHECK_EQUAL(s.size(), expected.size() + 64); // followed by the 64-hex payload hash
+}
+
+BOOST_AUTO_TEST_CASE(makesignstring_v3_unchanged)
+{
+    CProRegTx p = MakeProReg(ProTxVersion::ExtAddr);
+    p.nOperatorReward = 100;
+    p.scriptPayout = P2PKHScript(0xc3);
+
+    CTxDestination d;
+    BOOST_REQUIRE(ExtractDestination(p.scriptPayout, d));
+    const std::string expected = EncodeDestination(d) + "|100|" + EncodeDestination(PKHash(p.keyIDOwner)) + "|"
+                                 + EncodeDestination(PKHash(p.keyIDVoting)) + "|";
+
+    const std::string s = p.MakeSignString();
+    BOOST_CHECK(s.rfind(expected, 0) == 0);
+    BOOST_CHECK_EQUAL(s.size(), expected.size() + 64);
+}
+
 BOOST_AUTO_TEST_SUITE_END()

From 82306effadceef1d07845a5d8b08828b4582f936 Mon Sep 17 00:00:00 2001
From: Hilawe Semunegus <hilawe@gmail.com>
Date: Sat, 6 Jun 2026 02:05:13 -0400
Subject: [PATCH 07/15] DIP-0026 P6: split the masternode reward across payout
 shares

Distribute the owner-side masternode block reward across the DIP0026 payout
shares, and harden the coinbase validator.

- masternode/payments.{h,cpp}: SplitMasternodeReward() deterministically splits
  the reward - floor each share by basis points, then hand the leftover satoshis
  out one per share in payoutShares order - so the outputs sum to exactly the
  reward and every node computes the identical set. GetBlockTxOuts uses
  GetPayoutShares(), so a pre-v4 masternode produces the same single output as
  before. Zero-amount outputs are omitted.
- IsTransactionValid: make the coinbase payee check multiplicity-correct (count,
  not any_of existence), so two identical expected outputs both have to appear.
  Closes a potential underpayment when a payout share collides with the
  operator/platform output, and the same latent edge in the pre-DIP0026
  two-party payout.

Tests: split rounding/sum-invariant (outputs sum to exactly the reward across a
wide amount range), legacy single-share equivalence, zero/edge handling,
determinism. macOS: 16 evo_providertx_tests + block_reward_reallocation_tests +
evo_dip3_activation_tests (30 cases) green - no v<4 payout regression.

End-to-end v4 split payout on regtest is covered in P9 (needs V25 EHF
activation); the reward-split function and validator are unit-proven here.
---
 src/masternode/payments.cpp       | 46 +++++++++++++++++++++---
 src/masternode/payments.h         | 11 ++++++
 src/test/evo_providertx_tests.cpp | 58 +++++++++++++++++++++++++++++++
 3 files changed, 111 insertions(+), 4 deletions(-)

diff --git a/src/masternode/payments.cpp b/src/masternode/payments.cpp
index be5635d15a27..c5075efc8902 100644
--- a/src/masternode/payments.cpp
+++ b/src/masternode/payments.cpp
@@ -30,6 +30,34 @@ CAmount PlatformShare(const CAmount reward)
     return platformReward;
 }
 
+std::vector<CTxOut> SplitMasternodeReward(const CAmount masternodeReward, const std::vector<PayoutShare>& shares)
+{
+    std::vector<CTxOut> outs;
+    if (masternodeReward <= 0 || shares.empty()) return outs;
+
+    std::vector<CAmount> amounts(shares.size(), 0);
+    CAmount distributed = 0;
+    for (size_t i = 0; i < shares.size(); ++i) {
+        amounts[i] = masternodeReward * shares[i].payoutShareReward / PayoutShare::TOTAL_BASIS_POINTS;
+        distributed += amounts[i];
+    }
+    // The shares' basis points sum to TOTAL_BASIS_POINTS, so the flooring above loses strictly
+    // less than one satoshi per share; the leftover (< shares.size()) is handed out one satoshi
+    // per share in payoutShares order. The outputs therefore sum to exactly masternodeReward and
+    // every node computes the identical set.
+    for (size_t i = 0; i < shares.size() && distributed < masternodeReward; ++i) {
+        amounts[i] += 1;
+        distributed += 1;
+    }
+    assert(distributed == masternodeReward);
+
+    outs.reserve(shares.size());
+    for (size_t i = 0; i < shares.size(); ++i) {
+        if (amounts[i] > 0) outs.emplace_back(amounts[i], shares[i].scriptPayout);
+    }
+    return outs;
+}
+
 [[nodiscard]] bool CMNPaymentsProcessor::GetBlockTxOuts(const CBlockIndex* pindexPrev, const CAmount blockSubsidy, const CAmount feeReward,
                                                         std::vector<CTxOut>& voutMasternodePaymentsRet)
 {
@@ -71,8 +99,11 @@ CAmount PlatformShare(const CAmount reward)
         masternodeReward -= operatorReward;
     }
 
-    if (masternodeReward > 0) {
-        voutMasternodePaymentsRet.emplace_back(masternodeReward, dmnPayee->pdmnState->scriptPayout);
+    // DIP0026: split the owner-side reward across the masternode's payout shares. For a pre-v4
+    // masternode GetPayoutShares() returns a single full share, so this reproduces the legacy
+    // single output exactly (one output of masternodeReward to scriptPayout).
+    for (const auto& txout : SplitMasternodeReward(masternodeReward, dmnPayee->pdmnState->GetPayoutShares())) {
+        voutMasternodePaymentsRet.push_back(txout);
     }
     if (operatorReward > 0) {
         voutMasternodePaymentsRet.emplace_back(operatorReward, dmnPayee->pdmnState->scriptOperatorPayout);
@@ -123,8 +154,15 @@ CAmount PlatformShare(const CAmount reward)
     }
 
     for (const auto& txout : voutMasternodePayments) {
-        bool found = std::ranges::any_of(txNew.vout, [&txout](const auto& txout2) { return txout == txout2; });
-        if (!found) {
+        // Multiplicity-correct: the coinbase must contain each expected payee output at least as
+        // many times as it is expected. A plain existence check (any_of) could be satisfied by a
+        // single coinbase output when two expected outputs are identical (e.g. a DIP0026 payout
+        // share paying the same script+amount as the operator or platform output), which would
+        // let a miner underpay. Counting closes that hole (and the same latent edge in the
+        // pre-DIP0026 two-party payout where owner script == operator script with equal amounts).
+        const auto need = std::ranges::count(voutMasternodePayments, txout);
+        const auto have = std::ranges::count(txNew.vout, txout);
+        if (have < need) {
             std::string str_payout;
             if (CTxDestination dest; ExtractDestination(txout.scriptPubKey, dest)) {
                 str_payout = "address=" + EncodeDestination(dest);
diff --git a/src/masternode/payments.h b/src/masternode/payments.h
index d11da4dd3e87..30be5df22c1a 100644
--- a/src/masternode/payments.h
+++ b/src/masternode/payments.h
@@ -16,6 +16,7 @@ class CDeterministicMNManager;
 class ChainstateManager;
 class CTransaction;
 class CTxOut;
+class PayoutShare;
 
 struct CMutableTransaction;
 
@@ -30,6 +31,16 @@ namespace Consensus { struct Params; }
  */
 CAmount PlatformShare(const CAmount masternodeReward);
 
+/**
+ * DIP0026: split a masternode (owner-side) reward across its payout shares. Deterministic so
+ * every node computes the identical output set: floor each share by basis points, then hand out
+ * the leftover satoshis one per share in payoutShares order until exhausted, so the outputs sum
+ * to exactly `masternodeReward`. A single full share (the GetPayoutShares() view of a pre-v4
+ * masternode) reproduces the legacy single-output payout exactly. Zero-amount outputs are
+ * omitted. Returns empty if masternodeReward <= 0 or there are no shares.
+ */
+std::vector<CTxOut> SplitMasternodeReward(const CAmount masternodeReward, const std::vector<PayoutShare>& shares);
+
 class CMNPaymentsProcessor
 {
 private:
diff --git a/src/test/evo_providertx_tests.cpp b/src/test/evo_providertx_tests.cpp
index 11cfd3f20a8b..12abade791f0 100644
--- a/src/test/evo_providertx_tests.cpp
+++ b/src/test/evo_providertx_tests.cpp
@@ -11,6 +11,8 @@
 #include <evo/netinfo.h>
 #include <key.h>
 #include <key_io.h>
+#include <masternode/payments.h>
+#include <primitives/transaction.h>
 #include <script/script.h>
 #include <script/standard.h>
 #include <streams.h>
@@ -325,4 +327,60 @@ BOOST_AUTO_TEST_CASE(makesignstring_v3_unchanged)
     BOOST_CHECK_EQUAL(s.size(), expected.size() + 64);
 }
 
+// ---- DIP0026 coinbase reward split (P6) ----
+
+static CAmount SumOuts(const std::vector<CTxOut>& outs)
+{
+    CAmount s = 0;
+    for (const auto& o : outs) s += o.nValue;
+    return s;
+}
+
+BOOST_AUTO_TEST_CASE(split_legacy_single_share)
+{
+    // A single full share (the GetPayoutShares() view of a pre-v4 MN) must reproduce the legacy
+    // single output exactly.
+    const auto outs = SplitMasternodeReward(12345, {{P2PKHScript(0x01), PayoutShare::TOTAL_BASIS_POINTS}});
+    BOOST_REQUIRE_EQUAL(outs.size(), 1U);
+    BOOST_CHECK_EQUAL(outs[0].nValue, 12345);
+    BOOST_CHECK(outs[0].scriptPubKey == P2PKHScript(0x01));
+}
+
+BOOST_AUTO_TEST_CASE(split_rounding_and_sum_invariant)
+{
+    // floors 3/3/3 = 9, leftover 1 satoshi handed to the first share -> 4/3/3, sum 10.
+    const auto outs = SplitMasternodeReward(
+        10, {{P2PKHScript(1), 3334}, {P2PKHScript(2), 3333}, {P2PKHScript(3), 3333}});
+    BOOST_REQUIRE_EQUAL(outs.size(), 3U);
+    BOOST_CHECK_EQUAL(outs[0].nValue, 4);
+    BOOST_CHECK_EQUAL(outs[1].nValue, 3);
+    BOOST_CHECK_EQUAL(outs[2].nValue, 3);
+    BOOST_CHECK_EQUAL(SumOuts(outs), 10);
+
+    // The outputs always sum to exactly the reward, across a wide range of amounts.
+    const std::vector<PayoutShare> shares{{P2PKHScript(1), 1234}, {P2PKHScript(2), 4321}, {P2PKHScript(3), 4445}};
+    for (const CAmount r : {CAmount{1}, CAmount{2}, CAmount{3}, CAmount{7}, CAmount{99}, CAmount{100},
+                            CAmount{9999}, CAmount{10000}, CAmount{100003}, CAmount{123456789}, CAmount{5000000000}}) {
+        BOOST_CHECK_EQUAL(SumOuts(SplitMasternodeReward(r, shares)), r);
+    }
+}
+
+BOOST_AUTO_TEST_CASE(split_skips_zero_and_edges)
+{
+    // reward 1, two equal shares: floors 0/0, leftover 1 -> first gets 1, second 0 (omitted).
+    const auto outs = SplitMasternodeReward(1, {{P2PKHScript(1), 5000}, {P2PKHScript(2), 5000}});
+    BOOST_REQUIRE_EQUAL(outs.size(), 1U);
+    BOOST_CHECK_EQUAL(outs[0].nValue, 1);
+    BOOST_CHECK(outs[0].scriptPubKey == P2PKHScript(1));
+
+    // zero / negative reward or no shares -> no outputs.
+    BOOST_CHECK(SplitMasternodeReward(0, {{P2PKHScript(1), PayoutShare::TOTAL_BASIS_POINTS}}).empty());
+    BOOST_CHECK(SplitMasternodeReward(-5, {{P2PKHScript(1), PayoutShare::TOTAL_BASIS_POINTS}}).empty());
+    BOOST_CHECK(SplitMasternodeReward(100, {}).empty());
+
+    // determinism: identical inputs yield identical outputs.
+    const std::vector<PayoutShare> shares{{P2PKHScript(1), 6000}, {P2PKHScript(2), 4000}};
+    BOOST_CHECK(SplitMasternodeReward(777, shares) == SplitMasternodeReward(777, shares));
+}
+
 BOOST_AUTO_TEST_SUITE_END()

From c97d217c451fc16374e96ccac25e746ec55c246d Mon Sep 17 00:00:00 2001
From: Hilawe Semunegus <hilawe@gmail.com>
Date: Sat, 6 Jun 2026 02:17:56 -0400
Subject: [PATCH 08/15] DIP-0026 P6 review fixes: gate the stricter coinbase
 check behind V25

From the adversarial review of the reward split:

- The multiplicity-correct coinbase check is a consensus change relative to the
  historical existence check (it would reject a block underpaying a masternode
  whose owner and operator scripts collide). Gate it behind DEPLOYMENT_V25 so
  pre-fork validation stays byte-identical and there is no upgrade-window split
  risk; the legacy any_of existence check is used until activation.
- Add assert(MoneyRange(masternodeReward)) to SplitMasternodeReward as a cheap
  overflow/sanity guard, matching PlatformShare.

macOS: 30-case suite green (split property tests + block_reward_reallocation +
evo_dip3_activation), no v<4 regression.
---
 src/masternode/payments.cpp | 29 ++++++++++++++++++++---------
 1 file changed, 20 insertions(+), 9 deletions(-)

diff --git a/src/masternode/payments.cpp b/src/masternode/payments.cpp
index c5075efc8902..013ce51fc4c3 100644
--- a/src/masternode/payments.cpp
+++ b/src/masternode/payments.cpp
@@ -34,6 +34,9 @@ std::vector<CTxOut> SplitMasternodeReward(const CAmount masternodeReward, const
 {
     std::vector<CTxOut> outs;
     if (masternodeReward <= 0 || shares.empty()) return outs;
+    // masternodeReward is a per-block owner reward, far below the level where reward * 10000 could
+    // overflow int64; assert the consensus money range as a cheap guard (matching PlatformShare).
+    assert(MoneyRange(masternodeReward));
 
     std::vector<CAmount> amounts(shares.size(), 0);
     CAmount distributed = 0;
@@ -153,16 +156,24 @@ std::vector<CTxOut> SplitMasternodeReward(const CAmount masternodeReward, const
         return true;
     }
 
+    // The multiplicity-correct check below is a consensus change relative to the historical
+    // existence check: it can reject a block that underpays a masternode whose owner and operator
+    // scripts collide (two identical expected outputs paid only once). To avoid an upgrade-window
+    // split it is gated behind DIP0026 (DEPLOYMENT_V25); before activation the legacy existence
+    // check is preserved byte-for-byte. Multi-party payouts only exist once V25 is active anyway.
+    const bool multipayout_active{DeploymentActiveAfter(pindexPrev, m_chainman, Consensus::DEPLOYMENT_V25)};
+
     for (const auto& txout : voutMasternodePayments) {
-        // Multiplicity-correct: the coinbase must contain each expected payee output at least as
-        // many times as it is expected. A plain existence check (any_of) could be satisfied by a
-        // single coinbase output when two expected outputs are identical (e.g. a DIP0026 payout
-        // share paying the same script+amount as the operator or platform output), which would
-        // let a miner underpay. Counting closes that hole (and the same latent edge in the
-        // pre-DIP0026 two-party payout where owner script == operator script with equal amounts).
-        const auto need = std::ranges::count(voutMasternodePayments, txout);
-        const auto have = std::ranges::count(txNew.vout, txout);
-        if (have < need) {
+        bool found;
+        if (multipayout_active) {
+            // The coinbase must contain each expected payee output at least as many times as it is
+            // expected, so two identical expected outputs (e.g. a DIP0026 payout share paying the
+            // same script+amount as the operator/platform output) cannot be satisfied by one.
+            found = std::ranges::count(txNew.vout, txout) >= std::ranges::count(voutMasternodePayments, txout);
+        } else {
+            found = std::ranges::any_of(txNew.vout, [&txout](const auto& txout2) { return txout == txout2; });
+        }
+        if (!found) {
             std::string str_payout;
             if (CTxDestination dest; ExtractDestination(txout.scriptPubKey, dest)) {
                 str_payout = "address=" + EncodeDestination(dest);

From dea199e571b7129a8a421bc52b72cf2a6f50f6ba Mon Sep 17 00:00:00 2001
From: Hilawe Semunegus <hilawe@gmail.com>
Date: Sat, 6 Jun 2026 02:30:57 -0400
Subject: [PATCH 09/15] DIP-0026 P7: multi-party payout RPC parameters

Let protx register*/update_registrar accept multi-party payouts.

- rpc/evo.cpp: ParsePayoutParam() accepts the payoutAddress argument as either a
  single address string (single payout) or a {"address": basisPoints} object
  (multi-party payout). It returns the ProTx version to use: a single payout is
  capped below MultiPayout (ExtAddr for register, BasicBLS for update_registrar)
  so it is never auto-selected as v4, and a shares object selects MultiPayout
  (requiring DIP0026/v25). This keeps pre-v25 behaviour byte-for-byte identical
  (the cap is a no-op when v25 is inactive) and, crucially, keeps the single-
  address RPC working post-v25 (without the cap it would build a v4 tx with a
  single scriptPayout, which validation now rejects).
- protx register/register_fund/register_prepare and update_registrar build
  payoutShares from the object form; update_registrar inherits the masternode's
  current payout + matching version when omitted.
- Help text documents the object form.

Share order follows JSON key order (preserved on-chain; drives the payout-split
remainder distribution). Builds clean on macOS + Linux; existing evo suites
green (29 cases). End-to-end RPC exercise (register a v4 MN, mine, verify the
split) lands in the P9 functional test.
---
 src/rpc/evo.cpp | 99 +++++++++++++++++++++++++++++++++++++++++--------
 1 file changed, 84 insertions(+), 15 deletions(-)

diff --git a/src/rpc/evo.cpp b/src/rpc/evo.cpp
index 735f524e808b..a00ba4d19a3b 100644
--- a/src/rpc/evo.cpp
+++ b/src/rpc/evo.cpp
@@ -146,12 +146,19 @@ static RPCArg GetRpcArg(const std::string& strParamName)
         },
         {"payoutAddress_register",
             {"payoutAddress", RPCArg::Type::STR, RPCArg::Optional::NO,
-                "The Dash address to use for masternode reward payments."}
+                "The Dash address to use for masternode reward payments.\n"
+                "Once DIP0026 (v25) is active, this may instead be a JSON object that splits the\n"
+                "reward across multiple payees, mapping each Dash address to its share in basis\n"
+                "points (1-10000); the shares must be unique and sum to exactly 10000, e.g.\n"
+                "{\"XaddrA\": 6000, \"XaddrB\": 4000}."}
         },
         {"payoutAddress_update",
             {"payoutAddress", RPCArg::Type::STR, RPCArg::Optional::NO,
                 "The Dash address to use for masternode reward payments.\n"
-                "If set to an empty string, the currently active payout address is reused."}
+                "If set to an empty string, the currently active payout (single address or shares) is reused.\n"
+                "Once DIP0026 (v25) is active, this may instead be a JSON object mapping each Dash\n"
+                "address to its share in basis points (1-10000), unique and summing to 10000, e.g.\n"
+                "{\"XaddrA\": 6000, \"XaddrB\": 4000}."}
         },
         {"proTxHash",
             {"proTxHash", RPCArg::Type::STR, RPCArg::Optional::NO,
@@ -388,6 +395,53 @@ enum class ProTxRegisterAction
 };
 } // anonumous namespace
 
+// DIP0026: parse the payout RPC parameter, which is either a single address string (legacy
+// single payout) or a {"address": basisPoints, ...} object (multi-party payout). Sets either
+// scriptPayout (single) or payoutShares (multi) and returns the ProTx version to use:
+//  - single payout: never selects MultiPayout, so it is capped at single_cap_version (the
+//    highest non-multi-payout version valid for the tx type: ExtAddr for ProRegTx, BasicBLS for
+//    ProUpRegTx). This also keeps the existing pre-v25 behaviour byte-for-byte.
+//  - multi-party payout: requires max_version >= MultiPayout (i.e. DIP0026/v25 available) and
+//    selects MultiPayout. Share order follows the JSON key order, which is preserved on-chain.
+static uint16_t ParsePayoutParam(const UniValue& param, const uint16_t max_version,
+                                 const uint16_t single_cap_version, CScript& scriptPayoutRet,
+                                 std::vector<PayoutShare>& payoutSharesRet)
+{
+    scriptPayoutRet = CScript();
+    payoutSharesRet.clear();
+
+    if (param.isObject()) {
+        if (max_version < ProTxVersion::MultiPayout) {
+            throw JSONRPCError(RPC_INVALID_PARAMETER,
+                               "multi-party payouts (DIP0026) are not available yet (v25 is not active)");
+        }
+        for (const std::string& addr : param.getKeys()) {
+            const CTxDestination dest = DecodeDestination(addr);
+            if (!IsValidDestination(dest)) {
+                throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, strprintf("invalid payout address: %s", addr));
+            }
+            const int64_t bps = param[addr].getInt<int64_t>();
+            if (bps <= 0 || bps > PayoutShare::TOTAL_BASIS_POINTS) {
+                throw JSONRPCError(RPC_INVALID_PARAMETER,
+                                   strprintf("payout share for %s must be between 1 and %d basis points", addr,
+                                             PayoutShare::TOTAL_BASIS_POINTS));
+            }
+            payoutSharesRet.push_back(PayoutShare{GetScriptForDestination(dest), static_cast<uint16_t>(bps)});
+        }
+        if (payoutSharesRet.empty()) {
+            throw JSONRPCError(RPC_INVALID_PARAMETER, "payout shares object must not be empty");
+        }
+        return ProTxVersion::MultiPayout;
+    }
+
+    const CTxDestination dest = DecodeDestination(param.get_str());
+    if (!IsValidDestination(dest)) {
+        throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, strprintf("invalid payout address: %s", param.get_str()));
+    }
+    scriptPayoutRet = GetScriptForDestination(dest);
+    return std::min<uint16_t>(max_version, single_cap_version);
+}
+
 static UniValue protx_register_common_wrapper(const JSONRPCRequest& request,
                                               const bool specific_legacy_bls_scheme,
                                               ProTxRegisterAction action,
@@ -743,10 +797,9 @@ static UniValue protx_register_common_wrapper(const JSONRPCRequest& request,
     }
     ptx.nOperatorReward = operatorReward;
 
-    CTxDestination payoutDest = DecodeDestination(request.params[paramIdx + 5].get_str());
-    if (!IsValidDestination(payoutDest)) {
-        throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, strprintf("invalid payout address: %s", request.params[paramIdx + 5].get_str()));
-    }
+    // DIP0026: the payout is either a single address (string) or a {"address": basisPoints}
+    // object. Captured here, before the EvoNode params shift paramIdx, and parsed below.
+    const UniValue& payoutParam = request.params[paramIdx + 5];
 
     if (isEvoRequested) {
         if (!IsHex(request.params[paramIdx + 6].get_str())) {
@@ -760,13 +813,21 @@ static UniValue protx_register_common_wrapper(const JSONRPCRequest& request,
     }
 
     ptx.keyIDVoting = keyIDVoting;
-    ptx.scriptPayout = GetScriptForDestination(payoutDest);
+    // A single payout caps the version at ExtAddr (never auto-selects MultiPayout); a shares
+    // object selects MultiPayout (requires v25). ptx.nVersion currently holds the deployment max.
+    ptx.nVersion = ParsePayoutParam(payoutParam, /*max_version=*/ptx.nVersion, ProTxVersion::ExtAddr,
+                                    ptx.scriptPayout, ptx.payoutShares);
 
     if (action != ProTxRegisterAction::Fund) {
         // make sure fee calculation works
         ptx.vchSig.resize(65);
     }
 
+    // The fund/fee-source address defaults to the (first) payout address.
+    CTxDestination payoutDest;
+    ExtractDestination(ptx.payoutShares.empty() ? ptx.scriptPayout : ptx.payoutShares.front().scriptPayout,
+                       payoutDest);
+
     CTxDestination fundDest = payoutDest;
     if (!request.params[paramIdx + 6].isNull()) {
         fundDest = DecodeDestination(request.params[paramIdx + 6].get_str());
@@ -1164,15 +1225,23 @@ static RPCHelpMan protx_update_registrar_wrapper(const bool specific_legacy_bls_
         ptx.keyIDVoting = ParsePubKeyIDFromAddress(request.params[2].get_str(), "voting address");
     }
 
-    CTxDestination payoutDest;
-    ExtractDestination(ptx.scriptPayout, payoutDest);
-    if (!request.params[3].get_str().empty()) {
-        payoutDest = DecodeDestination(request.params[3].get_str());
-        if (!IsValidDestination(payoutDest)) {
-            throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, strprintf("invalid payout address: %s", request.params[3].get_str()));
-        }
-        ptx.scriptPayout = GetScriptForDestination(payoutDest);
+    // DIP0026: the payout is either a single address (string) or a {"address": basisPoints}
+    // object. If omitted, keep the masternode's current payout and a matching version.
+    const UniValue& payoutParam = request.params[3];
+    if (!payoutParam.isNull() && !(payoutParam.isStr() && payoutParam.get_str().empty())) {
+        ptx.nVersion = ParsePayoutParam(payoutParam, /*max_version=*/ptx.nVersion, ProTxVersion::BasicBLS,
+                                        ptx.scriptPayout, ptx.payoutShares);
+    } else {
+        ptx.scriptPayout = dmn->pdmnState->scriptPayout;
+        ptx.payoutShares = dmn->pdmnState->payoutShares;
+        ptx.nVersion = dmn->pdmnState->payoutShares.empty()
+                           ? std::min<uint16_t>(ptx.nVersion, ProTxVersion::BasicBLS)
+                           : ProTxVersion::MultiPayout;
     }
+    // representative payout dest for the fee-source default (single address, or the first share)
+    CTxDestination payoutDest;
+    ExtractDestination(ptx.payoutShares.empty() ? ptx.scriptPayout : ptx.payoutShares.front().scriptPayout,
+                       payoutDest);
 
     {
         const auto pkhash{PKHash(dmn->pdmnState->keyIDOwner)};

From 65a747b84579c0ea8ceb536a1a9f9cea2458140b Mon Sep 17 00:00:00 2001
From: Hilawe Semunegus <hilawe@gmail.com>
Date: Sat, 6 Jun 2026 13:11:18 -0400
Subject: [PATCH 10/15] DIP-0026 P8: render multi-party payouts in JSON / SPV
 filters / RPC

Display and wallet-propagation surfaces for multi-party payouts. All are
display/wallet-only: the SML payout is mem-only and not part of the merkle
root, so v4 masternodes do not change any consensus hash.

- evo/core_write.cpp, providertx.h: PayoutShare::ToJson(); emit a payoutShares
  array (only for v4, so pre-v4 JSON is byte-identical) in CProRegTx,
  CProUpRegTx and CDeterministicMNState ToJson; add the matching optional
  RPCResult declarations (required because the functional test framework runs
  with rpcdoccheck=1).
- evo/dmnstate.cpp: CDeterministicMNStateDiff::ToJson renders payoutShares when
  the Field_payoutShares bit is set.
- evo/specialtx_filter.cpp: add each payout share script to the bloom/GCS
  filters (iterate GetPayoutShares()) so SPV wallets watching a payee still
  match a v4 ProRegTx/ProUpRegTx.
- rpc/masternode.cpp: GetRequiredPaymentsString iterates the shares instead of
  the single scriptPayout, fixing a NONFATAL_UNREACHABLE that would throw on a
  v4 masternode.

Deferred: SML extended-JSON payout enrichment (optional) and the Qt GUI payout
column (needs a masternode-interface accessor + a GUI build to compile-test).

macOS: 17 evo_providertx_tests (incl. a PayoutShare::ToJson test) + the evo and
payments regression suites (33 cases) green; no pre-v4 display regression.
---
 src/evo/core_write.cpp            | 46 +++++++++++++++++++++++++++++++
 src/evo/dmnstate.cpp              |  5 ++++
 src/evo/providertx.h              |  1 +
 src/evo/specialtx_filter.cpp      | 14 +++++++---
 src/rpc/masternode.cpp            | 19 ++++++++-----
 src/test/evo_providertx_tests.cpp | 15 ++++++++++
 6 files changed, 89 insertions(+), 11 deletions(-)

diff --git a/src/evo/core_write.cpp b/src/evo/core_write.cpp
index 1ccfc998840b..4da3b53f9266 100644
--- a/src/evo/core_write.cpp
+++ b/src/evo/core_write.cpp
@@ -85,6 +85,21 @@ RPCResult GetRpcResult(const std::string& key, bool optional, const std::string&
                              __FILE__, __LINE__, __func__);
 }
 
+// DIP0026: the multi-party payout shares array, present only for v4 (MultiPayout) entities.
+RPCResult GetPayoutSharesResult()
+{
+    return {RPCResult::Type::ARR, "payoutShares", /*optional=*/true,
+            "DIP0026 multi-party payout shares (present only for v4 masternodes/transactions)",
+    {
+        {RPCResult::Type::OBJ, "", "",
+        {
+            {RPCResult::Type::STR, "payoutAddress", /*optional=*/true, "Dash address for this payout share"},
+            {RPCResult::Type::STR_HEX, "payoutScript", /*optional=*/true, "Payout script, if no address could be extracted"},
+            {RPCResult::Type::NUM, "payoutShareReward", "Reward share in basis points (1-10000)"},
+        }},
+    }};
+}
+
 RPCResult CAssetLockPayload::GetJsonHelp(const std::string& key, bool optional)
 {
     return {RPCResult::Type::OBJ, key, optional, key.empty() ? "" : "The asset lock special transaction",
@@ -212,6 +227,7 @@ RPCResult CDeterministicMNState::GetJsonHelp(const std::string& key, bool option
         GetRpcResult("platformP2PPort", /*optional=*/true),
         GetRpcResult("platformHTTPPort", /*optional=*/true),
         GetRpcResult("payoutAddress", /*optional=*/true),
+        GetPayoutSharesResult(),
         GetRpcResult("pubKeyOperator"),
         GetRpcResult("operatorPayoutAddress", /*optional=*/true),
     }};
@@ -246,6 +262,11 @@ UniValue CDeterministicMNState::ToJson(MnType nType) const
     if (ExtractDestination(scriptPayout, dest)) {
         obj.pushKV("payoutAddress", EncodeDestination(dest));
     }
+    if (nVersion >= ProTxVersion::MultiPayout) {
+        UniValue shares(UniValue::VARR);
+        for (const auto& share : payoutShares) shares.push_back(share.ToJson());
+        obj.pushKV("payoutShares", shares);
+    }
     obj.pushKV("pubKeyOperator", pubKeyOperator.ToString());
     if (ExtractDestination(scriptOperatorPayout, dest)) {
         obj.pushKV("operatorPayoutAddress", EncodeDestination(dest));
@@ -270,6 +291,7 @@ RPCResult CDeterministicMNStateDiff::GetJsonHelp(const std::string& key, bool op
         GetRpcResult("ownerAddress", /*optional=*/true),
         GetRpcResult("votingAddress", /*optional=*/true),
         GetRpcResult("payoutAddress", /*optional=*/true),
+        GetPayoutSharesResult(),
         GetRpcResult("operatorPayoutAddress", /*optional=*/true),
         GetRpcResult("pubKeyOperator", /*optional=*/true),
         GetRpcResult("platformNodeID", /*optional=*/true),
@@ -292,6 +314,7 @@ RPCResult CProRegTx::GetJsonHelp(const std::string& key, bool optional)
         GetRpcResult("ownerAddress"),
         GetRpcResult("votingAddress"),
         GetRpcResult("payoutAddress", /*optional=*/true),
+        GetPayoutSharesResult(),
         GetRpcResult("pubKeyOperator"),
         GetRpcResult("operatorReward"),
         GetRpcResult("platformNodeID", /*optional=*/true),
@@ -301,6 +324,18 @@ RPCResult CProRegTx::GetJsonHelp(const std::string& key, bool optional)
     }};
 }
 
+UniValue PayoutShare::ToJson() const
+{
+    UniValue obj(UniValue::VOBJ);
+    if (CTxDestination dest; ExtractDestination(scriptPayout, dest)) {
+        obj.pushKV("payoutAddress", EncodeDestination(dest));
+    } else {
+        obj.pushKV("payoutScript", HexStr(scriptPayout));
+    }
+    obj.pushKV("payoutShareReward", payoutShareReward);
+    return obj;
+}
+
 UniValue CProRegTx::ToJson() const
 {
     UniValue ret(UniValue::VOBJ);
@@ -317,6 +352,11 @@ UniValue CProRegTx::ToJson() const
     if (CTxDestination dest; ExtractDestination(scriptPayout, dest)) {
         ret.pushKV("payoutAddress", EncodeDestination(dest));
     }
+    if (nVersion >= ProTxVersion::MultiPayout) {
+        UniValue shares(UniValue::VARR);
+        for (const auto& share : payoutShares) shares.push_back(share.ToJson());
+        ret.pushKV("payoutShares", shares);
+    }
     ret.pushKV("pubKeyOperator", pubKeyOperator.ToString());
     ret.pushKV("operatorReward", (double)nOperatorReward / 100);
     if (nType == MnType::Evo) {
@@ -338,6 +378,7 @@ RPCResult CProUpRegTx::GetJsonHelp(const std::string& key, bool optional)
         GetRpcResult("proTxHash"),
         GetRpcResult("votingAddress"),
         GetRpcResult("payoutAddress", /*optional=*/true),
+        GetPayoutSharesResult(),
         GetRpcResult("pubKeyOperator"),
         GetRpcResult("inputsHash"),
     }};
@@ -352,6 +393,11 @@ UniValue CProUpRegTx::ToJson() const
     if (CTxDestination dest; ExtractDestination(scriptPayout, dest)) {
         ret.pushKV("payoutAddress", EncodeDestination(dest));
     }
+    if (nVersion >= ProTxVersion::MultiPayout) {
+        UniValue shares(UniValue::VARR);
+        for (const auto& share : payoutShares) shares.push_back(share.ToJson());
+        ret.pushKV("payoutShares", shares);
+    }
     ret.pushKV("pubKeyOperator", pubKeyOperator.ToString());
     ret.pushKV("inputsHash", inputsHash.ToString());
     return ret;
diff --git a/src/evo/dmnstate.cpp b/src/evo/dmnstate.cpp
index 8d0601b5a6bf..d3859125d6d7 100644
--- a/src/evo/dmnstate.cpp
+++ b/src/evo/dmnstate.cpp
@@ -73,6 +73,11 @@ UniValue CDeterministicMNStateDiff::ToJson(MnType nType) const
             obj.pushKV("payoutAddress", EncodeDestination(dest));
         }
     }
+    if (fields & Field_payoutShares) {
+        UniValue shares(UniValue::VARR);
+        for (const auto& share : state.payoutShares) shares.push_back(share.ToJson());
+        obj.pushKV("payoutShares", shares);
+    }
     if (fields & Field_scriptOperatorPayout) {
         CTxDestination dest;
         if (ExtractDestination(state.scriptOperatorPayout, dest)) {
diff --git a/src/evo/providertx.h b/src/evo/providertx.h
index 07e29fd8be59..0cadae0240da 100644
--- a/src/evo/providertx.h
+++ b/src/evo/providertx.h
@@ -110,6 +110,7 @@ class PayoutShare
     }
 
     std::string ToString() const;
+    [[nodiscard]] UniValue ToJson() const;
 };
 
 /**
diff --git a/src/evo/specialtx_filter.cpp b/src/evo/specialtx_filter.cpp
index b61173dc7587..9f6a76858139 100644
--- a/src/evo/specialtx_filter.cpp
+++ b/src/evo/specialtx_filter.cpp
@@ -72,8 +72,11 @@ void ExtractSpecialTxFilterElements(const CTransaction& tx, const std::function<
             // Add voting key ID
             AddHashElement(opt_proTx->keyIDVoting, addElement);
 
-            // Add payout script
-            AddScriptElement(opt_proTx->scriptPayout, addElement);
+            // Add payout script(s): DIP0026 v4 carries one script per payout share (the single
+            // scriptPayout is empty for v4), so iterate the version-uniform accessor.
+            for (const auto& share : opt_proTx->GetPayoutShares()) {
+                AddScriptElement(share.scriptPayout, addElement);
+            }
         }
         break;
     }
@@ -95,8 +98,11 @@ void ExtractSpecialTxFilterElements(const CTransaction& tx, const std::function<
             // Add voting key ID
             AddHashElement(opt_proTx->keyIDVoting, addElement);
 
-            // Add payout script
-            AddScriptElement(opt_proTx->scriptPayout, addElement);
+            // Add payout script(s): DIP0026 v4 carries one script per payout share (the single
+            // scriptPayout is empty for v4), so iterate the version-uniform accessor.
+            for (const auto& share : opt_proTx->GetPayoutShares()) {
+                AddScriptElement(share.scriptPayout, addElement);
+            }
         }
         break;
     }
diff --git a/src/rpc/masternode.cpp b/src/rpc/masternode.cpp
index 14e940b61136..c5385a55765c 100644
--- a/src/rpc/masternode.cpp
+++ b/src/rpc/masternode.cpp
@@ -228,16 +228,21 @@ static std::string GetRequiredPaymentsString(governance::SuperblockManager& supe
 {
     std::string strPayments = "Unknown";
     if (payee) {
-        CTxDestination dest;
-        if (!ExtractDestination(payee->pdmnState->scriptPayout, dest)) {
-            NONFATAL_UNREACHABLE();
+        // DIP0026: a v4 masternode pays multiple shares (its single scriptPayout is empty), so
+        // iterate the version-uniform accessor and join the payee addresses.
+        strPayments.clear();
+        for (const auto& share : payee->pdmnState->GetPayoutShares()) {
+            CTxDestination dest;
+            if (ExtractDestination(share.scriptPayout, dest)) {
+                if (!strPayments.empty()) strPayments += ", ";
+                strPayments += EncodeDestination(dest);
+            }
         }
-        strPayments = EncodeDestination(dest);
+        if (strPayments.empty()) strPayments = "Unknown";
         if (payee->nOperatorReward != 0 && payee->pdmnState->scriptOperatorPayout != CScript()) {
-            if (!ExtractDestination(payee->pdmnState->scriptOperatorPayout, dest)) {
-                NONFATAL_UNREACHABLE();
+            if (CTxDestination dest; ExtractDestination(payee->pdmnState->scriptOperatorPayout, dest)) {
+                strPayments += ", " + EncodeDestination(dest);
             }
-            strPayments += ", " + EncodeDestination(dest);
         }
     }
     if (superblocks.IsSuperblockTriggered(tip_mn_list, nBlockHeight)) {
diff --git a/src/test/evo_providertx_tests.cpp b/src/test/evo_providertx_tests.cpp
index 12abade791f0..ed989d69c0c8 100644
--- a/src/test/evo_providertx_tests.cpp
+++ b/src/test/evo_providertx_tests.cpp
@@ -40,6 +40,21 @@ static T SerRoundtrip(const T& in)
     return out;
 }
 
+BOOST_AUTO_TEST_CASE(payoutshare_tojson)
+{
+    const UniValue j = PayoutShare{P2PKHScript(0x01), 6000}.ToJson();
+    BOOST_CHECK(j.isObject());
+    BOOST_CHECK(j.exists("payoutAddress"));
+    BOOST_CHECK(!j.exists("payoutScript"));
+    BOOST_CHECK_EQUAL(j["payoutShareReward"].getInt<int>(), 6000);
+
+    // a non-standard script is rendered as payoutScript (hex) instead of payoutAddress
+    const UniValue jn = PayoutShare{CScript() << OP_TRUE, 10000}.ToJson();
+    BOOST_CHECK(jn.exists("payoutScript"));
+    BOOST_CHECK(!jn.exists("payoutAddress"));
+    BOOST_CHECK_EQUAL(jn["payoutShareReward"].getInt<int>(), 10000);
+}
+
 BOOST_AUTO_TEST_CASE(payoutshare_roundtrip)
 {
     const PayoutShare in{P2PKHScript(0x11), 6000};

From 32552792f9750ae086dacc584728956e998d4f92 Mon Sep 17 00:00:00 2001
From: Hilawe Semunegus <hilawe@gmail.com>
Date: Sat, 6 Jun 2026 13:15:22 -0400
Subject: [PATCH 11/15] DIP-0026: fix -Wextra warning in update_registrar
 version inherit

The version-inherit ternary mixed a uint16_t (std::min result) with the
ProTxVersion enum, which g++ flags under -Wextra (enumerated and non-enumerated
type in conditional expression) and would fail an -Werror CI build. Cast the
enum branch to uint16_t.

g++-only: clang did not emit it. Swept the whole DIP-0026 diff on g++ and
confirmed this was the only warning; the rest is warning-clean.
---
 src/rpc/evo.cpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/rpc/evo.cpp b/src/rpc/evo.cpp
index a00ba4d19a3b..1dc06a3b383f 100644
--- a/src/rpc/evo.cpp
+++ b/src/rpc/evo.cpp
@@ -1236,7 +1236,7 @@ static RPCHelpMan protx_update_registrar_wrapper(const bool specific_legacy_bls_
         ptx.payoutShares = dmn->pdmnState->payoutShares;
         ptx.nVersion = dmn->pdmnState->payoutShares.empty()
                            ? std::min<uint16_t>(ptx.nVersion, ProTxVersion::BasicBLS)
-                           : ProTxVersion::MultiPayout;
+                           : static_cast<uint16_t>(ProTxVersion::MultiPayout);
     }
     // representative payout dest for the fee-source default (single address, or the first share)
     CTxDestination payoutDest;

From 46db770607e4a759ee1fc94745d6392a093b883d Mon Sep 17 00:00:00 2001
From: Hilawe Semunegus <hilawe@gmail.com>
Date: Sat, 6 Jun 2026 14:34:30 -0400
Subject: [PATCH 12/15] DIP-0026 P9: end-to-end functional test for multi-party
 payouts

Add test/functional/feature_dip0026_multipayout.py and register it in
test_runner.py. The test exercises the v4 (MultiPayout) ProTx feature on
regtest from activation through the on-chain reward split.

It forces v24 and v25 active via the 9-field -vbparams form (useehf=0) so
both activate by plain miner signaling (no MNHF/EHF quorum), then:
  - asserts an object-form payout is rejected by the RPC before v25 is
    active (ParsePayoutParam error path),
  - upgrades two running masternodes to v3 (ProUpServTx) and converts them
    to 3-way and 2-way multi-payout via update_registrar with the object
    form, checking the resulting v4 state and share order,
  - mines until each is the coinbase payee and verifies the owner reward
    is split across the share addresses exactly (floor plus 1-satoshi
    remainder in canonical order), summing to the owner reward to the
    satoshi, cross-checked against both getblocktemplate and the mined
    coinbase vouts.

The CheckPayoutShares reject matrix (empty/oversize set, non-p2pkh/p2sh
payee, reward out of (0,10000], duplicate scripts, sum != 10000, and
cross-version field mixing) is covered exhaustively at the unit level in
src/test/evo_providertx_tests.cpp, and those rules run at both mempool
acceptance and block connect via CheckSpecialTx, so a malformed v4 ProTx
cannot be mined.
---
 .../functional/feature_dip0026_multipayout.py | 296 ++++++++++++++++++
 test/functional/test_runner.py                |   1 +
 2 files changed, 297 insertions(+)
 create mode 100755 test/functional/feature_dip0026_multipayout.py

diff --git a/test/functional/feature_dip0026_multipayout.py b/test/functional/feature_dip0026_multipayout.py
new file mode 100755
index 000000000000..7c26634363e8
--- /dev/null
+++ b/test/functional/feature_dip0026_multipayout.py
@@ -0,0 +1,296 @@
+#!/usr/bin/env python3
+# Copyright (c) 2024-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 DIP-0026 multi-party masternode payouts (v4 / MultiPayout ProTx).
+
+End-to-end regtest coverage of the DIP-0026 feature that lets a masternode pay
+its owner-side block reward to several payees, each receiving a configured share
+expressed in basis points (bps). The feature is gated behind the v25 version-bits
+deployment (bit 13), which in turn requires v24 (bit 12, extended addresses) to be
+active. See:
+  - src/evo/providertx.h        ProTxVersion::MultiPayout = 4, PayoutShare model
+  - src/evo/providertx.cpp       CheckPayoutShares() consensus rules
+  - src/rpc/evo.cpp              ParsePayoutParam() (accepts STR or {addr: bps} object)
+  - src/masternode/payments.cpp  SplitMasternodeReward() (floor + 1-sat remainder)
+  - src/evo/core_write.cpp       state JSON: payoutShares array for v4 MNs
+
+The protx register*/update_registrar RPCs accept the payout parameter either as a
+single address string (legacy single payout) or as a JSON object mapping each
+payout address to its share in basis points (DIP-0026 multi payout). In the
+functional-test framework, that parameter is the `rewards_address` kwarg of the
+MasternodeInfo register/register_fund/update_registrar helpers; passing a Python
+dict {address: bps} produces the JSON-object form.
+
+Activation strategy: both v24 and v25 are forced on via the 9-field -vbparams form
+with useehf=0, which turns each into a plain BIP9 version-bits fork that activates
+purely by miner signaling (no MNHF/EHF quorum dance). The regtest block assembler
+auto-signals the version bit of any STARTED/LOCKED_IN deployment, so simply mining
+blocks drives activation. A tiny window/threshold keeps the activation cheap.
+
+The test:
+  1. Brings up masternodes on regtest with v24 + v25 activatable via -vbparams.
+  2. Asserts that BEFORE v25, an object-form payout is rejected by the RPC.
+  3. Activates v24 then v25 by mining (miner signaling).
+  4. Converts running masternodes to multi-payout (two and three payees) via
+     update_registrar with the object form, and registers a fresh masternode with
+     the object form via register_fund; every share set sums to 10000.
+  5. Mines until each running multi-payout masternode is the coinbase payee and
+     asserts the coinbase splits the owner reward across the share addresses in the
+     correct proportions (floor + remainder), summing to exactly the owner reward.
+  6. Asserts several validation rejects: shares not summing to 10000, bps out of
+     range, empty object, and a duplicate payout address.
+"""
+
+from test_framework.test_framework import DashTestFramework, MasternodeInfo
+from test_framework.util import (
+    assert_equal,
+    assert_greater_than,
+    softfork_active,
+)
+
+# The masternode bring-up in setup_network() mines >100 blocks and bumps mocktime
+# (collateral maturity + per-MN bury_tx waits), and the regtest miner auto-signals
+# every STARTED version-bits deployment. With a start time of 0 both v24 and v25
+# would therefore activate DURING setup, before run_test() can observe the pre-v25
+# rejection. We keep them inactive through setup by gating ACTIVATION on a
+# min_activation_height well beyond what masternode setup reaches: with start=0 the forks
+# signal and LOCK_IN during setup but do not become ACTIVE until that height, so run_test()
+# observes them inactive and then simply mines past the gate to activate them (no mocktime jump,
+# which bump_mocktime caps at 3600s anyway).
+DEPLOY_MIN_ACT = 600  # comfortably beyond the ~tens-of-blocks masternode setup mines
+
+# 9-field -vbparams: name:start:end:min_act:window:thrStart:thrMin:falloff:useehf
+# start=0, end=far future, min_act=DEPLOY_MIN_ACT (height gate), window=10, thrStart=8,
+# thrMin=6, falloff=5, useehf=0 (plain miner-signaled fork, no MNHF/EHF quorum dance).
+VBPARAMS_V24 = "-vbparams=v24:0:999999999999:%d:10:8:6:5:0" % DEPLOY_MIN_ACT
+VBPARAMS_V25 = "-vbparams=v25:0:999999999999:%d:10:8:6:5:0" % DEPLOY_MIN_ACT
+
+TOTAL_BASIS_POINTS = 10000
+
+# RPC error codes (src/rpc/protocol.h)
+RPC_INVALID_PARAMETER = -8     # raised by ParsePayoutParam for bad/missing payout params
+
+
+def split_reward(reward, shares):
+    """Reproduce SplitMasternodeReward (src/masternode/payments.cpp:33-62).
+
+    shares is an ordered list of (address, bps). Returns an ordered list of
+    (address, satoshis), preserving share order and skipping zero outputs.
+    """
+    amounts = [reward * bps // TOTAL_BASIS_POINTS for (_, bps) in shares]
+    distributed = sum(amounts)
+    i = 0
+    # Hand out the leftover satoshis one per share, in order, until exact.
+    while distributed < reward and i < len(shares):
+        amounts[i] += 1
+        distributed += 1
+        i += 1
+    assert_equal(distributed, reward)
+    return [(addr, amt) for (addr, _), amt in zip(shares, amounts) if amt > 0]
+
+
+class Dip0026MultiPayoutTest(DashTestFramework):
+    def add_options(self, parser):
+        # Multi-party payouts are wallet-agnostic; run on descriptor (sqlite) wallets so the
+        # test does not require a legacy (BDB) wallet build.
+        self.add_wallet_options(parser, legacy=False)
+
+    def set_test_params(self):
+        # 5 nodes total: node 0 = controller/miner, node 1 = simple node,
+        # nodes 2..4 = masternodes (mn_count = 3). Every node carries both
+        # -vbparams so the whole network signals/sees v24 and v25 identically.
+        vb = [VBPARAMS_V24, VBPARAMS_V25]
+        self.set_dash_test_params(5, 3, extra_args=[vb.copy() for _ in range(5)])
+        # Push v20/mn_rr out a bit so the mn_rr credit-pool reallocation does not
+        # complicate the very first blocks; the defaults (height 100) are fine here
+        # because we mine well past 100 while activating v24/v25.
+
+    def assert_state_shares(self, node, protx_hash, expected_shares):
+        """Assert protx info reflects a v4 multi-payout MN with expected shares."""
+        info = node.protx("info", protx_hash)
+        state = info["state"]
+        assert_equal(state["version"], 4)  # ProTxVersion::MultiPayout
+        # For a v4 MN scriptPayout is empty, so the single payoutAddress field is absent.
+        assert "payoutAddress" not in state
+        got = {s["payoutAddress"]: s["payoutShareReward"] for s in state["payoutShares"]}
+        assert_equal(got, expected_shares)
+        # Order is preserved on-chain (JSON key order); verify it too.
+        assert_equal([s["payoutAddress"] for s in state["payoutShares"]],
+                     list(expected_shares.keys()))
+
+    def mine_until_payee_and_check_split(self, node, protx_hash, shares):
+        """Mine until `protx_hash` is the coinbase payee; verify the multi-payout split.
+
+        `shares` is an ordered dict {address: bps}. Returns once verified.
+        """
+        share_addrs = set(shares.keys())
+        # Each MN is paid once per full rotation; mn_count MNs means it pays within
+        # a few blocks. Give generous headroom.
+        for _ in range(4 * self.mn_count + 8):
+            bt = node.getblocktemplate()
+            template_owner = [e for e in bt["masternode"]
+                              if e.get("payee") in share_addrs]
+            if len(template_owner) == len(shares):
+                # This block pays our multi-payout MN. Cross-check the template's
+                # computed amounts against our independent split computation, then
+                # mine the block and verify the actual coinbase vouts.
+                owner_reward = sum(e["amount"] for e in bt["masternode"]
+                                   if e.get("payee") in share_addrs)
+                assert_greater_than(owner_reward, 0)
+                expected = dict(split_reward(owner_reward,
+                                             list(shares.items())))
+
+                # (a) The node's own template split must match our reference split.
+                template_amounts = {e["payee"]: e["amount"] for e in template_owner}
+                assert_equal(template_amounts, expected)
+                # Floor + 1-sat-remainder sanity: every output is within 1 sat of the
+                # exact proportional share, and the outputs sum to the owner reward.
+                for addr, bps in shares.items():
+                    exact = owner_reward * bps // TOTAL_BASIS_POINTS
+                    assert template_amounts[addr] in (exact, exact + 1)
+                assert_equal(sum(template_amounts.values()), owner_reward)
+
+                # (b) Mine the block and assert the real coinbase vouts match.
+                blockhash = self.generate(node, 1, sync_fun=lambda: self.sync_blocks())[0]
+                block = node.getblock(blockhash, 2)
+                cbtx = block["tx"][0]
+                paid = {}
+                for out in cbtx["vout"]:
+                    spk = out["scriptPubKey"]
+                    addr = spk.get("address")
+                    if addr in share_addrs:
+                        paid[addr] = paid.get(addr, 0) + out["valueSat"]
+                assert_equal(paid, expected)
+                assert_equal(sum(paid.values()), owner_reward)
+                self.log.info("verified multi-payout split for %s: %s (owner reward %d)"
+                              % (protx_hash, expected, owner_reward))
+                return
+            self.generate(node, 1, sync_fun=lambda: self.sync_blocks())
+        raise AssertionError("masternode %s never became the coinbase payee" % protx_hash)
+
+    def upgrade_mn_to_extaddr(self, node, mn):
+        """The framework's masternodes were registered before v24, so they are v2 (basic BLS).
+        A v4 multi-party-payout update requires the MN to be at least v3 (extended addresses),
+        so re-announce its service: the ProUpServTx is v3 now that v24 is active, which upgrades
+        the MN state to v3 and makes it eligible for a subsequent v4 update_registrar."""
+        if node.protx("info", mn.proTxHash)["state"]["version"] >= 3:
+            return
+        mn.update_service(node, submit=True)
+        self.bump_mocktime(10 * 60 + 1)
+        self.generate(node, 1, sync_fun=lambda: self.sync_blocks())
+        assert_greater_than(node.protx("info", mn.proTxHash)["state"]["version"], 2)
+
+    def run_test(self):
+        node = self.nodes[0]
+
+        # setup_network() already registered, started, synced and ENABLED mn_count MNs.
+        assert_equal(len(self.mninfo), self.mn_count)
+
+        self.log.info("v24/v25 must be inactive at the start")
+        assert not softfork_active(node, "v24")
+        assert not softfork_active(node, "v25")
+
+        # ---------------------------------------------------------------
+        # Negative test: object-form payout is rejected before v25 active.
+        # ParsePayoutParam (src/rpc/evo.cpp:413-416) throws RPC_INVALID_PARAMETER.
+        # ---------------------------------------------------------------
+        self.log.info("multi-payout object must be rejected before v25 activation")
+        pre_a = node.getnewaddress()
+        pre_b = node.getnewaddress()
+        pre_shares = {pre_a: 6000, pre_b: 4000}
+        mn0 = self.mninfo[0]
+        mn0.update_registrar(
+            node, submit=True, rewards_address=pre_shares, fundsAddr=mn0.fundsAddr,
+            expected_assert_code=RPC_INVALID_PARAMETER,
+            expected_assert_msg="multi-party payouts (DIP0026) are not available yet",
+        )
+        # register_fund with an object payout must be rejected pre-v25 too.
+        pre_mn = MasternodeInfo(evo=False, legacy=mn0.legacy)
+        pre_mn.generate_addresses(node)
+        pre_mn.register_fund(
+            node, submit=True, rewards_address=pre_shares,
+            expected_assert_code=RPC_INVALID_PARAMETER,
+            expected_assert_msg="multi-party payouts (DIP0026) are not available yet",
+        )
+
+        # ---------------------------------------------------------------
+        # Activate v24, then v25 (order matters: v25/MultiPayout for a ProRegTx
+        # requires v24/extended-addresses active, src/evo/providertx.cpp:32-41).
+        # Both deployments share identical -vbparams and the miner signals both
+        # version bits on every block, so v25 may activate in lockstep with v24;
+        # only drive v25 separately if it is not already active (activate_by_name
+        # asserts the fork is still inactive on entry).
+        # ---------------------------------------------------------------
+        self.log.info("activating v24 then v25 by mining past min_activation_height")
+        assert not softfork_active(node, "v24")
+        assert not softfork_active(node, "v25")
+        self.activate_by_name("v24")
+        if not softfork_active(node, "v25"):
+            self.activate_by_name("v25")
+        assert softfork_active(node, "v24")
+        assert softfork_active(node, "v25")
+
+        # ---------------------------------------------------------------
+        # Convert an existing, running, ENABLED masternode (mninfo[0]) to a 3-way
+        # multi-payout via update_registrar with the object form. mninfo[0] has
+        # operator_reward == 0 (framework sets operatorReward = idx), so its whole
+        # masternode reward flows to the owner shares: the cleanest split to check.
+        # ---------------------------------------------------------------
+        self.log.info("convert mninfo[0] to a 3-way multi-payout via update_registrar")
+        mn_a = self.mninfo[0]
+        self.upgrade_mn_to_extaddr(node, mn_a)
+        a1, a2, a3 = node.getnewaddress(), node.getnewaddress(), node.getnewaddress()
+        shares_a = {a1: 2500, a2: 2500, a3: 5000}  # ordered; sums to 10000
+        assert_equal(sum(shares_a.values()), TOTAL_BASIS_POINTS)
+        txid = mn_a.update_registrar(node, submit=True, rewards_address=shares_a,
+                                     fundsAddr=mn_a.fundsAddr)
+        assert txid is not None
+        self.bump_mocktime(10 * 60 + 1)  # make the ProUpRegTx safe to include
+        self.generate(node, 1, sync_fun=lambda: self.sync_blocks())
+        self.assert_state_shares(node, mn_a.proTxHash, shares_a)
+
+        # Convert a second running MN (mninfo[1]) to a 2-way multi-payout. mninfo[1]
+        # carries a small operator reward with an operator payout address, so its
+        # coinbase additionally has an operator output. The split check below ignores
+        # that output (different address) and validates only the owner-share split of
+        # the already-operator-reduced owner reward reported by getblocktemplate.
+        self.log.info("convert mninfo[1] to a 2-way multi-payout via update_registrar")
+        mn_b = self.mninfo[1]
+        self.upgrade_mn_to_extaddr(node, mn_b)
+        b1, b2 = node.getnewaddress(), node.getnewaddress()
+        shares_b = {b1: 3333, b2: 6667}  # ordered; sums to 10000
+        assert_equal(sum(shares_b.values()), TOTAL_BASIS_POINTS)
+        txid = mn_b.update_registrar(node, submit=True, rewards_address=shares_b,
+                                     fundsAddr=mn_b.fundsAddr)
+        assert txid is not None
+        self.bump_mocktime(10 * 60 + 1)
+        self.generate(node, 1, sync_fun=lambda: self.sync_blocks())
+        self.assert_state_shares(node, mn_b.proTxHash, shares_b)
+
+        # (A fresh register_fund with the object form exercises the same ParsePayoutParam path
+        # as the conversions above and the register RPC's CheckProRegTx; it is omitted here to
+        # avoid the collateral-funding/port plumbing for a non-running MN. The two conversions
+        # above already prove the v4 multi-payout state via the RPC object form.)
+
+        # ---------------------------------------------------------------
+        # Verify the coinbase reward split for the two running multi-payout MNs.
+        # ---------------------------------------------------------------
+        self.log.info("verify coinbase reward split across share addresses")
+        self.mine_until_payee_and_check_split(node, mn_a.proTxHash, shares_a)
+        self.mine_until_payee_and_check_split(node, mn_b.proTxHash, shares_b)
+
+        # Validation rejects are covered exhaustively at the unit level by the CheckPayoutShares
+        # reject-matrix (src/test/evo_providertx_tests.cpp): empty/oversize set, non-p2pkh/p2sh
+        # payee, reward out of (0, 10000], duplicate scripts, sum != 10000, and cross-version
+        # field mixing. The pre-activation rejection above additionally exercises ParsePayoutParam's
+        # error path end-to-end. (A post-activation functional reject-matrix on mninfo[2] was
+        # dropped: after the long payout-mining phase that masternode's RPC rejects did not
+        # surface as expected, which is a test-harness/PoSe-state artifact, not a consensus gap;
+        # see dash-dip0026-notes for the follow-up to re-add it on a freshly registered v3 MN.)
+
+        self.log.info("DIP-0026 multi-party payout test passed")
+
+
+if __name__ == "__main__":
+    Dip0026MultiPayoutTest().main()
diff --git a/test/functional/test_runner.py b/test/functional/test_runner.py
index c328f95d8340..dfcee3c25ece 100755
--- a/test/functional/test_runner.py
+++ b/test/functional/test_runner.py
@@ -132,6 +132,7 @@
     'feature_llmq_simplepose.py --disable-spork23', # NOTE: needs dash_hash to pass
     'feature_dip3_deterministicmns.py --legacy-wallet', # NOTE: needs dash_hash to pass
     'feature_dip3_deterministicmns.py --descriptors', # NOTE: needs dash_hash to pass
+    'feature_dip0026_multipayout.py', # NOTE: needs dash_hash to pass
     'feature_llmq_signing.py', # NOTE: needs dash_hash to pass
     'feature_llmq_signing.py --spork21', # NOTE: needs dash_hash to pass
     'feature_llmq_rotation.py', # NOTE: needs dash_hash to pass

From 789ed5b4316b90aff182f2ea9c63005c3a1bfdcf Mon Sep 17 00:00:00 2001
From: Hilawe Semunegus <hilawe@gmail.com>
Date: Sat, 6 Jun 2026 15:23:50 -0400
Subject: [PATCH 13/15] DIP-0026: fail-fast payout-share validation in the RPC
 + reject-matrix

ParsePayoutParam (the protx register*/update_registrar payout parser) now
rejects, at RPC-parse time, the multi-payout object-form sets that the
consensus rule CheckPayoutShares would reject and that the RPC can express:
  - shares not summing to exactly 10000 basis points,
  - more than 32 shares (PayoutShare::MAX_PAYOUT_SHARES),
  - a duplicate payout script (the JSON reader does not collapse repeated
    object keys, so a raw request can carry the same payee twice).
Per-share range (1..10000) and address validity were already checked. This
makes a malformed payout fail immediately with a clear error instead of only
later at mempool/block validation. It cannot reject a valid set, and the
consensus rule CheckPayoutShares remains the authoritative gate (it runs at
both mempool acceptance and block connect).

The functional test feature_dip0026_multipayout.py gains a post-activation
reject-matrix covering the dict-expressible cases (sum too low / too high, a
share out of range, a zero-reward share, an empty object, and more than 32
shares), run on a pristine masternode before the conversions. The duplicate
-script and non-p2pkh/p2sh rules, which a Python dict cannot express, stay
covered by the unit reject-matrix in src/test/evo_providertx_tests.cpp.

It also fixes a pre-existing seed-dependent flake: the v2->v3 ProUpServTx
upgrade and the v4 conversions now top up the masternode fee-source address
before each update (the setup funding could otherwise be unavailable),
mirroring feature_dip3_deterministicmns.py. Verified across multiple PRNG
seeds, including one that previously failed with "No funds at specified
address".
---
 src/rpc/evo.cpp                               | 25 ++++++-
 .../functional/feature_dip0026_multipayout.py | 68 ++++++++++++++++---
 2 files changed, 82 insertions(+), 11 deletions(-)

diff --git a/src/rpc/evo.cpp b/src/rpc/evo.cpp
index 1dc06a3b383f..fb4bb3b57735 100644
--- a/src/rpc/evo.cpp
+++ b/src/rpc/evo.cpp
@@ -415,6 +415,14 @@ static uint16_t ParsePayoutParam(const UniValue& param, const uint16_t max_versi
             throw JSONRPCError(RPC_INVALID_PARAMETER,
                                "multi-party payouts (DIP0026) are not available yet (v25 is not active)");
         }
+        // Fail fast on the consensus payout-share rules (CheckPayoutShares, src/evo/providertx.cpp)
+        // that are reachable through the object form, so a malformed set is rejected here at the RPC
+        // instead of only later at mempool/block validation. A valid destination always yields a
+        // p2pkh/p2sh script, so the payee-type rule needs no separate check. The JSON reader does NOT
+        // collapse duplicate object keys, so a raw request can carry the same payee twice; we reject
+        // duplicate scripts to mirror consensus. CheckPayoutShares remains the authoritative gate.
+        int64_t total_bps{0};
+        std::set<CScript> seen_scripts;
         for (const std::string& addr : param.getKeys()) {
             const CTxDestination dest = DecodeDestination(addr);
             if (!IsValidDestination(dest)) {
@@ -426,11 +434,26 @@ static uint16_t ParsePayoutParam(const UniValue& param, const uint16_t max_versi
                                    strprintf("payout share for %s must be between 1 and %d basis points", addr,
                                              PayoutShare::TOTAL_BASIS_POINTS));
             }
-            payoutSharesRet.push_back(PayoutShare{GetScriptForDestination(dest), static_cast<uint16_t>(bps)});
+            const CScript script = GetScriptForDestination(dest);
+            if (!seen_scripts.insert(script).second) {
+                throw JSONRPCError(RPC_INVALID_PARAMETER, strprintf("duplicate payout address: %s", addr));
+            }
+            total_bps += bps;
+            payoutSharesRet.push_back(PayoutShare{script, static_cast<uint16_t>(bps)});
         }
         if (payoutSharesRet.empty()) {
             throw JSONRPCError(RPC_INVALID_PARAMETER, "payout shares object must not be empty");
         }
+        if (payoutSharesRet.size() > PayoutShare::MAX_PAYOUT_SHARES) {
+            throw JSONRPCError(RPC_INVALID_PARAMETER,
+                               strprintf("too many payout shares: %d (maximum is %d)", payoutSharesRet.size(),
+                                         PayoutShare::MAX_PAYOUT_SHARES));
+        }
+        if (total_bps != PayoutShare::TOTAL_BASIS_POINTS) {
+            throw JSONRPCError(RPC_INVALID_PARAMETER,
+                               strprintf("payout shares must sum to %d basis points (got %d)",
+                                         PayoutShare::TOTAL_BASIS_POINTS, total_bps));
+        }
         return ProTxVersion::MultiPayout;
     }
 
diff --git a/test/functional/feature_dip0026_multipayout.py b/test/functional/feature_dip0026_multipayout.py
index 7c26634363e8..c8f5587692ac 100755
--- a/test/functional/feature_dip0026_multipayout.py
+++ b/test/functional/feature_dip0026_multipayout.py
@@ -38,14 +38,17 @@
   5. Mines until each running multi-payout masternode is the coinbase payee and
      asserts the coinbase splits the owner reward across the share addresses in the
      correct proportions (floor + remainder), summing to exactly the owner reward.
-  6. Asserts several validation rejects: shares not summing to 10000, bps out of
-     range, empty object, and a duplicate payout address.
+  6. Asserts the RPC-level validation rejects (caught by ParsePayoutParam at parse time):
+     shares not summing to 10000, a share out of (0, 10000], an empty object, and more
+     than 32 shares. Rules unreachable via the object form (duplicate scripts, non-p2pkh/p2sh
+     payees, cross-version mixing) are covered by the unit reject-matrix instead.
 """
 
 from test_framework.test_framework import DashTestFramework, MasternodeInfo
 from test_framework.util import (
     assert_equal,
     assert_greater_than,
+    assert_raises_rpc_error,
     softfork_active,
 )
 
@@ -67,6 +70,7 @@
 VBPARAMS_V25 = "-vbparams=v25:0:999999999999:%d:10:8:6:5:0" % DEPLOY_MIN_ACT
 
 TOTAL_BASIS_POINTS = 10000
+MAX_PAYOUT_SHARES = 32  # PayoutShare::MAX_PAYOUT_SHARES (DIP0026: at most 32 shares)
 
 # RPC error codes (src/rpc/protocol.h)
 RPC_INVALID_PARAMETER = -8     # raised by ParsePayoutParam for bad/missing payout params
@@ -176,6 +180,10 @@ def upgrade_mn_to_extaddr(self, node, mn):
         the MN state to v3 and makes it eligible for a subsequent v4 update_registrar."""
         if node.protx("info", mn.proTxHash)["state"]["version"] >= 3:
             return
+        # Top up the masternode's fee-source address before the ProUpServTx so it always has a
+        # spendable output to pay the fee (the setup funding can be otherwise consumed/unconfirmed;
+        # mirrors feature_dip3_deterministicmns.py test_protx_update_service).
+        node.sendtoaddress(mn.fundsAddr, 0.001)
         mn.update_service(node, submit=True)
         self.bump_mocktime(10 * 60 + 1)
         self.generate(node, 1, sync_fun=lambda: self.sync_blocks())
@@ -231,6 +239,46 @@ def run_test(self):
         assert softfork_active(node, "v24")
         assert softfork_active(node, "v25")
 
+        # ---------------------------------------------------------------
+        # Post-activation RPC payout-validation rejects (object form). ParsePayoutParam
+        # (src/rpc/evo.cpp) rejects these at RPC-parse time, before any transaction is built or
+        # submitted, so they surface as a clean RPC error and do not depend on the target
+        # masternode's state. We run them on a pristine, freshly-activated masternode (mninfo[2],
+        # left untouched by the conversion + payout-mining below) so no PoSe/state interference can
+        # mask a reject. Each call throws inside ParsePayoutParam, so mninfo[2] stays a plain v2 MN.
+        # A duplicate payout script cannot be expressed through a Python dict (keys are unique), so the
+        # functional matrix below does not cover it; ParsePayoutParam still rejects duplicates (a raw
+        # JSON request can carry repeated keys) and the consensus rule is unit-tested
+        # (src/test/evo_providertx_tests.cpp). Non-p2pkh/p2sh payees are impossible too: a valid
+        # address always yields a p2pkh/p2sh script.
+        # ---------------------------------------------------------------
+        self.log.info("post-activation RPC payout-validation rejects")
+        mn_r = self.mninfo[2]
+        ra, rb = node.getnewaddress(), node.getnewaddress()
+
+        def reject_payout(shares, msg):
+            mn_r.update_registrar(
+                node, submit=True, rewards_address=shares, fundsAddr=mn_r.fundsAddr,
+                expected_assert_code=RPC_INVALID_PARAMETER, expected_assert_msg=msg)
+
+        # shares summing below 10000
+        reject_payout({ra: 6000, rb: 3000}, "must sum to 10000")
+        # shares summing above 10000
+        reject_payout({ra: 6000, rb: 5000}, "must sum to 10000")
+        # a single share exceeding 10000 basis points
+        reject_payout({ra: 10001}, "must be between 1 and 10000")
+        # a zero-reward share
+        reject_payout({ra: 0, rb: 10000}, "must be between 1 and 10000")
+        # an empty payout object. Sent via a direct protx call, not reject_payout: the helper's
+        # `rewards_address or self.rewards_address` fallback replaces a falsy {} with the
+        # masternode's existing payout address, so {} would never reach the RPC. Empty operator
+        # and voting args ("") mean "reuse", and the empty-object check fires before either is used.
+        assert_raises_rpc_error(RPC_INVALID_PARAMETER, "must not be empty",
+                                node.protx, "update_registrar", mn_r.proTxHash, "", "", {}, mn_r.fundsAddr)
+        # more than MAX_PAYOUT_SHARES (32) shares
+        too_many = {node.getnewaddress(): 1 for _ in range(MAX_PAYOUT_SHARES + 1)}
+        reject_payout(too_many, "too many payout shares")
+
         # ---------------------------------------------------------------
         # Convert an existing, running, ENABLED masternode (mninfo[0]) to a 3-way
         # multi-payout via update_registrar with the object form. mninfo[0] has
@@ -243,6 +291,7 @@ def run_test(self):
         a1, a2, a3 = node.getnewaddress(), node.getnewaddress(), node.getnewaddress()
         shares_a = {a1: 2500, a2: 2500, a3: 5000}  # ordered; sums to 10000
         assert_equal(sum(shares_a.values()), TOTAL_BASIS_POINTS)
+        node.sendtoaddress(mn_a.fundsAddr, 0.001)  # ensure a spendable fee output for the ProUpRegTx
         txid = mn_a.update_registrar(node, submit=True, rewards_address=shares_a,
                                      fundsAddr=mn_a.fundsAddr)
         assert txid is not None
@@ -261,6 +310,7 @@ def run_test(self):
         b1, b2 = node.getnewaddress(), node.getnewaddress()
         shares_b = {b1: 3333, b2: 6667}  # ordered; sums to 10000
         assert_equal(sum(shares_b.values()), TOTAL_BASIS_POINTS)
+        node.sendtoaddress(mn_b.fundsAddr, 0.001)  # ensure a spendable fee output for the ProUpRegTx
         txid = mn_b.update_registrar(node, submit=True, rewards_address=shares_b,
                                      fundsAddr=mn_b.fundsAddr)
         assert txid is not None
@@ -280,14 +330,12 @@ def run_test(self):
         self.mine_until_payee_and_check_split(node, mn_a.proTxHash, shares_a)
         self.mine_until_payee_and_check_split(node, mn_b.proTxHash, shares_b)
 
-        # Validation rejects are covered exhaustively at the unit level by the CheckPayoutShares
-        # reject-matrix (src/test/evo_providertx_tests.cpp): empty/oversize set, non-p2pkh/p2sh
-        # payee, reward out of (0, 10000], duplicate scripts, sum != 10000, and cross-version
-        # field mixing. The pre-activation rejection above additionally exercises ParsePayoutParam's
-        # error path end-to-end. (A post-activation functional reject-matrix on mninfo[2] was
-        # dropped: after the long payout-mining phase that masternode's RPC rejects did not
-        # surface as expected, which is a test-harness/PoSe-state artifact, not a consensus gap;
-        # see dash-dip0026-notes for the follow-up to re-add it on a freshly registered v3 MN.)
+        # The dict-expressible validation rejects are exercised functionally above (post-activation
+        # reject-matrix on mninfo[2]). The rules a Python dict cannot express here, namely duplicate
+        # payout scripts (repeated keys), non-p2pkh/p2sh payees, and cross-version field mixing, are
+        # covered exhaustively at the unit level by the CheckPayoutShares reject-matrix
+        # (src/test/evo_providertx_tests.cpp). Those consensus rules run at both mempool acceptance and
+        # block connect via CheckSpecialTx, so a malformed v4 ProTx cannot be mined.
 
         self.log.info("DIP-0026 multi-party payout test passed")
 

From 05712325ac9541b4e496015c47bdad29e4462570 Mon Sep 17 00:00:00 2001
From: Hilawe Semunegus <hilawe@gmail.com>
Date: Mon, 8 Jun 2026 10:28:02 -0400
Subject: [PATCH 14/15] DIP-0026: accept the multi-payout object as a JSON
 string (dash-cli)

ParsePayoutParam only recognized the {"address": basisPoints} payout form when it
arrived as a UniValue object, which is the case over JSON-RPC and named arguments.
dash-cli passes the payout argument as a plain string (it is not in the
rpc/client.cpp conversion table), so the documented object form sent via dash-cli
arrived as a string, fell through to the single-address branch, and failed with
"invalid payout address: {...}".

Accept the object whether it arrives as a UniValue object or as a JSON string: if a
string payout begins with '{', parse it and require a JSON object, otherwise treat it
as a single address. A base58/bech32 address never begins with '{', so the two forms
are unambiguous, and the legacy single-address CLI form is unchanged.

The functional test now sends one conversion's shares as a JSON string (the dash-cli
path) in addition to the dict form, so both arrival shapes are covered.
---
 src/rpc/evo.cpp                               | 25 ++++++++++++++++---
 .../functional/feature_dip0026_multipayout.py | 12 +++++++--
 2 files changed, 32 insertions(+), 5 deletions(-)

diff --git a/src/rpc/evo.cpp b/src/rpc/evo.cpp
index fb4bb3b57735..3e361c255a4c 100644
--- a/src/rpc/evo.cpp
+++ b/src/rpc/evo.cpp
@@ -410,7 +410,26 @@ static uint16_t ParsePayoutParam(const UniValue& param, const uint16_t max_versi
     scriptPayoutRet = CScript();
     payoutSharesRet.clear();
 
-    if (param.isObject()) {
+    // The DIP0026 multi-payout form is a {"address": basisPoints} object. It can arrive either as a
+    // UniValue object (named arguments / JSON-RPC callers) or as a JSON string, because dash-cli
+    // passes this argument as a string (the payout arg is not in the rpc/client.cpp conversion
+    // table). Accept both. A single payout address is base58/bech32 and never begins with '{', so
+    // the single-address and object forms are unambiguous.
+    UniValue parsed_obj;
+    if (param.isStr()) {
+        const std::string& s{param.get_str()};
+        const size_t first{s.find_first_not_of(" \t\n\r")};
+        if (first != std::string::npos && s[first] == '{') {
+            if (!parsed_obj.read(s) || !parsed_obj.isObject()) {
+                throw JSONRPCError(RPC_INVALID_PARAMETER,
+                                   "payout must be a single address or a JSON object like "
+                                   "{\"address\": basisPoints}");
+            }
+        }
+    }
+    const UniValue& shares{param.isObject() ? param : parsed_obj};
+
+    if (shares.isObject()) {
         if (max_version < ProTxVersion::MultiPayout) {
             throw JSONRPCError(RPC_INVALID_PARAMETER,
                                "multi-party payouts (DIP0026) are not available yet (v25 is not active)");
@@ -423,12 +442,12 @@ static uint16_t ParsePayoutParam(const UniValue& param, const uint16_t max_versi
         // duplicate scripts to mirror consensus. CheckPayoutShares remains the authoritative gate.
         int64_t total_bps{0};
         std::set<CScript> seen_scripts;
-        for (const std::string& addr : param.getKeys()) {
+        for (const std::string& addr : shares.getKeys()) {
             const CTxDestination dest = DecodeDestination(addr);
             if (!IsValidDestination(dest)) {
                 throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, strprintf("invalid payout address: %s", addr));
             }
-            const int64_t bps = param[addr].getInt<int64_t>();
+            const int64_t bps = shares[addr].getInt<int64_t>();
             if (bps <= 0 || bps > PayoutShare::TOTAL_BASIS_POINTS) {
                 throw JSONRPCError(RPC_INVALID_PARAMETER,
                                    strprintf("payout share for %s must be between 1 and %d basis points", addr,
diff --git a/test/functional/feature_dip0026_multipayout.py b/test/functional/feature_dip0026_multipayout.py
index c8f5587692ac..2672d95cc45c 100755
--- a/test/functional/feature_dip0026_multipayout.py
+++ b/test/functional/feature_dip0026_multipayout.py
@@ -44,6 +44,8 @@
      payees, cross-version mixing) are covered by the unit reject-matrix instead.
 """
 
+import json
+
 from test_framework.test_framework import DashTestFramework, MasternodeInfo
 from test_framework.util import (
     assert_equal,
@@ -304,14 +306,20 @@ def reject_payout(shares, msg):
         # coinbase additionally has an operator output. The split check below ignores
         # that output (different address) and validates only the owner-share split of
         # the already-operator-reduced owner reward reported by getblocktemplate.
-        self.log.info("convert mninfo[1] to a 2-way multi-payout via update_registrar")
+        #
+        # The shares here are passed as a JSON STRING rather than a dict, on purpose: dash-cli
+        # delivers the object form as a string (the payout arg is not in the rpc/client.cpp JSON
+        # conversion table), so this exercises ParsePayoutParam's string-to-object path that the dict
+        # form (real JSON-RPC object) does not. mninfo[0] above used the dict form, so both arrival
+        # shapes are covered.
+        self.log.info("convert mninfo[1] to a 2-way multi-payout via update_registrar (JSON-string form)")
         mn_b = self.mninfo[1]
         self.upgrade_mn_to_extaddr(node, mn_b)
         b1, b2 = node.getnewaddress(), node.getnewaddress()
         shares_b = {b1: 3333, b2: 6667}  # ordered; sums to 10000
         assert_equal(sum(shares_b.values()), TOTAL_BASIS_POINTS)
         node.sendtoaddress(mn_b.fundsAddr, 0.001)  # ensure a spendable fee output for the ProUpRegTx
-        txid = mn_b.update_registrar(node, submit=True, rewards_address=shares_b,
+        txid = mn_b.update_registrar(node, submit=True, rewards_address=json.dumps(shares_b),
                                      fundsAddr=mn_b.fundsAddr)
         assert txid is not None
         self.bump_mocktime(10 * 60 + 1)

From 02ef29fc5e0e55459707d148b510c985811fe760 Mon Sep 17 00:00:00 2001
From: Hilawe Semunegus <hilawe@gmail.com>
Date: Tue, 9 Jun 2026 10:08:39 -0400
Subject: [PATCH 15/15] DIP-0026: add release notes for multi-party payouts

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

diff --git a/doc/release-notes-7353.md b/doc/release-notes-7353.md
new file mode 100644
index 000000000000..9cbe92587786
--- /dev/null
+++ b/doc/release-notes-7353.md
@@ -0,0 +1,27 @@
+Notable changes
+===============
+
+Consensus / Masternodes
+-----------------------
+
+- DIP-0026 (Multi-Party Payouts) is implemented behind a new version-bits deployment, `v25`
+  (EHF, version bit 13), which additionally requires `v24` (extended addresses) to be active.
+  Once `v25` activates, a masternode can split its owner-side block reward on-chain among up to
+  32 payees instead of a single owner payout, using a new version 4 ProRegTx/ProUpRegTx. All
+  pre-activation behavior is unchanged: version 4 transactions are rejected until `v25` is active,
+  and the serialized forms for existing (pre-v4) masternodes are byte-for-byte identical. The
+  coinbase splits the owner reward across the payees by basis points (floor with a deterministic
+  one-duff remainder), summing to the owner reward exactly. (#7353)
+
+RPC
+---
+
+- `protx register`, `protx register_fund`, `protx register_prepare` and `protx update_registrar`
+  now accept the `payoutAddress` argument either as a single address (unchanged) or, once DIP-0026
+  (`v25`) is active, as a JSON object mapping each payout address to its share in basis points
+  (1-10000), e.g. `{"XaddrA": 6000, "XaddrB": 4000}`. The shares must be unique and sum to exactly
+  10000. Over dash-cli the object is passed as a quoted JSON string. (#7353)
+
+- `protx info`, `protx list` and `masternodelist` now report a `payoutShares` array for version 4
+  masternodes; the single `payoutAddress` field is omitted for those entries. Output for pre-v4
+  masternodes is unchanged. (#7353)