Where validation becomes chain state

6251bool ChainstateManager::DeleteChainstate(Chainstate& chainstate)
6252{
6253    AssertLockHeld(::cs_main);
6254    assert(!chainstate.m_coins_views);
6255    const fs::path db_path{chainstate.StoragePath()};
6256    if (!DeleteCoinsDBFromDisk(db_path, /*is_snapshot=*/bool{chainstate.m_from_snapshot_blockhash})) {
6257        LogError("Deletion of %s failed. Please remove it manually to continue reindexing.",
6258                  fs::PathToString(db_path));
6259        return false;
6260    }
6261    std::unique_ptr<Chainstate> prev_chainstate{Assert(RemoveChainstate(chainstate))};
6262    Chainstate& curr_chainstate{CurrentChainstate()};
6263    assert(!prev_chainstate->m_mempool || prev_chainstate->m_mempool->size() == 0);
6264    assert(!curr_chainstate.m_mempool);
6265    std::swap(curr_chainstate.m_mempool, prev_chainstate->m_mempool);
6266    return true;
6267}
6268
6269ChainstateRole Chainstate::GetRole() const
6270{
6271    return ChainstateRole{.validated = m_assumeutxo == Assumeutxo::VALIDATED, .historical = bool{m_target_blockhash}};
6272}
6273
6274void ChainstateManager::RecalculateBestHeader()
6275{
6276    AssertLockHeld(cs_main);
6277    m_best_header = ActiveChain().Tip();
6278    for (auto& entry : m_blockman.m_block_index) {
6279        if (!(entry.second.nStatus & BLOCK_FAILED_VALID) && m_best_header->nChainWork < entry.second.nChainWork) {
6280            m_best_header = &entry.second;
6281        }
6282    }
6283}
6284
6285std::optional<int> ChainstateManager::BlocksAheadOfTip() const
6286{
6287    LOCK(::cs_main);
6288    const CBlockIndex* best_header{m_best_header};
6289    const CBlockIndex* tip{ActiveChain().Tip()};
6290    // Only consider headers that extend the active tip; ignore competing branches.
6291    if (best_header && tip && best_header->nChainWork > tip->nChainWork &&
6292        best_header->GetAncestor(tip->nHeight) == tip) {
6293        return best_header->nHeight - tip->nHeight;
6294    }
6295    return std::nullopt;
6296}
6297
6298bool ChainstateManager::ValidatedSnapshotCleanup(Chainstate& validated_cs, Chainstate& unvalidated_cs)
6299{
6300    AssertLockHeld(::cs_main);
6301    if (unvalidated_cs.m_assumeutxo != Assumeutxo::VALIDATED) {
6302        // No need to clean up.
6303        return false;
6304    }
6305
6306    const fs::path validated_path{validated_cs.StoragePath()};
6307    const fs::path assumed_valid_path{unvalidated_cs.StoragePath()};
6308    const fs::path delete_path{validated_path + "_todelete"};
6309
6310    // Since we're going to be moving around the underlying leveldb filesystem content
6311    // for each chainstate, make sure that the chainstates (and their constituent
6312    // CoinsViews members) have been destructed first.
6313    //
6314    // The caller of this method will be responsible for reinitializing chainstates
6315    // if they want to continue operation.
6316    this->ResetChainstates();
6317    assert(this->m_chainstates.size() == 0);
6318
6319    LogInfo("[snapshot] deleting background chainstate directory (now unnecessary) (%s)",
6320              fs::PathToString(validated_path));
6321
6322    auto rename_failed_abort = [this](
6323                                   fs::path p_old,
6324                                   fs::path p_new,
6325                                   const fs::filesystem_error& err) {
6326        LogError("[snapshot] Error renaming path (%s) -> (%s): %s\n",
6327                  fs::PathToString(p_old), fs::PathToString(p_new), err.what());
6328        GetNotifications().fatalError(strprintf(_(
6329            "Rename of '%s' -> '%s' failed. "
6330            "Cannot clean up the background chainstate leveldb directory."),
6331            fs::PathToString(p_old), fs::PathToString(p_new)));
6332    };
6333
6334    try {
6335        fs::rename(validated_path, delete_path);
6336    } catch (const fs::filesystem_error& e) {
6337        rename_failed_abort(validated_path, delete_path, e);
6338        throw;
6339    }
6340
6341    LogInfo("[snapshot] moving snapshot chainstate (%s) to "
6342              "default chainstate directory (%s)",
6343              fs::PathToString(assumed_valid_path), fs::PathToString(validated_path));
6344
6345    try {
6346        fs::rename(assumed_valid_path, validated_path);
6347    } catch (const fs::filesystem_error& e) {
6348        rename_failed_abort(assumed_valid_path, validated_path, e);
6349        throw;
6350    }
6351
6352    if (!DeleteCoinsDBFromDisk(delete_path, /*is_snapshot=*/false)) {
6353        // No need to FatalError because once the unneeded bg chainstate data is
6354        // moved, it will not interfere with subsequent initialization.
6355        LogWarning("Deletion of %s failed. Please remove it manually, as the "
6356                   "directory is now unnecessary.",
6357                   fs::PathToString(delete_path));
6358    } else {
6359        LogInfo("[snapshot] deleted background chainstate directory (%s)",
6360                fs::PathToString(validated_path));
6361    }
6362    return true;
6363}
6364
6365std::pair<int, int> Chainstate::GetPruneRange(int last_height_can_prune) const
6366{
6367    if (m_chain.Height() <= 0) {
6368        return {0, 0};
6369    }
6370    int prune_start{0};
6371
6372    if (m_from_snapshot_blockhash && m_assumeutxo != Assumeutxo::VALIDATED) {
6373        // Only prune blocks _after_ the snapshot if this is a snapshot chain
6374        // that has not been fully validated yet. The earlier blocks need to be
6375        // kept to validate the snapshot
6376        prune_start = Assert(SnapshotBase())->nHeight + 1;
6377    }
6378
6379    int max_prune = std::max<int>(
6380        0, m_chain.Height() - static_cast<int>(MIN_BLOCKS_TO_KEEP));
6381
6382    // last block to prune is the lesser of (caller-specified height, MIN_BLOCKS_TO_KEEP from the tip)
6383    //
6384    // While you might be tempted to prune the background chainstate more
6385    // aggressively (i.e. fewer MIN_BLOCKS_TO_KEEP), this won't work with index
6386    // building - specifically blockfilterindex requires undo data, and if
6387    // we don't maintain this trailing window, we hit indexing failures.
6388    int prune_end = std::min(last_height_can_prune, max_prune);
6389
6390    return {prune_start, prune_end};
6391}
6392
6393std::optional<std::pair<const CBlockIndex*, const CBlockIndex*>> ChainstateManager::GetHistoricalBlockRange() const
6394{
6395    const Chainstate* chainstate{HistoricalChainstate()};
6396    if (!chainstate) return {};
6397    return std::make_pair(chainstate->m_chain.Tip(), chainstate->TargetBlock());
6398}
6399
6400util::Result<void> ChainstateManager::ActivateBestChains()
6401{
6402    // We can't hold cs_main during ActivateBestChain even though we're accessing
6403    // the chainman unique_ptrs since ABC requires us not to be holding cs_main, so retrieve
6404    // the relevant pointers before the ABC call.
6405    AssertLockNotHeld(cs_main);
6406    std::vector<Chainstate*> chainstates;
6407    {
6408        LOCK(GetMutex());
6409        chainstates.reserve(m_chainstates.size());
6410        for (const auto& chainstate : m_chainstates) {
6411            if (chainstate && chainstate->m_assumeutxo != Assumeutxo::INVALID && !chainstate->m_target_utxohash) {
6412                chainstates.push_back(chainstate.get());
6413            }
6414        }
6415    }
6416    for (Chainstate* chainstate : chainstates) {
6417        BlockValidationState state;
6418        if (!chainstate->ActivateBestChain(state, nullptr)) {
6419            LOCK(GetMutex());
6420            return util::Error{Untranslated(strprintf("%s Failed to connect best block (%s)", chainstate->ToString(), state.ToString()))};
6421        }
6422    }
6423    return {};
6424}
6425