751
752        // RBF-related members
753        /** Whether the transaction(s) would replace any mempool transactions and/or evict any siblings.
754         * If so, RBF rules apply. */
755        bool m_rbf{false};
756        /** Mempool transactions that were replaced. */
757        std::list<CTransactionRef> m_replaced_transactions;
758        /* Changeset representing adding transactions and removing their conflicts. */
759        std::unique_ptr<CTxMemPool::ChangeSet> m_changeset;
760
761        /** Total modified fees of mempool transactions being replaced. */
762        CAmount m_conflicting_fees{0};
763        /** Total size (in virtual bytes) of mempool transactions being replaced. */
764        size_t m_conflicting_size{0};
765    };
766
767    struct SubPackageState m_subpackage;
768
769    /** Re-set sub-package state to not leak between evaluations */
770    void ClearSubPackageState() EXCLUSIVE_LOCKS_REQUIRED(cs_main, m_pool.cs)
771    {
772        m_subpackage = SubPackageState{};
773
774        // And clean coins while at it
775        CleanupTemporaryCoins();
776    }
777};
778
779bool MemPoolAccept::PreChecks(ATMPArgs& args, Workspace& ws)
780{
781    AssertLockHeld(cs_main);
782    AssertLockHeld(m_pool.cs);
783    const CTransactionRef& ptx = ws.m_ptx;
784    const CTransaction& tx = *ws.m_ptx;
785    const Txid& hash = ws.m_hash;
786
787    // Copy/alias what we need out of args
788    const int64_t nAcceptTime = args.m_accept_time;
789    const bool bypass_limits = args.m_bypass_limits;
790    std::vector<COutPoint>& coins_to_uncache = args.m_coins_to_uncache;
791
792    // Alias what we need out of ws
793    TxValidationState& state = ws.m_state;
794
795    if (!CheckTransaction(tx, state)) {
796        return false; // state filled in by CheckTransaction
797    }
798
799    // Coinbase is only valid in a block, not as a loose transaction
800    if (tx.IsCoinBase())
801        return state.Invalid(TxValidationResult::TX_CONSENSUS, "coinbase");
802
803    // Rather not work on nonstandard transactions (unless -testnet/-regtest)
804    std::string reason;
805    if (m_pool.m_opts.require_standard && !IsStandardTx(tx, m_pool.m_opts.max_datacarrier_bytes, m_pool.m_opts.permit_bare_multisig, m_pool.m_opts.dust_relay_feerate, reason)) {
806        return state.Invalid(TxValidationResult::TX_NOT_STANDARD, reason);
807    }
808
809    // Transactions smaller than 65 non-witness bytes are not relayed to mitigate CVE-2017-12842.
810    if (::GetSerializeSize(TX_NO_WITNESS(tx)) < MIN_STANDARD_TX_NONWITNESS_SIZE)
811        return state.Invalid(TxValidationResult::TX_NOT_STANDARD, "tx-size-small");
812
813    // Only accept nLockTime-using transactions that can be mined in the next
814    // block; we don't want our mempool filled up with transactions that can't
815    // be mined yet.
816    if (!CheckFinalTxAtTip(*Assert(m_active_chainstate.m_chain.Tip()), tx)) {
817        return state.Invalid(TxValidationResult::TX_PREMATURE_SPEND, "non-final");
818    }
819
820    if (m_pool.exists(tx.GetWitnessHash())) {
821        // Exact transaction already exists in the mempool.
822        return state.Invalid(TxValidationResult::TX_CONFLICT, "txn-already-in-mempool");
823    } else if (m_pool.exists(tx.GetHash())) {
824        // Transaction with the same non-witness data but different witness (same txid, different
825        // wtxid) already exists in the mempool.
826        return state.Invalid(TxValidationResult::TX_CONFLICT, "txn-same-nonwitness-data-in-mempool");
827    }
828
829    // Check for conflicts with in-memory transactions
830    for (const CTxIn &txin : tx.vin)
831    {
832        const CTransaction* ptxConflicting = m_pool.GetConflictTx(txin.prevout);
833        if (ptxConflicting) {
834            if (!args.m_allow_replacement) {
835                // Transaction conflicts with a mempool tx, but we're not allowing replacements in this context.
836                return state.Invalid(TxValidationResult::TX_MEMPOOL_POLICY, "bip125-replacement-disallowed");
837            }
838            ws.m_conflicts.insert(ptxConflicting->GetHash());
839        }
840    }
841
842    m_view.SetBackend(m_viewmempool);
843
844    const CCoinsViewCache& coins_cache = m_active_chainstate.CoinsTip();
845    // do all inputs exist?
846    for (const CTxIn& txin : tx.vin) {
847        if (!coins_cache.HaveCoinInCache(txin.prevout)) {
848            coins_to_uncache.push_back(txin.prevout);
849        }
850
851        // Note: this call may add txin.prevout to the coins cache
852        // (coins_cache.cacheCoins) by way of FetchCoin(). It should be removed
853        // later (via coins_to_uncache) if this tx turns out to be invalid.
854        if (!m_view.HaveCoin(txin.prevout)) {
855            // Are inputs missing because we already have the tx?
856            for (size_t out = 0; out < tx.vout.size(); out++) {
857                // Optimistically just do efficient check of cache for outputs
858                if (coins_cache.HaveCoinInCache(COutPoint(hash, out))) {
859                    return state.Invalid(TxValidationResult::TX_CONFLICT, "txn-already-known");
860                }
861            }
862            // Otherwise assume this might be an orphan tx for which we just haven't seen parents yet
863            return state.Invalid(TxValidationResult::TX_MISSING_INPUTS, "bad-txns-inputs-missingorspent");
864        }
865    }
866
867    // This is const, but calls into `CCoinsViewCache::GetBestBlock()` to refresh
868    // the cached best block through `m_viewmempool` after caching inputs.
869    (void)m_view.GetBestBlock();
870
871    // All required inputs are cached now, so switch m_view to the empty backend.
872    // This keeps already-fetched cache entries for later checks and prevents new
873    // backend lookups (which would avoid coins_to_uncache tracking).
874    m_view.SetBackend(CoinsViewEmpty::Get());
875
876    assert(m_active_chainstate.m_blockman.LookupBlockIndex(m_view.GetBestBlock()) == m_active_chainstate.m_chain.Tip());
877
878    // Only accept BIP68 sequence locked transactions that can be mined in the next
879    // block; we don't want our mempool filled up with transactions that can't
880    // be mined yet.
881    // Pass in m_view which has all of the relevant inputs cached. Note that, since m_view's
882    // backend was removed, it no longer pulls coins from the mempool.
883    const std::optional<LockPoints> lock_points{CalculateLockPointsAtTip(m_active_chainstate.m_chain.Tip(), m_view, tx)};
884    if (!lock_points.has_value() || !CheckSequenceLocksAtTip(m_active_chainstate.m_chain.Tip(), *lock_points)) {
885        return state.Invalid(TxValidationResult::TX_PREMATURE_SPEND, "non-BIP68-final");
886    }
887
888    // The mempool holds txs for the next block, so pass height+1 to CheckTxInputs
889    if (!Consensus::CheckTxInputs(tx, state, m_view, m_active_chainstate.m_chain.Height() + 1, ws.m_base_fees)) {
890        return false; // state filled in by CheckTxInputs
891    }
892
893    if (m_pool.m_opts.require_standard) {
894        state = ValidateInputsStandardness(tx, m_view);
895        if (state.IsInvalid()) {
896            return false;
897        }
898    }
899
900    // Check for non-standard witnesses.
901    if (tx.HasWitness() && m_pool.m_opts.require_standard && !IsWitnessStandard(tx, m_view)) {
902        return state.Invalid(TxValidationResult::TX_WITNESS_MUTATED, "bad-witness-nonstandard");
903    }
904
905    int64_t nSigOpsCost = GetTransactionSigOpCost(tx, m_view, STANDARD_SCRIPT_VERIFY_FLAGS);
906
907    // Keep track of transactions that spend a coinbase, which we re-scan
908    // during reorgs to ensure COINBASE_MATURITY is still met.
909    bool fSpendsCoinbase = false;
910    for (const CTxIn &txin : tx.vin) {
911        const Coin &coin = m_view.AccessCoin(txin.prevout);
912        if (coin.IsCoinBase()) {
913            fSpendsCoinbase = true;
914            break;
915        }
916    }
917
918    // Set entry_sequence to 0 when bypass_limits is used; this allows txs from a block
919    // reorg to be marked earlier than any child txs that were already in the mempool.
920    const uint64_t entry_sequence = bypass_limits ? 0 : m_pool.GetSequence();
921    if (!m_subpackage.m_changeset) {
922        m_subpackage.m_changeset = m_pool.GetChangeSet();
923    }
924    ws.m_tx_handle = m_subpackage.m_changeset->StageAddition(ptx, ws.m_base_fees, nAcceptTime, m_active_chainstate.m_chain.Height(), entry_sequence, fSpendsCoinbase, nSigOpsCost, lock_points.value());
925
926    // ws.m_modified_fees includes any fee deltas from PrioritiseTransaction
927    ws.m_modified_fees = ws.m_tx_handle->GetModifiedFee();
928
929    ws.m_vsize = ws.m_tx_handle->GetTxSize();
930
931    // Enforces 0-fee for dust transactions, no incentive to be mined alone
932    if (m_pool.m_opts.require_standard) {
933        if (!PreCheckEphemeralTx(*ptx, m_pool.m_opts.dust_relay_feerate, ws.m_base_fees, ws.m_modified_fees, state)) {
934            return false; // state filled in by PreCheckEphemeralTx
935        }
936    }
937
938    if (nSigOpsCost > MAX_STANDARD_TX_SIGOPS_COST)
939        return state.Invalid(TxValidationResult::TX_NOT_STANDARD, "bad-txns-too-many-sigops",
940                strprintf("%d", nSigOpsCost));
941
942    // No individual transactions are allowed below the mempool min feerate except from disconnected
943    // blocks and transactions in a package. Package transactions will be checked using package
944    // feerate later.
945    if (!bypass_limits && !args.m_package_feerates && !CheckFeeRate(ws.m_vsize, ws.m_modified_fees, state)) return false;
946
947    ws.m_iters_conflicting = m_pool.GetIterSet(ws.m_conflicts);
948
949    ws.m_parents = m_pool.GetParents(*ws.m_tx_handle);
950
951    if (!args.m_bypass_limits) {
952        // Perform the TRUC checks, using the in-mempool parents.
953        if (const auto err{SingleTRUCChecks(m_pool, ws.m_ptx, ws.m_parents, ws.m_conflicts, ws.m_vsize)}) {
954            // Single transaction contexts only.
955            if (args.m_allow_sibling_eviction && err->second != nullptr) {
956                // We should only be considering where replacement is considered valid as well.
957                Assume(args.m_allow_replacement);
958                // Potential sibling eviction. Add the sibling to our list of mempool conflicts to be
959                // included in RBF checks.
960                ws.m_conflicts.insert(err->second->GetHash());
961                // Adding the sibling to m_iters_conflicting here means that it doesn't count towards
962                // RBF Carve Out above. This is correct, since removing to-be-replaced transactions from
963                // the descendant count is done separately in SingleTRUCChecks for TRUC transactions.
964                ws.m_iters_conflicting.insert(m_pool.GetIter(err->second->GetHash()).value());
965                ws.m_sibling_eviction = true;
966                // The sibling will be treated as part of the to-be-replaced set in ReplacementChecks.
967                // Note that we are not checking whether it opts in to replaceability via BIP125 or TRUC
968                // (which is normally done in PreChecks). However, the only way a TRUC transaction can
969                // have a non-TRUC and non-BIP125 descendant is due to a reorg.
970            } else {
971                return state.Invalid(TxValidationResult::TX_MEMPOOL_POLICY, "TRUC-violation", err->first);
972            }
973        }
974    }
975
976    // We want to detect conflicts in any tx in a package to trigger package RBF logic
977    m_subpackage.m_rbf |= !ws.m_conflicts.empty();
978    return true;
979}
980
981bool MemPoolAccept::ReplacementChecks(Workspace& ws)
982{
983    AssertLockHeld(cs_main);
984    AssertLockHeld(m_pool.cs);
985
986    const CTransaction& tx = *ws.m_ptx;
987    const Txid& hash = ws.m_hash;
988    TxValidationState& state = ws.m_state;
989
990    CTxMemPool::setEntries all_conflicts;
991
992    // Calculate all conflicting entries and enforce Rule #5.
993    if (const auto err_string{GetEntriesForConflicts(tx, m_pool, ws.m_iters_conflicting, all_conflicts)}) {
994        return state.Invalid(TxValidationResult::TX_MEMPOOL_POLICY,
995                             strprintf("too many potential replacements%s", ws.m_sibling_eviction ? " (including sibling eviction)" : ""), *err_string);
996    }
997
998    // Check if it's economically rational to mine this transaction rather than the ones it
999    // replaces and pays for its own relay fees. Enforce Rules #3 and #4.
1000    for (CTxMemPool::txiter it : all_conflicts) {