/root/bitcoin/src/node/chainstate.cpp

Source
// Copyright (c) 2021-2022 The Bitcoin Core developers
// Distributed under the MIT software license, see the accompanying
// file COPYING or http://www.opensource.org/licenses/mit-license.php.

#include <node/chainstate.h>

#include <arith_uint256.h>
#include <chain.h>
#include <coins.h>
#include <consensus/params.h>
#include <kernel/caches.h>
#include <logging.h>
#include <node/blockstorage.h>
#include <sync.h>
#include <threadsafety.h>
#include <tinyformat.h>
#include <txdb.h>
#include <uint256.h>
#include <util/fs.h>
#include <util/signalinterrupt.h>
#include <util/time.h>
#include <util/translation.h>
#include <validation.h>

#include <algorithm>
#include <cassert>
#include <vector>

using kernel::CacheSizes;

namespace node {
// Complete initialization of chainstates after the initial call has been made
// to ChainstateManager::InitializeChainstate().
static ChainstateLoadResult CompleteChainstateInitialization(
    ChainstateManager& chainman,
    const ChainstateLoadOptions& options) EXCLUSIVE_LOCKS_REQUIRED(::cs_main)
{
    if (chainman.m_interrupt) return {ChainstateLoadStatus::INTERRUPTED, {}};

    // LoadBlockIndex will load m_have_pruned if we've ever removed a
    // block file from disk.
    // Note that it also sets m_blockfiles_indexed based on the disk flag!
    if (!chainman.LoadBlockIndex()) {
        if (chainman.m_interrupt) return {ChainstateLoadStatus::INTERRUPTED, {}};
        return {ChainstateLoadStatus::FAILURE, _("Error loading block database")};
    }

    if (!chainman.BlockIndex().empty() &&
            !chainman.m_blockman.LookupBlockIndex(chainman.GetConsensus().hashGenesisBlock)) {
        // If the loaded chain has a wrong genesis, bail out immediately
        // (we're likely using a testnet datadir, or the other way around).
        return {ChainstateLoadStatus::FAILURE_INCOMPATIBLE_DB, _("Incorrect or no genesis block found. Wrong datadir for network?")};
    }

    // Check for changed -prune state.  What we are concerned about is a user who has pruned blocks
    // in the past, but is now trying to run unpruned.
    if (chainman.m_blockman.m_have_pruned && !options.prune) {
        return {ChainstateLoadStatus::FAILURE, _("You need to rebuild the database using -reindex to go back to unpruned mode.  This will redownload the entire blockchain")};
    }

    // At this point blocktree args are consistent with what's on disk.
    // If we're not mid-reindex (based on disk + args), add a genesis block on disk
    // (otherwise we use the one already on disk).
    // This is called again in ImportBlocks after the reindex completes.
    if (chainman.m_blockman.m_blockfiles_indexed && !chainman.ActiveChainstate().LoadGenesisBlock()) {
        return {ChainstateLoadStatus::FAILURE, _("Error initializing block database")};
    }

    auto is_coinsview_empty = [&](Chainstate* chainstate) EXCLUSIVE_LOCKS_REQUIRED(::cs_main) {
        return options.wipe_chainstate_db || chainstate->CoinsTip().GetBestBlock().IsNull();
    };

    assert(chainman.m_total_coinstip_cache > 0);
    assert(chainman.m_total_coinsdb_cache > 0);

    // If running with multiple chainstates, limit the cache sizes with a
    // discount factor. If discounted the actual cache size will be
    // recalculated by `chainman.MaybeRebalanceCaches()`. The discount factor
    // is conservatively chosen such that the sum of the caches does not exceed
    // the allowable amount during this temporary initialization state.
    double init_cache_fraction = chainman.GetAll().size() > 1 ? 0.2 : 1.0;

    // At this point we're either in reindex or we've loaded a useful
    // block tree into BlockIndex()!

    for (Chainstate* chainstate : chainman.GetAll()) {
        LogPrintf("Initializing chainstate %s\n", chainstate->ToString());

        try {
            chainstate->InitCoinsDB(
                /*cache_size_bytes=*/chainman.m_total_coinsdb_cache * init_cache_fraction,
                /*in_memory=*/options.coins_db_in_memory,
                /*should_wipe=*/options.wipe_chainstate_db);
        } catch (dbwrapper_error& err) {
            LogError("%s\n", err.what());
            return {ChainstateLoadStatus::FAILURE, _("Error opening coins database")};
        }

        if (options.coins_error_cb) {
            chainstate->CoinsErrorCatcher().AddReadErrCallback(options.coins_error_cb);
        }

        // Refuse to load unsupported database format.
        // This is a no-op if we cleared the coinsviewdb with -reindex or -reindex-chainstate
        if (chainstate->CoinsDB().NeedsUpgrade()) {
            return {ChainstateLoadStatus::FAILURE_INCOMPATIBLE_DB, _("Unsupported chainstate database format found. "
                                                                     "Please restart with -reindex-chainstate. This will "
                                                                     "rebuild the chainstate database.")};
        }

        // ReplayBlocks is a no-op if we cleared the coinsviewdb with -reindex or -reindex-chainstate
        if (!chainstate->ReplayBlocks()) {
            return {ChainstateLoadStatus::FAILURE, _("Unable to replay blocks. You will need to rebuild the database using -reindex-chainstate.")};
        }

        // The on-disk coinsdb is now in a good state, create the cache
        chainstate->InitCoinsCache(chainman.m_total_coinstip_cache * init_cache_fraction);
        assert(chainstate->CanFlushToDisk());

        if (!is_coinsview_empty(chainstate)) {
            // LoadChainTip initializes the chain based on CoinsTip()'s best block
            if (!chainstate->LoadChainTip()) {
                return {ChainstateLoadStatus::FAILURE, _("Error initializing block database")};
            }
            assert(chainstate->m_chain.Tip() != nullptr);
        }
    }

    auto chainstates{chainman.GetAll()};
    if (std::any_of(chainstates.begin(), chainstates.end(),
                    [](const Chainstate* cs) EXCLUSIVE_LOCKS_REQUIRED(cs_main) { return cs->NeedsRedownload(); })) {
        return {ChainstateLoadStatus::FAILURE, strprintf(_("Witness data for blocks after height %d requires validation. Please restart with -reindex."),
                                                         chainman.GetConsensus().SegwitHeight)};
    };

    // Now that chainstates are loaded and we're able to flush to
    // disk, rebalance the coins caches to desired levels based
    // on the condition of each chainstate.
    chainman.MaybeRebalanceCaches();

    return {ChainstateLoadStatus::SUCCESS, {}};
}

ChainstateLoadResult LoadChainstate(ChainstateManager& chainman, const CacheSizes& cache_sizes,
                                    const ChainstateLoadOptions& options)
{
    if (!chainman.AssumedValidBlock().IsNull()) {
        LogPrintf("Assuming ancestors of block %s have valid signatures.\n", chainman.AssumedValidBlock().GetHex());
    } else {
        LogPrintf("Validating signatures for all blocks.\n");
    }
    LogPrintf("Setting nMinimumChainWork=%s\n", chainman.MinimumChainWork().GetHex());
    if (chainman.MinimumChainWork() < UintToArith256(chainman.GetConsensus().nMinimumChainWork)) {
        LogPrintf("Warning: nMinimumChainWork set below default value of %s\n", chainman.GetConsensus().nMinimumChainWork.GetHex());
    }
    if (chainman.m_blockman.GetPruneTarget() == BlockManager::PRUNE_TARGET_MANUAL) {
        LogPrintf("Block pruning enabled.  Use RPC call pruneblockchain(height) to manually prune block and undo files.\n");
    } else if (chainman.m_blockman.GetPruneTarget()) {
        LogPrintf("Prune configured to target %u MiB on disk for block and undo files.\n", chainman.m_blockman.GetPruneTarget() / 1024 / 1024);
    }

    LOCK(cs_main);

    chainman.m_total_coinstip_cache = cache_sizes.coins;
    chainman.m_total_coinsdb_cache = cache_sizes.coins_db;

    // Load the fully validated chainstate.
    chainman.InitializeChainstate(options.mempool);

    // Load a chain created from a UTXO snapshot, if any exist.
    bool has_snapshot = chainman.DetectSnapshotChainstate();

    if (has_snapshot && options.wipe_chainstate_db) {
        LogPrintf("[snapshot] deleting snapshot chainstate due to reindexing\n");
        if (!chainman.DeleteSnapshotChainstate()) {
            return {ChainstateLoadStatus::FAILURE_FATAL, Untranslated("Couldn't remove snapshot chainstate.")};
        }
    }

    auto [init_status, init_error] = CompleteChainstateInitialization(chainman, options);
    if (init_status != ChainstateLoadStatus::SUCCESS) {
        return {init_status, init_error};
    }

    // If a snapshot chainstate was fully validated by a background chainstate during
    // the last run, detect it here and clean up the now-unneeded background
    // chainstate.
    //
    // Why is this cleanup done here (on subsequent restart) and not just when the
    // snapshot is actually validated? Because this entails unusual
    // filesystem operations to move leveldb data directories around, and that seems
    // too risky to do in the middle of normal runtime.
    auto snapshot_completion = chainman.MaybeCompleteSnapshotValidation();

    if (snapshot_completion == SnapshotCompletionResult::SKIPPED) {
        // do nothing; expected case
    } else if (snapshot_completion == SnapshotCompletionResult::SUCCESS) {
        LogPrintf("[snapshot] cleaning up unneeded background chainstate, then reinitializing\n");
        if (!chainman.ValidatedSnapshotCleanup()) {
            return {ChainstateLoadStatus::FAILURE_FATAL, Untranslated("Background chainstate cleanup failed unexpectedly.")};
        }

        // Because ValidatedSnapshotCleanup() has torn down chainstates with
        // ChainstateManager::ResetChainstates(), reinitialize them here without
        // duplicating the blockindex work above.
        assert(chainman.GetAll().empty());
        assert(!chainman.IsSnapshotActive());
        assert(!chainman.IsSnapshotValidated());

        chainman.InitializeChainstate(options.mempool);

        // A reload of the block index is required to recompute setBlockIndexCandidates
        // for the fully validated chainstate.
        chainman.ActiveChainstate().ClearBlockIndexCandidates();

        auto [init_status, init_error] = CompleteChainstateInitialization(chainman, options);
        if (init_status != ChainstateLoadStatus::SUCCESS) {
            return {init_status, init_error};
        }
    } else {
        return {ChainstateLoadStatus::FAILURE_FATAL, _(
           "UTXO snapshot failed to validate. "
           "Restart to resume normal initial block download, or try loading a different snapshot.")};
    }

    return {ChainstateLoadStatus::SUCCESS, {}};
}

ChainstateLoadResult VerifyLoadedChainstate(ChainstateManager& chainman, const ChainstateLoadOptions& options)
{
    auto is_coinsview_empty = [&](Chainstate* chainstate) EXCLUSIVE_LOCKS_REQUIRED(::cs_main) {
        return options.wipe_chainstate_db || chainstate->CoinsTip().GetBestBlock().IsNull();
    };

    LOCK(cs_main);

    for (Chainstate* chainstate : chainman.GetAll()) {
        if (!is_coinsview_empty(chainstate)) {
            const CBlockIndex* tip = chainstate->m_chain.Tip();
            if (tip && tip->nTime > GetTime() + MAX_FUTURE_BLOCK_TIME) {
                return {ChainstateLoadStatus::FAILURE, _("The block database contains a block which appears to be from the future. "
                                                         "This may be due to your computer's date and time being set incorrectly. "
                                                         "Only rebuild the block database if you are sure that your computer's date and time are correct")};
            }

            VerifyDBResult result = CVerifyDB(chainman.GetNotifications()).VerifyDB(
                *chainstate, chainman.GetConsensus(), chainstate->CoinsDB(),
                options.check_level,
                options.check_blocks);
            switch (result) {
            case VerifyDBResult::SUCCESS:
            case VerifyDBResult::SKIPPED_MISSING_BLOCKS:
                break;
            case VerifyDBResult::INTERRUPTED:
                return {ChainstateLoadStatus::INTERRUPTED, _("Block verification was interrupted")};
            case VerifyDBResult::CORRUPTED_BLOCK_DB:
                return {ChainstateLoadStatus::FAILURE, _("Corrupted block database detected")};
            case VerifyDBResult::SKIPPED_L3_CHECKS:
                if (options.require_full_verification) {
                    return {ChainstateLoadStatus::FAILURE_INSUFFICIENT_DBCACHE, _("Insufficient dbcache for block verification")};
                }
                break;
            } // no default case, so the compiler can warn about missing cases
        }
    }

    return {ChainstateLoadStatus::SUCCESS, {}};
}
} // namespace node

Coverage Report

Created: 2025-05-14 12:32

Line	Count	Source
1		// Copyright (c) 2021-2022 The Bitcoin Core developers
2		// Distributed under the MIT software license, see the accompanying
3		// file COPYING or http://www.opensource.org/licenses/mit-license.php.
4
5		#include <node/chainstate.h>
6
7		#include <arith_uint256.h>
8		#include <chain.h>
9		#include <coins.h>
10		#include <consensus/params.h>
11		#include <kernel/caches.h>
12		#include <logging.h>
13		#include <node/blockstorage.h>
14		#include <sync.h>
15		#include <threadsafety.h>
16		#include <tinyformat.h>
17		#include <txdb.h>
18		#include <uint256.h>
19		#include <util/fs.h>
20		#include <util/signalinterrupt.h>
21		#include <util/time.h>
22		#include <util/translation.h>
23		#include <validation.h>
24
25		#include <algorithm>
26		#include <cassert>
27		#include <vector>
28
29		using kernel::CacheSizes;
30
31		namespace node {
32		// Complete initialization of chainstates after the initial call has been made
33		// to ChainstateManager::InitializeChainstate().
34		static ChainstateLoadResult CompleteChainstateInitialization(
35		ChainstateManager& chainman,
36		const ChainstateLoadOptions& options) EXCLUSIVE_LOCKS_REQUIRED(::cs_main)
37	0	{
38	0	if (chainman.m_interrupt) return {ChainstateLoadStatus::INTERRUPTED, {}};
39
40		// LoadBlockIndex will load m_have_pruned if we've ever removed a
41		// block file from disk.
42		// Note that it also sets m_blockfiles_indexed based on the disk flag!
43	0	if (!chainman.LoadBlockIndex()) {
44	0	if (chainman.m_interrupt) return {ChainstateLoadStatus::INTERRUPTED, {}};
45	0	return {ChainstateLoadStatus::FAILURE, _("Error loading block database")};
46	0	}
47
48	0	if (!chainman.BlockIndex().empty() &&
49	0	!chainman.m_blockman.LookupBlockIndex(chainman.GetConsensus().hashGenesisBlock)) {
50		// If the loaded chain has a wrong genesis, bail out immediately
51		// (we're likely using a testnet datadir, or the other way around).
52	0	return {ChainstateLoadStatus::FAILURE_INCOMPATIBLE_DB, _("Incorrect or no genesis block found. Wrong datadir for network?")};
53	0	}
54
55		// Check for changed -prune state. What we are concerned about is a user who has pruned blocks
56		// in the past, but is now trying to run unpruned.
57	0	if (chainman.m_blockman.m_have_pruned && !options.prune) {
58	0	return {ChainstateLoadStatus::FAILURE, _("You need to rebuild the database using -reindex to go back to unpruned mode. This will redownload the entire blockchain")};
59	0	}
60
61		// At this point blocktree args are consistent with what's on disk.
62		// If we're not mid-reindex (based on disk + args), add a genesis block on disk
63		// (otherwise we use the one already on disk).
64		// This is called again in ImportBlocks after the reindex completes.
65	0	if (chainman.m_blockman.m_blockfiles_indexed && !chainman.ActiveChainstate().LoadGenesisBlock()) {
66	0	return {ChainstateLoadStatus::FAILURE, _("Error initializing block database")};
67	0	}
68
69	0	auto is_coinsview_empty = [&](Chainstate* chainstate) EXCLUSIVE_LOCKS_REQUIRED(::cs_main) {
70	0	return options.wipe_chainstate_db \|\| chainstate->CoinsTip().GetBestBlock().IsNull();
71	0	};
72
73	0	assert(chainman.m_total_coinstip_cache > 0);
74	0	assert(chainman.m_total_coinsdb_cache > 0);
75
76		// If running with multiple chainstates, limit the cache sizes with a
77		// discount factor. If discounted the actual cache size will be
78		// recalculated by `chainman.MaybeRebalanceCaches()`. The discount factor
79		// is conservatively chosen such that the sum of the caches does not exceed
80		// the allowable amount during this temporary initialization state.
81	0	double init_cache_fraction = chainman.GetAll().size() > 1 ? 0.2 : 1.0;
82
83		// At this point we're either in reindex or we've loaded a useful
84		// block tree into BlockIndex()!
85
86	0	for (Chainstate* chainstate : chainman.GetAll()) {
87	0	LogPrintf("Initializing chainstate %s\n", chainstate->ToString());
88
89	0	try {
90	0	chainstate->InitCoinsDB(
91	0	/cache_size_bytes=/chainman.m_total_coinsdb_cache * init_cache_fraction,
92	0	/in_memory=/options.coins_db_in_memory,
93	0	/should_wipe=/options.wipe_chainstate_db);
94	0	} catch (dbwrapper_error& err) {
95	0	LogError("%s\n", err.what());
96	0	return {ChainstateLoadStatus::FAILURE, _("Error opening coins database")};
97	0	}
98
99	0	if (options.coins_error_cb) {
100	0	chainstate->CoinsErrorCatcher().AddReadErrCallback(options.coins_error_cb);
101	0	}
102
103		// Refuse to load unsupported database format.
104		// This is a no-op if we cleared the coinsviewdb with -reindex or -reindex-chainstate
105	0	if (chainstate->CoinsDB().NeedsUpgrade()) {
106	0	return {ChainstateLoadStatus::FAILURE_INCOMPATIBLE_DB, _("Unsupported chainstate database format found. "
107	0	"Please restart with -reindex-chainstate. This will "
108	0	"rebuild the chainstate database.")};
109	0	}
110
111		// ReplayBlocks is a no-op if we cleared the coinsviewdb with -reindex or -reindex-chainstate
112	0	if (!chainstate->ReplayBlocks()) {
113	0	return {ChainstateLoadStatus::FAILURE, _("Unable to replay blocks. You will need to rebuild the database using -reindex-chainstate.")};
114	0	}
115
116		// The on-disk coinsdb is now in a good state, create the cache
117	0	chainstate->InitCoinsCache(chainman.m_total_coinstip_cache * init_cache_fraction);
118	0	assert(chainstate->CanFlushToDisk());
119
120	0	if (!is_coinsview_empty(chainstate)) {
121		// LoadChainTip initializes the chain based on CoinsTip()'s best block
122	0	if (!chainstate->LoadChainTip()) {
123	0	return {ChainstateLoadStatus::FAILURE, _("Error initializing block database")};
124	0	}
125	0	assert(chainstate->m_chain.Tip() != nullptr);
126	0	}
127	0	}
128
129	0	auto chainstates{chainman.GetAll()};
130	0	if (std::any_of(chainstates.begin(), chainstates.end(),
131	0	[](const Chainstate* cs) EXCLUSIVE_LOCKS_REQUIRED(cs_main) { return cs->NeedsRedownload(); })) {
132	0	return {ChainstateLoadStatus::FAILURE, strprintf(_("Witness data for blocks after height %d requires validation. Please restart with -reindex."),
133	0	chainman.GetConsensus().SegwitHeight)};
134	0	};
135
136		// Now that chainstates are loaded and we're able to flush to
137		// disk, rebalance the coins caches to desired levels based
138		// on the condition of each chainstate.
139	0	chainman.MaybeRebalanceCaches();
140
141	0	return {ChainstateLoadStatus::SUCCESS, {}};
142	0	}
143
144		ChainstateLoadResult LoadChainstate(ChainstateManager& chainman, const CacheSizes& cache_sizes,
145		const ChainstateLoadOptions& options)
146	0	{
147	0	if (!chainman.AssumedValidBlock().IsNull()) {
148	0	LogPrintf("Assuming ancestors of block %s have valid signatures.\n", chainman.AssumedValidBlock().GetHex());
149	0	} else {
150	0	LogPrintf("Validating signatures for all blocks.\n");
151	0	}
152	0	LogPrintf("Setting nMinimumChainWork=%s\n", chainman.MinimumChainWork().GetHex());
153	0	if (chainman.MinimumChainWork() < UintToArith256(chainman.GetConsensus().nMinimumChainWork)) {
154	0	LogPrintf("Warning: nMinimumChainWork set below default value of %s\n", chainman.GetConsensus().nMinimumChainWork.GetHex());
155	0	}
156	0	if (chainman.m_blockman.GetPruneTarget() == BlockManager::PRUNE_TARGET_MANUAL) {
157	0	LogPrintf("Block pruning enabled. Use RPC call pruneblockchain(height) to manually prune block and undo files.\n");
158	0	} else if (chainman.m_blockman.GetPruneTarget()) {
159	0	LogPrintf("Prune configured to target %u MiB on disk for block and undo files.\n", chainman.m_blockman.GetPruneTarget() / 1024 / 1024);
160	0	}
161
162	0	LOCK(cs_main);
163
164	0	chainman.m_total_coinstip_cache = cache_sizes.coins;
165	0	chainman.m_total_coinsdb_cache = cache_sizes.coins_db;
166
167		// Load the fully validated chainstate.
168	0	chainman.InitializeChainstate(options.mempool);
169
170		// Load a chain created from a UTXO snapshot, if any exist.
171	0	bool has_snapshot = chainman.DetectSnapshotChainstate();
172
173	0	if (has_snapshot && options.wipe_chainstate_db) {
174	0	LogPrintf("[snapshot] deleting snapshot chainstate due to reindexing\n");
175	0	if (!chainman.DeleteSnapshotChainstate()) {
176	0	return {ChainstateLoadStatus::FAILURE_FATAL, Untranslated("Couldn't remove snapshot chainstate.")};
177	0	}
178	0	}
179
180	0	auto [init_status, init_error] = CompleteChainstateInitialization(chainman, options);
181	0	if (init_status != ChainstateLoadStatus::SUCCESS) {
182	0	return {init_status, init_error};
183	0	}
184
185		// If a snapshot chainstate was fully validated by a background chainstate during
186		// the last run, detect it here and clean up the now-unneeded background
187		// chainstate.
188		//
189		// Why is this cleanup done here (on subsequent restart) and not just when the
190		// snapshot is actually validated? Because this entails unusual
191		// filesystem operations to move leveldb data directories around, and that seems
192		// too risky to do in the middle of normal runtime.
193	0	auto snapshot_completion = chainman.MaybeCompleteSnapshotValidation();
194
195	0	if (snapshot_completion == SnapshotCompletionResult::SKIPPED) {
196		// do nothing; expected case
197	0	} else if (snapshot_completion == SnapshotCompletionResult::SUCCESS) {
198	0	LogPrintf("[snapshot] cleaning up unneeded background chainstate, then reinitializing\n");
199	0	if (!chainman.ValidatedSnapshotCleanup()) {
200	0	return {ChainstateLoadStatus::FAILURE_FATAL, Untranslated("Background chainstate cleanup failed unexpectedly.")};
201	0	}
202
203		// Because ValidatedSnapshotCleanup() has torn down chainstates with
204		// ChainstateManager::ResetChainstates(), reinitialize them here without
205		// duplicating the blockindex work above.
206	0	assert(chainman.GetAll().empty());
207	0	assert(!chainman.IsSnapshotActive());
208	0	assert(!chainman.IsSnapshotValidated());
209
210	0	chainman.InitializeChainstate(options.mempool);
211
212		// A reload of the block index is required to recompute setBlockIndexCandidates
213		// for the fully validated chainstate.
214	0	chainman.ActiveChainstate().ClearBlockIndexCandidates();
215
216	0	auto [init_status, init_error] = CompleteChainstateInitialization(chainman, options);
217	0	if (init_status != ChainstateLoadStatus::SUCCESS) {
218	0	return {init_status, init_error};
219	0	}
220	0	} else {
221	0	return {ChainstateLoadStatus::FAILURE_FATAL, _(
222	0	"UTXO snapshot failed to validate. "
223	0	"Restart to resume normal initial block download, or try loading a different snapshot.")};
224	0	}
225
226	0	return {ChainstateLoadStatus::SUCCESS, {}};
227	0	}
228
229		ChainstateLoadResult VerifyLoadedChainstate(ChainstateManager& chainman, const ChainstateLoadOptions& options)
230	0	{
231	0	auto is_coinsview_empty = [&](Chainstate* chainstate) EXCLUSIVE_LOCKS_REQUIRED(::cs_main) {
232	0	return options.wipe_chainstate_db \|\| chainstate->CoinsTip().GetBestBlock().IsNull();
233	0	};
234
235	0	LOCK(cs_main);
236
237	0	for (Chainstate* chainstate : chainman.GetAll()) {
238	0	if (!is_coinsview_empty(chainstate)) {
239	0	const CBlockIndex* tip = chainstate->m_chain.Tip();
240	0	if (tip && tip->nTime > GetTime() + MAX_FUTURE_BLOCK_TIME) {
241	0	return {ChainstateLoadStatus::FAILURE, _("The block database contains a block which appears to be from the future. "
242	0	"This may be due to your computer's date and time being set incorrectly. "
243	0	"Only rebuild the block database if you are sure that your computer's date and time are correct")};
244	0	}
245
246	0	VerifyDBResult result = CVerifyDB(chainman.GetNotifications()).VerifyDB(
247	0	*chainstate, chainman.GetConsensus(), chainstate->CoinsDB(),
248	0	options.check_level,
249	0	options.check_blocks);
250	0	switch (result) {
251	0	case VerifyDBResult::SUCCESS:
252	0	case VerifyDBResult::SKIPPED_MISSING_BLOCKS:
253	0	break;
254	0	case VerifyDBResult::INTERRUPTED:
255	0	return {ChainstateLoadStatus::INTERRUPTED, _("Block verification was interrupted")};
256	0	case VerifyDBResult::CORRUPTED_BLOCK_DB:
257	0	return {ChainstateLoadStatus::FAILURE, _("Corrupted block database detected")};
258	0	case VerifyDBResult::SKIPPED_L3_CHECKS:
259	0	if (options.require_full_verification) {
260	0	return {ChainstateLoadStatus::FAILURE_INSUFFICIENT_DBCACHE, _("Insufficient dbcache for block verification")};
261	0	}
262	0	break;
263	0	} // no default case, so the compiler can warn about missing cases
264	0	}
265	0	}
266
267	0	return {ChainstateLoadStatus::SUCCESS, {}};
268	0	}
269		} // namespace node