Where validation becomes chain state

2501                    pindex->nHeight, block_hash.ToString());
2502        }
2503        m_last_script_check_reason_logged = script_check_reason;
2504    }
2505
2506    CBlockUndo blockundo;
2507
2508    // Precomputed transaction data pointers must not be invalidated
2509    // until after `control` has run the script checks (potentially
2510    // in multiple threads). Preallocate the vector size so a new allocation
2511    // doesn't invalidate pointers into the vector, and keep txsdata in scope
2512    // for as long as `control`.
2513    std::vector<PrecomputedTransactionData> txsdata(block.vtx.size());
2514    std::optional<CCheckQueueControl<CScriptCheck>> control;
2515    if (auto& queue = m_chainman.GetCheckQueue(); queue.HasThreads() && fScriptChecks) control.emplace(queue);
2516
2517    std::vector<int> prevheights;
2518    CAmount nFees = 0;
2519    int nInputs = 0;
2520    int64_t nSigOpsCost = 0;
2521    blockundo.vtxundo.reserve(block.vtx.size() - 1);
2522    for (unsigned int i = 0; i < block.vtx.size(); i++)
2523    {
2524        if (!state.IsValid()) break;
2525        const CTransaction &tx = *(block.vtx[i]);
2526
2527        nInputs += tx.vin.size();
2528
2529        if (!tx.IsCoinBase())
2530        {
2531            CAmount txfee = 0;
2532            TxValidationState tx_state;
2533            if (!Consensus::CheckTxInputs(tx, tx_state, view, pindex->nHeight, txfee)) {
2534                // Any transaction validation failure in ConnectBlock is a block consensus failure
2535                state.Invalid(BlockValidationResult::BLOCK_CONSENSUS,
2536                              tx_state.GetRejectReason(),
2537                              tx_state.GetDebugMessage() + " in transaction " + tx.GetHash().ToString());
2538                break;
2539            }
2540            nFees += txfee;
2541            if (!MoneyRange(nFees)) {
2542                state.Invalid(BlockValidationResult::BLOCK_CONSENSUS, "bad-txns-accumulated-fee-outofrange",
2543                              "accumulated fee in the block out of range");
2544                break;
2545            }
2546
2547            // Check that transaction is BIP68 final
2548            // BIP68 lock checks (as opposed to nLockTime checks) must
2549            // be in ConnectBlock because they require the UTXO set
2550            prevheights.resize(tx.vin.size());
2551            for (size_t j = 0; j < tx.vin.size(); j++) {
2552                prevheights[j] = view.AccessCoin(tx.vin[j].prevout).nHeight;
2553            }
2554
2555            if (!SequenceLocks(tx, nLockTimeFlags, prevheights, *pindex)) {
2556                state.Invalid(BlockValidationResult::BLOCK_CONSENSUS, "bad-txns-nonfinal",
2557                              "contains a non-BIP68-final transaction " + tx.GetHash().ToString());
2558                break;
2559            }
2560        }
2561
2562        // GetTransactionSigOpCost counts 3 types of sigops:
2563        // * legacy (always)
2564        // * p2sh (when P2SH enabled in flags and excludes coinbase)
2565        // * witness (when witness enabled in flags and excludes coinbase)
2566        nSigOpsCost += GetTransactionSigOpCost(tx, view, flags);
2567        if (nSigOpsCost > MAX_BLOCK_SIGOPS_COST) {
2568            state.Invalid(BlockValidationResult::BLOCK_CONSENSUS, "bad-blk-sigops", "too many sigops");
2569            break;
2570        }
2571
2572        if (!tx.IsCoinBase() && fScriptChecks)
2573        {
2574            bool fCacheResults = fJustCheck; /* Don't cache results if we're actually connecting blocks (still consult the cache, though) */
2575            bool tx_ok;
2576            TxValidationState tx_state;
2577            // If CheckInputScripts is called with a pointer to a checks vector, the resulting checks are appended to it. In that case
2578            // they need to be added to control which runs them asynchronously. Otherwise, CheckInputScripts runs the checks before returning.
2579            if (control) {
2580                std::vector<CScriptCheck> vChecks;
2581                tx_ok = CheckInputScripts(tx, tx_state, view, flags, fCacheResults, fCacheResults, txsdata[i], m_chainman.m_validation_cache, &vChecks);
2582                if (tx_ok) control->Add(std::move(vChecks));
2583            } else {
2584                tx_ok = CheckInputScripts(tx, tx_state, view, flags, fCacheResults, fCacheResults, txsdata[i], m_chainman.m_validation_cache);
2585            }
2586            if (!tx_ok) {
2587                // Any transaction validation failure in ConnectBlock is a block consensus failure
2588                state.Invalid(BlockValidationResult::BLOCK_CONSENSUS,
2589                              tx_state.GetRejectReason(), tx_state.GetDebugMessage());
2590                break;
2591            }
2592        }
2593
2594        CTxUndo undoDummy;
2595        if (i > 0) {
2596            blockundo.vtxundo.emplace_back();
2597        }
2598        UpdateCoins(tx, view, i == 0 ? undoDummy : blockundo.vtxundo.back(), pindex->nHeight);
2599    }
2600    const auto time_3{SteadyClock::now()};
2601    m_chainman.time_connect += time_3 - time_2;
2602    LogDebug(BCLog::BENCH, "      - Connect %u transactions: %.2fms (%.3fms/tx, %.3fms/txin) [%.2fs (%.2fms/blk)]\n", (unsigned)block.vtx.size(),
2603             Ticks<MillisecondsDouble>(time_3 - time_2), Ticks<MillisecondsDouble>(time_3 - time_2) / block.vtx.size(),
2604             nInputs <= 1 ? 0 : Ticks<MillisecondsDouble>(time_3 - time_2) / (nInputs - 1),
2605             Ticks<SecondsDouble>(m_chainman.time_connect),
2606             Ticks<MillisecondsDouble>(m_chainman.time_connect) / m_chainman.num_blocks_total);
2607
2608    CAmount blockReward = nFees + GetBlockSubsidy(pindex->nHeight, params.GetConsensus());
2609    if (block.vtx[0]->GetValueOut() > blockReward && state.IsValid()) {
2610        state.Invalid(BlockValidationResult::BLOCK_CONSENSUS, "bad-cb-amount",
2611                      strprintf("coinbase pays too much (actual=%d vs limit=%d)", block.vtx[0]->GetValueOut(), blockReward));
2612    }
2613    if (control) {
2614        auto parallel_result = control->Complete();
2615        if (parallel_result.has_value() && state.IsValid()) {
2616            state.Invalid(BlockValidationResult::BLOCK_CONSENSUS, strprintf("block-script-verify-flag-failed (%s)", ScriptErrorString(parallel_result->first)), parallel_result->second);
2617        }
2618    }
2619    if (!state.IsValid()) {
2620        LogInfo("Block validation error: %s", state.ToString());
2621        return false;
2622    }
2623    const auto time_4{SteadyClock::now()};
2624    m_chainman.time_verify += time_4 - time_2;
2625    LogDebug(BCLog::BENCH, "    - Verify %u txins: %.2fms (%.3fms/txin) [%.2fs (%.2fms/blk)]\n", nInputs - 1,
2626             Ticks<MillisecondsDouble>(time_4 - time_2),
2627             nInputs <= 1 ? 0 : Ticks<MillisecondsDouble>(time_4 - time_2) / (nInputs - 1),
2628             Ticks<SecondsDouble>(m_chainman.time_verify),
2629             Ticks<MillisecondsDouble>(m_chainman.time_verify) / m_chainman.num_blocks_total);
2630
2631    if (fJustCheck) {
2632        return true;
2633    }
2634
2635    if (!m_blockman.WriteBlockUndo(blockundo, state, *pindex)) {
2636        return false;
2637    }
2638
2639    const auto time_5{SteadyClock::now()};
2640    m_chainman.time_undo += time_5 - time_4;
2641    LogDebug(BCLog::BENCH, "    - Write undo data: %.2fms [%.2fs (%.2fms/blk)]\n",
2642             Ticks<MillisecondsDouble>(time_5 - time_4),
2643             Ticks<SecondsDouble>(m_chainman.time_undo),
2644             Ticks<MillisecondsDouble>(m_chainman.time_undo) / m_chainman.num_blocks_total);
2645
2646    if (!pindex->IsValid(BLOCK_VALID_SCRIPTS)) {
2647        pindex->RaiseValidity(BLOCK_VALID_SCRIPTS);
2648        m_blockman.m_dirty_blockindex.insert(pindex);
2649    }
2650
2651    // add this block to the view's block chain
2652    view.SetBestBlock(pindex->GetBlockHash());
2653
2654    const auto time_6{SteadyClock::now()};
2655    m_chainman.time_index += time_6 - time_5;
2656    LogDebug(BCLog::BENCH, "    - Index writing: %.2fms [%.2fs (%.2fms/blk)]\n",
2657             Ticks<MillisecondsDouble>(time_6 - time_5),
2658             Ticks<SecondsDouble>(m_chainman.time_index),
2659             Ticks<MillisecondsDouble>(m_chainman.time_index) / m_chainman.num_blocks_total);
2660
2661    TRACEPOINT(validation, block_connected,
2662        block_hash.data(),
2663        pindex->nHeight,
2664        block.vtx.size(),
2665        nInputs,
2666        nSigOpsCost,
2667        Ticks<std::chrono::nanoseconds>(time_5 - time_start)
2668    );
2669
2670    return true;
2671}
2672
2673CoinsCacheSizeState Chainstate::GetCoinsCacheSizeState()
2674{
2675    AssertLockHeld(::cs_main);
2676    return this->GetCoinsCacheSizeState(
2677        m_coinstip_cache_size_bytes,
2678        m_mempool ? m_mempool->m_opts.max_size_bytes : 0);
2679}
2680
2681CoinsCacheSizeState Chainstate::GetCoinsCacheSizeState(
2682    size_t max_coins_cache_size_bytes,
2683    size_t max_mempool_size_bytes)
2684{
2685    AssertLockHeld(::cs_main);
2686    const int64_t nMempoolUsage = m_mempool ? m_mempool->DynamicMemoryUsage() : 0;
2687    int64_t cacheSize = CoinsTip().DynamicMemoryUsage();
2688    int64_t nTotalSpace =
2689        max_coins_cache_size_bytes + std::max<int64_t>(int64_t(max_mempool_size_bytes) - nMempoolUsage, 0);
2690
2691    if (cacheSize > nTotalSpace) {
2692        LogInfo("Cache size (%s) exceeds total space (%s)\n", cacheSize, nTotalSpace);
2693        return CoinsCacheSizeState::CRITICAL;
2694    } else if (cacheSize > LargeCoinsCacheThreshold(nTotalSpace)) {
2695        return CoinsCacheSizeState::LARGE;
2696    }
2697    return CoinsCacheSizeState::OK;
2698}
2699
2700bool Chainstate::FlushStateToDisk(
2701    BlockValidationState &state,
2702    FlushStateMode mode,
2703    int nManualPruneHeight)
2704{
2705    LOCK(cs_main);
2706    assert(this->CanFlushToDisk());
2707    std::set<int> setFilesToPrune;
2708    bool full_flush_completed = false;
2709
2710    [[maybe_unused]] const size_t coins_count{CoinsTip().GetCacheSize()};
2711    [[maybe_unused]] const size_t coins_mem_usage{CoinsTip().DynamicMemoryUsage()};
2712
2713    try {
2714    {
2715        bool fFlushForPrune = false;
2716
2717        CoinsCacheSizeState cache_state = GetCoinsCacheSizeState();
2718        if (m_blockman.IsPruneMode() && (m_blockman.m_check_for_pruning || nManualPruneHeight > 0) && m_chainman.m_blockman.m_blockfiles_indexed) {
2719            // make sure we don't prune above any of the prune locks bestblocks
2720            // pruning is height-based
2721            int last_prune{m_chain.Height()}; // last height we can prune
2722            std::optional<std::string> limiting_lock; // prune lock that actually was the limiting factor, only used for logging
2723
2724            for (const auto& prune_lock : m_blockman.m_prune_locks) {
2725                if (prune_lock.second.height_first == std::numeric_limits<int>::max()) continue;
2726                // Remove the buffer and one additional block here to get actual height that is outside of the buffer
2727                const int lock_height{prune_lock.second.height_first - PRUNE_LOCK_BUFFER - 1};
2728                last_prune = std::max(1, std::min(last_prune, lock_height));
2729                if (last_prune == lock_height) {
2730                    limiting_lock = prune_lock.first;
2731                }
2732            }
2733
2734            if (limiting_lock) {
2735                LogDebug(BCLog::PRUNE, "%s limited pruning to height %d\n", limiting_lock.value(), last_prune);
2736            }
2737
2738            if (nManualPruneHeight > 0) {
2739                LOG_TIME_MILLIS_WITH_CATEGORY("find files to prune (manual)", BCLog::BENCH);
2740
2741                m_blockman.FindFilesToPruneManual(
2742                    setFilesToPrune,
2743                    std::min(last_prune, nManualPruneHeight),
2744                    *this);
2745            } else {
2746                LOG_TIME_MILLIS_WITH_CATEGORY("find files to prune", BCLog::BENCH);
2747
2748                m_blockman.FindFilesToPrune(setFilesToPrune, last_prune, *this, m_chainman);
2749                m_blockman.m_check_for_pruning = false;
2750            }