feat!: BLS scheme upgrade

src/bls/bls.h

@@ -99,7 +99,6 @@ class CBLSWrapper
         *(static_cast<C*>(this)) = C();
     }
 
-    //TODO: Overwrite function with default value of specificLegacyScheme
     void SetByteVector(const std::vector<uint8_t>& vecBytes, const bool specificLegacyScheme)
     {
         if (vecBytes.size() != SerSize) {
@@ -125,7 +124,6 @@ class CBLSWrapper
         SetByteVector(vecBytes, bls::bls_legacy_scheme.load());
     }
 
-    //TODO: Overwrite function with default value of specificLegacyScheme
     std::vector<uint8_t> ToByteVector(const bool specificLegacyScheme) const
     {
         if (!fValid) {
@@ -147,8 +145,7 @@ class CBLSWrapper
         return cachedHash;
     }
 
-    //TODO: Add version with argument (bool specificLegacyScheme)
-    bool SetHexStr(const std::string& str)
+    bool SetHexStr(const std::string& str, const bool specificLegacyScheme)
     {
         if (!IsHex(str)) {
             Reset();
@@ -159,16 +156,20 @@ class CBLSWrapper
             Reset();
             return false;
         }
-        SetByteVector(b);
+        SetByteVector(b, specificLegacyScheme);
         return IsValid();
     }
 
+    bool SetHexStr(const std::string& str)
+    {
+        return SetHexStr(str, bls::bls_legacy_scheme.load());
+    }
+
     inline void Serialize(CSizeComputer& s) const
     {
         s.seek(SerSize);
     }
 
-    //TODO: Overwrite function with default value of specificLegacyScheme
     template <typename Stream>
     inline void Serialize(Stream& s, const bool specificLegacyScheme) const
     {
@@ -181,15 +182,14 @@ class CBLSWrapper
         Serialize(s, bls::bls_legacy_scheme.load());
     }
 
-    //TODO: Overwrite function with default value of specificLegacyScheme
     template <typename Stream>
     inline void Unserialize(Stream& s, const bool specificLegacyScheme, bool checkMalleable = true)
     {
         std::vector<uint8_t> vecBytes(SerSize, 0);
         s.read(reinterpret_cast<char*>(vecBytes.data()), SerSize);
         SetByteVector(vecBytes, specificLegacyScheme);
 
-        if (checkMalleable && !CheckMalleable(vecBytes)) {
+        if (checkMalleable && !CheckMalleable(vecBytes, specificLegacyScheme)) {
             throw std::ios_base::failure("malleable BLS object");
         }
     }
@@ -200,7 +200,6 @@ class CBLSWrapper
         Unserialize(s, bls::bls_legacy_scheme.load(), checkMalleable);
     }
 
-    //TODO: Overwrite function with default value of specificLegacyScheme
     inline bool CheckMalleable(const std::vector<uint8_t>& vecBytes, const bool specificLegacyScheme) const
     {
         if (memcmp(vecBytes.data(), ToByteVector(specificLegacyScheme).data(), SerSize)) {
@@ -305,6 +304,44 @@ class CBLSPublicKey : public CBLSWrapper<bls::G1Element, BLS_CURVE_PUBKEY_SIZE,
 
 };
 
+class ConstCBLSPublicKeyVersionWrapper {
+private:
+    bool legacy;
+    bool checkMalleable;
+    const CBLSPublicKey& obj;
+public:
+    ConstCBLSPublicKeyVersionWrapper(const CBLSPublicKey& obj, bool legacy, bool checkMalleable = true)
+            : obj(obj)
+            , legacy(legacy)
+            , checkMalleable(checkMalleable)
+    {}
+    template <typename Stream>
+    inline void Serialize(Stream& s) const {
+        obj.Serialize(s, legacy);
+    }
+};
+
+class CBLSPublicKeyVersionWrapper {
+private:
+    bool legacy;
+    bool checkMalleable;
+    CBLSPublicKey& obj;
+public:
+    CBLSPublicKeyVersionWrapper(CBLSPublicKey& obj, bool legacy, bool checkMalleable = true)
+            : obj(obj)
+            , legacy(legacy)
+            , checkMalleable(checkMalleable)
+    {}
+    template <typename Stream>
+    inline void Serialize(Stream& s) const {
+        obj.Serialize(s, legacy);
+    }
+    template <typename Stream>
+    inline void Unserialize(Stream& s) {
+        obj.Unserialize(s, legacy, checkMalleable);
+    }
+};
+
 class CBLSSignature : public CBLSWrapper<bls::G2Element, BLS_CURVE_SIG_SIZE, CBLSSignature>
 {
     friend class CBLSSecretKey;
@@ -332,6 +369,27 @@ class CBLSSignature : public CBLSWrapper<bls::G2Element, BLS_CURVE_SIG_SIZE, CBL
     bool Recover(const std::vector<CBLSSignature>& sigs, const std::vector<CBLSId>& ids);
 };
 
+class CBLSSignatureVersionWrapper {
+private:
+    bool legacy;
+    bool checkMalleable;
+    CBLSSignature& obj;
+public:
+    CBLSSignatureVersionWrapper(CBLSSignature& obj, bool legacy, bool checkMalleable = true)
+            : obj(obj)
+            , legacy(legacy)
+            , checkMalleable(checkMalleable)
+    {}
+    template <typename Stream>
+    inline void Serialize(Stream& s) const {
+        obj.Serialize(s, legacy);
+    }
+    template <typename Stream>
+    inline void Unserialize(Stream& s, bool checkMalleable = true) {
+        obj.Unserialize(s, legacy, checkMalleable);
+    }
+};
+
 #ifndef BUILD_BITCOIN_INTERNAL
 template<typename BLSObject>
 class CBLSLazyWrapper
@@ -341,6 +399,7 @@ class CBLSLazyWrapper
 
     mutable std::vector<uint8_t> vecBytes;
     mutable bool bufValid{false};
+    mutable bool bufLegacyScheme{true};
 
     mutable BLSObject obj;
     mutable bool objInitialized{false};
@@ -349,7 +408,8 @@ class CBLSLazyWrapper
 
 public:
     CBLSLazyWrapper() :
-        vecBytes(BLSObject::SerSize, 0)
+            vecBytes(BLSObject::SerSize, 0),
+            bufLegacyScheme(bls::bls_legacy_scheme.load())
     {
         // the all-zero buf is considered a valid buf, but the resulting object will return false for IsValid
         bufValid = true;
@@ -365,6 +425,7 @@ class CBLSLazyWrapper
     {
         std::unique_lock<std::mutex> l(r.mutex);
         bufValid = r.bufValid;
+        bufLegacyScheme = r.bufLegacyScheme;
         if (r.bufValid) {
             vecBytes = r.vecBytes;
         } else {
@@ -386,30 +447,47 @@ class CBLSLazyWrapper
     }
 
     template<typename Stream>
-    inline void Serialize(Stream& s) const
+    inline void Serialize(Stream& s, const bool specificLegacyScheme) const
     {
         std::unique_lock<std::mutex> l(mutex);
         if (!objInitialized && !bufValid) {
-            throw std::ios_base::failure("obj and buf not initialized");
+            // the all-zero buf is considered a valid buf
+            std::fill(vecBytes.begin(), vecBytes.end(), 0);
+            bufLegacyScheme = specificLegacyScheme;
+            bufValid = true;
         }
-        if (!bufValid) {
-            vecBytes = obj.ToByteVector();
+        if (!bufValid || (bufLegacyScheme != specificLegacyScheme)) {
+            vecBytes = obj.ToByteVector(specificLegacyScheme);
             bufValid = true;
+            bufLegacyScheme = specificLegacyScheme;
             hash.SetNull();
         }
         s.write(reinterpret_cast<const char*>(vecBytes.data()), vecBytes.size());
     }
 
     template<typename Stream>
-    inline void Unserialize(Stream& s)
+    inline void Serialize(Stream& s) const
+    {
+        Serialize(s, bls::bls_legacy_scheme.load());
+    }
+
+    template<typename Stream>
+    inline void Unserialize(Stream& s, const bool specificLegacyScheme) const
     {
         std::unique_lock<std::mutex> l(mutex);
         s.read(reinterpret_cast<char*>(vecBytes.data()), BLSObject::SerSize);
         bufValid = true;
+        bufLegacyScheme = specificLegacyScheme;
         objInitialized = false;
         hash.SetNull();
     }
 
+    template<typename Stream>
+    inline void Unserialize(Stream& s) const
+    {
+        Unserialize(s, bls::bls_legacy_scheme.load());
+    }
+
     void Set(const BLSObject& _obj)
     {
         std::unique_lock<std::mutex> l(mutex);
@@ -426,8 +504,17 @@ class CBLSLazyWrapper
             return invalidObj;
         }
         if (!objInitialized) {
-            obj.SetByteVector(vecBytes);
-            if (!obj.CheckMalleable(vecBytes)) {
+            obj.SetByteVector(vecBytes, bufLegacyScheme);
+            if (!obj.IsValid()) {
+                // If setting of BLS object using one scheme failed, then we need to attempt again with the opposite scheme.
+                // This is due to the fact that LazyBLSWrapper receives a serialised buffer but attempts to create actual BLS object when needed.
+                // That could happen when the fork has been activated and the enforced scheme has switched.
+                obj.SetByteVector(vecBytes, !bufLegacyScheme);
+                if (obj.IsValid()) {
+                    bufLegacyScheme = !bufLegacyScheme;
+                }
+            }
+            if (!obj.CheckMalleable(vecBytes, bufLegacyScheme)) {
                 bufValid = false;
                 objInitialized = false;
                 obj = invalidObj;
@@ -440,7 +527,7 @@ class CBLSLazyWrapper
 
     bool operator==(const CBLSLazyWrapper& r) const
     {
-        if (bufValid && r.bufValid) {
+        if (bufValid && r.bufValid && bufLegacyScheme == r.bufLegacyScheme) {
             return vecBytes == r.vecBytes;
         }
         if (objInitialized && r.objInitialized) {
@@ -454,12 +541,13 @@ class CBLSLazyWrapper
         return !(*this == r);
     }
 
-    uint256 GetHash() const
+    uint256 GetHash(const bool specificLegacyScheme = bls::bls_legacy_scheme.load()) const
     {
         std::unique_lock<std::mutex> l(mutex);
-        if (!bufValid) {
-            vecBytes = obj.ToByteVector();
+        if (!bufValid || bufLegacyScheme != specificLegacyScheme) {
+            vecBytes = obj.ToByteVector(specificLegacyScheme);
             bufValid = true;
+            bufLegacyScheme = specificLegacyScheme;
             hash.SetNull();
         }
         if (hash.IsNull()) {
@@ -472,6 +560,25 @@ class CBLSLazyWrapper
 };
 using CBLSLazySignature = CBLSLazyWrapper<CBLSSignature>;
 using CBLSLazyPublicKey = CBLSLazyWrapper<CBLSPublicKey>;
+
+class CBLSLazyPublicKeyVersionWrapper {
+private:
+    bool legacy;
+    CBLSLazyPublicKey& obj;
+public:
+    CBLSLazyPublicKeyVersionWrapper(CBLSLazyPublicKey& obj, bool legacy)
+            : obj(obj)
+            , legacy(legacy)
+    {}
+    template <typename Stream>
+    inline void Serialize(Stream& s) const {
+        obj.Serialize(s, legacy);
+    }
+    template <typename Stream>
+    inline void Unserialize(Stream& s) {
+        obj.Unserialize(s, legacy);
+    }
+};
 #endif
 
 using BLSIdVector = std::vector<CBLSId>;

src/coinjoin/coinjoin.cpp

@@ -10,6 +10,7 @@
 #include <consensus/validation.h>
 #include <llmq/chainlocks.h>
 #include <llmq/instantsend.h>
+#include <llmq/utils.h>
 #include <masternode/node.h>
 #include <masternode/sync.h>
 #include <messagesigner.h>
@@ -55,7 +56,8 @@ bool CCoinJoinQueue::Sign()
     if (!sig.IsValid()) {
         return false;
     }
-    vchSig = sig.ToByteVector();
+    bool legacy_bls_scheme = !llmq::utils::IsV19Active(::ChainActive().Tip());
+    vchSig = sig.ToByteVector(legacy_bls_scheme);
 
     return true;
 }
@@ -97,12 +99,12 @@ bool CCoinJoinBroadcastTx::Sign()
     if (!fMasternodeMode) return false;
 
     uint256 hash = GetSignatureHash();
-
     CBLSSignature sig = WITH_LOCK(activeMasternodeInfoCs, return activeMasternodeInfo.blsKeyOperator->Sign(hash));
     if (!sig.IsValid()) {
         return false;
     }
-    vchSig = sig.ToByteVector();
+    bool legacy_bls_scheme = !llmq::utils::IsV19Active(::ChainActive().Tip());
+    vchSig = sig.ToByteVector(legacy_bls_scheme);
 
     return true;
 }

src/evo/deterministicmns.cpp

@@ -354,14 +354,19 @@ CSimplifiedMNListDiff CDeterministicMNList::BuildSimplifiedDiff(const CDetermini
     CSimplifiedMNListDiff diffRet;
     diffRet.baseBlockHash = blockHash;
     diffRet.blockHash = to.blockHash;
+    diffRet.nVersion = llmq::utils::IsV19Active(::ChainActive().Tip()) ? CSimplifiedMNListDiff::BASIC_BLS_VERSION : CSimplifiedMNListDiff::LEGACY_BLS_VERSION;
 
     to.ForEachMN(false, [&](auto& toPtr) {
         auto fromPtr = GetMN(toPtr.proTxHash);
         if (fromPtr == nullptr) {
+            CSimplifiedMNListEntry sme(toPtr);
+            sme.nVersion = diffRet.nVersion;
             diffRet.mnList.emplace_back(toPtr);
         } else {
             CSimplifiedMNListEntry sme1(toPtr);
             CSimplifiedMNListEntry sme2(*fromPtr);
+            sme1.nVersion = diffRet.nVersion;
+            sme2.nVersion = diffRet.nVersion;
             if (sme1 != sme2) {
                 diffRet.mnList.emplace_back(toPtr);
             } else if (extended && (sme1.scriptPayout != sme2.scriptPayout || sme1.scriptOperatorPayout != sme2.scriptOperatorPayout)) {
@@ -1136,7 +1141,7 @@ bool CheckProRegTx(const CTransaction& tx, const CBlockIndex* pindexPrev, CValid
         return state.Invalid(ValidationInvalidReason::CONSENSUS, false, REJECT_INVALID, "bad-protx-payload");
     }
 
-    if (auto maybe_err = ptx.IsTriviallyValid(); maybe_err.did_err) {
+    if (auto maybe_err = ptx.IsTriviallyValid(llmq::utils::IsV19Active(pindexPrev)); maybe_err.did_err) {
         return state.Invalid(maybe_err.reason, false, REJECT_INVALID, std::string(maybe_err.error_str));
     }
 
@@ -1241,7 +1246,7 @@ bool CheckProUpServTx(const CTransaction& tx, const CBlockIndex* pindexPrev, CVa
         return state.Invalid(ValidationInvalidReason::CONSENSUS, false, REJECT_INVALID, "bad-protx-payload");
     }
 
-    if (auto maybe_err = ptx.IsTriviallyValid(); maybe_err.did_err) {
+    if (auto maybe_err = ptx.IsTriviallyValid(llmq::utils::IsV19Active(pindexPrev)); maybe_err.did_err) {
         return state.Invalid(maybe_err.reason, false, REJECT_INVALID, std::string(maybe_err.error_str));
     }
 
@@ -1296,7 +1301,7 @@ bool CheckProUpRegTx(const CTransaction& tx, const CBlockIndex* pindexPrev, CVal
         return state.Invalid(ValidationInvalidReason::CONSENSUS, false, REJECT_INVALID, "bad-protx-payload");
     }
 
-    if (auto maybe_err = ptx.IsTriviallyValid(); maybe_err.did_err) {
+    if (auto maybe_err = ptx.IsTriviallyValid(llmq::utils::IsV19Active(pindexPrev)); maybe_err.did_err) {
         return state.Invalid(maybe_err.reason, false, REJECT_INVALID, std::string(maybe_err.error_str));
     }
 
@@ -1369,7 +1374,7 @@ bool CheckProUpRevTx(const CTransaction& tx, const CBlockIndex* pindexPrev, CVal
         return state.Invalid(ValidationInvalidReason::CONSENSUS, false, REJECT_INVALID, "bad-protx-payload");
     }
 
-    if (auto maybe_err = ptx.IsTriviallyValid(); maybe_err.did_err) {
+    if (auto maybe_err = ptx.IsTriviallyValid(llmq::utils::IsV19Active(pindexPrev)); maybe_err.did_err) {
         return state.Invalid(maybe_err.reason, false, REJECT_INVALID, std::string(maybe_err.error_str));
     }