501                            /*client_maxfeerate=*/ {}, // checked by caller
502            };
503        }
504
505        /** Parameters for test package mempool validation through testmempoolaccept. */
506        static ATMPArgs PackageTestAccept(int64_t accept_time,
507                                          std::vector<COutPoint>& coins_to_uncache) {
508            return ATMPArgs{/*accept_time=*/ accept_time,
509                            /*bypass_limits=*/ false,
510                            /*coins_to_uncache=*/ coins_to_uncache,
511                            /*test_accept=*/ true,
512                            /*allow_replacement=*/ false,
513                            /*allow_sibling_eviction=*/ false,
514                            /*package_submission=*/ false, // not submitting to mempool
515                            /*package_feerates=*/ false,
516                            /*client_maxfeerate=*/ {}, // checked by caller
517            };
518        }
519
520        /** Parameters for child-with-parents package validation. */
521        static ATMPArgs PackageChildWithParents(int64_t accept_time,
522                                                std::vector<COutPoint>& coins_to_uncache, const std::optional<CFeeRate>& client_maxfeerate) {
523            return ATMPArgs{/*accept_time=*/ accept_time,
524                            /*bypass_limits=*/ false,
525                            /*coins_to_uncache=*/ coins_to_uncache,
526                            /*test_accept=*/ false,
527                            /*allow_replacement=*/ true,
528                            /*allow_sibling_eviction=*/ false,
529                            /*package_submission=*/ true,
530                            /*package_feerates=*/ true,
531                            /*client_maxfeerate=*/ client_maxfeerate,
532            };
533        }
534
535        /** Parameters for a single transaction within a package. */
536        static ATMPArgs SingleInPackageAccept(const ATMPArgs& package_args) {
537            return ATMPArgs{/*accept_time=*/ package_args.m_accept_time,
538                            /*bypass_limits=*/ false,
539                            /*coins_to_uncache=*/ package_args.m_coins_to_uncache,
540                            /*test_accept=*/ package_args.m_test_accept,
541                            /*allow_replacement=*/ true,
542                            /*allow_sibling_eviction=*/ true,
543                            /*package_submission=*/ true, // trim at the end of AcceptPackage()
544                            /*package_feerates=*/ false, // only 1 transaction
545                            /*client_maxfeerate=*/ package_args.m_client_maxfeerate,
546            };
547        }
548
549    private:
550        // Private ctor to avoid exposing details to clients and allowing the possibility of
551        // mixing up the order of the arguments. Use static functions above instead.
552        ATMPArgs(int64_t accept_time,
553                 bool bypass_limits,
554                 std::vector<COutPoint>& coins_to_uncache,
555                 bool test_accept,
556                 bool allow_replacement,
557                 bool allow_sibling_eviction,
558                 bool package_submission,
559                 bool package_feerates,
560                 std::optional<CFeeRate> client_maxfeerate)
561            : m_accept_time{accept_time},
562              m_bypass_limits{bypass_limits},
563              m_coins_to_uncache{coins_to_uncache},
564              m_test_accept{test_accept},
565              m_allow_replacement{allow_replacement},
566              m_allow_sibling_eviction{allow_sibling_eviction},
567              m_package_submission{package_submission},
568              m_package_feerates{package_feerates},
569              m_client_maxfeerate{client_maxfeerate}
570        {
571            // If we are using package feerates, we must be doing package submission.
572            // It also means sibling eviction is not permitted.
573            if (m_package_feerates) {
574                Assume(m_package_submission);
575                Assume(!m_allow_sibling_eviction);
576            }
577            if (m_allow_sibling_eviction) Assume(m_allow_replacement);
578        }
579    };
580
581    /** Clean up all non-chainstate coins from m_view and m_viewmempool. */
582    void CleanupTemporaryCoins() EXCLUSIVE_LOCKS_REQUIRED(cs_main, m_pool.cs);
583
584    // Single transaction acceptance
585    MempoolAcceptResult AcceptSingleTransactionAndCleanup(const CTransactionRef& ptx, ATMPArgs& args) EXCLUSIVE_LOCKS_REQUIRED(cs_main) {
586        LOCK(m_pool.cs);
587        MempoolAcceptResult result = AcceptSingleTransactionInternal(ptx, args);
588        ClearSubPackageState();
589        return result;
590    }
591    MempoolAcceptResult AcceptSingleTransactionInternal(const CTransactionRef& ptx, ATMPArgs& args) EXCLUSIVE_LOCKS_REQUIRED(cs_main, m_pool.cs);
592
593    /**
594    * Multiple transaction acceptance. Transactions may or may not be interdependent, but must not
595    * conflict with each other, and the transactions cannot already be in the mempool. Parents must
596    * come before children if any dependencies exist.
597    */
598    PackageMempoolAcceptResult AcceptMultipleTransactionsAndCleanup(const std::vector<CTransactionRef>& txns, ATMPArgs& args) EXCLUSIVE_LOCKS_REQUIRED(cs_main) {
599        LOCK(m_pool.cs);
600        PackageMempoolAcceptResult result = AcceptMultipleTransactionsInternal(txns, args);
601        ClearSubPackageState();
602        return result;
603    }
604    PackageMempoolAcceptResult AcceptMultipleTransactionsInternal(const std::vector<CTransactionRef>& txns, ATMPArgs& args) EXCLUSIVE_LOCKS_REQUIRED(cs_main, m_pool.cs);
605
606    /**
607     * Submission of a subpackage.
608     * If subpackage size == 1, calls AcceptSingleTransaction() with adjusted ATMPArgs to
609     * enable sibling eviction and creates a PackageMempoolAcceptResult
610     * wrapping the result.
611     *
612     * If subpackage size > 1, calls AcceptMultipleTransactions() with the provided ATMPArgs.
613     *
614     * Also cleans up all non-chainstate coins from m_view at the end.
615    */
616    PackageMempoolAcceptResult AcceptSubPackage(const std::vector<CTransactionRef>& subpackage, ATMPArgs& args)
617        EXCLUSIVE_LOCKS_REQUIRED(cs_main, m_pool.cs);
618
619    /**
620     * Package (more specific than just multiple transactions) acceptance. Package must be a child
621     * with all of its unconfirmed parents, and topologically sorted.
622     */
623    PackageMempoolAcceptResult AcceptPackage(const Package& package, ATMPArgs& args) EXCLUSIVE_LOCKS_REQUIRED(cs_main);
624
625private:
626    // All the intermediate state that gets passed between the various levels
627    // of checking a given transaction.
628    struct Workspace {
629        explicit Workspace(const CTransactionRef& ptx) : m_ptx(ptx), m_hash(ptx->GetHash()) {}
630        /** Txids of mempool transactions that this transaction directly conflicts with or may
631         * replace via sibling eviction. */
632        std::set<Txid> m_conflicts;
633        /** Iterators to mempool entries that this transaction directly conflicts with or may
634         * replace via sibling eviction. */
635        CTxMemPool::setEntries m_iters_conflicting;
636        /** All mempool parents of this transaction. */
637        std::vector<CTxMemPoolEntry::CTxMemPoolEntryRef> m_parents;
638        /* Handle to the tx in the changeset */
639        CTxMemPool::ChangeSet::TxHandle m_tx_handle;
640        /** Whether RBF-related data structures (m_conflicts, m_iters_conflicting,
641         * m_replaced_transactions) include a sibling in addition to txns with conflicting inputs. */
642        bool m_sibling_eviction{false};
643
644        /** Virtual size of the transaction as used by the mempool, calculated using serialized size
645         * of the transaction and sigops. */
646        int64_t m_vsize;
647        /** Fees paid by this transaction: total input amounts subtracted by total output amounts. */
648        CAmount m_base_fees;
649        /** Base fees + any fee delta set by the user with prioritisetransaction. */
650        CAmount m_modified_fees;
651
652        /** If we're doing package validation (i.e. m_package_feerates=true), the "effective"
653         * package feerate of this transaction is the total fees divided by the total size of
654         * transactions (which may include its ancestors and/or descendants). */
655        CFeeRate m_package_feerate{0};
656
657        const CTransactionRef& m_ptx;
658        /** Txid. */
659        const Txid& m_hash;
660        TxValidationState m_state;
661        /** A temporary cache containing serialized transaction data for signature verification.
662         * Reused across PolicyScriptChecks and ConsensusScriptChecks. */
663        PrecomputedTransactionData m_precomputed_txdata;
664    };
665
666    // Run the policy checks on a given transaction, excluding any script checks.
667    // Looks up inputs, calculates feerate, considers replacement, evaluates
668    // package limits, etc. As this function can be invoked for "free" by a peer,
669    // only tests that are fast should be done here (to avoid CPU DoS).
670    bool PreChecks(ATMPArgs& args, Workspace& ws) EXCLUSIVE_LOCKS_REQUIRED(cs_main, m_pool.cs);
671
672    // Run checks for mempool replace-by-fee, only used in AcceptSingleTransaction.
673    bool ReplacementChecks(Workspace& ws) EXCLUSIVE_LOCKS_REQUIRED(cs_main, m_pool.cs);
674
675    bool PackageRBFChecks(const std::vector<CTransactionRef>& txns,
676                          std::vector<Workspace>& workspaces,
677                          PackageValidationState& package_state) EXCLUSIVE_LOCKS_REQUIRED(cs_main, m_pool.cs);
678
679    // Run the script checks using our policy flags. As this can be slow, we should
680    // only invoke this on transactions that have otherwise passed policy checks.
681    bool PolicyScriptChecks(Workspace& ws) EXCLUSIVE_LOCKS_REQUIRED(cs_main, m_pool.cs);
682
683    // Re-run the script checks, using consensus flags, and try to cache the
684    // result in the scriptcache. This should be done after
685    // PolicyScriptChecks(). This requires that all inputs either be in our
686    // utxo set or in the mempool.
687    bool ConsensusScriptChecks(Workspace& ws) EXCLUSIVE_LOCKS_REQUIRED(cs_main, m_pool.cs);
688
689    // Try to add the transaction to the mempool, removing any conflicts first.
690    void FinalizeSubpackage(const ATMPArgs& args) EXCLUSIVE_LOCKS_REQUIRED(cs_main, m_pool.cs);
691
692    // Submit all transactions to the mempool and call ConsensusScriptChecks to add to the script
693    // cache - should only be called after successful validation of all transactions in the package.
694    // Does not call LimitMempoolSize(), so mempool max_size_bytes may be temporarily exceeded.
695    bool SubmitPackage(const ATMPArgs& args, std::vector<Workspace>& workspaces, PackageValidationState& package_state,
696                       std::map<Wtxid, MempoolAcceptResult>& results)
697         EXCLUSIVE_LOCKS_REQUIRED(cs_main, m_pool.cs);
698
699    // Compare a package's feerate against minimum allowed.
700    bool CheckFeeRate(size_t package_size, CAmount package_fee, TxValidationState& state) EXCLUSIVE_LOCKS_REQUIRED(::cs_main, m_pool.cs)
701    {
702        AssertLockHeld(::cs_main);
703        AssertLockHeld(m_pool.cs);
704        CAmount mempoolRejectFee = m_pool.GetMinFee().GetFee(package_size);
705        if (mempoolRejectFee > 0 && package_fee < mempoolRejectFee) {
706            return state.Invalid(TxValidationResult::TX_RECONSIDERABLE, "mempool min fee not met", strprintf("%d < %d", package_fee, mempoolRejectFee));
707        }
708
709        if (package_fee < m_pool.m_opts.min_relay_feerate.GetFee(package_size)) {
710            return state.Invalid(TxValidationResult::TX_RECONSIDERABLE, "min relay fee not met",
711                                 strprintf("%d < %d", package_fee, m_pool.m_opts.min_relay_feerate.GetFee(package_size)));
712        }
713        return true;
714    }
715
716    ValidationCache& GetValidationCache()
717    {
718        return m_active_chainstate.m_chainman.m_validation_cache;
719    }
720
721private:
722    CTxMemPool& m_pool;
723
724    /** Holds a cached view of available coins from the UTXO set, mempool, and artificial temporary coins (to enable package validation).
725     * The view doesn't track whether a coin previously existed but has now been spent. We detect conflicts in other ways:
726     * - conflicts within a transaction are checked in CheckTransaction (bad-txns-inputs-duplicate)
727     * - conflicts within a package are checked in IsWellFormedPackage (conflict-in-package)
728     * - conflicts with an existing mempool transaction are found in CTxMemPool::GetConflictTx and replacements are allowed
729     * The temporary coins should persist between individual transaction checks so that package validation is possible,
730     * but must be cleaned up when we finish validating a subpackage, whether accepted or rejected. The cache must also
731     * be cleared when mempool contents change (when a changeset is applied or when the mempool trims itself) because it
732     * can return cached coins that no longer exist in the backend. Use CleanupTemporaryCoins() anytime you are finished
733     * with a SubPackageState or call LimitMempoolSize().
734     */
735    CCoinsViewCache m_view;
736
737    // These are the two possible backends for m_view.
738    /** When m_view is connected to m_viewmempool as its backend, it can pull coins from the mempool and from the UTXO
739     * set. This is also where temporary coins are stored. */
740    CCoinsViewMemPool m_viewmempool;
741
742    Chainstate& m_active_chainstate;
743
744    // Fields below are per *sub*package state and must be reset prior to subsequent
745    // AcceptSingleTransaction and AcceptMultipleTransactions invocations
746    struct SubPackageState {
747        /** Aggregated modified fees of all transactions, used to calculate package feerate. */
748        CAmount m_total_modified_fees{0};
749        /** Aggregated virtual size of all transactions, used to calculate package feerate. */
750        int64_t m_total_vsize{0};