Where validation becomes chain state

3001struct ConnectedBlock {
3002    const CBlockIndex* pindex;
3003    std::shared_ptr<const CBlock> pblock;
3004};
3005
3006/**
3007 * Connect a new block to m_chain. block_to_connect is either nullptr or a pointer to a CBlock
3008 * corresponding to pindexNew, to bypass loading it again from disk.
3009 *
3010 * The block is added to connected_blocks if connection succeeds.
3011 */
3012bool Chainstate::ConnectTip(
3013    BlockValidationState& state,
3014    CBlockIndex* pindexNew,
3015    std::shared_ptr<const CBlock> block_to_connect,
3016    std::vector<ConnectedBlock>& connected_blocks,
3017    DisconnectedBlockTransactions& disconnectpool)
3018{
3019    AssertLockHeld(cs_main);
3020    if (m_mempool) AssertLockHeld(m_mempool->cs);
3021
3022    assert(pindexNew->pprev == m_chain.Tip());
3023    // Read block from disk.
3024    const auto time_1{SteadyClock::now()};
3025    if (!block_to_connect) {
3026        std::shared_ptr<CBlock> pblockNew = std::make_shared<CBlock>();
3027        if (!m_blockman.ReadBlock(*pblockNew, *pindexNew)) {
3028            return FatalError(m_chainman.GetNotifications(), state, _("Failed to read block."));
3029        }
3030        block_to_connect = std::move(pblockNew);
3031    } else {
3032        LogDebug(BCLog::BENCH, "  - Using cached block\n");
3033    }
3034    // Apply the block atomically to the chain state.
3035    const auto time_2{SteadyClock::now()};
3036    SteadyClock::time_point time_3;
3037    // When adding aggregate statistics in the future, keep in mind that
3038    // num_blocks_total may be zero until the ConnectBlock() call below.
3039    LogDebug(BCLog::BENCH, "  - Load block from disk: %.2fms\n",
3040             Ticks<MillisecondsDouble>(time_2 - time_1));
3041    {
3042        CoinsViewOverlay& view{*m_coins_views->m_connect_block_view};
3043        const auto reset_guard{view.StartFetching(*block_to_connect)};
3044        bool rv = ConnectBlock(*block_to_connect, state, pindexNew, view);
3045        if (m_chainman.m_options.signals) {
3046            m_chainman.m_options.signals->BlockChecked(block_to_connect, state);
3047        }
3048        if (!rv) {
3049            if (state.IsInvalid())
3050                InvalidBlockFound(pindexNew, state);
3051            LogError("%s: ConnectBlock %s failed, %s\n", __func__, pindexNew->GetBlockHash().ToString(), state.ToString());
3052            return false;
3053        }
3054        time_3 = SteadyClock::now();
3055        m_chainman.time_connect_total += time_3 - time_2;
3056        assert(m_chainman.num_blocks_total > 0);
3057        LogDebug(BCLog::BENCH, "  - Connect total: %.2fms [%.2fs (%.2fms/blk)]\n",
3058                 Ticks<MillisecondsDouble>(time_3 - time_2),
3059                 Ticks<SecondsDouble>(m_chainman.time_connect_total),
3060                 Ticks<MillisecondsDouble>(m_chainman.time_connect_total) / m_chainman.num_blocks_total);
3061        view.Flush(/*reallocate_cache=*/false); // No need to reallocate since it only has capacity for 1 block
3062    }
3063    const auto time_4{SteadyClock::now()};
3064    m_chainman.time_flush += time_4 - time_3;
3065    LogDebug(BCLog::BENCH, "  - Flush: %.2fms [%.2fs (%.2fms/blk)]\n",
3066             Ticks<MillisecondsDouble>(time_4 - time_3),
3067             Ticks<SecondsDouble>(m_chainman.time_flush),
3068             Ticks<MillisecondsDouble>(m_chainman.time_flush) / m_chainman.num_blocks_total);
3069    // Write the chain state to disk, if necessary.
3070    if (!FlushStateToDisk(state, FlushStateMode::IF_NEEDED)) {
3071        return false;
3072    }
3073    const auto time_5{SteadyClock::now()};
3074    m_chainman.time_chainstate += time_5 - time_4;
3075    LogDebug(BCLog::BENCH, "  - Writing chainstate: %.2fms [%.2fs (%.2fms/blk)]\n",
3076             Ticks<MillisecondsDouble>(time_5 - time_4),
3077             Ticks<SecondsDouble>(m_chainman.time_chainstate),
3078             Ticks<MillisecondsDouble>(m_chainman.time_chainstate) / m_chainman.num_blocks_total);
3079    // Remove conflicting transactions from the mempool.
3080    std::vector<RemovedMempoolTransactionInfo> txs_removed_for_block;
3081    if (m_mempool) {
3082        txs_removed_for_block = m_mempool->removeForBlock(block_to_connect->vtx);
3083        disconnectpool.removeForBlock(block_to_connect->vtx);
3084    }
3085    // Update m_chain & related variables.
3086    m_chain.SetTip(*pindexNew);
3087    m_chainman.UpdateIBDStatus();
3088    // Not fired while IBD is active. removeForBlock() above still runs.
3089    if (m_mempool && m_chainman.m_options.signals && !m_chainman.IsInitialBlockDownload()) {
3090        m_chainman.m_options.signals->MempoolTransactionsRemovedForBlock(block_to_connect, std::move(txs_removed_for_block), pindexNew->nHeight);
3091    }
3092    UpdateTip(pindexNew);
3093
3094    const auto time_6{SteadyClock::now()};
3095    m_chainman.time_post_connect += time_6 - time_5;
3096    m_chainman.time_total += time_6 - time_1;
3097    LogDebug(BCLog::BENCH, "  - Connect postprocess: %.2fms [%.2fs (%.2fms/blk)]\n",
3098             Ticks<MillisecondsDouble>(time_6 - time_5),
3099             Ticks<SecondsDouble>(m_chainman.time_post_connect),
3100             Ticks<MillisecondsDouble>(m_chainman.time_post_connect) / m_chainman.num_blocks_total);
3101    LogDebug(BCLog::BENCH, "- Connect block: %.2fms [%.2fs (%.2fms/blk)]\n",
3102             Ticks<MillisecondsDouble>(time_6 - time_1),
3103             Ticks<SecondsDouble>(m_chainman.time_total),
3104             Ticks<MillisecondsDouble>(m_chainman.time_total) / m_chainman.num_blocks_total);
3105
3106    // See if this chainstate has reached a target block and can be used to
3107    // validate an assumeutxo snapshot. If it can, hashing the UTXO database
3108    // will be slow, and cs_main could remain locked here for several minutes.
3109    // If the snapshot is validated, the UTXO hash will be saved to
3110    // this->m_target_utxohash, causing HistoricalChainstate() to return null
3111    // and this chainstate to no longer be used. ActivateBestChain() will also
3112    // stop connecting blocks to this chainstate because this->ReachedTarget()
3113    // will be true and this->setBlockIndexCandidates will not have additional
3114    // blocks.
3115    Chainstate& current_cs{m_chainman.CurrentChainstate()};
3116    m_chainman.MaybeValidateSnapshot(*this, current_cs);
3117
3118    connected_blocks.emplace_back(pindexNew, std::move(block_to_connect));
3119    return true;
3120}
3121
3122/**
3123 * Return the tip of the chain with the most work in it, that isn't
3124 * known to be invalid (it's however far from certain to be valid).
3125 */
3126CBlockIndex* Chainstate::FindMostWorkChain()
3127{
3128    AssertLockHeld(::cs_main);
3129    do {
3130        CBlockIndex *pindexNew = nullptr;
3131
3132        // Find the best candidate header.
3133        {
3134            std::set<CBlockIndex*, CBlockIndexWorkComparator>::reverse_iterator it = setBlockIndexCandidates.rbegin();
3135            if (it == setBlockIndexCandidates.rend())
3136                return nullptr;
3137            pindexNew = *it;
3138        }
3139
3140        // Check whether all blocks on the path between the currently active chain and the candidate are valid.
3141        // Just going until the active chain is an optimization, as we know all blocks in it are valid already.
3142        bool fInvalidAncestor = false;
3143        for (CBlockIndex *pindexTest = pindexNew; pindexTest && !m_chain.Contains(*pindexTest); pindexTest = pindexTest->pprev) {
3144            assert(pindexTest->HaveNumChainTxs() || pindexTest->nHeight == 0);
3145
3146            // Pruned nodes may have entries in setBlockIndexCandidates for
3147            // which block files have been deleted.  Remove those as candidates
3148            // for the most work chain if we come across them; we can't switch
3149            // to a chain unless we have all the non-active-chain parent blocks.
3150            bool fFailedChain = pindexTest->nStatus & BLOCK_FAILED_VALID;
3151            bool fMissingData = !(pindexTest->nStatus & BLOCK_HAVE_DATA);
3152            if (fFailedChain || fMissingData) {
3153                // Candidate chain is not usable (either invalid or missing data)
3154                if (fFailedChain && (m_chainman.m_best_invalid == nullptr || pindexNew->nChainWork > m_chainman.m_best_invalid->nChainWork)) {
3155                    m_chainman.m_best_invalid = pindexNew;
3156                }
3157                // Remove the entire chain from the set.
3158                for (CBlockIndex *pindexFailed = pindexNew; pindexFailed != pindexTest; pindexFailed = pindexFailed->pprev) {
3159                    // If we're missing data and not a descendant of an invalid block,
3160                    // then add back to m_blocks_unlinked, so that if the block arrives in the future
3161                    // we can try adding to setBlockIndexCandidates again.
3162                    if (fMissingData && !fFailedChain) {
3163                        // Avoid duplicate entries in m_blocks_unlinked. If the same entry is
3164                        // processed twice in ReceivedBlockTransactions(), it may be re-added to
3165                        // setBlockIndexCandidates with a modified nSequenceId, breaking ordering
3166                        // guarantees and leading to undefined behavior.
3167                        m_blockman.AddUnlinkedBlock(pindexFailed);
3168                    }
3169                    setBlockIndexCandidates.erase(pindexFailed);
3170                }
3171                setBlockIndexCandidates.erase(pindexTest);
3172                fInvalidAncestor = true;
3173                break;
3174            }
3175        }
3176        if (!fInvalidAncestor)
3177            return pindexNew;
3178    } while(true);
3179}
3180
3181/** Delete all entries in setBlockIndexCandidates that are worse than the current tip. */
3182void Chainstate::PruneBlockIndexCandidates() {
3183    // Note that we can't delete the current block itself, as we may need to return to it later in case a
3184    // reorganization to a better block fails.
3185    std::set<CBlockIndex*, CBlockIndexWorkComparator>::iterator it = setBlockIndexCandidates.begin();
3186    while (it != setBlockIndexCandidates.end() && setBlockIndexCandidates.value_comp()(*it, m_chain.Tip())) {
3187        setBlockIndexCandidates.erase(it++);
3188    }
3189    // Either the current tip or a successor of it we're working towards is left in setBlockIndexCandidates.
3190    assert(!setBlockIndexCandidates.empty());
3191}
3192
3193/**
3194 * Try to make some progress towards making index_most_work the active block.
3195 * pblock is either nullptr or a pointer to a CBlock corresponding to index_most_work.
3196 *
3197 * @returns true unless a system error occurred
3198 */
3199bool Chainstate::ActivateBestChainStep(BlockValidationState& state, CBlockIndex& index_most_work, const std::shared_ptr<const CBlock>& pblock, bool& fInvalidFound, std::vector<ConnectedBlock>& connected_blocks)
3200{
3201    AssertLockHeld(cs_main);
3202    if (m_mempool) AssertLockHeld(m_mempool->cs);
3203
3204    const CBlockIndex* pindexOldTip = m_chain.Tip();
3205    const CBlockIndex* pindexFork = m_chain.FindFork(index_most_work);
3206
3207    // Disconnect active blocks which are no longer in the best chain.
3208    bool fBlocksDisconnected = false;
3209    DisconnectedBlockTransactions disconnectpool{MAX_DISCONNECTED_TX_POOL_BYTES};
3210    while (m_chain.Tip() && m_chain.Tip() != pindexFork) {
3211        if (!DisconnectTip(state, &disconnectpool)) {
3212            // This is likely a fatal error, but keep the mempool consistent,
3213            // just in case. Only remove from the mempool in this case.
3214            MaybeUpdateMempoolForReorg(disconnectpool, false);
3215
3216            // If we're unable to disconnect a block during normal operation,
3217            // then that is a failure of our local system -- we should abort
3218            // rather than stay on a less work chain.
3219            FatalError(m_chainman.GetNotifications(), state, _("Failed to disconnect block."));
3220            return false;
3221        }
3222        fBlocksDisconnected = true;
3223    }
3224
3225    // Build list of new blocks to connect (in descending height order).
3226    std::vector<CBlockIndex*> vpindexToConnect;
3227    bool fContinue = true;
3228    int nHeight = pindexFork ? pindexFork->nHeight : -1;
3229    while (fContinue && nHeight != index_most_work.nHeight) {
3230        // Don't iterate the entire list of potential improvements toward the best tip, as we likely only need
3231        // a few blocks along the way.
3232        int nTargetHeight = std::min(nHeight + 32, index_most_work.nHeight);
3233        vpindexToConnect.clear();
3234        vpindexToConnect.reserve(nTargetHeight - nHeight);
3235        CBlockIndex* pindexIter = index_most_work.GetAncestor(nTargetHeight);
3236        while (pindexIter && pindexIter->nHeight != nHeight) {
3237            vpindexToConnect.push_back(pindexIter);
3238            pindexIter = pindexIter->pprev;
3239        }
3240        nHeight = nTargetHeight;
3241
3242        // Connect new blocks.
3243        for (CBlockIndex* pindexConnect : vpindexToConnect | std::views::reverse) {
3244            if (!ConnectTip(state, pindexConnect, pindexConnect == &index_most_work ? pblock : std::shared_ptr<const CBlock>(), connected_blocks, disconnectpool)) {
3245                if (state.IsInvalid()) {
3246                    // The block violates a consensus rule.
3247                    if (state.GetResult() != BlockValidationResult::BLOCK_MUTATED) {
3248                        InvalidChainFound(vpindexToConnect.front());
3249                    }
3250                    state = BlockValidationState();