feat: masternode payment reallocation from coin base to platform

Move funds from the coinbase, into the Asset Lock Pool. This is to incentivize MNs to upgrade to platform, because only MNs running platform will get these migrated rewards

Author: knst

src/evo/creditpool.cpp

@@ -7,10 +7,10 @@
 #include <evo/assetlocktx.h>
 #include <evo/cbtx.h>
 
-#include <llmq/utils.h>
-
 #include <chain.h>
+#include <llmq/utils.h>
 #include <logging.h>
+#include <spork.h>
 #include <util/validation.h>
 #include <validation.h>
 
@@ -251,16 +251,31 @@ CCreditPoolDiff::CCreditPoolDiff(CCreditPool starter, const CBlockIndex *pindex,
     assert(pindex);
 }
 
+void CCreditPoolDiff::addRewardRealloced(const CAmount reward) {
+    masternodeReward += reward;
+}
+
 bool CCreditPoolDiff::setTarget(const CTransaction& tx, TxValidationState& state)
 {
     CCbTx cbTx;
     if (!GetTxPayload(tx, cbTx)) {
         return state.Invalid(TxValidationResult::TX_CONSENSUS, "bad-cbtx-payload");
     }
 
-    if (cbTx.nVersion == 3) {
-        targetLocked = cbTx.assetLockedAmount;
+    if (cbTx.nVersion != 3) return true;
+
+    targetLocked = cbTx.assetLockedAmount;
+
+
+    if (isIgnoringMNRewardReallocation(*sporkManager)) return true;
+
+    CAmount blockReward = 0;
+    for (const CTxOut& txout : tx.vout) {
+        blockReward += txout.nValue;
     }
+    masternodeReward = GetMasternodePayment(cbTx.nHeight, blockReward, Params().GetConsensus().BRRHeight);
+    LogPrintf("CreditPool: set target to %lld with MN reward %lld\n", *targetLocked, masternodeReward);
+
     return true;
 }
 
@@ -333,3 +348,11 @@ bool CCreditPoolDiff::processTransaction(const CTransaction& tx, TxValidationSta
         return state.Invalid(TxValidationResult::TX_CONSENSUS, "failed-procassetlocksinblock");
     }
 }
+
+bool isIgnoringMNRewardReallocation(const CSporkManager& spork_manager) {
+    if (Params().NetworkIDString() != CBaseChainParams::REGTEST) return false;
+
+    bool ret = spork_manager.IsSporkActive(SPORK_24_IGNORE_MN_REWARD_REALLOCED);
+    LogPrintf("%s: spork IGNORE_MN_REWARD_REALLOCED value: %d\n", __func__, ret);
+    return ret;
+}

src/evo/creditpool.h

@@ -21,6 +21,7 @@
 
 class CBlockIndex;
 class TxValidationState;
+class CSporkManager;
 
 namespace Consensus
 {
@@ -103,6 +104,7 @@ class CCreditPoolDiff {
 
     CAmount sessionLocked{0};
     CAmount sessionUnlocked{0};
+    CAmount masternodeReward{0};
 
     // target value is used to validate CbTx. If values mismatched, block is invalid
     std::optional<CAmount> targetLocked;
@@ -118,8 +120,14 @@ class CCreditPoolDiff {
      */
     bool processTransaction(const CTransaction& tx, TxValidationState& state);
 
+    /**
+     * This function should be called by miner for initalization of MasterNode reward
+     *
+     */
+    void addRewardRealloced(const CAmount reward);
+
     CAmount getTotalLocked() const {
-        return pool.locked + sessionLocked - sessionUnlocked;
+        return pool.locked + sessionLocked - sessionUnlocked + masternodeReward;
     }
 
     const std::optional<CAmount>& getTargetLocked() const {
@@ -170,6 +178,8 @@ class CCreditPoolManager
     CCreditPool constructCreditPool(const CBlockIndex* block_index, CCreditPool prev, const Consensus::Params& consensusParams);
 };
 
+bool isIgnoringMNRewardReallocation(const CSporkManager& spork_manager);
+
 extern std::unique_ptr<CCreditPoolManager> creditPoolManager;
 
 #endif

src/evo/specialtxman.cpp

@@ -17,8 +17,10 @@
 #include <llmq/commitment.h>
 #include <llmq/utils.h>
 #include <primitives/block.h>
+#include <spork.h>
 #include <validation.h>
 
+#include <masternode/payments.h>
 bool CheckSpecialTx(const CTransaction& tx, const CBlockIndex* pindexPrev, const CCoinsViewCache& view, const CCreditPool& creditPool, bool check_sigs, TxValidationState& state)
 {
     AssertLockHeld(cs_main);

src/masternode/payments.cpp

@@ -12,14 +12,16 @@
 #include <governance/governance.h>
 #include <key_io.h>
 #include <logging.h>
+#include <llmq/utils.h>
 #include <masternode/sync.h>
 #include <primitives/block.h>
 #include <script/standard.h>
+#include <spork.h>
 #include <tinyformat.h>
 #include <util/ranges.h>
 #include <util/system.h>
 #include <validation.h>
-
+#include <evo/creditpool.h>
 #include <string>
 
 CMasternodePayments mnpayments;
@@ -276,22 +278,28 @@ bool CMasternodePayments::GetBlockTxOuts(int nBlockHeight, CAmount blockReward,
 {
     voutMasternodePaymentsRet.clear();
 
+    CAmount masternodeReward = GetMasternodePayment(nBlockHeight, blockReward, Params().GetConsensus().BRRHeight);
+
+    bool fV20Active_context = llmq::utils::IsV20Active(::ChainActive().Tip());
+    if (fV20Active_context && !isIgnoringMNRewardReallocation(*sporkManager)) {
+        LogPrintf("CMasternodePayments::%s -- MN reward %lld reallocated to credit pool\n", __func__, masternodeReward);
+        voutMasternodePaymentsRet.emplace_back(masternodeReward, CScript() << OP_RETURN);
+        return true;
+    }
+
     const CBlockIndex* pindex = WITH_LOCK(cs_main, return ::ChainActive()[nBlockHeight - 1]);
     auto dmnPayee = deterministicMNManager->GetListForBlock(pindex).GetMNPayee(pindex);
     if (!dmnPayee) {
         return false;
     }
 
     CAmount operatorReward = 0;
-    CAmount masternodeReward = GetMasternodePayment(nBlockHeight, blockReward, Params().GetConsensus().BRRHeight);
-
     if (dmnPayee->nOperatorReward != 0 && dmnPayee->pdmnState->scriptOperatorPayout != CScript()) {
         // This calculation might eventually turn out to result in 0 even if an operator reward percentage is given.
         // This will however only happen in a few years when the block rewards drops very low.
         operatorReward = (masternodeReward * dmnPayee->nOperatorReward) / 10000;
         masternodeReward -= operatorReward;
     }
-
     if (masternodeReward > 0) {
         voutMasternodePaymentsRet.emplace_back(masternodeReward, dmnPayee->pdmnState->scriptPayout);
     }

src/miner.cpp

@@ -232,6 +232,17 @@ std::unique_ptr<CBlockTemplate> BlockAssembler::CreateNewBlock(CChainState& chai
                     LogPrintf("CreateNewBlock() height[%d] CBTx bestCLHeightDiff[%d] CLSig[%s]\n", nHeight, cbTx.bestCLHeightDiff, cbTx.bestCLSignature.ToString());
                 }
                 assert(creditPoolDiff);
+
+                if (!isIgnoringMNRewardReallocation(spork_manager)) {
+                    if (!CMasternodePayments::GetMasternodeTxOuts(nHeight, blockReward, pblocktemplate->voutMasternodePayments)) {
+                        LogPrint(BCLog::MNPAYMENTS, "%s -- no masternode to pay (MN list probably empty)\n", __func__);
+                    }
+                    for (const auto& txout : pblocktemplate->voutMasternodePayments) {
+                        // subtract MN payment from miner reward
+                        LogPrintf("CreateNewBlock() add MN reward %lld to credit pool\n", txout.nValue);
+                        creditPoolDiff->addRewardRealloced(txout.nValue);
+                    }
+                }
                 cbTx.assetLockedAmount = creditPoolDiff->getTotalLocked();
             }
         }

src/spork.h

@@ -38,6 +38,7 @@ enum SporkId : int32_t {
     SPORK_19_CHAINLOCKS_ENABLED                            = 10018,
     SPORK_21_QUORUM_ALL_CONNECTED                          = 10020,
     SPORK_23_QUORUM_POSE                                   = 10022,
+    SPORK_24_IGNORE_MN_REWARD_REALLOCED                    = 10023,
 
     SPORK_INVALID                                          = -1,
 };
@@ -63,14 +64,15 @@ struct CSporkDef
 };
 
 #define MAKE_SPORK_DEF(name, defaultValue) CSporkDef{name, defaultValue, #name}
-[[maybe_unused]] static constexpr std::array<CSporkDef, 7> sporkDefs = {
+[[maybe_unused]] static constexpr std::array<CSporkDef, 8> sporkDefs = {
     MAKE_SPORK_DEF(SPORK_2_INSTANTSEND_ENABLED,            4070908800ULL), // OFF
     MAKE_SPORK_DEF(SPORK_3_INSTANTSEND_BLOCK_FILTERING,    4070908800ULL), // OFF
     MAKE_SPORK_DEF(SPORK_9_SUPERBLOCKS_ENABLED,            4070908800ULL), // OFF
     MAKE_SPORK_DEF(SPORK_17_QUORUM_DKG_ENABLED,            4070908800ULL), // OFF
     MAKE_SPORK_DEF(SPORK_19_CHAINLOCKS_ENABLED,            4070908800ULL), // OFF
     MAKE_SPORK_DEF(SPORK_21_QUORUM_ALL_CONNECTED,          4070908800ULL), // OFF
     MAKE_SPORK_DEF(SPORK_23_QUORUM_POSE,                   4070908800ULL), // OFF
+    MAKE_SPORK_DEF(SPORK_24_IGNORE_MN_REWARD_REALLOCED,    4070908800ULL), // OFF
 };
 #undef MAKE_SPORK_DEF
 extern std::unique_ptr<CSporkManager> sporkManager;

src/test/evo_deterministicmns_tests.cpp

@@ -271,6 +271,11 @@ void FuncDIP3Protx(TestChainSetup& setup)
     sporkManager->SetSporkAddress(EncodeDestination(PKHash(sporkKey.GetPubKey())));
     sporkManager->SetPrivKey(EncodeSecret(sporkKey));
 
+    // broadcast new spork
+    if (sporkManager->UpdateSpork(SporkId::SPORK_24_IGNORE_MN_REWARD_REALLOCED, 0, *setup.m_node.connman)) {
+        LogPrintf("spork SPORK_24_IGNORE_MN_REWARD_REALLOCED updated\n");
+    }
+
     auto utxos = BuildSimpleUtxoMap(setup.m_coinbase_txns);
 
     int nHeight = ::ChainActive().Height();

test/functional/feature_asset_locks.py

@@ -169,6 +169,8 @@ def set_sporks(self):
         self.nodes[0].sporkupdate("SPORK_19_CHAINLOCKS_ENABLED", spork_disabled)
         self.nodes[0].sporkupdate("SPORK_3_INSTANTSEND_BLOCK_FILTERING", spork_disabled)
         self.nodes[0].sporkupdate("SPORK_2_INSTANTSEND_ENABLED", spork_disabled)
+        self.nodes[0].sporkupdate("SPORK_24_IGNORE_MN_REWARD_REALLOCED", spork_enabled)
+
         self.wait_for_sporks_same()
 
     def ensure_tx_is_not_mined(self, tx_id):

test/functional/feature_llmq_is_cl_conflicts.py

@@ -20,6 +20,7 @@
 from test_framework.test_framework import DashTestFramework
 from test_framework.util import assert_equal, assert_raises_rpc_error, hex_str_to_bytes, get_bip9_status, wait_until
 
+from test_framework.address import ADDRESS_BCRT1_UNSPENDABLE
 
 class TestP2PConn(P2PInterface):
     def __init__(self):
@@ -317,6 +318,8 @@ def create_block(self, node, vtx=None):
 
         outputs = {miner_address: str(Decimal(miner_amount) / COIN)}
         if mn_amount > 0:
+            if mn_payee is None or mn_payee == '':
+                mn_payee = ADDRESS_BCRT1_UNSPENDABLE
             outputs[mn_payee] = str(Decimal(mn_amount) / COIN)
 
         coinbase = FromHex(CTransaction(), node.createrawtransaction([], outputs))