251    // signifies no relative lock time.
252    return LockPoints{min_height, min_time, Assert(tip->GetAncestor(max_input_height))};
253}
254
255bool CheckSequenceLocksAtTip(CBlockIndex* tip,
256                             const LockPoints& lock_points)
257{
258    assert(tip != nullptr);
259
260    CBlockIndex index;
261    index.pprev = tip;
262    // CheckSequenceLocksAtTip() uses active_chainstate.m_chain.Height()+1 to evaluate
263    // height based locks because when SequenceLocks() is called within
264    // ConnectBlock(), the height of the block *being*
265    // evaluated is what is used.
266    // Thus if we want to know if a transaction can be part of the
267    // *next* block, we need to use one more than active_chainstate.m_chain.Height()
268    index.nHeight = tip->nHeight + 1;
269
270    return EvaluateSequenceLocks(index, {lock_points.height, lock_points.time});
271}
272
273static void LimitMempoolSize(CTxMemPool& pool, CCoinsViewCache& coins_cache)
274    EXCLUSIVE_LOCKS_REQUIRED(::cs_main, pool.cs)
275{
276    AssertLockHeld(::cs_main);
277    AssertLockHeld(pool.cs);
278    int expired = pool.Expire(GetTime<std::chrono::seconds>() - pool.m_opts.expiry);
279    if (expired != 0) {
280        LogDebug(BCLog::MEMPOOL, "Expired %i transactions from the memory pool\n", expired);
281    }
282
283    std::vector<COutPoint> vNoSpendsRemaining;
284    pool.TrimToSize(pool.m_opts.max_size_bytes, &vNoSpendsRemaining);
285    for (const COutPoint& removed : vNoSpendsRemaining)
286        coins_cache.Uncache(removed);
287}
288
289static bool IsCurrentForFeeEstimation(Chainstate& active_chainstate) EXCLUSIVE_LOCKS_REQUIRED(cs_main)
290{
291    AssertLockHeld(cs_main);
292    if (active_chainstate.m_chainman.IsInitialBlockDownload()) {
293        return false;
294    }
295    if (active_chainstate.m_chain.Tip()->GetBlockTime() < count_seconds(GetTime<std::chrono::seconds>() - MAX_FEE_ESTIMATION_TIP_AGE))
296        return false;
297    if (active_chainstate.m_chain.Height() < active_chainstate.m_chainman.m_best_header->nHeight - 1) {
298        return false;
299    }
300    return true;
301}
302
303void Chainstate::MaybeUpdateMempoolForReorg(
304    DisconnectedBlockTransactions& disconnectpool,
305    bool fAddToMempool)
306{
307    if (!m_mempool) return;
308
309    AssertLockHeld(cs_main);
310    AssertLockHeld(m_mempool->cs);
311    std::vector<Txid> vHashUpdate;
312    {
313        // disconnectpool is ordered so that the front is the most recently-confirmed
314        // transaction (the last tx of the block at the tip) in the disconnected chain.
315        // Iterate disconnectpool in reverse, so that we add transactions
316        // back to the mempool starting with the earliest transaction that had
317        // been previously seen in a block.
318        const auto queuedTx = disconnectpool.take();
319        auto it = queuedTx.rbegin();
320        while (it != queuedTx.rend()) {
321            // ignore validation errors in resurrected transactions
322            if (!fAddToMempool || (*it)->IsCoinBase() ||
323                AcceptToMemoryPool(*this, *it, GetTime(),
324                    /*bypass_limits=*/true, /*test_accept=*/false).m_result_type !=
325                        MempoolAcceptResult::ResultType::VALID) {
326                // If the transaction doesn't make it in to the mempool, remove any
327                // transactions that depend on it (which would now be orphans).
328                m_mempool->removeRecursive(**it, MemPoolRemovalReason::REORG);
329            } else if (m_mempool->exists((*it)->GetHash())) {
330                vHashUpdate.push_back((*it)->GetHash());
331            }
332            ++it;
333        }
334    }
335
336    // AcceptToMemoryPool/addNewTransaction all assume that new mempool entries have
337    // no in-mempool children, which is generally not true when adding
338    // previously-confirmed transactions back to the mempool.
339    // UpdateTransactionsFromBlock finds descendants of any transactions in
340    // the disconnectpool that were added back and cleans up the mempool state.
341    m_mempool->UpdateTransactionsFromBlock(vHashUpdate);
342
343    // Predicate to use for filtering transactions in removeForReorg.
344    // Checks whether the transaction is still final and, if it spends a coinbase output, mature.
345    // Also updates valid entries' cached LockPoints if needed.
346    // If false, the tx is still valid and its lockpoints are updated.
347    // If true, the tx would be invalid in the next block; remove this entry and all of its descendants.
348    // Note that TRUC rules are not applied here, so reorgs may cause violations of TRUC inheritance or
349    // topology restrictions.
350    const auto filter_final_and_mature = [&](CTxMemPool::txiter it)
351        EXCLUSIVE_LOCKS_REQUIRED(m_mempool->cs, ::cs_main) {
352        AssertLockHeld(m_mempool->cs);
353        AssertLockHeld(::cs_main);
354        const CTransaction& tx = it->GetTx();
355
356        // The transaction must be final.
357        if (!CheckFinalTxAtTip(*Assert(m_chain.Tip()), tx)) return true;
358
359        const LockPoints& lp = it->GetLockPoints();
360        // CheckSequenceLocksAtTip checks if the transaction will be final in the next block to be
361        // created on top of the new chain.
362        if (TestLockPointValidity(m_chain, lp)) {
363            if (!CheckSequenceLocksAtTip(m_chain.Tip(), lp)) {
364                return true;
365            }
366        } else {
367            const CCoinsViewMemPool view_mempool{&CoinsTip(), *m_mempool};
368            const std::optional<LockPoints> new_lock_points{CalculateLockPointsAtTip(m_chain.Tip(), view_mempool, tx)};
369            if (new_lock_points.has_value() && CheckSequenceLocksAtTip(m_chain.Tip(), *new_lock_points)) {
370                // Now update the mempool entry lockpoints as well.
371                it->UpdateLockPoints(*new_lock_points);
372            } else {
373                return true;
374            }
375        }
376
377        // If the transaction spends any coinbase outputs, it must be mature.
378        if (it->GetSpendsCoinbase()) {
379            for (const CTxIn& txin : tx.vin) {
380                if (m_mempool->exists(txin.prevout.hash)) continue;
381                const Coin& coin{CoinsTip().AccessCoin(txin.prevout)};
382                assert(!coin.IsSpent());
383                const auto mempool_spend_height{m_chain.Tip()->nHeight + 1};
384                if (coin.IsCoinBase() && mempool_spend_height - coin.nHeight < COINBASE_MATURITY) {
385                    return true;
386                }
387            }
388        }
389        // Transaction is still valid and cached LockPoints are updated.
390        return false;
391    };
392
393    // We also need to remove any now-immature transactions
394    m_mempool->removeForReorg(m_chain, filter_final_and_mature);
395    // Re-limit mempool size, in case we added any transactions
396    LimitMempoolSize(*m_mempool, this->CoinsTip());
397}
398
399/**
400* Checks to avoid mempool polluting consensus critical paths since cached
401* signature and script validity results will be reused if we validate this
402* transaction again during block validation.
403* */
404static bool CheckInputsFromMempoolAndCache(const CTransaction& tx, TxValidationState& state,
405                const CCoinsViewCache& view, const CTxMemPool& pool,
406                script_verify_flags flags, PrecomputedTransactionData& txdata, CCoinsViewCache& coins_tip,
407                ValidationCache& validation_cache)
408                EXCLUSIVE_LOCKS_REQUIRED(cs_main, pool.cs)
409{
410    AssertLockHeld(cs_main);
411    AssertLockHeld(pool.cs);
412
413    assert(!tx.IsCoinBase());
414    for (const CTxIn& txin : tx.vin) {
415        const Coin& coin = view.AccessCoin(txin.prevout);
416
417        // This coin was checked in PreChecks and MemPoolAccept
418        // has been holding cs_main since then.
419        Assume(!coin.IsSpent());
420        if (coin.IsSpent()) return false;
421
422        // If the Coin is available, there are 2 possibilities:
423        // it is available in our current ChainstateActive UTXO set,
424        // or it's a UTXO provided by a transaction in our mempool.
425        // Ensure the scriptPubKeys in Coins from CoinsView are correct.
426        const CTransactionRef& txFrom = pool.get(txin.prevout.hash);
427        if (txFrom) {
428            assert(txFrom->GetHash() == txin.prevout.hash);
429            assert(txFrom->vout.size() > txin.prevout.n);
430            assert(txFrom->vout[txin.prevout.n] == coin.out);
431        } else {
432            const Coin& coinFromUTXOSet = coins_tip.AccessCoin(txin.prevout);
433            assert(!coinFromUTXOSet.IsSpent());
434            assert(coinFromUTXOSet.out == coin.out);
435        }
436    }
437
438    // Call CheckInputScripts() to cache signature and script validity against current tip consensus rules.
439    return CheckInputScripts(tx, state, view, flags, /* cacheSigStore= */ true, /* cacheFullScriptStore= */ true, txdata, validation_cache);
440}
441
442namespace {
443
444class MemPoolAccept
445{
446public:
447    explicit MemPoolAccept(CTxMemPool& mempool, Chainstate& active_chainstate) :
448        m_pool(mempool),
449        m_view(&CoinsViewEmpty::Get()),
450        m_viewmempool(&active_chainstate.CoinsTip(), m_pool),
451        m_active_chainstate(active_chainstate)
452    {
453    }
454
455    // We put the arguments we're handed into a struct, so we can pass them
456    // around easier.
457    struct ATMPArgs {
458        const int64_t m_accept_time;
459        const bool m_bypass_limits;
460        /*
461         * Return any outpoints which were not previously present in the coins
462         * cache, but were added as a result of validating the tx for mempool
463         * acceptance. This allows the caller to optionally remove the cache
464         * additions if the associated transaction ends up being rejected by
465         * the mempool.
466         */
467        std::vector<COutPoint>& m_coins_to_uncache;
468        /** When true, the transaction or package will not be submitted to the mempool. */
469        const bool m_test_accept;
470        /** Whether we allow transactions to replace mempool transactions. If false,
471         * any transaction spending the same inputs as a transaction in the mempool is considered
472         * a conflict. */
473        const bool m_allow_replacement;
474        /** When true, allow sibling eviction. This only occurs in single transaction package settings. */
475        const bool m_allow_sibling_eviction;
476        /** Used to skip the LimitMempoolSize() call within AcceptSingleTransaction(). This should be used when multiple
477         * AcceptSubPackage calls are expected and the mempool will be trimmed at the end of AcceptPackage(). */
478        const bool m_package_submission;
479        /** When true, use package feerates instead of individual transaction feerates for fee-based
480         * policies such as mempool min fee and min relay fee.
481         */
482        const bool m_package_feerates;
483        /** Used for local submission of transactions to catch "absurd" fees
484         * due to fee miscalculation by wallets. std:nullopt implies unset, allowing any feerates.
485         * Any individual transaction failing this check causes immediate failure.
486         */
487        const std::optional<CFeeRate> m_client_maxfeerate;
488
489        /** Parameters for single transaction mempool validation. */
490        static ATMPArgs SingleAccept(int64_t accept_time,
491                                     bool bypass_limits, std::vector<COutPoint>& coins_to_uncache,
492                                     bool test_accept) {
493            return ATMPArgs{/*accept_time=*/ accept_time,
494                            /*bypass_limits=*/ bypass_limits,
495                            /*coins_to_uncache=*/ coins_to_uncache,
496                            /*test_accept=*/ test_accept,
497                            /*allow_replacement=*/ true,
498                            /*allow_sibling_eviction=*/ true,
499                            /*package_submission=*/ false,
500                            /*package_feerates=*/ false,