501         * (approximate) fees for the next block increased, perhaps more so after
502         * Cluster Mempool.
503         *
504         * We'll also create a new template if the tip changed during this iteration.
505         */
506        if (wait_options.fee_threshold < MAX_MONEY || tip_changed) {
507            auto new_tmpl{BlockAssembler{
508                chainman.ActiveChainstate(),
509                mempool,
510                create_options
511                }.CreateNewBlock()};
512
513            // If the tip changed, return the new template regardless of its fees.
514            if (tip_changed) return new_tmpl;
515
516            // Calculate the original template total fees if we haven't already
517            if (current_fees == -1) {
518                current_fees = std::accumulate(block_template->vTxFees.begin(), block_template->vTxFees.end(), CAmount{0});
519            }
520
521            // Check if fees increased enough to return the new template
522            const CAmount new_fees = std::accumulate(new_tmpl->vTxFees.begin(), new_tmpl->vTxFees.end(), CAmount{0});
523            Assume(wait_options.fee_threshold != MAX_MONEY);
524            if (new_fees >= current_fees + wait_options.fee_threshold) return new_tmpl;
525        }
526
527        now = NodeClock::now();
528    } while (now < deadline);
529
530    return nullptr;
531}
532
533std::optional<BlockRef> GetTip(ChainstateManager& chainman)
534{
535    LOCK(::cs_main);
536    CBlockIndex* tip{chainman.ActiveChain().Tip()};
537    if (!tip) return {};
538    return BlockRef{tip->GetBlockHash(), tip->nHeight};
539}
540
541bool CooldownIfHeadersAhead(ChainstateManager& chainman, KernelNotifications& kernel_notifications, const BlockRef& last_tip, bool& interrupt_mining)
542{
543    uint256 last_tip_hash{last_tip.hash};
544
545    while (const std::optional<int> remaining = chainman.BlocksAheadOfTip()) {
546        const int cooldown_seconds = std::clamp(*remaining, 3, 20);
547        const auto cooldown_deadline{MockableSteadyClock::now() + std::chrono::seconds{cooldown_seconds}};
548
549        {
550            WAIT_LOCK(kernel_notifications.m_tip_block_mutex, lock);
551            kernel_notifications.m_tip_block_cv.wait_until(lock, cooldown_deadline, [&]() EXCLUSIVE_LOCKS_REQUIRED(kernel_notifications.m_tip_block_mutex) {
552                const auto tip_block = kernel_notifications.TipBlock();
553                return chainman.m_interrupt || interrupt_mining || (tip_block && *tip_block != last_tip_hash);
554            });
555            if (chainman.m_interrupt || interrupt_mining) {
556                interrupt_mining = false;
557                return false;
558            }
559
560            // If the tip changed during the wait, extend the deadline
561            const auto tip_block = kernel_notifications.TipBlock();
562            if (tip_block && *tip_block != last_tip_hash) {
563                last_tip_hash = *tip_block;
564                continue;
565            }
566        }
567
568        // No tip change and the cooldown window has expired.
569        if (MockableSteadyClock::now() >= cooldown_deadline) break;
570    }
571
572    return true;
573}
574
575std::optional<BlockRef> WaitTipChanged(ChainstateManager& chainman, KernelNotifications& kernel_notifications, const uint256& current_tip, MillisecondsDouble& timeout, bool& interrupt)
576{
577    Assume(timeout >= 0ms); // No internal callers should use a negative timeout
578    if (timeout < 0ms) timeout = 0ms;
579    if (timeout > std::chrono::years{100}) timeout = std::chrono::years{100}; // Upper bound to avoid UB in std::chrono
580    auto deadline{std::chrono::steady_clock::now() + timeout};
581    {
582        WAIT_LOCK(kernel_notifications.m_tip_block_mutex, lock);
583        // For callers convenience, wait longer than the provided timeout
584        // during startup for the tip to be non-null. That way this function
585        // always returns valid tip information when possible and only
586        // returns null when shutting down, not when timing out.
587        kernel_notifications.m_tip_block_cv.wait(lock, [&]() EXCLUSIVE_LOCKS_REQUIRED(kernel_notifications.m_tip_block_mutex) {
588            return kernel_notifications.TipBlock() || chainman.m_interrupt || interrupt;
589        });
590        if (chainman.m_interrupt || interrupt) {
591            interrupt = false;
592            return {};
593        }
594        // At this point TipBlock is set, so continue to wait until it is
595        // different then `current_tip` provided by caller.
596        kernel_notifications.m_tip_block_cv.wait_until(lock, deadline, [&]() EXCLUSIVE_LOCKS_REQUIRED(kernel_notifications.m_tip_block_mutex) {
597            return Assume(kernel_notifications.TipBlock()) != current_tip || chainman.m_interrupt || interrupt;
598        });
599        if (chainman.m_interrupt || interrupt) {
600            interrupt = false;
601            return {};
602        }
603    }
604
605    // Must release m_tip_block_mutex before getTip() locks cs_main, to
606    // avoid deadlocks.
607    return GetTip(chainman);
608}
609
610} // namespace node
611