backport: assumeutxo M4 — evo snapshot format v3 and LLMQ reconstruction

src/init.cpp

@@ -2075,6 +2075,10 @@ bool AppInitMain(NodeContext& node, interfaces::BlockAndHeaderTipInfo* tip_info)
     const bool quorums_watch = args.GetBoolArg("-watchquorums", llmq::DEFAULT_WATCH_QUORUMS);
     const llmq::QvvecSyncModeMap sync_map{llmq::GetEnabledQuorumVvecSyncEntries(args)};
     const util::DbWrapperParams dash_db_params{.path = args.GetDataDirNet(), .memory = false, .wipe = (fReindex || fReindexChainState)};
+    // TODO(assumeutxo M5): runtime loadtxoutset must recreate/rebind the
+    // Chainstate&-holding ActiveContext signers and NetInstantSend below after
+    // ChainstateManager switches active chainstates. Startup detection and the
+    // completion-time ResetChainstates path finish before these are constructed.
     if (const auto operator_sk_str = args.GetArg("-masternodeblsprivkey", ""); !operator_sk_str.empty()) {
         const CBLSSecretKey operator_sk{ParseHex(operator_sk_str)};
         if (!operator_sk.IsValid()) {

src/node/blockstorage.cpp

@@ -249,6 +249,12 @@ void BlockManager::UpdatePruneLock(const std::string& name, const PruneLockInfo&
     m_prune_locks[name] = lock_info;
 }
 
+bool BlockManager::DeletePruneLock(const std::string& name)
+{
+    AssertLockHeld(::cs_main);
+    return m_prune_locks.erase(name) > 0;
+}
+
 CBlockIndex* BlockManager::InsertBlockIndex(const uint256& hash)
 {
     AssertLockHeld(cs_main);

src/node/blockstorage.h

@@ -226,6 +226,9 @@ class BlockManager
 
     //! Create or update a prune lock identified by its name
     void UpdatePruneLock(const std::string& name, const PruneLockInfo& lock_info) EXCLUSIVE_LOCKS_REQUIRED(::cs_main);
+
+    //! Delete a prune lock identified by its name. Returns true if the lock existed.
+    bool DeletePruneLock(const std::string& name) EXCLUSIVE_LOCKS_REQUIRED(::cs_main);
 };
 
 void CleanupBlockRevFiles();

src/node/chainstate.cpp

@@ -37,6 +37,26 @@
 #include <vector>
 
 namespace node {
+static bool RemoveSnapshotChainstateArtifacts(const fs::path& data_dir, bilingual_str& error)
+{
+    // Explicit reindexing discards both coins databases and EvoDB. Remove every
+    // snapshot lifecycle directory at the same time so a directory whose b_dcs*
+    // markers were wiped cannot be detected as a resumable snapshot below.
+    for (const auto& name : {"chainstate_snapshot", "chainstate_snapshot_INVALID", "chainstate_todelete"}) {
+        const fs::path path{data_dir / name};
+        if (!fs::exists(path)) continue;
+        try {
+            fs::remove_all(path);
+            DirectoryCommit(data_dir);
+        } catch (const fs::filesystem_error& e) {
+            error = strprintf(_("Failed to remove snapshot chainstate artifact %s for reindex: %s"),
+                              fs::PathToString(path), e.what());
+            return false;
+        }
+    }
+    return true;
+}
+
 static bool RecoverSnapshotCleanup(CEvoDB& evodb, const fs::path& data_dir, bilingual_str& error)
 {
     const fs::path normal{data_dir / "chainstate"};
@@ -189,6 +209,10 @@ static ChainstateLoadResult CompleteChainstateInitialization(ChainstateManager&
         return {ChainstateLoadStatus::FAILURE, _("Error loading block database")};
     }
 
+    // Detection happens before LoadBlockIndex. Once the base is resolvable,
+    // keep its full block available for Dash's completion-time CbTx check.
+    chainman.ProtectSnapshotBaseFromPruning();
+
     if (!chainman.BlockIndex().empty() &&
             !chainman.m_blockman.LookupBlockIndex(chainman.GetConsensus().hashGenesisBlock)) {
         // If the loaded chain has a wrong genesis, bail out immediately
@@ -326,6 +350,13 @@ ChainstateLoadResult LoadChainstate(ChainstateManager& chainman, const CacheSize
 
     LOCK(cs_main);
 
+    if (options.reindex || options.reindex_chainstate) {
+        bilingual_str cleanup_error;
+        if (!RemoveSnapshotChainstateArtifacts(options.data_dir, cleanup_error)) {
+            return {ChainstateLoadStatus::FAILURE, cleanup_error};
+        }
+    }
+
     evodb.reset();
     // TODO: pass DbWrapperParams as options instead multiple params
     evodb = std::make_unique<CEvoDB>(util::DbWrapperParams{

src/test/blockmanager_tests.cpp

@@ -85,4 +85,17 @@ BOOST_FIXTURE_TEST_CASE(blockmanager_scan_unlink_already_pruned_files, TestChain
     BOOST_CHECK(!CAutoFile(OpenBlockFile(new_pos, true), SER_DISK, CLIENT_VERSION).IsNull());
 }
 
+BOOST_FIXTURE_TEST_CASE(prune_lock_update_and_delete, TestingSetup)
+{
+    LOCK(::cs_main);
+    auto& chainman{*Assert(m_node.chainman)};
+    auto& blockman{chainman.m_blockman};
+
+    blockman.UpdatePruneLock("test_lock", node::PruneLockInfo{.height_first = 100});
+    blockman.UpdatePruneLock("test_lock", node::PruneLockInfo{.height_first = 200});
+    BOOST_CHECK(blockman.DeletePruneLock("test_lock"));
+    BOOST_CHECK(!blockman.DeletePruneLock("test_lock"));
+    BOOST_CHECK(!blockman.DeletePruneLock("nonexistent"));
+}
+
 BOOST_AUTO_TEST_SUITE_END()

src/test/validation_chainstatemanager_tests.cpp

@@ -181,6 +181,57 @@ BOOST_AUTO_TEST_CASE(chainstatemanager)
     m_node.dmnman.reset();
 }
 
+BOOST_AUTO_TEST_CASE(snapshot_startup_missing_base_header_is_nonfatal)
+{
+    ChainstateManager& manager = *m_node.chainman;
+    Chainstate& background = WITH_LOCK(::cs_main, return manager.InitializeChainstate(
+        m_node.mempool.get(), *m_node.evodb, m_node.chain_helper));
+    background.InitCoinsDB(/*cache_size_bytes=*/1 << 23, /*in_memory=*/true, /*should_wipe=*/false);
+    WITH_LOCK(::cs_main, background.InitCoinsCache(1 << 23));
+    m_node.dmnman = std::make_unique<CDeterministicMNManager>(*m_node.evodb, *Assert(m_node.mn_metaman.get()));
+    DashChainstateSetup(manager, m_node, /*llmq_dbs_in_memory=*/true, /*llmq_dbs_wipe=*/false);
+    BOOST_REQUIRE(background.LoadGenesisBlock());
+
+    const uint256 missing_base{GetRandHash()};
+    SeedSnapshotMarker(*m_node.evodb, missing_base);
+    Chainstate* snapshot = WITH_LOCK(::cs_main, return manager.ActivateExistingSnapshot(
+        m_node.mempool.get(), missing_base));
+    BOOST_REQUIRE(snapshot);
+
+    // Startup detection is allowed to precede receipt/loading of the base
+    // header. Accessors and background candidate setup must fail softly.
+    WITH_LOCK(::cs_main, {
+        BOOST_CHECK(snapshot->SnapshotBase() == nullptr);
+        const size_t candidates_before{background.setBlockIndexCandidates.size()};
+        background.TryAddBlockIndexCandidate(manager.m_blockman.LookupBlockIndex(
+            manager.GetConsensus().hashGenesisBlock));
+        BOOST_CHECK_EQUAL(background.setBlockIndexCandidates.size(), candidates_before);
+    });
+
+    DashChainstateSetupClose(m_node);
+    // dmnman holds a reference to m_node.evodb, it mustn't outlive it
+    m_node.dmnman.reset();
+}
+
+BOOST_FIXTURE_TEST_CASE(snapshot_prune_lock_release_survives_disconnect, TestChain100Setup)
+{
+    ChainstateManager& manager{*Assert(m_node.chainman)};
+
+    WITH_LOCK(::cs_main, {
+        manager.m_blockman.UpdatePruneLock("assumeutxo", {.height_first = manager.ActiveHeight()});
+        manager.ReleaseSnapshotPruneLock();
+        BOOST_CHECK(!manager.m_blockman.DeletePruneLock("assumeutxo"));
+    });
+
+    BlockValidationState state;
+    BOOST_REQUIRE(manager.ActiveChainstate().InvalidateBlock(
+        state, WITH_LOCK(::cs_main, return manager.ActiveTip())));
+
+    // DisconnectTip rewinds every remaining prune lock. The released snapshot
+    // lock must not be recreated or start constraining pruning after a reorg.
+    BOOST_CHECK(WITH_LOCK(::cs_main, return !manager.m_blockman.DeletePruneLock("assumeutxo")));
+}
+
 //! Test rebalancing the caches associated with each chainstate.
 BOOST_FIXTURE_TEST_CASE(chainstatemanager_rebalance_caches, TestChain100Setup)
 {

src/validation.cpp

@@ -1668,9 +1668,10 @@ std::string Chainstate::EvoDbInconsistencyMessage()
 const CBlockIndex* Chainstate::SnapshotBase()
 {
     if (!m_from_snapshot_blockhash) return nullptr;
-    // Unlike upstream, a missing base block is not Assert()ed away: synthetic
-    // unit fixtures activate a snapshot chainstate before inserting its base
-    // into the block index, and ChainstateManager::LoadBlockIndex() reports a
+    // Unlike upstream, a missing base block is not Assert()ed away: snapshot
+    // detection precedes LoadBlockIndex during startup, synthetic unit
+    // fixtures activate a snapshot chainstate before inserting its base into
+    // the block index, and ChainstateManager::LoadBlockIndex() reports a
     // missing on-disk base as a startup error rather than an abort. Callers
     // that require existence Assert at the call site.
     if (!m_cached_snapshot_base) m_cached_snapshot_base = m_chainman.m_blockman.LookupBlockIndex(*m_from_snapshot_blockhash);
@@ -3917,7 +3918,8 @@ void Chainstate::TryAddBlockIndexCandidate(CBlockIndex* pindex)
         // For the background chainstate, we only consider connecting blocks
         // towards the snapshot base (which can't be nullptr or else we'll
         // never make progress).
-        const CBlockIndex* snapshot_base{Assert(m_chainman.GetSnapshotBaseBlock())};
+        const CBlockIndex* snapshot_base{m_chainman.GetSnapshotBaseBlock()};
+        if (!snapshot_base) return;
         if (snapshot_base->GetAncestor(pindex->nHeight) == pindex) {
             setBlockIndexCandidates.insert(pindex);
         }
@@ -5699,6 +5701,7 @@ bool ChainstateManager::ActivateSnapshot(
     }
     if (!snapshot_ok) {
         LOCK(::cs_main);
+        this->ReleaseSnapshotPruneLock();
         this->MaybeRebalanceCaches();
 
         // PopulateAndValidateSnapshot commits the snapshot best-block and
@@ -5807,6 +5810,11 @@ bool ChainstateManager::PopulateAndValidateSnapshot(
         return false;
     }
 
+    // Protect the full base block before the long-running population step.
+    // Snapshot activation is not visible yet, so use the resolved base directly.
+    WITH_LOCK(::cs_main, m_blockman.UpdatePruneLock(
+        "assumeutxo", {.height_first = snapshot_start_block->nHeight}));
+
     int base_height = snapshot_start_block->nHeight;
     auto maybe_au_data = ExpectedAssumeutxo(base_height, GetParams());
 
@@ -6273,6 +6281,7 @@ bool ChainstateManager::HandleSnapshotStateMismatch(
     m_ibd_chainstate->m_mempool = m_snapshot_chainstate->m_mempool;
     m_snapshot_chainstate->m_mempool = nullptr;
     m_snapshot_chainstate->m_disabled = true;
+    ReleaseSnapshotPruneLock();
     assert(!IsUsable(m_snapshot_chainstate.get()));
     assert(IsUsable(m_ibd_chainstate.get()));
 
@@ -6406,7 +6415,10 @@ SnapshotCompletionResult ChainstateManager::MaybeCompleteSnapshotValidation(
     }
 
     // The base block is necessarily available after background validation
-    // reaches it. Complete any CbTx checks that could not run at snapshot load.
+    // reaches it. The assumeutxo prune lock is held until this check completes,
+    // so the shared BlockManager cannot prune the base out from under the
+    // snapshot chainstate. Complete any CbTx checks deferred at snapshot load.
+    assert(index_new.nStatus & BLOCK_HAVE_DATA);
     if (DeploymentActiveAt(index_new, GetConsensus(), Consensus::DEPLOYMENT_DIP0003)) {
         evo::CEvoSnapshot retained_snapshot;
         CBlock base_block;
@@ -6481,6 +6493,7 @@ SnapshotCompletionResult ChainstateManager::MaybeCompleteSnapshotValidation(
         snapshot_blockhash.ToString());
 
     m_ibd_chainstate->m_disabled = true;
+    ReleaseSnapshotPruneLock();
     this->MaybeRebalanceCaches();
 
     return SnapshotCompletionResult::SUCCESS;
@@ -6608,6 +6621,24 @@ void ChainstateManager::ResetChainstates()
     m_active_chainstate = nullptr;
 }
 
+void ChainstateManager::ProtectSnapshotBaseFromPruning()
+{
+    AssertLockHeld(::cs_main);
+    const CBlockIndex* base{GetSnapshotBaseBlock()};
+    if (!base) return;
+
+    // The generic prune-lock buffer makes this conservative: automatic and
+    // manual pruning both stop below the base, keeping its full block available
+    // for Dash's deferred CbTx/evo check at background-validation completion.
+    m_blockman.UpdatePruneLock("assumeutxo", {.height_first = base->nHeight});
+}
+
+void ChainstateManager::ReleaseSnapshotPruneLock()
+{
+    AssertLockHeld(::cs_main);
+    m_blockman.DeletePruneLock("assumeutxo");
+}
+
 ChainstateManager::~ChainstateManager()
 {
     LOCK(::cs_main);

src/validation.h

@@ -1246,6 +1246,10 @@ class ChainstateManager
 
     void ResetChainstates() EXCLUSIVE_LOCKS_REQUIRED(::cs_main);
 
+    //! Keep the snapshot base block available for deferred Dash evo validation.
+    void ProtectSnapshotBaseFromPruning() EXCLUSIVE_LOCKS_REQUIRED(::cs_main);
+    void ReleaseSnapshotPruneLock() EXCLUSIVE_LOCKS_REQUIRED(::cs_main);
+
     //! Switch the active chainstate to one based on a UTXO snapshot that was loaded
     //! previously.
     Chainstate* ActivateExistingSnapshot(CTxMemPool* mempool, uint256 base_blockhash)

test/functional/feature_reindex.py

@@ -11,6 +11,7 @@
 """
 
 import os
+from pathlib import Path
 from test_framework.test_framework import BitcoinTestFramework
 from test_framework.messages import MAGIC_BYTES
 from test_framework.util import assert_equal
@@ -25,9 +26,19 @@ def reindex(self, justchainstate=False, txindex=0):
         self.generatetoaddress(self.nodes[0], 3, self.nodes[0].get_deterministic_priv_key().address)
         blockcount = self.nodes[0].getblockcount()
         self.stop_nodes()
+        chain_dir = Path(self.nodes[0].datadir) / self.nodes[0].chain
+        snapshot_artifacts = [
+            chain_dir / "chainstate_snapshot",
+            chain_dir / "chainstate_snapshot_INVALID",
+            chain_dir / "chainstate_todelete",
+        ]
+        for artifact in snapshot_artifacts:
+            artifact.mkdir()
+            (artifact / "stale").touch()
         extra_args = [["-reindex-chainstate", "-txindex=0"]] if justchainstate else [["-reindex", f"-txindex={txindex}"]]
         self.start_nodes(extra_args)
         assert_equal(self.nodes[0].getblockcount(), blockcount)  # start_node is blocking on reindex
+        assert all(not artifact.exists() for artifact in snapshot_artifacts)
         self.log.info("Success")
 
     # Check that blocks can be processed out of order