Where validation becomes chain state

4751            if (chainstate.m_chainman.m_interrupt) return VerifyDBResult::INTERRUPTED;
4752        }
4753    }
4754
4755    LogInfo("Verification: checked last %i blocks at level %i", block_count, nCheckLevel);
4756    if (nCheckLevel >= 3 && !skipped_l3_checks) {
4757        LogInfo("Verification: no coin database inconsistencies (%i transactions)", nGoodTransactions);
4758    }
4759
4760    if (skipped_l3_checks) {
4761        return VerifyDBResult::SKIPPED_L3_CHECKS;
4762    }
4763    if (skipped_no_block_data) {
4764        return VerifyDBResult::SKIPPED_MISSING_BLOCKS;
4765    }
4766    return VerifyDBResult::SUCCESS;
4767}
4768
4769/** Apply the effects of a block on the utxo cache, ignoring that it may already have been applied. */
4770bool Chainstate::RollforwardBlock(const CBlockIndex* pindex, CCoinsViewCache& inputs)
4771{
4772    AssertLockHeld(cs_main);
4773    // TODO: merge with ConnectBlock
4774    CBlock block;
4775    if (!m_blockman.ReadBlock(block, *pindex)) {
4776        LogError("ReplayBlock(): ReadBlock failed at %d, hash=%s\n", pindex->nHeight, pindex->GetBlockHash().ToString());
4777        return false;
4778    }
4779
4780    for (const CTransactionRef& tx : block.vtx) {
4781        if (!tx->IsCoinBase()) {
4782            for (const CTxIn &txin : tx->vin) {
4783                inputs.SpendCoin(txin.prevout);
4784            }
4785        }
4786        // Pass check = true as every addition may be an overwrite.
4787        AddCoins(inputs, *tx, pindex->nHeight, true);
4788    }
4789    return true;
4790}
4791
4792bool Chainstate::ReplayBlocks()
4793{
4794    LOCK(cs_main);
4795
4796    CCoinsView& db = this->CoinsDB();
4797    CCoinsViewCache cache(&db);
4798
4799    std::vector<uint256> hashHeads = db.GetHeadBlocks();
4800    if (hashHeads.empty()) return true; // We're already in a consistent state.
4801    if (hashHeads.size() != 2) {
4802        LogError("ReplayBlocks(): unknown inconsistent state\n");
4803        return false;
4804    }
4805
4806    m_chainman.GetNotifications().progress(_("Replaying blocks…"), 0, false);
4807    LogInfo("Replaying blocks");
4808
4809    const CBlockIndex* pindexOld = nullptr;  // Old tip during the interrupted flush.
4810    const CBlockIndex* pindexNew;            // New tip during the interrupted flush.
4811    const CBlockIndex* pindexFork = nullptr; // Latest block common to both the old and the new tip.
4812
4813    if (!m_blockman.m_block_index.contains(hashHeads[0])) {
4814        LogError("ReplayBlocks(): reorganization to unknown block requested\n");
4815        return false;
4816    }
4817    pindexNew = &(m_blockman.m_block_index[hashHeads[0]]);
4818
4819    if (!hashHeads[1].IsNull()) { // The old tip is allowed to be 0, indicating it's the first flush.
4820        if (!m_blockman.m_block_index.contains(hashHeads[1])) {
4821            LogError("ReplayBlocks(): reorganization from unknown block requested\n");
4822            return false;
4823        }
4824        pindexOld = &(m_blockman.m_block_index[hashHeads[1]]);
4825        pindexFork = LastCommonAncestor(pindexOld, pindexNew);
4826        assert(pindexFork != nullptr);
4827    }
4828
4829    // Rollback along the old branch.
4830    const int nForkHeight{pindexFork ? pindexFork->nHeight : 0};
4831    if (pindexOld != pindexFork) {
4832        LogInfo("Rolling back from %s (%i to %i)", pindexOld->GetBlockHash().ToString(), pindexOld->nHeight, nForkHeight);
4833        while (pindexOld != pindexFork) {
4834            if (pindexOld->nHeight > 0) { // Never disconnect the genesis block.
4835                CBlock block;
4836                if (!m_blockman.ReadBlock(block, *pindexOld)) {
4837                    LogError("RollbackBlock(): ReadBlock() failed at %d, hash=%s\n", pindexOld->nHeight, pindexOld->GetBlockHash().ToString());
4838                    return false;
4839                }
4840                if (pindexOld->nHeight % 10'000 == 0) {
4841                    LogInfo("Rolling back %s (%i)", pindexOld->GetBlockHash().ToString(), pindexOld->nHeight);
4842                }
4843                DisconnectResult res = DisconnectBlock(block, pindexOld, cache);
4844                if (res == DISCONNECT_FAILED) {
4845                    LogError("RollbackBlock(): DisconnectBlock failed at %d, hash=%s\n", pindexOld->nHeight, pindexOld->GetBlockHash().ToString());
4846                    return false;
4847                }
4848                // If DISCONNECT_UNCLEAN is returned, it means a non-existing UTXO was deleted, or an existing UTXO was
4849                // overwritten. It corresponds to cases where the block-to-be-disconnect never had all its operations
4850                // applied to the UTXO set. However, as both writing a UTXO and deleting a UTXO are idempotent operations,
4851                // the result is still a version of the UTXO set with the effects of that block undone.
4852            }
4853            pindexOld = pindexOld->pprev;
4854        }
4855        LogInfo("Rolled back to %s", pindexFork->GetBlockHash().ToString());
4856    }
4857
4858    // Roll forward from the forking point to the new tip.
4859    if (nForkHeight < pindexNew->nHeight) {
4860        LogInfo("Rolling forward to %s (%i to %i)", pindexNew->GetBlockHash().ToString(), nForkHeight, pindexNew->nHeight);
4861        for (int nHeight = nForkHeight + 1; nHeight <= pindexNew->nHeight; ++nHeight) {
4862            const CBlockIndex& pindex{*Assert(pindexNew->GetAncestor(nHeight))};
4863
4864            if (nHeight % 10'000 == 0) {
4865                LogInfo("Rolling forward %s (%i)", pindex.GetBlockHash().ToString(), nHeight);
4866            }
4867            m_chainman.GetNotifications().progress(_("Replaying blocks…"), (int)((nHeight - nForkHeight) * 100.0 / (pindexNew->nHeight - nForkHeight)), false);
4868            if (!RollforwardBlock(&pindex, cache)) return false;
4869        }
4870        LogInfo("Rolled forward to %s", pindexNew->GetBlockHash().ToString());
4871    }
4872
4873    cache.SetBestBlock(pindexNew->GetBlockHash());
4874    cache.Flush(/*reallocate_cache=*/false); // local CCoinsViewCache goes out of scope
4875    m_chainman.GetNotifications().progress(bilingual_str{}, 100, false);
4876    return true;
4877}
4878
4879bool Chainstate::NeedsRedownload() const
4880{
4881    AssertLockHeld(cs_main);
4882
4883    // At and above m_params.SegwitHeight, segwit consensus rules must be validated
4884    CBlockIndex* block{m_chain.Tip()};
4885
4886    while (block != nullptr && DeploymentActiveAt(*block, m_chainman, Consensus::DEPLOYMENT_SEGWIT)) {
4887        if (!(block->nStatus & BLOCK_OPT_WITNESS)) {
4888            // block is insufficiently validated for a segwit client
4889            return true;
4890        }
4891        block = block->pprev;
4892    }
4893
4894    return false;
4895}
4896
4897void Chainstate::ClearBlockIndexCandidates()
4898{
4899    AssertLockHeld(::cs_main);
4900    setBlockIndexCandidates.clear();
4901}
4902
4903void Chainstate::PopulateBlockIndexCandidates()
4904{
4905    AssertLockHeld(::cs_main);
4906
4907    for (CBlockIndex* pindex : m_blockman.GetAllBlockIndices()) {
4908        // With assumeutxo, the snapshot block is a candidate for the tip, but it
4909        // may not have BLOCK_VALID_TRANSACTIONS (e.g. if we haven't yet downloaded
4910        // the block), so we special-case it here.
4911        if (pindex == SnapshotBase() ||
4912                (pindex->IsValid(BLOCK_VALID_TRANSACTIONS) &&
4913                 (pindex->HaveNumChainTxs() || pindex->pprev == nullptr))) {
4914            TryAddBlockIndexCandidate(pindex);
4915        }
4916    }
4917}
4918
4919bool ChainstateManager::LoadBlockIndex()
4920{
4921    AssertLockHeld(cs_main);
4922    // Load block index from databases
4923    if (m_blockman.m_blockfiles_indexed) {
4924        bool ret{m_blockman.LoadBlockIndexDB(CurrentChainstate().m_from_snapshot_blockhash)};
4925        if (!ret) return false;
4926
4927        m_blockman.ScanAndUnlinkAlreadyPrunedFiles();
4928
4929        std::vector<CBlockIndex*> vSortedByHeight{m_blockman.GetAllBlockIndices()};
4930        std::sort(vSortedByHeight.begin(), vSortedByHeight.end(),
4931                  CBlockIndexHeightOnlyComparator());
4932
4933        for (CBlockIndex* pindex : vSortedByHeight) {
4934            if (m_interrupt) return false;
4935            if (pindex->nStatus & BLOCK_FAILED_VALID && (!m_best_invalid || pindex->nChainWork > m_best_invalid->nChainWork)) {
4936                m_best_invalid = pindex;
4937            }
4938            if (pindex->IsValid(BLOCK_VALID_TREE) && (m_best_header == nullptr || CBlockIndexWorkComparator()(m_best_header, pindex)))
4939                m_best_header = pindex;
4940        }
4941    }
4942    return true;
4943}
4944
4945bool ChainstateManager::LoadGenesisBlock()
4946{
4947    LOCK(cs_main);
4948
4949    const CBlock& genesis_block{GetParams().GenesisBlock()};
4950
4951    // Check whether we're already initialized by checking for genesis in
4952    // m_blockman.m_block_index. Note that we can't use a chainstate's m_chain here, since it is
4953    // set based on the coins db, not the block index db, which is the only
4954    // thing loaded at this point.
4955    if (m_blockman.m_block_index.contains(genesis_block.GetHash())) {
4956        return true;
4957    }
4958
4959    try {
4960        FlatFilePos blockPos{m_blockman.WriteBlock(genesis_block, 0)};
4961        if (blockPos.IsNull()) {
4962            LogError("Writing genesis block to disk failed");
4963            return false;
4964        }
4965        CBlockIndex* pindex{m_blockman.AddToBlockIndex(genesis_block, m_best_header)};
4966        ReceivedBlockTransactions(genesis_block, pindex, blockPos);
4967    } catch (const std::runtime_error& e) {
4968        LogError("Failed to write genesis block: %s", e.what());
4969        return false;
4970    }
4971
4972    return true;
4973}
4974
4975void ChainstateManager::LoadExternalBlockFile(
4976    AutoFile& file_in,
4977    FlatFilePos* dbp,
4978    std::multimap<uint256, FlatFilePos>* blocks_with_unknown_parent)
4979{
4980    // Either both should be specified (-reindex), or neither (-loadblock).
4981    assert(!dbp == !blocks_with_unknown_parent);
4982
4983    const auto start{SteadyClock::now()};
4984    const CChainParams& params{GetParams()};
4985
4986    int nLoaded = 0;
4987    try {
4988        BufferedFile blkdat{file_in, 2 * MAX_BLOCK_SERIALIZED_SIZE, MAX_BLOCK_SERIALIZED_SIZE + 8};
4989        // nRewind indicates where to resume scanning in case something goes wrong,
4990        // such as a block fails to deserialize.
4991        uint64_t nRewind = blkdat.GetPos();
4992        while (!blkdat.eof()) {
4993            if (m_interrupt) return;
4994
4995            blkdat.SetPos(nRewind);
4996            nRewind++; // start one byte further next time, in case of failure
4997            blkdat.SetLimit(); // remove former limit
4998            unsigned int nSize = 0;
4999            try {
5000                // locate a header