backport: bitcoin#29215, #29370, #29720, #29726, #30053, #30267, #29996, #30320, #29519, #30636, #30807, #30962, #30909, #34286, #34728, #34852

doc/design/assumeutxo.md

@@ -1,20 +1,27 @@
 # assumeutxo
 
 Assumeutxo is a feature that allows fast bootstrapping of a validating dashd
-instance with a very similar security model to assumevalid.
+instance.
 
 ## Loading a snapshot
 
 There is currently no canonical source for snapshots, but any downloaded snapshot
 will be checked against a hash that's been hardcoded in source code.
 
 Once you've obtained the snapshot, you can use the RPC command `loadtxoutset`
-(yet to be merged) to load it.
+to load it. `loadtxoutset` and `getchainstates` are hidden and available on
+regtest only.
+
+A masternode does not load snapshots, and a node does not start with
+`-masternodeblsprivkey` while it has a snapshot chainstate, validated or not,
+until a restart has promoted it.
 
 ### Pruning
 
-A pruned node can load a snapshot. To save space, it's possible to delete the
-snapshot file as soon as `loadtxoutset` finishes.
+A pruned node cannot load a snapshot, and a node does not start with `-prune`
+while it has a snapshot chainstate, validated or not, until a restart has
+promoted it. It's possible to delete the snapshot file as soon as
+`loadtxoutset` finishes.
 
 The minimum `-dbcache` setting is 550 MiB, but this functionality ignores that
 minimum and uses at least 1100 MiB.
@@ -25,10 +32,17 @@ downloaded snapshot).
 
 ### Indexes
 
-Indexes work but don't take advantage of this feature. They always start building
+A node with `-addressindex`, `-spentindex` or `-timestampindex` cannot load a
+snapshot, and does not start with them while it has a snapshot chainstate.
+
+Other indexes work but don't take advantage of this feature. They always start building
 from the genesis block. Once the background validation reaches the snapshot block,
 indexes will continue to build all the way to the tip.
 
+Governance waits until background validation has completed and the governance
+collateral index has caught up: until then the node neither processes nor relays
+governance objects, and `gobject prepare` and `gobject submit` refuse.
+
 For indexes that support pruning, note that no pruning will take place between
 the snapshot and the tip, until the background sync has completed - after which
 everything is pruned. Depending on how old the snapshot is, this may temporarily
@@ -51,18 +65,12 @@ The utility script
 
 ## Design notes
 
-- A new block index `nStatus` flag is introduced, `BLOCK_ASSUMED_VALID`, to mark block
-  index entries that are required to be assumed-valid by a chainstate created
-  from a UTXO snapshot. This flag is used as a way to modify certain
-  CheckBlockIndex() logic to account for index entries that are pending validation by a
-  chainstate running asynchronously in the background.
-
 - The concept of UTXO snapshots is treated as an implementation detail that lives
   behind the ChainstateManager interface. The external presentation of the changes
   required to facilitate the use of UTXO snapshots is the understanding that there are
-  now certain regions of the chain that can be temporarily assumed to be valid (using
-  the nStatus flag mentioned above). In certain cases, e.g. wallet rescanning, this is
-  very similar to dealing with a pruned chain.
+  now certain regions of the chain that can be temporarily assumed to be valid.
+  In certain cases, e.g. wallet rescanning, this is very similar to dealing with
+  a pruned chain.
 
   Logic outside ChainstateManager should try not to know about snapshots, instead
   preferring to work in terms of more general states like assumed-valid.

doc/release-notes-7593.md

@@ -0,0 +1,16 @@
+Updated RPCs
+------------
+
+- On a pruned node, `quorum info`, `quorum memberof` and `quorum selectquorum`
+  fail with `RPC_INTERNAL_ERROR` for a quorum whose members this node cannot
+  compute because the block that fixes them was pruned. They used to work with
+  members computed from a substitute value, which could be wrong. (#7593)
+
+Other changes
+-------------
+
+- A pruned node no longer substitutes the block hash for the quorum score
+  modifier of a pruned work block. It keeps such a quorum's public key, from
+  its mined commitment, without members, so it still verifies signatures
+  by that quorum (for example on masternode hard-fork signals) and never
+  stalls on them. (#7593)

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)

doc/zmq.md

@@ -141,11 +141,11 @@ Where the 8-byte uints correspond to the mempool sequence number.
     | hashtx | <32-byte transaction hash in Little Endian> | <uint32 sequence number in Little Endian>
 
 
-`rawblock`: Notifies when the chain tip is updated. Messages are ZMQ multipart messages with three parts. The first part is the topic (`rawblock`), the second part is the serialized block, and the last part is a sequence number (representing the message count to detect lost messages).
+`rawblock`: Notifies when the chain tip is updated. When assumeutxo is in use, this notification will not be issued for historical blocks connected to the background validation chainstate. Messages are ZMQ multipart messages with three parts. The first part is the topic (`rawblock`), the second part is the serialized block, and the last part is a sequence number (representing the message count to detect lost messages).
 
     | rawblock | <serialized block> | <uint32 sequence number in Little Endian>
 
-`hashblock`: Notifies when the chain tip is updated. Messages are ZMQ multipart messages with three parts. The first part is the topic (`hashblock`), the second part is the 32-byte block hash, and the last part is a sequence number (representing the message count to detect lost messages).
+`hashblock`: Notifies when the chain tip is updated. When assumeutxo is in use, this notification will not be issued for historical blocks connected to the background validation chainstate. Messages are ZMQ multipart messages with three parts. The first part is the topic (`hashblock`), the second part is the 32-byte block hash, and the last part is a sequence number (representing the message count to detect lost messages).
 
     | hashblock | <32-byte block hash in Little Endian> | <uint32 sequence number in Little Endian>
 

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,8 @@ libbitcoin_node_a_SOURCES = \
   evo/simplifiedmns.cpp \
   evo/smldiff.cpp \
   evo/snapshot.cpp \
+  evo/snapshot_chain.cpp \
+  evo/snapshot_config.cpp \
   evo/specialtx.cpp \
   evo/specialtx_filter.cpp \
   evo/specialtxman.cpp \
@@ -1312,6 +1317,9 @@ libdashkernel_la_SOURCES = \
   evo/providertx_util.cpp \
   evo/simplifiedmns.cpp \
   evo/smldiff.cpp \
+  evo/snapshot.cpp \
+  evo/snapshot_chain.cpp \
+  evo/snapshot_config.cpp \
   evo/specialtx.cpp \
   evo/specialtx_filter.cpp \
   evo/specialtxman.cpp \

src/Makefile.test_util.include

@@ -11,6 +11,7 @@ TEST_UTIL_H = \
   test/util/blockfilter.h \
   test/util/chainstate.h \
   test/util/coins.h \
+  test/util/evo_snapshot.h \
   test/util/json.h \
   test/util/index.h \
   test/util/llmq_tests.h \

src/active/dkgsessionhandler.cpp

@@ -114,15 +114,31 @@ 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));
 
+    const bool waiting_for_round_start{!curPhase.has_value()};
+    bool logged_snapshot_wait{false};
     while (true) {
-        if (m_chainman.IsSnapshotActiveAndUnvalidated()) {
-            LogPrint(BCLog::LLMQ_DKG, "ActiveDKGSessionHandler::%s -- %s qi[%d] - aborting because snapshot background validation is incomplete\n", __func__, params.name, quorumIndex);
-            throw AbortPhaseException();
-        }
         if (stopRequested) {
             LogPrint(BCLog::LLMQ_DKG, "ActiveDKGSessionHandler::%s -- %s qi[%d] - aborting due to stop/shutdown requested\n", __func__, params.name, quorumIndex);
             throw AbortPhaseException();
         }
+        if (m_chainman.IsSnapshotActiveAndUnvalidated()) {
+            if (!waiting_for_round_start) {
+                LogPrint(BCLog::LLMQ_DKG,
+                         "ActiveDKGSessionHandler::%s -- %s qi[%d] - aborting because snapshot background validation "
+                         "is incomplete\n",
+                         __func__, params.name, quorumIndex);
+                throw AbortPhaseException();
+            }
+            // No round can start until background validation completes, so wait instead of aborting
+            if (!logged_snapshot_wait) {
+                LogPrint(BCLog::LLMQ_DKG,
+                         "ActiveDKGSessionHandler::%s -- %s qi[%d] - waiting for snapshot background validation\n",
+                         __func__, params.name, quorumIndex);
+                logged_snapshot_wait = true;
+            }
+            UninterruptibleSleep(std::chrono::milliseconds{100});
+            continue;
+        }
         auto [_phase, _quorumHash] = GetPhaseAndQuorumHash();
         if (!expectedQuorumHash.IsNull() && _quorumHash != expectedQuorumHash) {
             LogPrint(BCLog::LLMQ_DKG, "ActiveDKGSessionHandler::%s -- %s qi[%d] - aborting due unexpected expectedQuorumHash change\n", __func__, params.name, quorumIndex);

src/bench/wallet_create_tx.cpp

@@ -71,7 +71,7 @@ void generateFakeBlock(const CChainParams& params,
 
     // notify wallet
     const auto& pindex = WITH_LOCK(::cs_main, return context.chainman->ActiveChain().Tip());
-    wallet.blockConnected(kernel::MakeBlockInfo(pindex, &block));
+    wallet.blockConnected(ChainstateRole::NORMAL, kernel::MakeBlockInfo(pindex, &block));
 }
 
 struct PreSelectInputs {

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;
     }