Directly use deterministicMNManager instead of compat code in CMasternodeMan

src/evo/deterministicmns.cpp

@@ -151,6 +151,15 @@ CDeterministicMNCPtr CDeterministicMNList::GetMNByCollateral(const COutPoint& co
     return GetUniquePropertyMN(collateralOutpoint);
 }
 
+CDeterministicMNCPtr CDeterministicMNList::GetValidMNByCollateral(const COutPoint& collateralOutpoint) const
+{
+    auto dmn = GetMNByCollateral(collateralOutpoint);
+    if (dmn && !IsMNValid(dmn)) {
+        return nullptr;
+    }
+    return dmn;
+}
+
 static int CompareByLastPaid_GetHeight(const CDeterministicMN& dmn)
 {
     int height = dmn.pdmnState->nLastPaidHeight;
@@ -826,20 +835,6 @@ CDeterministicMNList CDeterministicMNManager::GetListAtChainTip()
     return GetListForBlock(tipBlockHash);
 }
 
-bool CDeterministicMNManager::HasValidMNCollateralAtChainTip(const COutPoint& outpoint)
-{
-    auto mnList = GetListAtChainTip();
-    auto dmn = mnList.GetMNByCollateral(outpoint);
-    return dmn && mnList.IsMNValid(dmn);
-}
-
-bool CDeterministicMNManager::HasMNCollateralAtChainTip(const COutPoint& outpoint)
-{
-    auto mnList = GetListAtChainTip();
-    auto dmn = mnList.GetMNByCollateral(outpoint);
-    return dmn != nullptr;
-}
-
 bool CDeterministicMNManager::IsProTxWithCollateral(const CTransactionRef& tx, uint32_t n)
 {
     if (tx->nVersion != 3 || tx->nType != TRANSACTION_PROVIDER_REGISTER) {

src/evo/deterministicmns.h

@@ -289,10 +289,23 @@ class CDeterministicMNList
     {
         return GetMN(proTxHash) != nullptr;
     }
+    bool HasValidMN(const uint256& proTxHash) const
+    {
+        return GetValidMN(proTxHash) != nullptr;
+    }
+    bool HasMNByCollateral(const COutPoint& collateralOutpoint) const
+    {
+        return GetMNByCollateral(collateralOutpoint) != nullptr;
+    }
+    bool HasValidMNByCollateral(const COutPoint& collateralOutpoint) const
+    {
+        return GetValidMNByCollateral(collateralOutpoint) != nullptr;
+    }
     CDeterministicMNCPtr GetMN(const uint256& proTxHash) const;
     CDeterministicMNCPtr GetValidMN(const uint256& proTxHash) const;
     CDeterministicMNCPtr GetMNByOperatorKey(const CBLSPublicKey& pubKey);
     CDeterministicMNCPtr GetMNByCollateral(const COutPoint& collateralOutpoint) const;
+    CDeterministicMNCPtr GetValidMNByCollateral(const COutPoint& collateralOutpoint) const;
     CDeterministicMNCPtr GetMNPayee() const;
 
     /**
@@ -479,10 +492,6 @@ class CDeterministicMNManager
     CDeterministicMNList GetListForBlock(const uint256& blockHash);
     CDeterministicMNList GetListAtChainTip();
 
-    // TODO remove after removal of old non-deterministic lists
-    bool HasValidMNCollateralAtChainTip(const COutPoint& outpoint);
-    bool HasMNCollateralAtChainTip(const COutPoint& outpoint);
-
     // Test if given TX is a ProRegTx which also contains the collateral at index n
     bool IsProTxWithCollateral(const CTransactionRef& tx, uint32_t n);
 

src/governance-object.cpp

@@ -116,14 +116,13 @@ bool CGovernanceObject::ProcessVote(CNode* pfrom,
         return false;
     }
 
-    if (!mnodeman.Has(vote.GetMasternodeOutpoint())) {
+    auto mnList = deterministicMNManager->GetListAtChainTip();
+
+    if (!mnList.HasValidMNByCollateral(vote.GetMasternodeOutpoint())) {
         std::ostringstream ostr;
         ostr << "CGovernanceObject::ProcessVote -- Masternode " << vote.GetMasternodeOutpoint().ToStringShort() << " not found";
         exception = CGovernanceException(ostr.str(), GOVERNANCE_EXCEPTION_WARNING);
         if (cmmapOrphanVotes.Insert(vote.GetMasternodeOutpoint(), vote_time_pair_t(vote, GetAdjustedTime() + GOVERNANCE_ORPHAN_EXPIRATION_TIME))) {
-            if (pfrom) {
-                mnodeman.AskForMN(pfrom, vote.GetMasternodeOutpoint(), connman);
-            }
             LogPrintf("%s\n", ostr.str());
         } else {
             LogPrint("gobject", "%s\n", ostr.str());
@@ -212,9 +211,11 @@ void CGovernanceObject::ClearMasternodeVotes()
 {
     LOCK(cs);
 
+    auto mnList = deterministicMNManager->GetListAtChainTip();
+
     vote_m_it it = mapCurrentMNVotes.begin();
     while (it != mapCurrentMNVotes.end()) {
-        if (!mnodeman.Has(it->first)) {
+        if (!mnList.HasValidMNByCollateral(it->first)) {
             fileVotes.RemoveVotesFromMasternode(it->first);
             mapCurrentMNVotes.erase(it++);
         } else {
@@ -552,9 +553,11 @@ bool CGovernanceObject::IsValidLocally(std::string& strError, bool& fMissingMast
             return true;
         }
 
+        auto mnList = deterministicMNManager->GetListAtChainTip();
+
         std::string strOutpoint = masternodeOutpoint.ToStringShort();
-        masternode_info_t infoMn;
-        if (!mnodeman.GetMasternodeInfo(masternodeOutpoint, infoMn)) {
+        auto dmn = mnList.GetValidMNByCollateral(masternodeOutpoint);
+        if (!dmn) {
             CMasternode::CollateralStatus err = CMasternode::CheckCollateral(masternodeOutpoint, CKeyID());
             if (err == CMasternode::COLLATERAL_UTXO_NOT_FOUND) {
                 strError = "Failed to find Masternode UTXO, missing masternode=" + strOutpoint + "\n";
@@ -572,16 +575,9 @@ bool CGovernanceObject::IsValidLocally(std::string& strError, bool& fMissingMast
         }
 
         // Check that we have a valid MN signature
-        if (deterministicMNManager->IsDIP3Active()) {
-            if (!CheckSignature(infoMn.blsPubKeyOperator)) {
-                strError = "Invalid masternode signature for: " + strOutpoint + ", pubkey id = " + infoMn.blsPubKeyOperator.ToString();
-                return false;
-            }
-        } else {
-            if (!CheckSignature(infoMn.legacyKeyIDOperator)) {
-                strError = "Invalid masternode signature for: " + strOutpoint + ", pubkey id = " + infoMn.legacyKeyIDOperator.ToString();
-                return false;
-            }
+        if (!CheckSignature(dmn->pdmnState->pubKeyOperator)) {
+            strError = "Invalid masternode signature for: " + strOutpoint + ", pubkey = " + dmn->pdmnState->pubKeyOperator.ToString();
+            return false;
         }
 
         return true;
@@ -779,7 +775,7 @@ void CGovernanceObject::UpdateSentinelVariables()
 {
     // CALCULATE MINIMUM SUPPORT LEVELS REQUIRED
 
-    int nMnCount = mnodeman.CountEnabled();
+    int nMnCount = (int)deterministicMNManager->GetListAtChainTip().GetValidMNsCount();
     if (nMnCount == 0) return;
 
     // CALCULATE THE MINUMUM VOTE COUNT REQUIRED FOR FULL SIGNAL
@@ -812,6 +808,7 @@ void CGovernanceObject::UpdateSentinelVariables()
 void CGovernanceObject::CheckOrphanVotes(CConnman& connman)
 {
     int64_t nNow = GetAdjustedTime();
+    auto mnList = deterministicMNManager->GetListAtChainTip();
     const vote_cmm_t::list_t& listVotes = cmmapOrphanVotes.GetItemList();
     vote_cmm_t::list_cit it = listVotes.begin();
     while (it != listVotes.end()) {
@@ -821,7 +818,7 @@ void CGovernanceObject::CheckOrphanVotes(CConnman& connman)
         const CGovernanceVote& vote = pairVote.first;
         if (pairVote.second < nNow) {
             fRemove = true;
-        } else if (!mnodeman.Has(vote.GetMasternodeOutpoint())) {
+        } else if (!mnList.HasValidMNByCollateral(vote.GetMasternodeOutpoint())) {
             ++it;
             continue;
         }

src/governance-vote.cpp

@@ -256,20 +256,16 @@ bool CGovernanceVote::IsValid(bool useVotingKey) const
         return false;
     }
 
-    masternode_info_t infoMn;
-    if (!mnodeman.GetMasternodeInfo(masternodeOutpoint, infoMn)) {
+    auto dmn = deterministicMNManager->GetListAtChainTip().GetValidMNByCollateral(masternodeOutpoint);
+    if (!dmn) {
         LogPrint("gobject", "CGovernanceVote::IsValid -- Unknown Masternode - %s\n", masternodeOutpoint.ToStringShort());
         return false;
     }
 
     if (useVotingKey) {
-        return CheckSignature(infoMn.keyIDVoting);
+        return CheckSignature(dmn->pdmnState->keyIDVoting);
     } else {
-        if (deterministicMNManager->IsDIP3Active()) {
-            return CheckSignature(infoMn.blsPubKeyOperator);
-        } else {
-            return CheckSignature(infoMn.legacyKeyIDOperator);
-        }
+        return CheckSignature(dmn->pdmnState->pubKeyOperator);
     }
 }
 

src/governance.cpp

@@ -515,12 +515,17 @@ std::vector<CGovernanceVote> CGovernanceManager::GetCurrentVotes(const uint256&
     if (it == mapObjects.end()) return vecResult;
     const CGovernanceObject& govobj = it->second;
 
-    CMasternode mn;
-    std::map<COutPoint, CMasternode> mapMasternodes;
+    auto mnList = deterministicMNManager->GetListAtChainTip();
+    std::map<COutPoint, CDeterministicMNCPtr> mapMasternodes;
     if (mnCollateralOutpointFilter.IsNull()) {
-        mapMasternodes = mnodeman.GetFullMasternodeMap();
-    } else if (mnodeman.Get(mnCollateralOutpointFilter, mn)) {
-        mapMasternodes[mnCollateralOutpointFilter] = mn;
+        mnList.ForEachMN(true, [&](const CDeterministicMNCPtr& dmn) {
+            mapMasternodes.emplace(dmn->collateralOutpoint, dmn);
+        });
+    } else {
+        auto dmn = mnList.GetValidMNByCollateral(mnCollateralOutpointFilter);
+        if (dmn) {
+            mapMasternodes.emplace(dmn->collateralOutpoint, dmn);
+        }
     }
 
     // Loop thru each MN collateral outpoint and get the votes for the `nParentHash` governance object
@@ -1074,7 +1079,7 @@ int CGovernanceManager::RequestGovernanceObjectVotes(const std::vector<CNode*>&
     int nMaxObjRequestsPerNode = 1;
     size_t nProjectedVotes = 2000;
     if (Params().NetworkIDString() != CBaseChainParams::MAIN) {
-        nMaxObjRequestsPerNode = std::max(1, int(nProjectedVotes / std::max(1, mnodeman.size())));
+        nMaxObjRequestsPerNode = std::max(1, int(nProjectedVotes / std::max(1, (int)deterministicMNManager->GetListAtChainTip().GetValidMNsCount())));
     }
 
     {

src/instantx.cpp

@@ -245,8 +245,7 @@ void CInstantSend::Vote(CTxLockCandidate& txLockCandidate, CConnman& connman)
 
         int nRank;
         uint256 quorumModifierHash;
-        int nMinRequiredProtocol = std::max(MIN_INSTANTSEND_PROTO_VERSION, mnpayments.GetMinMasternodePaymentsProto());
-        if (!mnodeman.GetMasternodeRank(activeMasternodeInfo.outpoint, nRank, quorumModifierHash, nLockInputHeight, nMinRequiredProtocol)) {
+        if (!mnodeman.GetMasternodeRank(activeMasternodeInfo.outpoint, nRank, quorumModifierHash, nLockInputHeight)) {
             LogPrint("instantsend", "CInstantSend::Vote -- Can't calculate rank for masternode %s\n", activeMasternodeInfo.outpoint.ToStringShort());
             continue;
         }
@@ -469,7 +468,8 @@ void CInstantSend::UpdateVotedOutpoints(const CTxLockVote& vote, CTxLockCandidat
                     txLockCandidate.MarkOutpointAsAttacked(vote.GetOutpoint());
                     it2->second.MarkOutpointAsAttacked(vote.GetOutpoint());
                     // apply maximum PoSe ban score to this masternode i.e. PoSe-ban it instantly
-                    mnodeman.PoSeBan(vote.GetMasternodeOutpoint());
+                    // TODO Call new PoSe system when it's ready
+                    //mnodeman.PoSeBan(vote.GetMasternodeOutpoint());
                     // NOTE: This vote must be relayed further to let all other nodes know about such
                     // misbehaviour of this masternode. This way they should also be able to construct
                     // conflicting lock and PoSe-ban this masternode.
@@ -1029,22 +1029,25 @@ bool CTxLockRequest::IsSimple() const
 
 bool CTxLockVote::IsValid(CNode* pnode, CConnman& connman) const
 {
-    if (!mnodeman.Has(outpointMasternode)) {
+    auto mnList = deterministicMNManager->GetListAtChainTip();
+
+    if (!mnList.HasValidMNByCollateral(outpointMasternode)) {
         LogPrint("instantsend", "CTxLockVote::IsValid -- Unknown masternode %s\n", outpointMasternode.ToStringShort());
         mnodeman.AskForMN(pnode, outpointMasternode, connman);
         return false;
     }
 
     // Verify that masternodeProTxHash belongs to the same MN referred by the collateral
-    // Only v13 nodes will send us locks with this field set, and only after spork15 activation
+    // This is a leftover from the legacy non-deterministic MN list where we used the collateral to identify MNs
+    // TODO eventually remove the collateral from CTxLockVote
     if (!masternodeProTxHash.IsNull()) {
-        masternode_info_t mnInfo;
-        if (!mnodeman.GetMasternodeInfo(masternodeProTxHash, mnInfo) || mnInfo.outpoint != outpointMasternode) {
+        auto dmn = mnList.GetValidMN(masternodeProTxHash);
+        if (!dmn || dmn->collateralOutpoint != outpointMasternode) {
             LogPrint("instantsend", "CTxLockVote::IsValid -- invalid masternodeProTxHash %s\n", masternodeProTxHash.ToString());
             return false;
         }
-    } else if (deterministicMNManager->IsDIP3Active()) {
-        LogPrint("instantsend", "CTxLockVote::IsValid -- missing masternodeProTxHash while DIP3 is active\n");
+    } else {
+        LogPrint("instantsend", "CTxLockVote::IsValid -- missing masternodeProTxHash\n");
         return false;
     }
 
@@ -1058,8 +1061,7 @@ bool CTxLockVote::IsValid(CNode* pnode, CConnman& connman) const
 
     int nRank;
     uint256 expectedQuorumModifierHash;
-    int nMinRequiredProtocol = std::max(MIN_INSTANTSEND_PROTO_VERSION, mnpayments.GetMinMasternodePaymentsProto());
-    if (!mnodeman.GetMasternodeRank(outpointMasternode, nRank, expectedQuorumModifierHash, nLockInputHeight, nMinRequiredProtocol)) {
+    if (!mnodeman.GetMasternodeRank(outpointMasternode, nRank, expectedQuorumModifierHash, nLockInputHeight)) {
         //can be caused by past versions trying to vote with an invalid protocol
         LogPrint("instantsend", "CTxLockVote::IsValid -- Can't calculate rank for masternode %s\n", outpointMasternode.ToStringShort());
         return false;
@@ -1105,83 +1107,33 @@ bool CTxLockVote::CheckSignature() const
 {
     std::string strError;
 
-    masternode_info_t infoMn;
-
-    if (!mnodeman.GetMasternodeInfo(outpointMasternode, infoMn)) {
-        LogPrintf("CTxLockVote::CheckSignature -- Unknown Masternode: masternode=%s\n", outpointMasternode.ToString());
+    auto dmn = deterministicMNManager->GetListAtChainTip().GetValidMN(masternodeProTxHash);
+    if (!dmn) {
+        LogPrintf("CTxLockVote::CheckSignature -- Unknown Masternode: masternode=%s\n", masternodeProTxHash.ToString());
         return false;
     }
 
-    if (deterministicMNManager->IsDIP3Active()) {
-        uint256 hash = GetSignatureHash();
+    uint256 hash = GetSignatureHash();
 
-        CBLSSignature sig;
-        sig.SetBuf(vchMasternodeSignature);
-        if (!sig.IsValid() || !sig.VerifyInsecure(infoMn.blsPubKeyOperator, hash)) {
-            LogPrintf("CTxLockVote::CheckSignature -- VerifyInsecure() failed\n");
-            return false;
-        }
-    } else if (sporkManager.IsSporkActive(SPORK_6_NEW_SIGS)) {
-        uint256 hash = GetSignatureHash();
-
-        if (!CHashSigner::VerifyHash(hash, infoMn.legacyKeyIDOperator, vchMasternodeSignature, strError)) {
-            // could be a signature in old format
-            std::string strMessage = txHash.ToString() + outpoint.ToStringShort();
-            if (!CMessageSigner::VerifyMessage(infoMn.legacyKeyIDOperator, vchMasternodeSignature, strMessage, strError)) {
-                // nope, not in old format either
-                LogPrintf("CTxLockVote::CheckSignature -- VerifyMessage() failed, error: %s\n", strError);
-                return false;
-            }
-        }
-    } else {
-        std::string strMessage = txHash.ToString() + outpoint.ToStringShort();
-        if (!CMessageSigner::VerifyMessage(infoMn.legacyKeyIDOperator, vchMasternodeSignature, strMessage, strError)) {
-            LogPrintf("CTxLockVote::CheckSignature -- VerifyMessage() failed, error: %s\n", strError);
-            return false;
-        }
+    CBLSSignature sig;
+    sig.SetBuf(vchMasternodeSignature);
+    if (!sig.IsValid() || !sig.VerifyInsecure(dmn->pdmnState->pubKeyOperator, hash)) {
+        LogPrintf("CTxLockVote::CheckSignature -- VerifyInsecure() failed\n");
+        return false;
     }
-
     return true;
 }
 
 bool CTxLockVote::Sign()
 {
-    std::string strError;
-
-    if (deterministicMNManager->IsDIP3Active()) {
-        uint256 hash = GetSignatureHash();
 
-        CBLSSignature sig = activeMasternodeInfo.blsKeyOperator->Sign(hash);
-        if (!sig.IsValid()) {
-            return false;
-        }
-        sig.GetBuf(vchMasternodeSignature);
-    } else if (sporkManager.IsSporkActive(SPORK_6_NEW_SIGS)) {
-        uint256 hash = GetSignatureHash();
-
-        if (!CHashSigner::SignHash(hash, activeMasternodeInfo.legacyKeyOperator, vchMasternodeSignature)) {
-            LogPrintf("CTxLockVote::Sign -- SignHash() failed\n");
-            return false;
-        }
-
-        if (!CHashSigner::VerifyHash(hash, activeMasternodeInfo.legacyKeyIDOperator, vchMasternodeSignature, strError)) {
-            LogPrintf("CTxLockVote::Sign -- VerifyHash() failed, error: %s\n", strError);
-            return false;
-        }
-    } else {
-        std::string strMessage = txHash.ToString() + outpoint.ToStringShort();
-
-        if (!CMessageSigner::SignMessage(strMessage, vchMasternodeSignature, activeMasternodeInfo.legacyKeyOperator)) {
-            LogPrintf("CTxLockVote::Sign -- SignMessage() failed\n");
-            return false;
-        }
+    uint256 hash = GetSignatureHash();
 
-        if (!CMessageSigner::VerifyMessage(activeMasternodeInfo.legacyKeyIDOperator, vchMasternodeSignature, strMessage, strError)) {
-            LogPrintf("CTxLockVote::Sign -- VerifyMessage() failed, error: %s\n", strError);
-            return false;
-        }
+    CBLSSignature sig = activeMasternodeInfo.blsKeyOperator->Sign(hash);
+    if (!sig.IsValid()) {
+        return false;
     }
-
+    sig.GetBuf(vchMasternodeSignature);
     return true;
 }