Where validation becomes chain state

1501                   [](const auto& ws) { return ws.m_ptx->GetWitnessHash(); });
1502    TxValidationState placeholder_state;
1503    if (args.m_package_feerates &&
1504        !CheckFeeRate(m_subpackage.m_total_vsize, m_subpackage.m_total_modified_fees, placeholder_state)) {
1505        package_state.Invalid(PackageValidationResult::PCKG_TX, "transaction failed");
1506        return PackageMempoolAcceptResult(package_state, {{workspaces.back().m_ptx->GetWitnessHash(),
1507            MempoolAcceptResult::FeeFailure(placeholder_state, CFeeRate(m_subpackage.m_total_modified_fees, m_subpackage.m_total_vsize), all_package_wtxids)}});
1508    }
1509
1510    // Apply package mempool RBF checks.
1511    if (m_subpackage.m_rbf && !PackageRBFChecks(txns, workspaces, package_state)) {
1512        return PackageMempoolAcceptResult(package_state, std::move(results));
1513    }
1514
1515    // Check if the transactions would exceed the cluster size limit.
1516    if (!m_subpackage.m_changeset->CheckMemPoolPolicyLimits()) {
1517        package_state.Invalid(PackageValidationResult::PCKG_POLICY, "too-large-cluster", "");
1518        return PackageMempoolAcceptResult(package_state, std::move(results));
1519    }
1520
1521    // Now that we've bounded the resulting possible ancestry count, check package for dust spends
1522    if (m_pool.m_opts.require_standard) {
1523        TxValidationState child_state;
1524        Wtxid child_wtxid;
1525        if (!CheckEphemeralSpends(txns, m_pool.m_opts.dust_relay_feerate, m_pool, child_state, child_wtxid)) {
1526            package_state.Invalid(PackageValidationResult::PCKG_TX, "unspent-dust");
1527            results.emplace(child_wtxid, MempoolAcceptResult::Failure(child_state));
1528            return PackageMempoolAcceptResult(package_state, std::move(results));
1529        }
1530    }
1531
1532    for (Workspace& ws : workspaces) {
1533        ws.m_package_feerate = package_feerate;
1534        if (!PolicyScriptChecks(ws)) {
1535            // Exit early to avoid doing pointless work. Update the failed tx result; the rest are unfinished.
1536            package_state.Invalid(PackageValidationResult::PCKG_TX, "transaction failed");
1537            results.emplace(ws.m_ptx->GetWitnessHash(), MempoolAcceptResult::Failure(ws.m_state));
1538            return PackageMempoolAcceptResult(package_state, std::move(results));
1539        }
1540        if (args.m_test_accept) {
1541            const auto effective_feerate = args.m_package_feerates ? ws.m_package_feerate :
1542                CFeeRate{ws.m_modified_fees, static_cast<int32_t>(ws.m_vsize)};
1543            const auto effective_feerate_wtxids = args.m_package_feerates ? all_package_wtxids :
1544                std::vector<Wtxid>{ws.m_ptx->GetWitnessHash()};
1545            results.emplace(ws.m_ptx->GetWitnessHash(),
1546                            MempoolAcceptResult::Success(std::move(m_subpackage.m_replaced_transactions),
1547                                                         ws.m_vsize, ws.m_base_fees, effective_feerate,
1548                                                         effective_feerate_wtxids));
1549        }
1550    }
1551
1552    if (args.m_test_accept) return PackageMempoolAcceptResult(package_state, std::move(results));
1553
1554    if (!SubmitPackage(args, workspaces, package_state, results)) {
1555        // PackageValidationState filled in by SubmitPackage().
1556        return PackageMempoolAcceptResult(package_state, std::move(results));
1557    }
1558
1559    return PackageMempoolAcceptResult(package_state, std::move(results));
1560}
1561
1562void MemPoolAccept::CleanupTemporaryCoins()
1563{
1564    // There are 3 kinds of coins in m_view:
1565    // (1) Temporary coins from the transactions in subpackage, constructed by m_viewmempool.
1566    // (2) Mempool coins from transactions in the mempool, constructed by m_viewmempool.
1567    // (3) Confirmed coins fetched from our current UTXO set.
1568    //
1569    // (1) Temporary coins need to be removed, regardless of whether the transaction was submitted.
1570    // If the transaction was submitted to the mempool, m_viewmempool will be able to fetch them from
1571    // there. If it wasn't submitted to mempool, it is incorrect to keep them - future calls may try
1572    // to spend those coins that don't actually exist.
1573    // (2) Mempool coins also need to be removed. If the mempool contents have changed as a result
1574    // of submitting or replacing transactions, coins previously fetched from mempool may now be
1575    // spent or nonexistent. Those coins need to be deleted from m_view.
1576    // (3) Confirmed coins don't need to be removed. The chainstate has not changed (we are
1577    // holding cs_main and no blocks have been processed) so the confirmed tx cannot disappear like
1578    // a mempool tx can. The coin may now be spent after we submitted a tx to mempool, but
1579    // we have already checked that the package does not have 2 transactions spending the same coin
1580    // and we check whether a mempool transaction spends conflicting coins (CTxMemPool::GetConflictTx).
1581    // Keeping them in m_view is an optimization to not re-fetch confirmed coins if we later look up
1582    // inputs for this transaction again.
1583    for (const auto& outpoint : m_viewmempool.GetNonBaseCoins()) {
1584        // In addition to resetting m_viewmempool, we also need to manually delete these coins from
1585        // m_view because it caches copies of the coins it fetched from m_viewmempool previously.
1586        m_view.Uncache(outpoint);
1587    }
1588    // This deletes the temporary and mempool coins.
1589    m_viewmempool.Reset();
1590}
1591
1592PackageMempoolAcceptResult MemPoolAccept::AcceptSubPackage(const std::vector<CTransactionRef>& subpackage, ATMPArgs& args)
1593{
1594    AssertLockHeld(::cs_main);
1595    AssertLockHeld(m_pool.cs);
1596    auto result = [&]() EXCLUSIVE_LOCKS_REQUIRED(::cs_main, m_pool.cs) {
1597        if (subpackage.size() > 1) {
1598            return AcceptMultipleTransactionsInternal(subpackage, args);
1599        }
1600        const auto& tx = subpackage.front();
1601        ATMPArgs single_args = ATMPArgs::SingleInPackageAccept(args);
1602        const auto single_res = AcceptSingleTransactionInternal(tx, single_args);
1603        PackageValidationState package_state_wrapped;
1604        if (single_res.m_result_type != MempoolAcceptResult::ResultType::VALID) {
1605            package_state_wrapped.Invalid(PackageValidationResult::PCKG_TX, "transaction failed");
1606        }
1607        return PackageMempoolAcceptResult(package_state_wrapped, {{tx->GetWitnessHash(), single_res}});
1608    }();
1609
1610    // Clean up m_view and m_viewmempool so that other subpackage evaluations don't have access to
1611    // coins they shouldn't. Keep some coins in order to minimize re-fetching coins from the UTXO set.
1612    // Clean up package feerate and rbf calculations
1613    ClearSubPackageState();
1614
1615    return result;
1616}
1617
1618PackageMempoolAcceptResult MemPoolAccept::AcceptPackage(const Package& package, ATMPArgs& args)
1619{
1620    Assert(!package.empty());
1621    AssertLockHeld(cs_main);
1622    // Used if returning a PackageMempoolAcceptResult directly from this function.
1623    PackageValidationState package_state_quit_early;
1624
1625    // There are two topologies we are able to handle through this function:
1626    // (1) A single transaction
1627    // (2) A child-with-parents package.
1628    // Check that the package is well-formed. If it isn't, we won't try to validate any of the
1629    // transactions and thus won't return any MempoolAcceptResults, just a package-wide error.
1630
1631    // Context-free package checks.
1632    if (!IsWellFormedPackage(package, package_state_quit_early)) {
1633        return PackageMempoolAcceptResult(package_state_quit_early, {});
1634    }
1635
1636    if (package.size() > 1 && !IsChildWithParents(package)) {
1637        // All transactions in the package must be a parent of the last transaction. This is just an
1638        // opportunity for us to fail fast on a context-free check without taking the mempool lock.
1639        package_state_quit_early.Invalid(PackageValidationResult::PCKG_POLICY, "package-not-child-with-parents");
1640        return PackageMempoolAcceptResult(package_state_quit_early, {});
1641    }
1642
1643    LOCK(m_pool.cs);
1644    // Stores results from which we will create the returned PackageMempoolAcceptResult.
1645    // A result may be changed if a mempool transaction is evicted later due to LimitMempoolSize().
1646    std::map<Wtxid, MempoolAcceptResult> results_final;
1647    // Results from individual validation which will be returned if no other result is available for
1648    // this transaction. "Nonfinal" because if a transaction fails by itself but succeeds later
1649    // (i.e. when evaluated with a fee-bumping child), the result in this map may be discarded.
1650    std::map<Wtxid, MempoolAcceptResult> individual_results_nonfinal;
1651    // Tracks whether we think package submission could result in successful entry to the mempool
1652    bool quit_early{false};
1653    std::vector<CTransactionRef> txns_package_eval;
1654    for (const auto& tx : package) {
1655        const auto& wtxid = tx->GetWitnessHash();
1656        const auto& txid = tx->GetHash();
1657        // There are 3 possibilities: already in mempool, same-txid-diff-wtxid already in mempool,
1658        // or not in mempool. An already confirmed tx is treated as one not in mempool, because all
1659        // we know is that the inputs aren't available.
1660        if (m_pool.exists(wtxid)) {
1661            // Exact transaction already exists in the mempool.
1662            // Node operators are free to set their mempool policies however they please, nodes may receive
1663            // transactions in different orders, and malicious counterparties may try to take advantage of
1664            // policy differences to pin or delay propagation of transactions. As such, it's possible for
1665            // some package transaction(s) to already be in the mempool, and we don't want to reject the
1666            // entire package in that case (as that could be a censorship vector). De-duplicate the
1667            // transactions that are already in the mempool, and only call AcceptMultipleTransactions() with
1668            // the new transactions. This ensures we don't double-count transaction counts and sizes when
1669            // checking ancestor/descendant limits, or double-count transaction fees for fee-related policy.
1670            const auto& entry{*Assert(m_pool.GetEntry(txid))};
1671            results_final.emplace(wtxid, MempoolAcceptResult::MempoolTx(entry.GetTxSize(), entry.GetFee()));
1672        } else if (m_pool.exists(txid)) {
1673            // Transaction with the same non-witness data but different witness (same txid,
1674            // different wtxid) already exists in the mempool.
1675            //
1676            // We don't allow replacement transactions right now, so just swap the package
1677            // transaction for the mempool one. Note that we are ignoring the validity of the
1678            // package transaction passed in.
1679            // TODO: allow witness replacement in packages.
1680            const auto& entry{*Assert(m_pool.GetEntry(txid))};
1681            // Provide the wtxid of the mempool tx so that the caller can look it up in the mempool.
1682            results_final.emplace(wtxid, MempoolAcceptResult::MempoolTxDifferentWitness(entry.GetTx().GetWitnessHash()));
1683        } else {
1684            // Transaction does not already exist in the mempool.
1685            // Try submitting the transaction on its own.
1686            const auto single_package_res = AcceptSubPackage({tx}, args);
1687            const auto& single_res = single_package_res.m_tx_results.at(wtxid);
1688            if (single_res.m_result_type == MempoolAcceptResult::ResultType::VALID) {
1689                // The transaction succeeded on its own and is now in the mempool. Don't include it
1690                // in package validation, because its fees should only be "used" once.
1691                assert(m_pool.exists(wtxid));
1692                results_final.emplace(wtxid, single_res);
1693            } else if (package.size() == 1 || // If there is only one transaction, no need to retry it "as a package"
1694                       (single_res.m_state.GetResult() != TxValidationResult::TX_RECONSIDERABLE &&
1695                       single_res.m_state.GetResult() != TxValidationResult::TX_MISSING_INPUTS)) {
1696                // Package validation policy only differs from individual policy in its evaluation
1697                // of feerate. For example, if a transaction fails here due to violation of a
1698                // consensus rule, the result will not change when it is submitted as part of a
1699                // package. To minimize the amount of repeated work, unless the transaction fails
1700                // due to feerate or missing inputs (its parent is a previous transaction in the
1701                // package that failed due to feerate), don't run package validation. Note that this
1702                // decision might not make sense if different types of packages are allowed in the
1703                // future.  Continue individually validating the rest of the transactions, because
1704                // some of them may still be valid.
1705                quit_early = true;
1706                package_state_quit_early.Invalid(PackageValidationResult::PCKG_TX, "transaction failed");
1707                individual_results_nonfinal.emplace(wtxid, single_res);
1708            } else {
1709                individual_results_nonfinal.emplace(wtxid, single_res);
1710                txns_package_eval.push_back(tx);
1711            }
1712        }
1713    }
1714
1715    auto multi_submission_result = quit_early || txns_package_eval.empty() ? PackageMempoolAcceptResult(package_state_quit_early, {}) :
1716        AcceptSubPackage(txns_package_eval, args);
1717    PackageValidationState& package_state_final = multi_submission_result.m_state;
1718
1719    // This is invoked by AcceptSubPackage() already, so this is just here for
1720    // clarity (since it's not permitted to invoke LimitMempoolSize() while a
1721    // changeset is outstanding).
1722    ClearSubPackageState();
1723
1724    // Make sure we haven't exceeded max mempool size.
1725    // Package transactions that were submitted to mempool or already in mempool may be evicted.
1726    // If mempool contents change, then the m_view cache is dirty. It has already been cleared above.
1727    LimitMempoolSize(m_pool, m_active_chainstate.CoinsTip());
1728
1729    for (const auto& tx : package) {
1730        const auto& wtxid = tx->GetWitnessHash();
1731        if (multi_submission_result.m_tx_results.contains(wtxid)) {
1732            // We shouldn't have re-submitted if the tx result was already in results_final.
1733            Assume(!results_final.contains(wtxid));
1734            // If it was submitted, check to see if the tx is still in the mempool. It could have
1735            // been evicted due to LimitMempoolSize() above.
1736            const auto& txresult = multi_submission_result.m_tx_results.at(wtxid);
1737            if (txresult.m_result_type == MempoolAcceptResult::ResultType::VALID && !m_pool.exists(wtxid)) {
1738                package_state_final.Invalid(PackageValidationResult::PCKG_TX, "transaction failed");
1739                TxValidationState mempool_full_state;
1740                mempool_full_state.Invalid(TxValidationResult::TX_MEMPOOL_POLICY, "mempool full");
1741                results_final.emplace(wtxid, MempoolAcceptResult::Failure(mempool_full_state));
1742            } else {
1743                results_final.emplace(wtxid, txresult);
1744            }
1745        } else if (const auto it{results_final.find(wtxid)}; it != results_final.end()) {
1746            // Already-in-mempool transaction. Check to see if it's still there, as it could have
1747            // been evicted when LimitMempoolSize() was called.
1748            Assume(it->second.m_result_type != MempoolAcceptResult::ResultType::INVALID);
1749            Assume(!individual_results_nonfinal.contains(wtxid));
1750            // Query by txid to include the same-txid-different-witness ones.