feat: implement Platform Ban PoSe DIP-0031

src/evo/deterministicmns.cpp

@@ -9,12 +9,13 @@
 #include <evo/providertx.h>
 #include <evo/simplifiedmns.h>
 #include <evo/specialtx.h>
-#include <index/txindex.h>
 
 #include <chainparams.h>
 #include <coins.h>
 #include <consensus/validation.h>
 #include <deploymentstatus.h>
+#include <index/txindex.h>
+#include <masternode/meta.h>
 #include <messagesigner.h>
 #include <script/standard.h>
 #include <stats/client.h>
@@ -639,6 +640,23 @@ bool CDeterministicMNManager::ProcessBlock(const CBlock& block, gsl::not_null<co
         oldList = GetListForBlockInternal(pindex->pprev);
         diff = oldList.BuildDiff(newList);
 
+        // apply platform unban for platform revive too
+        for (int i = 1; i < (int)block.vtx.size(); i++) {
+            const CTransaction& tx = *block.vtx[i];
+            if (!tx.IsSpecialTxVersion() || tx.nType != TRANSACTION_PROVIDER_UPDATE_SERVICE) {
+                // only interested in revive transactions
+                continue;
+            }
+            const auto opt_proTx = GetTxPayload<CProUpServTx>(tx);
+            if (!opt_proTx) continue; // should not happen but does not matter
+
+            if (auto meta_info = m_mn_metaman.GetMetaInfo(opt_proTx->proTxHash, false);
+                !meta_info || !meta_info->SetPlatformBan(false, nHeight)) {
+                LogPrint(BCLog::LLMQ, "%s -- MN %s is failed to Platform revived at height %d\n", __func__,
+                         opt_proTx->proTxHash.ToString(), nHeight);
+            }
+        }
+
         m_evoDb.Write(std::make_pair(DB_LIST_DIFF, newList.GetBlockHash()), diff);
         if ((nHeight % DISK_SNAPSHOT_PERIOD) == 0 || pindex->pprev == m_initial_snapshot_index) {
             m_evoDb.Write(std::make_pair(DB_LIST_SNAPSHOT, newList.GetBlockHash()), newList);

src/evo/deterministicmns.h

@@ -32,6 +32,7 @@ class CCoinsViewCache;
 class CEvoDB;
 class CSimplifiedMNList;
 class CSimplifiedMNListEntry;
+class CMasternodeMetaMan;
 class TxValidationState;
 
 extern RecursiveMutex cs_main;
@@ -602,15 +603,17 @@ class CDeterministicMNManager
     std::atomic<int> to_cleanup {0};
 
     CEvoDB& m_evoDb;
+    CMasternodeMetaMan& m_mn_metaman;
 
     std::unordered_map<uint256, CDeterministicMNList, StaticSaltedHasher> mnListsCache GUARDED_BY(cs);
     std::unordered_map<uint256, CDeterministicMNListDiff, StaticSaltedHasher> mnListDiffsCache GUARDED_BY(cs);
     const CBlockIndex* tipIndex GUARDED_BY(cs) {nullptr};
     const CBlockIndex* m_initial_snapshot_index GUARDED_BY(cs) {nullptr};
 
 public:
-    explicit CDeterministicMNManager(CEvoDB& evoDb) :
-        m_evoDb(evoDb)
+    explicit CDeterministicMNManager(CEvoDB& evoDb, CMasternodeMetaMan& mn_metaman) :
+        m_evoDb(evoDb),
+        m_mn_metaman(mn_metaman)
     {
     }
     ~CDeterministicMNManager() = default;

src/llmq/dkgsession.cpp

@@ -492,11 +492,15 @@ void CDKGSession::VerifyConnectionAndMinProtoVersions(CConnman& connman) const
             m->badConnection = true;
             logger.Batch("%s does not have min proto version %d (has %d)", m->dmn->proTxHash.ToString(), MIN_MASTERNODE_PROTO_VERSION, it->second);
         }
-
-        if (m_mn_metaman.GetMetaInfo(m->dmn->proTxHash)->OutboundFailedTooManyTimes()) {
+        const auto meta_info = m_mn_metaman.GetMetaInfo(m->dmn->proTxHash);
+        if (meta_info->OutboundFailedTooManyTimes()) {
             m->badConnection = true;
             logger.Batch("%s failed to connect to it too many times", m->dmn->proTxHash.ToString());
         }
+        if (meta_info->IsPlatformBanned()) {
+            m->badConnection = true;
+            logger.Batch("%s is Platform PoSe banned", m->dmn->proTxHash.ToString());
+        }
     }
 }
 

src/masternode/meta.cpp

@@ -8,7 +8,7 @@
 #include <univalue.h>
 #include <util/time.h>
 
-const std::string MasternodeMetaStore::SERIALIZATION_VERSION_STRING = "CMasternodeMetaMan-Version-3";
+const std::string MasternodeMetaStore::SERIALIZATION_VERSION_STRING = "CMasternodeMetaMan-Version-4";
 
 CMasternodeMetaMan::CMasternodeMetaMan() :
     m_db{std::make_unique<db_type>("mncache.dat", "magicMasternodeCache")}
@@ -41,6 +41,11 @@ UniValue CMasternodeMetaInfo::ToJson() const
     ret.pushKV("lastOutboundAttemptElapsed", now - lastOutboundAttempt.load());
     ret.pushKV("lastOutboundSuccess", lastOutboundSuccess.load());
     ret.pushKV("lastOutboundSuccessElapsed", now - lastOutboundSuccess.load());
+    {
+        LOCK(cs);
+        ret.pushKV("is_platform_banned", m_platform_ban);
+        ret.pushKV("platform_ban_height_updated", m_platform_ban_updated);
+    }
 
     return ret;
 }
@@ -125,8 +130,33 @@ std::vector<uint256> CMasternodeMetaMan::GetAndClearDirtyGovernanceObjectHashes(
     return vecTmp;
 }
 
+bool CMasternodeMetaMan::AlreadyHavePlatformBan(const uint256& inv_hash) const
+{
+    LOCK(cs);
+    return m_seen_platform_bans.exists(inv_hash);
+}
+
+std::optional<PlatformBanMessage> CMasternodeMetaMan::GetPlatformBan(const uint256& inv_hash) const
+{
+    LOCK(cs);
+    PlatformBanMessage ret;
+    if (!m_seen_platform_bans.get(inv_hash, ret)) {
+        return std::nullopt;
+    }
+
+    return ret;
+}
+
+void CMasternodeMetaMan::RememberPlatformBan(const uint256& inv_hash, PlatformBanMessage&& msg)
+{
+    LOCK(cs);
+    m_seen_platform_bans.insert(inv_hash, std::move(msg));
+}
+
 std::string MasternodeMetaStore::ToString() const
 {
     LOCK(cs);
     return strprintf("Masternodes: meta infos object count: %d, nDsqCount: %d", metaInfos.size(), nDsqCount);
 }
+
+uint256 PlatformBanMessage::GetHash() const { return ::SerializeHash(*this); }

src/masternode/meta.h

@@ -5,14 +5,18 @@
 #ifndef BITCOIN_MASTERNODE_META_H
 #define BITCOIN_MASTERNODE_META_H
 
+#include <bls/bls.h>
+#include <saltedhasher.h>
 #include <serialize.h>
 #include <sync.h>
 #include <threadsafety.h>
 #include <uint256.h>
+#include <unordered_lru_cache.h>
 
 #include <atomic>
 #include <map>
 #include <memory>
+#include <optional>
 #include <vector>
 
 class CConnman;
@@ -46,6 +50,11 @@ class CMasternodeMetaInfo
     std::atomic<int64_t> lastOutboundAttempt{0};
     std::atomic<int64_t> lastOutboundSuccess{0};
 
+    //! bool flag is node currently under platform ban by p2p message
+    bool m_platform_ban GUARDED_BY(cs){false};
+    //! height at which platform ban has been applied or removed
+    int m_platform_ban_updated GUARDED_BY(cs){0};
+
 public:
     CMasternodeMetaInfo() = default;
     explicit CMasternodeMetaInfo(const uint256& _proTxHash) : proTxHash(_proTxHash) {}
@@ -55,22 +64,18 @@ class CMasternodeMetaInfo
         nMixingTxCount(ref.nMixingTxCount.load()),
         mapGovernanceObjectsVotedOn(ref.mapGovernanceObjectsVotedOn),
         lastOutboundAttempt(ref.lastOutboundAttempt.load()),
-        lastOutboundSuccess(ref.lastOutboundSuccess.load())
+        lastOutboundSuccess(ref.lastOutboundSuccess.load()),
+        m_platform_ban(ref.m_platform_ban),
+        m_platform_ban_updated(ref.m_platform_ban_updated)
     {
     }
 
     SERIALIZE_METHODS(CMasternodeMetaInfo, obj)
     {
         LOCK(obj.cs);
-        READWRITE(
-                obj.proTxHash,
-                obj.nLastDsq,
-                obj.nMixingTxCount,
-                obj.mapGovernanceObjectsVotedOn,
-                obj.outboundAttemptCount,
-                obj.lastOutboundAttempt,
-                obj.lastOutboundSuccess
-                );
+        READWRITE(obj.proTxHash, obj.nLastDsq, obj.nMixingTxCount, obj.mapGovernanceObjectsVotedOn,
+                  obj.outboundAttemptCount, obj.lastOutboundAttempt, obj.lastOutboundSuccess, obj.m_platform_ban,
+                  obj.m_platform_ban_updated);
     }
 
     UniValue ToJson() const;
@@ -96,6 +101,24 @@ class CMasternodeMetaInfo
     int64_t GetLastOutboundAttempt() const { return lastOutboundAttempt; }
     void SetLastOutboundSuccess(int64_t t) { lastOutboundSuccess = t; outboundAttemptCount = 0; }
     int64_t GetLastOutboundSuccess() const { return lastOutboundSuccess; }
+    bool SetPlatformBan(bool is_banned, int height)
+    {
+        LOCK(cs);
+        if (height <= m_platform_ban_updated) {
+            return false;
+        }
+        if (height == m_platform_ban_updated && !is_banned) {
+            return false;
+        }
+        m_platform_ban = is_banned;
+        m_platform_ban_updated = height;
+        return true;
+    }
+    bool IsPlatformBanned() const
+    {
+        LOCK(cs);
+        return m_platform_ban;
+    }
 };
 using CMasternodeMetaInfoPtr = std::shared_ptr<CMasternodeMetaInfo>;
 
@@ -150,6 +173,41 @@ class MasternodeMetaStore
     std::string ToString() const;
 };
 
+/**
+ * Platform PoSe Ban are result in the node voting against the targeted evonode in all future DKG sessions until that targeted
+ *evonode has been successfully banned. Platform will initiate this ban process by passing relevant information to Core using RPC. See DIP-0031
+ *
+ * We use 2 main classes to manage Platform PoSe Ban
+ *
+ * PlatformBanMessage
+ * CMasternodeMetaInfo - a higher-level construct which store extra (non-deterministic) information about masternodes including platform ban status
+ **/
+
+/**
+ * PlatformBanMessage - low-level constructs which present p2p message PlatformBan containing the protx hash, requested
+ * height to ban, and BLS data: quorum hash and bls signature
+ */
+class PlatformBanMessage
+{
+public:
+    uint256 m_protx_hash;
+    int32_t m_requested_height{0};
+    uint256 m_quorum_hash;
+    CBLSSignature m_signature;
+
+    PlatformBanMessage() = default;
+
+    SERIALIZE_METHODS(PlatformBanMessage, obj)
+    {
+        READWRITE(obj.m_protx_hash, obj.m_requested_height, obj.m_quorum_hash);
+        if (!(s.GetType() & SER_GETHASH)) {
+            READWRITE(CBLSSignatureVersionWrapper(const_cast<CBLSSignature&>(obj.m_signature), false));
+        }
+    }
+
+    uint256 GetHash() const;
+};
+
 class CMasternodeMetaMan : public MasternodeMetaStore
 {
 private:
@@ -161,6 +219,12 @@ class CMasternodeMetaMan : public MasternodeMetaStore
 
     std::vector<uint256> vecDirtyGovernanceObjectHashes GUARDED_BY(cs);
 
+    // equal to double of expected amount of all evo nodes, see DIP-0028
+    // it consumes no more than 1Mb of RAM but will cover extreme cases
+    static constexpr size_t SeenBanInventorySize = 900;
+    mutable unordered_lru_cache<uint256, PlatformBanMessage, StaticSaltedHasher> m_seen_platform_bans GUARDED_BY(cs){
+        SeenBanInventorySize};
+
 public:
     explicit CMasternodeMetaMan();
     ~CMasternodeMetaMan();
@@ -181,6 +245,10 @@ class CMasternodeMetaMan : public MasternodeMetaStore
     void RemoveGovernanceObject(const uint256& nGovernanceObjectHash);
 
     std::vector<uint256> GetAndClearDirtyGovernanceObjectHashes();
+
+    bool AlreadyHavePlatformBan(const uint256& inv_hash) const;
+    std::optional<PlatformBanMessage> GetPlatformBan(const uint256& inv_hash) const;
+    void RememberPlatformBan(const uint256& inv_hash, PlatformBanMessage&& msg);
 };
 
 #endif // BITCOIN_MASTERNODE_META_H