feat: v20 evonodes payment adjustment - cummulative changes from dashpay#5493

Author: ogabrielides

src/evo/deterministicmns.cpp

@@ -182,10 +182,10 @@ CDeterministicMNCPtr CDeterministicMNList::GetMNPayee(const CBlockIndex* pIndex)
     }
 
     bool isv19Active = llmq::utils::IsV19Active(pIndex);
-    // Starting from v19 and until v20 (Platform release), HPMN will be rewarded 4 blocks in a row
-    // TODO: Skip this code once v20 is active
+    bool isMNRewardReallocation = llmq::utils::IsMNRewardReallocationActive(pIndex);
+    // Starting from v19 and until MNRewardReallocation (Platform release), HPMN will be rewarded 4 blocks in a row
     CDeterministicMNCPtr best = nullptr;
-    if (isv19Active) {
+    if (isv19Active && !isMNRewardReallocation) {
         ForEachMNShared(true, [&](const CDeterministicMNCPtr& dmn) {
             if (dmn->pdmnState->nLastPaidHeight == nHeight) {
                 // We found the last MN Payee.
@@ -211,7 +211,12 @@ CDeterministicMNCPtr CDeterministicMNList::GetMNPayee(const CBlockIndex* pIndex)
     return best;
 }
 
-std::vector<CDeterministicMNCPtr> CDeterministicMNList::GetProjectedMNPayees(int nCount) const
+std::vector<CDeterministicMNCPtr> CDeterministicMNList::GetProjectedMNPayeesAtChainTip(int nCount) const
+{
+    return GetProjectedMNPayees(::ChainActive()[nHeight], nCount);
+}
+
+std::vector<CDeterministicMNCPtr> CDeterministicMNList::GetProjectedMNPayees(const CBlockIndex* const pindex, int nCount) const
 {
     if (nCount < 0 ) {
         return {};
@@ -223,11 +228,12 @@ std::vector<CDeterministicMNCPtr> CDeterministicMNList::GetProjectedMNPayees(int
 
     auto remaining_hpmn_payments = 0;
     CDeterministicMNCPtr hpmn_to_be_skipped = nullptr;
+    bool isMNRewardReallocation = llmq::utils::IsMNRewardReallocationActive(pindex);
     ForEachMNShared(true, [&](const CDeterministicMNCPtr& dmn) {
         if (dmn->pdmnState->nLastPaidHeight == nHeight) {
             // We found the last MN Payee.
             // If the last payee is a HPMN, we need to check its consecutive payments and pay him again if needed
-            if (dmn->nType == MnType::HighPerformance && dmn->pdmnState->nConsecutivePayments < dmn_types::HighPerformance.voting_weight) {
+            if (!isMNRewardReallocation && dmn->nType == MnType::HighPerformance && dmn->pdmnState->nConsecutivePayments < dmn_types::HighPerformance.voting_weight) {
                 remaining_hpmn_payments = dmn_types::HighPerformance.voting_weight - dmn->pdmnState->nConsecutivePayments;
                 for ([[maybe_unused]] auto _ : irange::range(remaining_hpmn_payments)) {
                     result.emplace_back(dmn);
@@ -720,6 +726,8 @@ bool CDeterministicMNManager::BuildNewListFromBlock(const CBlock& block, const C
 
     DecreasePoSePenalties(newList);
 
+    bool isMNRewardReallocation = llmq::utils::IsMNRewardReallocationActive(pindexPrev);
+
     // we skip the coinbase
     for (int i = 1; i < (int)block.vtx.size(); i++) {
         const CTransaction& tx = *block.vtx[i];
@@ -937,11 +945,10 @@ bool CDeterministicMNManager::BuildNewListFromBlock(const CBlock& block, const C
         auto dmn = newList.GetMN(payee->proTxHash);
         auto newState = std::make_shared<CDeterministicMNState>(*dmn->pdmnState);
         newState->nLastPaidHeight = nHeight;
-        // Starting from v19 and until v20, HPMN will be paid 4 blocks in a row
+        // Starting from v19 and until MNRewardReallocation, HPMN will be paid 4 blocks in a row
         // No need to check if v19 is active, since HPMN ProRegTx are allowed only after v19 activation
-        // TODO: Skip this code once v20 is active
         // Note: If the payee wasn't found in the current block that's fine
-        if (dmn->nType == MnType::HighPerformance) {
+        if (dmn->nType == MnType::HighPerformance && !isMNRewardReallocation) {
             ++newState->nConsecutivePayments;
             if (debugLogs) {
                 LogPrint(BCLog::MNPAYMENTS, "CDeterministicMNManager::%s -- MN %s is a HPMN, bumping nConsecutivePayments to %d\n",
@@ -959,8 +966,8 @@ bool CDeterministicMNManager::BuildNewListFromBlock(const CBlock& block, const C
     // reset nConsecutivePayments on non-paid HPMNs
     auto newList2 = newList;
     newList2.ForEachMN(false, [&](auto& dmn) {
-        if (payee != nullptr && dmn.proTxHash == payee->proTxHash) return;
         if (dmn.nType != MnType::HighPerformance) return;
+        if (payee != nullptr && dmn.proTxHash == payee->proTxHash && !isMNRewardReallocation) return;
         if (dmn.pdmnState->nConsecutivePayments == 0) return;
         if (debugLogs) {
             LogPrint(BCLog::MNPAYMENTS, "CDeterministicMNManager::%s -- MN %s, reset nConsecutivePayments %d->0\n",

src/evo/deterministicmns.h

@@ -342,7 +342,8 @@ class CDeterministicMNList
      * @param nCount the number of payees to return. "nCount = max()"" means "all", use it to avoid calling GetValidWeightedMNsCount twice.
      * @return
      */
-    [[nodiscard]] std::vector<CDeterministicMNCPtr> GetProjectedMNPayees(int nCount = std::numeric_limits<int>::max()) const;
+    [[nodiscard]] std::vector<CDeterministicMNCPtr> GetProjectedMNPayees(const CBlockIndex* const pindex, int nCount = std::numeric_limits<int>::max()) const;
+    [[nodiscard]] std::vector<CDeterministicMNCPtr> GetProjectedMNPayeesAtChainTip(int nCount = std::numeric_limits<int>::max()) const;
 
     /**
      * Calculate a quorum based on the modifier. The resulting list is deterministically sorted by score

src/llmq/utils.cpp

@@ -726,6 +726,7 @@ bool IsV20Active(const CBlockIndex* pindex)
 
 bool IsMNRewardReallocationActive(const CBlockIndex* pindex)
 {
+    assert(pindex);
     if (!IsV20Active(pindex)) return false;
 
     LOCK(cs_llmq_vbc);

src/qt/masternodelist.cpp

@@ -191,7 +191,7 @@ void MasternodeList::updateDIP3List()
 
     nTimeUpdatedDIP3 = GetTime();
 
-    auto projectedPayees = mnList.GetProjectedMNPayees();
+    auto projectedPayees = mnList.GetProjectedMNPayeesAtChainTip();
     std::map<uint256, int> nextPayments;
     for (size_t i = 0; i < projectedPayees.size(); i++) {
         const auto& dmn = projectedPayees[i];

src/rpc/masternode.cpp

@@ -136,7 +136,7 @@ static UniValue masternode_count(const JSONRPCRequest& request)
 static UniValue GetNextMasternodeForPayment(int heightShift)
 {
     auto mnList = deterministicMNManager->GetListAtChainTip();
-    auto payees = mnList.GetProjectedMNPayees(heightShift);
+    auto payees = mnList.GetProjectedMNPayeesAtChainTip(heightShift);
     if (payees.empty())
         return "unknown";
     auto payee = payees.back();
@@ -362,7 +362,7 @@ static UniValue masternode_winners(const JSONRPCRequest& request, const Chainsta
         obj.pushKV(strprintf("%d", h), strPayments);
     }
 
-    auto projection = deterministicMNManager->GetListForBlock(pindexTip).GetProjectedMNPayees(20);
+    auto projection = deterministicMNManager->GetListForBlock(pindexTip).GetProjectedMNPayees(pindexTip, 20);
     for (size_t i = 0; i < projection.size(); i++) {
         int h = nChainTipHeight + 1 + i;
         std::string strPayments = GetRequiredPaymentsString(h, projection[i]);

test/functional/feature_llmq_hpmn.py

@@ -114,41 +114,55 @@ def run_test(self):
         self.log.info("Test that HPMNs are paid 4x blocks in a row")
         self.test_hpmn_payments(window_analysis=256)
 
+        self.activate_mn_rr()
+        self.log.info("Activated MN RewardReallocation at height:" + str(self.nodes[0].getblockcount()))
+
+        # Generate a few blocks to make HPMN/MN analysis on a pure MN RewardReallocation window
+        self.bump_mocktime(1)
+        self.nodes[0].generate(4)
+        self.sync_blocks()
+
+        self.log.info("Test that HPMNs are paid 1 block in a row after MN RewardReallocation activation")
+        self.test_hpmn_payments(window_analysis=256, v20active=True)
+
         self.log.info(self.nodes[0].masternodelist())
 
         return
 
-    def test_hpmn_payments(self, window_analysis):
+    def test_hpmn_payments(self, window_analysis, v20active=False):
         current_hpmn = None
         consecutive_payments = 0
+        n_payments = 0 if v20active else 4
         for i in range(0, window_analysis):
             payee = self.get_mn_payee_for_block(self.nodes[0].getbestblockhash())
             if payee is not None and payee.hpmn:
                 if current_hpmn is not None and payee.proTxHash == current_hpmn.proTxHash:
                     # same HPMN
                     assert consecutive_payments > 0
-                    consecutive_payments += 1
+                    if not v20active:
+                        consecutive_payments += 1
                     consecutive_payments_rpc = self.nodes[0].protx('info', current_hpmn.proTxHash)['state']['consecutivePayments']
                     assert_equal(consecutive_payments, consecutive_payments_rpc)
                 else:
                     # new HPMN
                     if current_hpmn is not None:
-                        # make sure the old one was paid 4 times in a row
-                        assert_equal(consecutive_payments, 4)
+                        # make sure the old one was paid N times in a row
+                        assert_equal(consecutive_payments, n_payments)
                         consecutive_payments_rpc = self.nodes[0].protx('info', current_hpmn.proTxHash)['state']['consecutivePayments']
                         # old HPMN should have its nConsecutivePayments reset to 0
                         assert_equal(consecutive_payments_rpc, 0)
                     consecutive_payments_rpc = self.nodes[0].protx('info', payee.proTxHash)['state']['consecutivePayments']
                     # if hpmn is the one we start "for" loop with,
                     # we have no idea how many times it was paid before - rely on rpc results here
-                    consecutive_payments = consecutive_payments_rpc if i == 0 and current_hpmn is None else 1
+                    new_payment_value = 0 if v20active else 1
+                    consecutive_payments = consecutive_payments_rpc if i == 0 and current_hpmn is None else new_payment_value
                     current_hpmn = payee
                     assert_equal(consecutive_payments, consecutive_payments_rpc)
             else:
                 # not a HPMN
                 if current_hpmn is not None:
-                    # make sure the old one was paid 4 times in a row
-                    assert_equal(consecutive_payments, 4)
+                    # make sure the old one was paid N times in a row
+                    assert_equal(consecutive_payments, n_payments)
                     consecutive_payments_rpc = self.nodes[0].protx('info', current_hpmn.proTxHash)['state']['consecutivePayments']
                     # old HPMN should have its nConsecutivePayments reset to 0
                     assert_equal(consecutive_payments_rpc, 0)