Multiple speed optimizations for deterministic MN list handling (#2972)

* Generalize CBLSLazyWrapper so that it can be used of pubkeys and secret keys

* Implement == and != operators for CBLSLazyWrapper

* Implement cached hash for CBLSLazyWrapper

* Use CBLSLazyPublicKey for CDeterministicMNState::pubKeyOperator

* Speed up GetProjectedMNPayees by sorting the MN list by last paid

Instead of updating a temporary list for each projected height and calling
GetMNPayee() on it.

* Cache intermediate lists in GetListForBlock

This avoids re-loading and applying diffs again and again.

* Only update masternode list UI max once every 3 seconds

This avoids updating the UI on every block, which turned out to be very
expensive.

* Fix compilation

* Drop time restrictions for mn list update in ClientModel

They are fully handled by MasternodeList now.

Author: codablock

src/bls/bls.cpp

@@ -424,33 +424,6 @@ bool CBLSSignature::Recover(const std::vector<CBLSSignature>& sigs, const std::v
 }
 
 #ifndef BUILD_BITCOIN_INTERNAL
-void CBLSLazySignature::SetSig(const CBLSSignature& _sig)
-{
-    std::unique_lock<std::mutex> l(mutex);
-    bufValid = false;
-    sigInitialized = true;
-    sig = _sig;
-}
-
-const CBLSSignature& CBLSLazySignature::GetSig() const
-{
-    std::unique_lock<std::mutex> l(mutex);
-    static CBLSSignature invalidSig;
-    if (!bufValid && !sigInitialized) {
-        return invalidSig;
-    }
-    if (!sigInitialized) {
-        sig.SetBuf(buf, sizeof(buf));
-        if (!sig.CheckMalleable(buf, sizeof(buf))) {
-            bufValid = false;
-            sigInitialized = false;
-            sig = invalidSig;
-        } else {
-            sigInitialized = true;
-        }
-    }
-    return sig;
-}
 
 static std::once_flag init_flag;
 static mt_pooled_secure_allocator<uint8_t>* secure_allocator_instance;

src/bls/bls.h

@@ -310,29 +310,34 @@ class CBLSSignature : public CBLSWrapper<bls::InsecureSignature, BLS_CURVE_SIG_S
 };
 
 #ifndef BUILD_BITCOIN_INTERNAL
-class CBLSLazySignature
+template<typename BLSObject>
+class CBLSLazyWrapper
 {
 private:
     mutable std::mutex mutex;
 
-    mutable char buf[BLS_CURVE_SIG_SIZE];
+    mutable char buf[BLSObject::SerSize];
     mutable bool bufValid{false};
 
-    mutable CBLSSignature sig;
-    mutable bool sigInitialized{false};
+    mutable BLSObject obj;
+    mutable bool objInitialized{false};
+
+    mutable uint256 hash;
 
 public:
-    CBLSLazySignature()
+    CBLSLazyWrapper()
     {
         memset(buf, 0, sizeof(buf));
+        // the all-zero buf is considered a valid buf, but the resulting object will return false for IsValid
+        bufValid = true;
     }
 
-    CBLSLazySignature(const CBLSLazySignature& r)
+    CBLSLazyWrapper(const CBLSLazyWrapper& r)
     {
         *this = r;
     }
 
-    CBLSLazySignature& operator=(const CBLSLazySignature& r)
+    CBLSLazyWrapper& operator=(const CBLSLazyWrapper& r)
     {
         std::unique_lock<std::mutex> l(r.mutex);
         bufValid = r.bufValid;
@@ -341,25 +346,27 @@ class CBLSLazySignature
         } else {
             memset(buf, 0, sizeof(buf));
         }
-        sigInitialized = r.sigInitialized;
-        if (r.sigInitialized) {
-            sig = r.sig;
+        objInitialized = r.objInitialized;
+        if (r.objInitialized) {
+            obj = r.obj;
         } else {
-            sig.Reset();
+            obj.Reset();
         }
+        hash = r.hash;
         return *this;
     }
 
     template<typename Stream>
     inline void Serialize(Stream& s) const
     {
         std::unique_lock<std::mutex> l(mutex);
-        if (!sigInitialized && !bufValid) {
-            throw std::ios_base::failure("sig and buf not initialized");
+        if (!objInitialized && !bufValid) {
+            throw std::ios_base::failure("obj and buf not initialized");
         }
         if (!bufValid) {
-            sig.GetBuf(buf, sizeof(buf));
+            obj.GetBuf(buf, sizeof(buf));
             bufValid = true;
+            hash = uint256();
         }
         s.write(buf, sizeof(buf));
     }
@@ -370,12 +377,78 @@ class CBLSLazySignature
         std::unique_lock<std::mutex> l(mutex);
         s.read(buf, sizeof(buf));
         bufValid = true;
-        sigInitialized = false;
+        objInitialized = false;
+        hash = uint256();
+    }
+
+    void Set(const BLSObject& _obj)
+    {
+        std::unique_lock<std::mutex> l(mutex);
+        bufValid = false;
+        objInitialized = true;
+        obj = _obj;
+        hash = uint256();
+    }
+    const BLSObject& Get() const
+    {
+        std::unique_lock<std::mutex> l(mutex);
+        static BLSObject invalidObj;
+        if (!bufValid && !objInitialized) {
+            return invalidObj;
+        }
+        if (!objInitialized) {
+            obj.SetBuf(buf, sizeof(buf));
+            if (!obj.CheckMalleable(buf, sizeof(buf))) {
+                bufValid = false;
+                objInitialized = false;
+                obj = invalidObj;
+            } else {
+                objInitialized = true;
+            }
+        }
+        return obj;
     }
 
-    void SetSig(const CBLSSignature& _sig);
-    const CBLSSignature& GetSig() const;
+    bool operator==(const CBLSLazyWrapper& r) const
+    {
+        if (bufValid && r.bufValid) {
+            return memcmp(buf, r.buf, sizeof(buf)) == 0;
+        }
+        if (objInitialized && r.objInitialized) {
+            return obj == r.obj;
+        }
+        return Get() == r.Get();
+    }
+
+    bool operator!=(const CBLSLazyWrapper& r) const
+    {
+        return !(*this == r);
+    }
+
+    uint256 GetHash() const
+    {
+        std::unique_lock<std::mutex> l(mutex);
+        if (!bufValid) {
+            obj.GetBuf(buf, sizeof(buf));
+            bufValid = true;
+            hash = uint256();
+        }
+        if (hash.IsNull()) {
+            UpdateHash();
+        }
+        return hash;
+    }
+private:
+    void UpdateHash() const
+    {
+        CHashWriter ss(SER_GETHASH, PROTOCOL_VERSION);
+        ss.write(buf, sizeof(buf));
+        hash = ss.GetHash();
+    }
 };
+typedef CBLSLazyWrapper<CBLSSignature> CBLSLazySignature;
+typedef CBLSLazyWrapper<CBLSPublicKey> CBLSLazyPublicKey;
+typedef CBLSLazyWrapper<CBLSSecretKey> CBLSLazySecretKey;
 #endif
 
 typedef std::vector<CBLSId> BLSIdVector;

src/evo/deterministicmns.cpp

@@ -38,7 +38,7 @@ std::string CDeterministicMNState::ToString() const
     return strprintf("CDeterministicMNState(nRegisteredHeight=%d, nLastPaidHeight=%d, nPoSePenalty=%d, nPoSeRevivedHeight=%d, nPoSeBanHeight=%d, nRevocationReason=%d, "
         "ownerAddress=%s, pubKeyOperator=%s, votingAddress=%s, addr=%s, payoutAddress=%s, operatorPayoutAddress=%s)",
         nRegisteredHeight, nLastPaidHeight, nPoSePenalty, nPoSeRevivedHeight, nPoSeBanHeight, nRevocationReason,
-        CBitcoinAddress(keyIDOwner).ToString(), pubKeyOperator.ToString(), CBitcoinAddress(keyIDVoting).ToString(), addr.ToStringIPPort(false), payoutAddress, operatorPayoutAddress);
+        CBitcoinAddress(keyIDOwner).ToString(), pubKeyOperator.Get().ToString(), CBitcoinAddress(keyIDVoting).ToString(), addr.ToStringIPPort(false), payoutAddress, operatorPayoutAddress);
 }
 
 void CDeterministicMNState::ToJson(UniValue& obj) const
@@ -60,7 +60,7 @@ void CDeterministicMNState::ToJson(UniValue& obj) const
         CBitcoinAddress payoutAddress(dest);
         obj.push_back(Pair("payoutAddress", payoutAddress.ToString()));
     }
-    obj.push_back(Pair("pubKeyOperator", pubKeyOperator.ToString()));
+    obj.push_back(Pair("pubKeyOperator", pubKeyOperator.Get().ToString()));
     if (ExtractDestination(scriptOperatorPayout, dest)) {
         CBitcoinAddress operatorPayoutAddress(dest);
         obj.push_back(Pair("operatorPayoutAddress", operatorPayoutAddress.ToString()));
@@ -147,7 +147,7 @@ CDeterministicMNCPtr CDeterministicMNList::GetValidMN(const uint256& proTxHash)
 CDeterministicMNCPtr CDeterministicMNList::GetMNByOperatorKey(const CBLSPublicKey& pubKey)
 {
     for (const auto& p : mnMap) {
-        if (p.second->pdmnState->pubKeyOperator == pubKey) {
+        if (p.second->pdmnState->pubKeyOperator.Get() == pubKey) {
             return p.second;
         }
     }
@@ -217,21 +217,21 @@ CDeterministicMNCPtr CDeterministicMNList::GetMNPayee() const
 
 std::vector<CDeterministicMNCPtr> CDeterministicMNList::GetProjectedMNPayees(int nCount) const
 {
+    if (nCount > GetValidMNsCount()) {
+        nCount = GetValidMNsCount();
+    }
+
     std::vector<CDeterministicMNCPtr> result;
     result.reserve(nCount);
 
-    CDeterministicMNList tmpMNList = *this;
-    for (int h = nHeight; h < nHeight + nCount; h++) {
-        tmpMNList.SetHeight(h);
-
-        CDeterministicMNCPtr payee = tmpMNList.GetMNPayee();
-        // push the original MN object instead of the one from the temporary list
-        result.push_back(GetMN(payee->proTxHash));
+    ForEachMN(true, [&](const CDeterministicMNCPtr& dmn) {
+        result.emplace_back(dmn);
+    });
+    std::sort(result.begin(), result.end(), [&](const CDeterministicMNCPtr& a, const CDeterministicMNCPtr& b) {
+        return CompareByLastPaid(a, b);
+    });
 
-        CDeterministicMNStatePtr newState = std::make_shared<CDeterministicMNState>(*payee->pdmnState);
-        newState->nLastPaidHeight = h;
-        tmpMNList.UpdateMN(payee->proTxHash, newState);
-    }
+    result.resize(nCount);
 
     return result;
 }
@@ -420,7 +420,7 @@ void CDeterministicMNList::AddMN(const CDeterministicMNCPtr& dmn)
         AddUniqueProperty(dmn, dmn->pdmnState->addr);
     }
     AddUniqueProperty(dmn, dmn->pdmnState->keyIDOwner);
-    if (dmn->pdmnState->pubKeyOperator.IsValid()) {
+    if (dmn->pdmnState->pubKeyOperator.Get().IsValid()) {
         AddUniqueProperty(dmn, dmn->pdmnState->pubKeyOperator);
     }
 }
@@ -448,7 +448,7 @@ void CDeterministicMNList::RemoveMN(const uint256& proTxHash)
         DeleteUniqueProperty(dmn, dmn->pdmnState->addr);
     }
     DeleteUniqueProperty(dmn, dmn->pdmnState->keyIDOwner);
-    if (dmn->pdmnState->pubKeyOperator.IsValid()) {
+    if (dmn->pdmnState->pubKeyOperator.Get().IsValid()) {
         DeleteUniqueProperty(dmn, dmn->pdmnState->pubKeyOperator);
     }
     mnMap = mnMap.erase(proTxHash);
@@ -692,7 +692,7 @@ bool CDeterministicMNManager::BuildNewListFromBlock(const CBlock& block, const C
 
             if (newState->nPoSeBanHeight != -1) {
                 // only revive when all keys are set
-                if (newState->pubKeyOperator.IsValid() && !newState->keyIDVoting.IsNull() && !newState->keyIDOwner.IsNull()) {
+                if (newState->pubKeyOperator.Get().IsValid() && !newState->keyIDVoting.IsNull() && !newState->keyIDOwner.IsNull()) {
                     newState->nPoSePenalty = 0;
                     newState->nPoSeBanHeight = -1;
                     newState->nPoSeRevivedHeight = nHeight;
@@ -720,12 +720,12 @@ bool CDeterministicMNManager::BuildNewListFromBlock(const CBlock& block, const C
                 return _state.DoS(100, false, REJECT_INVALID, "bad-protx-hash");
             }
             auto newState = std::make_shared<CDeterministicMNState>(*dmn->pdmnState);
-            if (newState->pubKeyOperator != proTx.pubKeyOperator) {
+            if (newState->pubKeyOperator.Get() != proTx.pubKeyOperator) {
                 // reset all operator related fields and put MN into PoSe-banned state in case the operator key changes
                 newState->ResetOperatorFields();
                 newState->BanIfNotBanned(nHeight);
             }
-            newState->pubKeyOperator = proTx.pubKeyOperator;
+            newState->pubKeyOperator.Set(proTx.pubKeyOperator);
             newState->keyIDVoting = proTx.keyIDVoting;
             newState->scriptPayout = proTx.scriptPayout;
 
@@ -857,12 +857,14 @@ CDeterministicMNList CDeterministicMNManager::GetListForBlock(const uint256& blo
         }
 
         if (evoDb.Read(std::make_pair(DB_LIST_SNAPSHOT, blockHashTmp), snapshot)) {
+            mnListsCache.emplace(blockHashTmp, snapshot);
             break;
         }
 
         CDeterministicMNListDiff diff;
         if (!evoDb.Read(std::make_pair(DB_LIST_DIFF, blockHashTmp), diff)) {
             snapshot = CDeterministicMNList(blockHashTmp, -1);
+            mnListsCache.emplace(blockHashTmp, snapshot);
             break;
         }
 
@@ -877,9 +879,10 @@ CDeterministicMNList CDeterministicMNManager::GetListForBlock(const uint256& blo
             snapshot.SetBlockHash(diff.blockHash);
             snapshot.SetHeight(diff.nHeight);
         }
+
+        mnListsCache.emplace(diff.blockHash, snapshot);
     }
 
-    mnListsCache.emplace(blockHash, snapshot);
     return snapshot;
 }
 

src/evo/deterministicmns.h

@@ -44,7 +44,7 @@ class CDeterministicMNState
     uint256 confirmedHashWithProRegTxHash;
 
     CKeyID keyIDOwner;
-    CBLSPublicKey pubKeyOperator;
+    CBLSLazyPublicKey pubKeyOperator;
     CKeyID keyIDVoting;
     CService addr;
     CScript scriptPayout;
@@ -55,7 +55,7 @@ class CDeterministicMNState
     CDeterministicMNState(const CProRegTx& proTx)
     {
         keyIDOwner = proTx.keyIDOwner;
-        pubKeyOperator = proTx.pubKeyOperator;
+        pubKeyOperator.Set(proTx.pubKeyOperator);
         keyIDVoting = proTx.keyIDVoting;
         addr = proTx.addr;
         scriptPayout = proTx.scriptPayout;
@@ -89,7 +89,7 @@ class CDeterministicMNState
 
     void ResetOperatorFields()
     {
-        pubKeyOperator = CBLSPublicKey();
+        pubKeyOperator.Set(CBLSPublicKey());
         addr = CService();
         scriptOperatorPayout = CScript();
         nRevocationReason = CProUpRevTx::REASON_NOT_SPECIFIED;

src/evo/mnauth.cpp

@@ -89,7 +89,7 @@ void CMNAuth::ProcessMessage(CNode* pnode, const std::string& strCommand, CDataS
             signHash = ::SerializeHash(std::make_tuple(dmn->pdmnState->pubKeyOperator, pnode->sentMNAuthChallenge, !pnode->fInbound));
         }
 
-        if (!mnauth.sig.VerifyInsecure(dmn->pdmnState->pubKeyOperator, signHash)) {
+        if (!mnauth.sig.VerifyInsecure(dmn->pdmnState->pubKeyOperator.Get(), signHash)) {
             LOCK(cs_main);
             // Same as above, MN seems to not know about his fate yet, so give him a chance to update. If this is a
             // malicious actor (DoSing us), we'll ban him soon.

src/evo/providertx.cpp

@@ -257,7 +257,7 @@ bool CheckProUpServTx(const CTransaction& tx, const CBlockIndex* pindexPrev, CVa
         if (!CheckInputsHash(tx, ptx, state)) {
             return false;
         }
-        if (!CheckHashSig(ptx, mn->pdmnState->pubKeyOperator, state)) {
+        if (!CheckHashSig(ptx, mn->pdmnState->pubKeyOperator.Get(), state)) {
             return false;
         }
     }
@@ -376,7 +376,7 @@ bool CheckProUpRevTx(const CTransaction& tx, const CBlockIndex* pindexPrev, CVal
 
         if (!CheckInputsHash(tx, ptx, state))
             return false;
-        if (!CheckHashSig(ptx, dmn->pdmnState->pubKeyOperator, state))
+        if (!CheckHashSig(ptx, dmn->pdmnState->pubKeyOperator.Get(), state))
             return false;
     }
 

src/evo/simplifiedmns.cpp

@@ -37,7 +37,7 @@ uint256 CSimplifiedMNListEntry::CalcHash() const
 std::string CSimplifiedMNListEntry::ToString() const
 {
     return strprintf("CSimplifiedMNListEntry(proRegTxHash=%s, confirmedHash=%s, service=%s, pubKeyOperator=%s, votingAddress=%s, isValid=%d)",
-        proRegTxHash.ToString(), confirmedHash.ToString(), service.ToString(false), pubKeyOperator.ToString(), CBitcoinAddress(keyIDVoting).ToString(), isValid);
+        proRegTxHash.ToString(), confirmedHash.ToString(), service.ToString(false), pubKeyOperator.Get().ToString(), CBitcoinAddress(keyIDVoting).ToString(), isValid);
 }
 
 void CSimplifiedMNListEntry::ToJson(UniValue& obj) const
@@ -47,7 +47,7 @@ void CSimplifiedMNListEntry::ToJson(UniValue& obj) const
     obj.push_back(Pair("proRegTxHash", proRegTxHash.ToString()));
     obj.push_back(Pair("confirmedHash", confirmedHash.ToString()));
     obj.push_back(Pair("service", service.ToString(false)));
-    obj.push_back(Pair("pubKeyOperator", pubKeyOperator.ToString()));
+    obj.push_back(Pair("pubKeyOperator", pubKeyOperator.Get().ToString()));
     obj.push_back(Pair("votingAddress", CBitcoinAddress(keyIDVoting).ToString()));
     obj.push_back(Pair("isValid", isValid));
 }