feat: isolate Evo state per chainstate while an AssumeUTXO snapshot is active

doc/release-notes-7887.md

@@ -0,0 +1,39 @@
+Updated RPCs
+------------
+
+- An RPC that fails with an error because this node cannot read the
+  masternode, quorum or other Evo state it needs, for example because the
+  block data it is derived from was pruned, now returns error code
+  `RPC_INTERNAL_ERROR` (-32603) instead of `RPC_MISC_ERROR` (-1). The request
+  was not at fault. The package RPCs report such a failure as described
+  below. (#7887)
+
+- `testmempoolaccept` with more than one transaction reports such a failure as
+  the `package-error` `evo-local-unavailable`, and `submitpackage` fails with
+  that reason. (#7887)
+
+Other changes
+-------------
+
+- A block this node has stored but cannot read back while deriving the credit
+  pool or the EHF signals no longer makes the block being validated invalid.
+  The node shuts down with a "Failed to read block" error instead, as it does
+  when it cannot read a block it is connecting. (#7887)
+
+- On a node without an assumeutxo snapshot, a warning about Evo state that
+  cannot be derived because block data was pruned now says so and suggests
+  restarting with `-reindex`. Startup still fails when the EHF signals at the
+  tip cannot be rebuilt. (#7887)
+
+- On a pruned node, a block whose masternode, quorum or other Evo state
+  depends on block data that was pruned is no longer marked invalid, which
+  left the node on a local fork until `reconsiderblock`. The node now stops
+  advancing at that block, logs an error and shows a warning that block data
+  was pruned; restart with `-reindex` to download it again. (#7887)
+
+- Developers: on regtest, every Evo database access must now be bound to a
+  chainstate's view (the hidden `-checkevobinding` option, on by default
+  there). A code path that reads Evo state without a binding fails with an
+  internal error, a dropped task or a stalled chainstate instead of reading
+  the default view. Local regtest networks run with it unless started with
+  `-checkevobinding=0`. (#7887)

src/Makefile.am

@@ -235,10 +235,13 @@ BITCOIN_CORE_H = \
   evo/simplifiedmns.h \
   evo/smldiff.h \
   evo/snapshot.h \
+  evo/snapshot_config.h \
+  evo/snapshot_types.h \
   evo/specialtx.h \
   evo/specialtx_filter.h \
   evo/specialtxman.h \
   evo/types.h \
+  evo/viewcache.h \
   external_signer.h \
   flat-database.h \
   flatfile.h \
@@ -570,6 +573,7 @@ libbitcoin_node_a_SOURCES = \
   evo/simplifiedmns.cpp \
   evo/smldiff.cpp \
   evo/snapshot.cpp \
+  evo/snapshot_config.cpp \
   evo/specialtx.cpp \
   evo/specialtx_filter.cpp \
   evo/specialtxman.cpp \
@@ -1312,6 +1316,7 @@ libdashkernel_la_SOURCES = \
   evo/providertx_util.cpp \
   evo/simplifiedmns.cpp \
   evo/smldiff.cpp \
+  evo/snapshot_config.cpp \
   evo/specialtx.cpp \
   evo/specialtx_filter.cpp \
   evo/specialtxman.cpp \

src/active/dkgsessionhandler.cpp

@@ -17,6 +17,8 @@
 #include <util/time.h>
 #include <validation.h>
 
+#include <utility>
+
 namespace llmq {
 ActiveDKGSessionHandler::ActiveDKGSessionHandler(
     CBLSWorker& bls_worker, CDeterministicMNManager& dmnman, CMasternodeMetaMan& mn_metaman,
@@ -114,8 +116,18 @@ void ActiveDKGSessionHandler::WaitForNextPhase(std::optional<QuorumPhase> curPha
 {
     LogPrint(BCLog::LLMQ_DKG, "ActiveDKGSessionHandler::%s -- %s qi[%d] - starting, curPhase=%d, nextPhase=%d\n", __func__, params.name, quorumIndex, curPhase.has_value() ? std23::to_underlying(*curPhase) : -1, std23::to_underlying(nextPhase));
 
+    bool logged_snapshot_wait{false};
     while (true) {
         if (m_chainman.IsSnapshotActiveAndUnvalidated()) {
+            if (!curPhase.has_value() && !stopRequested) {
+                // No round can start before background validation completes, so there is nothing to abort
+                if (!std::exchange(logged_snapshot_wait, true)) {
+                    LogPrint(BCLog::LLMQ_DKG, "%s -- %s qi[%d] - waiting for snapshot background validation\n",
+                             __func__, params.name, quorumIndex);
+                }
+                UninterruptibleSleep(std::chrono::milliseconds{100});
+                continue;
+            }
             LogPrint(BCLog::LLMQ_DKG, "ActiveDKGSessionHandler::%s -- %s qi[%d] - aborting because snapshot background validation is incomplete\n", __func__, params.name, quorumIndex);
             throw AbortPhaseException();
         }

src/bls/bls.cpp

@@ -15,9 +15,40 @@
 #include <cstring>
 
 namespace bls {
-    std::atomic<bool> bls_legacy_scheme = std::atomic<bool>(true);
+std::atomic<bool> bls_legacy_scheme = std::atomic<bool>(true);
+
+namespace {
+//! Trivially destructible, like util/threadnames.cpp's thread-local name.
+thread_local std::optional<bool> g_thread_legacy_scheme;
+} // namespace
+
+bool EffectiveLegacyScheme() { return g_thread_legacy_scheme ? *g_thread_legacy_scheme : bls_legacy_scheme.load(); }
+
+void SetEffectiveLegacyScheme(bool legacy)
+{
+    if (g_thread_legacy_scheme) {
+        g_thread_legacy_scheme = legacy;
+    } else {
+        bls_legacy_scheme.store(legacy);
+    }
 }
 
+ScopedLegacySchemeOverride::ScopedLegacySchemeOverride(bool legacy) noexcept :
+    m_saved{g_thread_legacy_scheme}
+{
+    g_thread_legacy_scheme = legacy;
+}
+
+ScopedLegacySchemeOverride::~ScopedLegacySchemeOverride() noexcept
+{
+    if (!m_committed || !m_saved) {
+        g_thread_legacy_scheme = m_saved;
+    }
+}
+
+bool ScopedLegacySchemeOverride::Active() noexcept { return g_thread_legacy_scheme.has_value(); }
+} // namespace bls
+
 static const std::unique_ptr<bls::CoreMPL> pSchemeLegacy{std::make_unique<bls::LegacySchemeMPL>()};
 static const std::unique_ptr<bls::CoreMPL> pScheme(std::make_unique<bls::BasicSchemeMPL>());
 
@@ -145,7 +176,7 @@ void CBLSPublicKey::AggregateInsecure(const CBLSPublicKey& o)
 {
     assert(IsValid() && o.IsValid());
     try {
-        impl = Scheme(bls::bls_legacy_scheme.load())->Aggregate({impl, o.impl});
+        impl = Scheme(bls::EffectiveLegacyScheme())->Aggregate({impl, o.impl});
     } catch (...) {
         fValid = false;
     }
@@ -166,7 +197,7 @@ CBLSPublicKey CBLSPublicKey::AggregateInsecure(Span<CBLSPublicKey> pks)
 
     CBLSPublicKey ret;
     try {
-        ret.impl = Scheme(bls::bls_legacy_scheme.load())->Aggregate(vecPublicKeys);
+        ret.impl = Scheme(bls::EffectiveLegacyScheme())->Aggregate(vecPublicKeys);
         ret.fValid = true;
     } catch (...) {
         ret.fValid = false;
@@ -230,7 +261,7 @@ void CBLSSignature::AggregateInsecure(const CBLSSignature& o)
 {
     assert(IsValid() && o.IsValid());
     try {
-        impl = Scheme(bls::bls_legacy_scheme.load())->Aggregate({impl, o.impl});
+        impl = Scheme(bls::EffectiveLegacyScheme())->Aggregate({impl, o.impl});
     } catch (...) {
         fValid = false;
     }
@@ -251,7 +282,7 @@ CBLSSignature CBLSSignature::AggregateInsecure(Span<CBLSSignature> sigs)
 
     CBLSSignature ret;
     try {
-        ret.impl = Scheme(bls::bls_legacy_scheme.load())->Aggregate(v);
+        ret.impl = Scheme(bls::EffectiveLegacyScheme())->Aggregate(v);
         ret.fValid = true;
     } catch (...) {
         ret.fValid = false;
@@ -283,7 +314,7 @@ CBLSSignature CBLSSignature::AggregateSecure(Span<CBLSSignature> sigs,
 
     CBLSSignature ret;
     try {
-        ret.impl = Scheme(bls::bls_legacy_scheme.load())->AggregateSecure(vecPublicKeys, vecSignatures, bls::Bytes(hash.begin(), hash.size()));
+        ret.impl = Scheme(bls::EffectiveLegacyScheme())->AggregateSecure(vecPublicKeys, vecSignatures, bls::Bytes(hash.begin(), hash.size()));
         ret.fValid = true;
     } catch (...) {
         ret.fValid = false;
@@ -322,10 +353,16 @@ bool CBLSSignature::VerifyInsecure(const CBLSPublicKey& pubKey, const uint256& h
 
 bool CBLSSignature::VerifyInsecure(const CBLSPublicKey& pubKey, const uint256& hash) const
 {
-    return VerifyInsecure(pubKey, hash, bls::bls_legacy_scheme.load());
+    return VerifyInsecure(pubKey, hash, bls::EffectiveLegacyScheme());
 }
 
 bool CBLSSignature::VerifyInsecureAggregated(Span<CBLSPublicKey> pubKeys, Span<uint256> hashes) const
+{
+    return VerifyInsecureAggregated(pubKeys, hashes, bls::EffectiveLegacyScheme());
+}
+
+bool CBLSSignature::VerifyInsecureAggregated(Span<CBLSPublicKey> pubKeys, Span<uint256> hashes,
+                                             const bool specificLegacyScheme) const
 {
     if (!IsValid()) {
         return false;
@@ -346,13 +383,18 @@ bool CBLSSignature::VerifyInsecureAggregated(Span<CBLSPublicKey> pubKeys, Span<u
     }
 
     try {
-        return Scheme(bls::bls_legacy_scheme.load())->AggregateVerify(pubKeyVec, hashes2, impl);
+        return Scheme(specificLegacyScheme)->AggregateVerify(pubKeyVec, hashes2, impl);
     } catch (...) {
         return false;
     }
 }
 
 bool CBLSSignature::VerifySecureAggregated(Span<CBLSPublicKey> pks, const uint256& hash) const
+{
+    return VerifySecureAggregated(pks, hash, bls::EffectiveLegacyScheme());
+}
+
+bool CBLSSignature::VerifySecureAggregated(Span<CBLSPublicKey> pks, const uint256& hash, const bool specificLegacyScheme) const
 {
     if (pks.empty()) {
         return false;
@@ -365,7 +407,7 @@ bool CBLSSignature::VerifySecureAggregated(Span<CBLSPublicKey> pks, const uint25
     }
 
     try {
-        return Scheme(bls::bls_legacy_scheme.load())->VerifySecure(vecPublicKeys, impl, bls::Bytes(hash.begin(), hash.size()));
+        return Scheme(specificLegacyScheme)->VerifySecure(vecPublicKeys, impl, bls::Bytes(hash.begin(), hash.size()));
     } catch (...) {
         return false;
     }

src/bls/bls.h

@@ -19,12 +19,48 @@
 #include <array>
 #include <atomic>
 #include <mutex>
+#include <optional>
 #include <ranges>
 #include <type_traits>
 
 namespace bls {
-    extern std::atomic<bool> bls_legacy_scheme;
-}
+//! Process-wide default scheme of BLS operations that are not given one. It
+//! follows the active chainstate's tip only: other threads read it outside
+//! cs_main, so work for any other chain context (a background chainstate, a dry
+//! run) sets a ScopedLegacySchemeOverride instead.
+extern std::atomic<bool> bls_legacy_scheme;
+
+//! The scheme of BLS operations on this thread that are not given one: the
+//! innermost ScopedLegacySchemeOverride if one is set, else bls_legacy_scheme.
+bool EffectiveLegacyScheme();
+
+//! Switches EffectiveLegacyScheme(): this thread's override if one is set,
+//! else bls_legacy_scheme.
+void SetEffectiveLegacyScheme(bool legacy);
+
+//! Sets EffectiveLegacyScheme() on this thread only, for the object's lifetime.
+//! Work handed to another thread does not see it and must capture the scheme.
+class ScopedLegacySchemeOverride
+{
+public:
+    explicit ScopedLegacySchemeOverride(bool legacy) noexcept;
+    ~ScopedLegacySchemeOverride() noexcept;
+
+    ScopedLegacySchemeOverride(const ScopedLegacySchemeOverride&) = delete;
+    ScopedLegacySchemeOverride& operator=(const ScopedLegacySchemeOverride&) = delete;
+
+    //! Leaves the scheme in force at scope exit to the enclosing override. The
+    //! outermost override always ends with its scope.
+    void Commit() noexcept { m_committed = true; }
+
+    //! Whether an override is set on this thread.
+    static bool Active() noexcept;
+
+private:
+    const std::optional<bool> m_saved;
+    bool m_committed{false};
+};
+} // namespace bls
 
 // reversed BLS12-381
 constexpr int BLS_CURVE_ID_SIZE{32};
@@ -181,7 +217,7 @@ class CBLSWrapper
     template <typename Stream>
     inline void Serialize(Stream& s) const
     {
-        Serialize(s, bls::bls_legacy_scheme.load());
+        Serialize(s, bls::EffectiveLegacyScheme());
     }
 
     template <typename Stream>
@@ -209,7 +245,7 @@ class CBLSWrapper
     template <typename Stream>
     inline void Unserialize(Stream& s)
     {
-        Unserialize(s, bls::bls_legacy_scheme.load());
+        Unserialize(s, bls::EffectiveLegacyScheme());
     }
 
     inline bool CheckMalleable(Span<uint8_t> vecBytes, const bool specificLegacyScheme) const
@@ -232,7 +268,7 @@ class CBLSWrapper
 
     inline std::string ToString() const
     {
-        return ToString(bls::bls_legacy_scheme.load());
+        return ToString(bls::EffectiveLegacyScheme());
     }
 };
 
@@ -369,8 +405,12 @@ class CBLSSignature : public CBLSWrapper<bls::G2Element, BLS_CURVE_SIG_SIZE, CBL
     void MulInsecure(const CBLSSecretKey& factor);
     [[nodiscard]] bool VerifyInsecure(const CBLSPublicKey& pubKey, const uint256& hash, const bool specificLegacyScheme) const;
     [[nodiscard]] bool VerifyInsecure(const CBLSPublicKey& pubKey, const uint256& hash) const;
+    [[nodiscard]] bool VerifyInsecureAggregated(Span<CBLSPublicKey> pubKeys, Span<uint256> hashes,
+                                                const bool specificLegacyScheme) const;
     [[nodiscard]] bool VerifyInsecureAggregated(Span<CBLSPublicKey> pubKeys, Span<uint256> hashes) const;
 
+    [[nodiscard]] bool VerifySecureAggregated(Span<CBLSPublicKey> pks, const uint256& hash,
+                                              const bool specificLegacyScheme) const;
     [[nodiscard]] bool VerifySecureAggregated(Span<CBLSPublicKey> pks, const uint256& hash) const;
 
     bool Recover(Span<CBLSSignature> sigs, Span<CBLSId> ids);
@@ -414,7 +454,7 @@ class CBLSLazyWrapper
 
 public:
     CBLSLazyWrapper() :
-        bufLegacyScheme(bls::bls_legacy_scheme.load())
+        bufLegacyScheme(bls::EffectiveLegacyScheme())
     {}
 
     explicit CBLSLazyWrapper(const CBLSLazyWrapper& r)

src/bls/bls_batchverifier.h

@@ -47,6 +47,8 @@ class CBLSBatchVerifier
     bool secureVerification;
     bool perMessageFallback;
     size_t subBatchSize;
+    //! Taken from the constructing thread, so a batch verifies under one scheme wherever Verify() runs
+    const bool legacyScheme;
 
     MessageMap messages;
     MessagesBySourceMap messagesBySource;
@@ -61,7 +63,8 @@ class CBLSBatchVerifier
     CBLSBatchVerifier(bool _secureVerification, bool _perMessageFallback, size_t _subBatchSize = 0) :
             secureVerification(_secureVerification),
             perMessageFallback(_perMessageFallback),
-            subBatchSize(_subBatchSize)
+            subBatchSize(_subBatchSize),
+            legacyScheme(bls::EffectiveLegacyScheme())
     {
     }
 
@@ -135,7 +138,7 @@ class CBLSBatchVerifier
                             }
 
                             const auto& msg = msgIt->second;
-                            if (!msg.sig.VerifyInsecure(msg.pubKey, msg.msgHash)) {
+                            if (!msg.sig.VerifyInsecure(msg.pubKey, msg.msgHash, legacyScheme)) {
                                 badMessages.emplace(msg.msgId);
                             }
                         }
@@ -201,7 +204,7 @@ class CBLSBatchVerifier
         }
 
         CBLSSignature aggSig = CBLSSignature::AggregateInsecure(sigsToAggregate);
-        return aggSig.VerifyInsecureAggregated(pubKeys, msgHashes);
+        return aggSig.VerifyInsecureAggregated(pubKeys, msgHashes, legacyScheme);
     }
 
     bool VerifyBatchSecure(std::map<uint256, std::vector<MessageMapIterator>>& byMessageHash)
@@ -251,7 +254,7 @@ class CBLSBatchVerifier
         assert(!msgHashes.empty());
 
         CBLSSignature aggSig = CBLSSignature::AggregateInsecure(sigsToAggregate);
-        return aggSig.VerifyInsecureAggregated(pubKeys, msgHashes);
+        return aggSig.VerifyInsecureAggregated(pubKeys, msgHashes, legacyScheme);
     }
 };