Where validation becomes chain state

4501        if (state.IsValid()) NONFATAL_UNREACHABLE();
4502        return state;
4503    }
4504
4505    /**
4506     * At this point ProcessNewBlock would call AcceptBlock(), but we
4507     * don't want to store the block or its header. Run individual checks
4508     * instead:
4509     * - skip AcceptBlockHeader() because:
4510     *   - we don't want to update the block index
4511     *   - we do not care about duplicates
4512     *   - we already ran CheckBlockHeader() via CheckBlock()
4513     *   - we already checked for prev-blk-not-found
4514     *   - we know the tip is valid, so no need to check bad-prevblk
4515     * - we already ran CheckBlock()
4516     * - do run ContextualCheckBlockHeader()
4517     * - do run ContextualCheckBlock()
4518     */
4519
4520    if (!ContextualCheckBlockHeader(block, state, chainstate.m_chainman, tip)) {
4521        if (state.IsValid()) NONFATAL_UNREACHABLE();
4522        return state;
4523    }
4524
4525    if (!ContextualCheckBlock(block, state, chainstate.m_chainman, tip)) {
4526        if (state.IsValid()) NONFATAL_UNREACHABLE();
4527        return state;
4528    }
4529
4530    // We don't want ConnectBlock to update the actual chainstate, so create
4531    // a cache on top of it, along with a dummy block index.
4532    CBlockIndex index_dummy{block};
4533    uint256 block_hash(block.GetHash());
4534    index_dummy.pprev = tip;
4535    index_dummy.nHeight = tip->nHeight + 1;
4536    index_dummy.phashBlock = &block_hash;
4537    CCoinsViewCache view_dummy(&chainstate.CoinsTip());
4538
4539    // Set fJustCheck to true in order to update, and not clear, validation caches.
4540    if(!chainstate.ConnectBlock(block, state, &index_dummy, view_dummy, /*fJustCheck=*/true)) {
4541        if (state.IsValid()) NONFATAL_UNREACHABLE();
4542        return state;
4543    }
4544
4545    // Ensure no check returned successfully while also setting an invalid state.
4546    if (!state.IsValid()) NONFATAL_UNREACHABLE();
4547
4548    return state;
4549}
4550
4551/* This function is called from the RPC code for pruneblockchain */
4552void PruneBlockFilesManual(Chainstate& active_chainstate, int nManualPruneHeight)
4553{
4554    BlockValidationState state;
4555    if (!active_chainstate.FlushStateToDisk(
4556            state, FlushStateMode::NONE, nManualPruneHeight)) {
4557        LogWarning("Failed to flush state after manual prune (%s)", state.ToString());
4558    }
4559}
4560
4561bool Chainstate::LoadChainTip()
4562{
4563    AssertLockHeld(cs_main);
4564    const CCoinsViewCache& coins_cache = CoinsTip();
4565    assert(!coins_cache.GetBestBlock().IsNull()); // Never called when the coins view is empty
4566    CBlockIndex* tip = m_chain.Tip();
4567
4568    if (tip && tip->GetBlockHash() == coins_cache.GetBestBlock()) {
4569        return true;
4570    }
4571
4572    // Load pointer to end of best chain
4573    CBlockIndex* pindex = m_blockman.LookupBlockIndex(coins_cache.GetBestBlock());
4574    if (!pindex) {
4575        return false;
4576    }
4577    m_chain.SetTip(*pindex);
4578    m_chainman.UpdateIBDStatus();
4579    m_last_flushed_block = pindex;
4580    tip = m_chain.Tip();
4581
4582    // nSequenceId is one of the keys used to sort setBlockIndexCandidates. Ensure all
4583    // candidate sets are empty to avoid UB, as nSequenceId is about to be modified.
4584    for (const auto& cs : m_chainman.m_chainstates) {
4585        assert(cs->setBlockIndexCandidates.empty());
4586    }
4587
4588    // Make sure our chain tip before shutting down scores better than any other candidate
4589    // to maintain a consistent best tip over reboots in case of a tie.
4590    auto target = tip;
4591    while (target) {
4592        target->nSequenceId = SEQ_ID_BEST_CHAIN_FROM_DISK;
4593        target = target->pprev;
4594    }
4595
4596    LogInfo("Loaded best chain: hashBestChain=%s height=%d date=%s progress=%f",
4597              tip->GetBlockHash().ToString(),
4598              m_chain.Height(),
4599              FormatISO8601DateTime(tip->GetBlockTime()),
4600              m_chainman.GuessVerificationProgress(tip));
4601
4602    // Ensure KernelNotifications m_tip_block is set even if no new block arrives.
4603    if (!this->GetRole().historical) {
4604        // Ignoring return value for now.
4605        (void)m_chainman.GetNotifications().blockTip(
4606            /*state=*/GetSynchronizationState(/*init=*/true, m_chainman.m_blockman.m_blockfiles_indexed),
4607            /*index=*/*pindex,
4608            /*verification_progress=*/m_chainman.GuessVerificationProgress(tip));
4609    }
4610
4611    CheckForkWarningConditions();
4612
4613    return true;
4614}
4615
4616CVerifyDB::CVerifyDB(Notifications& notifications)
4617    : m_notifications{notifications}
4618{
4619    m_notifications.progress(_("Verifying blocks…"), 0, false);
4620}
4621
4622CVerifyDB::~CVerifyDB()
4623{
4624    m_notifications.progress(bilingual_str{}, 100, false);
4625}
4626
4627VerifyDBResult CVerifyDB::VerifyDB(
4628    Chainstate& chainstate,
4629    const Consensus::Params& consensus_params,
4630    CCoinsView& coinsview,
4631    int nCheckLevel, int nCheckDepth)
4632{
4633    AssertLockHeld(cs_main);
4634
4635    if (chainstate.m_chain.Tip() == nullptr || chainstate.m_chain.Tip()->pprev == nullptr) {
4636        return VerifyDBResult::SUCCESS;
4637    }
4638
4639    // Verify blocks in the best chain
4640    if (nCheckDepth <= 0 || nCheckDepth > chainstate.m_chain.Height()) {
4641        nCheckDepth = chainstate.m_chain.Height();
4642    }
4643    nCheckLevel = std::max(0, std::min(4, nCheckLevel));
4644    LogInfo("Verifying last %i blocks at level %i", nCheckDepth, nCheckLevel);
4645    CCoinsViewCache coins(&coinsview);
4646    CBlockIndex* pindex;
4647    CBlockIndex* pindexFailure = nullptr;
4648    int nGoodTransactions = 0;
4649    BlockValidationState state;
4650    int reportDone = 0;
4651    bool skipped_no_block_data{false};
4652    bool skipped_l3_checks{false};
4653    LogInfo("Verification progress: 0%%");
4654
4655    const bool is_snapshot_cs{chainstate.m_from_snapshot_blockhash};
4656
4657    for (pindex = chainstate.m_chain.Tip(); pindex && pindex->pprev; pindex = pindex->pprev) {
4658        const int percentageDone = std::max(1, std::min(99, (int)(((double)(chainstate.m_chain.Height() - pindex->nHeight)) / (double)nCheckDepth * (nCheckLevel >= 4 ? 50 : 100))));
4659        if (reportDone < percentageDone / 10) {
4660            // report every 10% step
4661            LogInfo("Verification progress: %d%%", percentageDone);
4662            reportDone = percentageDone / 10;
4663        }
4664        m_notifications.progress(_("Verifying blocks…"), percentageDone, false);
4665        if (pindex->nHeight <= chainstate.m_chain.Height() - nCheckDepth) {
4666            break;
4667        }
4668        if ((chainstate.m_blockman.IsPruneMode() || is_snapshot_cs) && !(pindex->nStatus & BLOCK_HAVE_DATA)) {
4669            // If pruning or running under an assumeutxo snapshot, only go
4670            // back as far as we have data.
4671            LogInfo("Block verification stopping at height %d (no data). This could be due to pruning or use of an assumeutxo snapshot.", pindex->nHeight);
4672            skipped_no_block_data = true;
4673            break;
4674        }
4675        CBlock block;
4676        // check level 0: read from disk
4677        if (!chainstate.m_blockman.ReadBlock(block, *pindex)) {
4678            LogError("Verification error: ReadBlock failed at %d, hash=%s", pindex->nHeight, pindex->GetBlockHash().ToString());
4679            return VerifyDBResult::CORRUPTED_BLOCK_DB;
4680        }
4681        // check level 1: verify block validity
4682        if (nCheckLevel >= 1 && !CheckBlock(block, state, consensus_params)) {
4683            LogError("Verification error: found bad block at %d, hash=%s (%s)",
4684                      pindex->nHeight, pindex->GetBlockHash().ToString(), state.ToString());
4685            return VerifyDBResult::CORRUPTED_BLOCK_DB;
4686        }
4687        // check level 2: verify undo validity
4688        if (nCheckLevel >= 2 && pindex) {
4689            CBlockUndo undo;
4690            if (!pindex->GetUndoPos().IsNull()) {
4691                if (!chainstate.m_blockman.ReadBlockUndo(undo, *pindex)) {
4692                    LogError("Verification error: found bad undo data at %d, hash=%s", pindex->nHeight, pindex->GetBlockHash().ToString());
4693                    return VerifyDBResult::CORRUPTED_BLOCK_DB;
4694                }
4695            }
4696        }
4697        // check level 3: check for inconsistencies during memory-only disconnect of tip blocks
4698        size_t curr_coins_usage = coins.DynamicMemoryUsage() + chainstate.CoinsTip().DynamicMemoryUsage();
4699
4700        if (nCheckLevel >= 3) {
4701            if (curr_coins_usage <= chainstate.m_coinstip_cache_size_bytes) {
4702                assert(coins.GetBestBlock() == pindex->GetBlockHash());
4703                DisconnectResult res = chainstate.DisconnectBlock(block, pindex, coins);
4704                if (res == DISCONNECT_FAILED) {
4705                    LogError("Verification error: irrecoverable inconsistency in block data at %d, hash=%s", pindex->nHeight, pindex->GetBlockHash().ToString());
4706                    return VerifyDBResult::CORRUPTED_BLOCK_DB;
4707                }
4708                if (res == DISCONNECT_UNCLEAN) {
4709                    nGoodTransactions = 0;
4710                    pindexFailure = pindex;
4711                } else {
4712                    nGoodTransactions += block.vtx.size();
4713                }
4714            } else {
4715                skipped_l3_checks = true;
4716            }
4717        }
4718        if (chainstate.m_chainman.m_interrupt) return VerifyDBResult::INTERRUPTED;
4719    }
4720    if (pindexFailure) {
4721        LogError("Verification error: coin database inconsistencies found (last %i blocks, %i good transactions before that)", chainstate.m_chain.Height() - pindexFailure->nHeight + 1, nGoodTransactions);
4722        return VerifyDBResult::CORRUPTED_BLOCK_DB;
4723    }
4724    if (skipped_l3_checks) {
4725        LogWarning("Skipped verification of level >=3 (insufficient database cache size). Consider increasing -dbcache.");
4726    }
4727
4728    // store block count as we move pindex at check level >= 4
4729    int block_count = chainstate.m_chain.Height() - pindex->nHeight;
4730
4731    // check level 4: try reconnecting blocks
4732    if (nCheckLevel >= 4 && !skipped_l3_checks) {
4733        while (pindex != chainstate.m_chain.Tip()) {
4734            const int percentageDone = std::max(1, std::min(99, 100 - (int)(((double)(chainstate.m_chain.Height() - pindex->nHeight)) / (double)nCheckDepth * 50)));
4735            if (reportDone < percentageDone / 10) {
4736                // report every 10% step
4737                LogInfo("Verification progress: %d%%", percentageDone);
4738                reportDone = percentageDone / 10;
4739            }
4740            m_notifications.progress(_("Verifying blocks…"), percentageDone, false);
4741            pindex = chainstate.m_chain.Next(*pindex);
4742            CBlock block;
4743            if (!chainstate.m_blockman.ReadBlock(block, *pindex)) {
4744                LogError("Verification error: ReadBlock failed at %d, hash=%s", pindex->nHeight, pindex->GetBlockHash().ToString());
4745                return VerifyDBResult::CORRUPTED_BLOCK_DB;
4746            }
4747            if (!chainstate.ConnectBlock(block, state, pindex, coins)) {
4748                LogError("Verification error: found unconnectable block at %d, hash=%s (%s)", pindex->nHeight, pindex->GetBlockHash().ToString(), state.ToString());
4749                return VerifyDBResult::CORRUPTED_BLOCK_DB;
4750            }