Merge bitcoin/bitcoin#31279: policy: ephemeral dust followups

466e4df3fb assert_mempool_contents: assert not duplicates expected (Greg Sanders) ea5db2f269 functional: only generate required blocks for test (Greg Sanders) d033acb608 fuzz: package_eval: let fuzzer run out input in main tx creation loop (Greg Sanders) ba35a570c5 CheckEphemeralSpends: return boolean, and set child state and txid outparams (Greg Sanders) cf0cee1617 func: add note about lack of 1P1C propagation in tree submitpackage (Greg Sanders) 8424290304 unit test: ephemeral_tests is using a dust relay rate, not minrelay (Greg Sanders) d9cfa5fc4e CheckEphemeralSpends: no need to iterate inputs if no parent dust (Greg Sanders) 87b26e3dc0 func: rename test_free_relay to test_no_minrelay_fee (Greg Sanders) e5709a4a41 func: slight elaboration on submitpackage restriction (Greg Sanders) 08e969bd10 RPC: only enforce dust rules on priority when standardness active (Greg Sanders) ca050d12e7 unit test: adapt to changing MAX_DUST_OUTPUTS_PER_TX (Greg Sanders) 7c3490169c fuzz: package_eval: move last_tx inside txn ctor (Greg Sanders) 445eaed182 fuzz: use optional status instead of should_rbf_eph_spend (Greg Sanders) 4dfdf615b9 fuzz: remove unused TransactionsDelta validation interface (Greg Sanders) 09ce926e4a func: cleanup reorg test comment (Greg Sanders) 768a0c1889 func: cleanup test_dustrelay comments (Greg Sanders) bedca1cb66 fuzz: Directly place transactions in vector (Greg Sanders) c041ad6ecc fuzz: explain package eval coin tracking better (Greg Sanders) bc0d98ea61 fuzz: remove dangling reference to GetEntry (Greg Sanders) 15b6cbf07f unit test: make dust index less magical (Greg Sanders) 5fbcfd12b8 unit test: assert txid returned on CheckEphemeralSpends failures (Greg Sanders) ef94d84b4e bench: remove unnecessary CMTxn constructors (Greg Sanders) c5c10fd317 ephemeral policy doxygen cleanup (Greg Sanders) dd9044b8d4 ephemeral policy: IWYU (Greg Sanders) c6859ce2de Move+rename GetDustIndexes -> GetDust (Greg Sanders) 62016b3230 Use std::ranges for ephemeral policy checks (Greg Sanders) 3ed930a1f4 Have HasDust and PreCheckValidEphemeralTx take CTransaction (Greg Sanders) 04a614bf9a Rename CheckValidEphemeralTx to PreCheckEphemeralTx (Greg Sanders) cbf1a47d60 CheckEphemeralSpends: only compute txid of tx when needed (Greg Sanders) Pull request description: Follow-up to https://github.com/bitcoin/bitcoin/pull/30239 Here are the parent PR's comments that should be addressed by this PR: https://github.com/bitcoin/bitcoin/pull/30239/files#r1834529646 https://github.com/bitcoin/bitcoin/pull/30239/files#r1831247308 https://github.com/bitcoin/bitcoin/pull/30239/files#r1832622481 https://github.com/bitcoin/bitcoin/pull/30239/files#r1831195216 https://github.com/bitcoin/bitcoin/pull/30239#discussion_r1835805164 https://github.com/bitcoin/bitcoin/pull/30239#discussion_r1835805164 https://github.com/bitcoin/bitcoin/pull/30239#discussion_r1834639096 https://github.com/bitcoin/bitcoin/pull/30239#discussion_r1834624976 https://github.com/bitcoin/bitcoin/pull/30239#discussion_r1834619709 https://github.com/bitcoin/bitcoin/pull/30239#discussion_r1834610434 https://github.com/bitcoin/bitcoin/pull/30239#discussion_r1834504436 https://github.com/bitcoin/bitcoin/pull/30239#discussion_r1834500036 https://github.com/bitcoin/bitcoin/pull/30239#discussion_r1832985488 https://github.com/bitcoin/bitcoin/pull/30239#discussion_r1830929809 https://github.com/bitcoin/bitcoin/pull/30239#discussion_r1832376920 https://github.com/bitcoin/bitcoin/pull/30239#discussion_r1832755799 https://github.com/bitcoin/bitcoin/pull/30239#discussion_r1832492686 https://github.com/bitcoin/bitcoin/pull/30239#discussion_r1832980576 https://github.com/bitcoin/bitcoin/pull/30239#discussion_r1832784278 https://github.com/bitcoin/bitcoin/pull/30239#discussion_r1837989979 https://github.com/bitcoin/bitcoin/pull/30239#discussion_r1830996993 https://github.com/bitcoin/bitcoin/pull/30239#discussion_r1830997947 https://github.com/bitcoin/bitcoin/pull/30239#discussion_r1830012890 https://github.com/bitcoin/bitcoin/pull/30239#discussion_r1830037288 https://github.com/bitcoin/bitcoin/pull/30239#discussion_r1830977092 https://github.com/bitcoin/bitcoin/pull/30239#discussion_r1832622481 https://github.com/bitcoin/bitcoin/pull/30239#discussion_r1834726168 https://github.com/bitcoin/bitcoin/pull/30239#discussion_r1832453654 https://github.com/bitcoin/bitcoin/pull/30239#discussion_r1848488226 ACKs for top commit: naumenkogs: ACK 466e4df3fb hodlinator: ACK 466e4df3fb theStack: lgtm ACK 466e4df3fb glozow: utACK 466e4df3fb Tree-SHA512: 89106f695755c238b84e0996b89446c0733e10a94c867f656d516d26697d2efe38dfc332188b8589a0a26a3d2bd2c88c6ab70c108e187ce5bfcb91bbf3fb0391
2026-06-04 18:22:57 +02:00 · 2024-11-25 13:47:31 -05:00
parent 2638fdb4f9 466e4df3fb
commit f7144b24be
15 changed files with 210 additions and 146 deletions
--- a/src/test/fuzz/package_eval.cpp
+++ b/src/test/fuzz/package_eval.cpp
@@ -167,7 +167,7 @@ std::optional<COutPoint> GetChildEvictingPrevout(const CTxMemPool& tx_pool)
    LOCK(tx_pool.cs);
    for (const auto& tx_info : tx_pool.infoAll()) {
        const auto& entry = *Assert(tx_pool.GetEntry(tx_info.tx->GetHash()));
-        std::vector<uint32_t> dust_indexes{GetDustIndexes(tx_info.tx, tx_pool.m_opts.dust_relay_feerate)};
+        std::vector<uint32_t> dust_indexes{GetDust(*tx_info.tx, tx_pool.m_opts.dust_relay_feerate)};
        if (!dust_indexes.empty()) {
            const auto& children = entry.GetMemPoolChildrenConst();
            if (!children.empty()) {
@@ -210,37 +210,33 @@ FUZZ_TARGET(ephemeral_package_eval, .init = initialize_tx_pool)

    chainstate.SetMempool(&tx_pool);

-    LIMITED_WHILE(fuzzed_data_provider.ConsumeBool(), 300)
+    LIMITED_WHILE(fuzzed_data_provider.remaining_bytes() > 0, 300)
    {
        Assert(!mempool_outpoints.empty());

        std::vector<CTransactionRef> txs;

        // Find something we may want to double-spend with two input single tx
-        std::optional<COutPoint> outpoint_to_rbf{GetChildEvictingPrevout(tx_pool)};
-        bool should_rbf_eph_spend = outpoint_to_rbf && fuzzed_data_provider.ConsumeBool();
+        std::optional<COutPoint> outpoint_to_rbf{fuzzed_data_provider.ConsumeBool() ? GetChildEvictingPrevout(tx_pool) : std::nullopt};

        // Make small packages
-        const auto num_txs = should_rbf_eph_spend ? 1 : (size_t) fuzzed_data_provider.ConsumeIntegralInRange<int>(1, 4);
+        const auto num_txs = outpoint_to_rbf ? 1 : (size_t) fuzzed_data_provider.ConsumeIntegralInRange<int>(1, 4);

        std::set<COutPoint> package_outpoints;
        while (txs.size() < num_txs) {
-
-            // Last transaction in a package needs to be a child of parents to get further in validation
-            // so the last transaction to be generated(in a >1 package) must spend all package-made outputs
-            // Note that this test currently only spends package outputs in last transaction.
-            bool last_tx = num_txs > 1 && txs.size() == num_txs - 1;
-
            // Create transaction to add to the mempool
-            const CTransactionRef tx = [&] {
+            txs.emplace_back([&] {
                CMutableTransaction tx_mut;
                tx_mut.version = CTransaction::CURRENT_VERSION;
                tx_mut.nLockTime = 0;
-                // Last tx will sweep half or more of all outpoints from package
-                const auto num_in = should_rbf_eph_spend ? 2 :
+                // Last transaction in a package needs to be a child of parents to get further in validation
+                // so the last transaction to be generated(in a >1 package) must spend all package-made outputs
+                // Note that this test currently only spends package outputs in last transaction.
+                bool last_tx = num_txs > 1 && txs.size() == num_txs - 1;
+                const auto num_in = outpoint_to_rbf ? 2 :
                    last_tx ? fuzzed_data_provider.ConsumeIntegralInRange<int>(package_outpoints.size()/2 + 1, package_outpoints.size()) :
                    fuzzed_data_provider.ConsumeIntegralInRange<int>(1, 4);
-                auto num_out = should_rbf_eph_spend ? 1 : fuzzed_data_provider.ConsumeIntegralInRange<int>(1, 4);
+                const auto num_out = outpoint_to_rbf ? 1 : fuzzed_data_provider.ConsumeIntegralInRange<int>(1, 4);

                auto& outpoints = last_tx ? package_outpoints : mempool_outpoints;

@@ -248,12 +244,13 @@ FUZZ_TARGET(ephemeral_package_eval, .init = initialize_tx_pool)

                CAmount amount_in{0};
                for (int i = 0; i < num_in; ++i) {
-                    // Pop random outpoint
+                    // Pop random outpoint. We erase them to avoid double-spending
+                    // while in this loop, but later add them back (unless last_tx).
                    auto pop = outpoints.begin();
                    std::advance(pop, fuzzed_data_provider.ConsumeIntegralInRange<size_t>(0, outpoints.size() - 1));
                    auto outpoint = *pop;

-                    if (i == 0 && should_rbf_eph_spend) {
+                    if (i == 0 && outpoint_to_rbf) {
                        outpoint = *outpoint_to_rbf;
                        outpoints.erase(outpoint);
                    } else {
@@ -277,7 +274,7 @@ FUZZ_TARGET(ephemeral_package_eval, .init = initialize_tx_pool)
                }

                // Note output amounts can naturally drop to dust on their own.
-                if (!should_rbf_eph_spend && fuzzed_data_provider.ConsumeBool()) {
+                if (!outpoint_to_rbf && fuzzed_data_provider.ConsumeBool()) {
                    uint32_t dust_index = fuzzed_data_provider.ConsumeIntegralInRange<uint32_t>(0, num_out);
                    tx_mut.vout.insert(tx_mut.vout.begin() + dust_index, CTxOut(0, P2WSH_EMPTY));
                }
@@ -298,8 +295,7 @@ FUZZ_TARGET(ephemeral_package_eval, .init = initialize_tx_pool)
                    outpoints_value[COutPoint(tx->GetHash(), i)] = tx->vout[i].nValue;
                }
                return tx;
-            }();
-            txs.push_back(tx);
+            }());
        }

        if (fuzzed_data_provider.ConsumeBool()) {
@@ -308,20 +304,15 @@ FUZZ_TARGET(ephemeral_package_eval, .init = initialize_tx_pool)
                                   PickValue(fuzzed_data_provider, mempool_outpoints).hash;
            const auto delta = fuzzed_data_provider.ConsumeIntegralInRange<CAmount>(-50 * COIN, +50 * COIN);
            // We only prioritise out of mempool transactions since PrioritiseTransaction doesn't
-            // filter for ephemeral dust GetEntry
+            // filter for ephemeral dust
            if (tx_pool.exists(GenTxid::Txid(txid))) {
                const auto tx_info{tx_pool.info(GenTxid::Txid(txid))};
-                if (GetDustIndexes(tx_info.tx, tx_pool.m_opts.dust_relay_feerate).empty()) {
+                if (GetDust(*tx_info.tx, tx_pool.m_opts.dust_relay_feerate).empty()) {
                    tx_pool.PrioritiseTransaction(txid.ToUint256(), delta);
                }
            }
        }

-        // Remember all added transactions
-        std::set<CTransactionRef> added;
-        auto txr = std::make_shared<TransactionsDelta>(added);
-        node.validation_signals->RegisterSharedValidationInterface(txr);
-
        auto single_submit = txs.size() == 1;

        const auto result_package = WITH_LOCK(::cs_main,
@@ -339,7 +330,6 @@ FUZZ_TARGET(ephemeral_package_eval, .init = initialize_tx_pool)
        }

        node.validation_signals->SyncWithValidationInterfaceQueue();
-        node.validation_signals->UnregisterSharedValidationInterface(txr);

        CheckMempoolEphemeralInvariants(tx_pool);
    }
@@ -374,7 +364,7 @@ FUZZ_TARGET(tx_package_eval, .init = initialize_tx_pool)

    chainstate.SetMempool(&tx_pool);

-    LIMITED_WHILE(fuzzed_data_provider.ConsumeBool(), 300)
+    LIMITED_WHILE(fuzzed_data_provider.remaining_bytes() > 0, 300)
    {
        Assert(!mempool_outpoints.empty());

@@ -384,18 +374,15 @@ FUZZ_TARGET(tx_package_eval, .init = initialize_tx_pool)
        const auto num_txs = (size_t) fuzzed_data_provider.ConsumeIntegralInRange<int>(1, 26);
        std::set<COutPoint> package_outpoints;
        while (txs.size() < num_txs) {
-
-            // Last transaction in a package needs to be a child of parents to get further in validation
-            // so the last transaction to be generated(in a >1 package) must spend all package-made outputs
-            // Note that this test currently only spends package outputs in last transaction.
-            bool last_tx = num_txs > 1 && txs.size() == num_txs - 1;
-
            // Create transaction to add to the mempool
-            const CTransactionRef tx = [&] {
+            txs.emplace_back([&] {
                CMutableTransaction tx_mut;
                tx_mut.version = fuzzed_data_provider.ConsumeBool() ? TRUC_VERSION : CTransaction::CURRENT_VERSION;
                tx_mut.nLockTime = fuzzed_data_provider.ConsumeBool() ? 0 : fuzzed_data_provider.ConsumeIntegral<uint32_t>();
-                // Last tx will sweep all outpoints in package
+                // Last transaction in a package needs to be a child of parents to get further in validation
+                // so the last transaction to be generated(in a >1 package) must spend all package-made outputs
+                // Note that this test currently only spends package outputs in last transaction.
+                bool last_tx = num_txs > 1 && txs.size() == num_txs - 1;
                const auto num_in = last_tx ? package_outpoints.size()  : fuzzed_data_provider.ConsumeIntegralInRange<int>(1, mempool_outpoints.size());
                auto num_out = fuzzed_data_provider.ConsumeIntegralInRange<int>(1, mempool_outpoints.size() * 2);

@@ -405,7 +392,8 @@ FUZZ_TARGET(tx_package_eval, .init = initialize_tx_pool)

                CAmount amount_in{0};
                for (size_t i = 0; i < num_in; ++i) {
-                    // Pop random outpoint
+                    // Pop random outpoint. We erase them to avoid double-spending
+                    // while in this loop, but later add them back (unless last_tx).
                    auto pop = outpoints.begin();
                    std::advance(pop, fuzzed_data_provider.ConsumeIntegralInRange<size_t>(0, outpoints.size() - 1));
                    const auto outpoint = *pop;
@@ -468,8 +456,7 @@ FUZZ_TARGET(tx_package_eval, .init = initialize_tx_pool)
                    outpoints_value[COutPoint(tx->GetHash(), i)] = tx->vout[i].nValue;
                }
                return tx;
-            }();
-            txs.push_back(tx);
+            }());
        }

        if (fuzzed_data_provider.ConsumeBool()) {
--- a/src/test/transaction_tests.cpp
+++ b/src/test/transaction_tests.cpp
@@ -814,9 +814,11 @@ BOOST_AUTO_TEST_CASE(test_IsStandard)
    CAmount nDustThreshold = 182 * g_dust.GetFeePerK() / 1000;
    BOOST_CHECK_EQUAL(nDustThreshold, 546);

-    // Add dust output to take dust slot, still standard!
-    t.vout.emplace_back(0, t.vout[0].scriptPubKey);
-    CheckIsStandard(t);
+    // Add dust outputs up to allowed maximum, still standard!
+    for (size_t i{0}; i < MAX_DUST_OUTPUTS_PER_TX; ++i) {
+        t.vout.emplace_back(0, t.vout[0].scriptPubKey);
+        CheckIsStandard(t);
+    }

    // dust:
    t.vout[0].nValue = nDustThreshold - 1;
@@ -974,9 +976,9 @@ BOOST_AUTO_TEST_CASE(test_IsStandard)
    CheckIsNotStandard(t, "bare-multisig");
    g_bare_multi = DEFAULT_PERMIT_BAREMULTISIG;

-    // Add dust output to take dust slot
+    // Add dust outputs up to allowed maximum
    assert(t.vout.size() == 1);
-    t.vout.emplace_back(0, t.vout[0].scriptPubKey);
+    t.vout.insert(t.vout.end(), MAX_DUST_OUTPUTS_PER_TX, {0, t.vout[0].scriptPubKey});

    // Check compressed P2PK outputs dust threshold (must have leading 02 or 03)
    t.vout[0].scriptPubKey = CScript() << std::vector<unsigned char>(33, 0x02) << OP_CHECKSIG;
--- a/src/test/txvalidation_tests.cpp
+++ b/src/test/txvalidation_tests.cpp
@@ -90,19 +90,22 @@ static inline CTransactionRef make_tx(const std::vector<COutPoint>& inputs, int3
    return MakeTransactionRef(mtx);
 }

+static constexpr auto NUM_EPHEMERAL_TX_OUTPUTS = 3;
+static constexpr auto EPHEMERAL_DUST_INDEX = NUM_EPHEMERAL_TX_OUTPUTS - 1;
+
 // Same as make_tx but adds 2 normal outputs and 0-value dust to end of vout
 static inline CTransactionRef make_ephemeral_tx(const std::vector<COutPoint>& inputs, int32_t version)
 {
    CMutableTransaction mtx = CMutableTransaction{};
    mtx.version = version;
    mtx.vin.resize(inputs.size());
-    mtx.vout.resize(3);
    for (size_t i{0}; i < inputs.size(); ++i) {
        mtx.vin[i].prevout = inputs[i];
    }
-    for (auto i{0}; i < 3; ++i) {
+    mtx.vout.resize(NUM_EPHEMERAL_TX_OUTPUTS);
+    for (auto i{0}; i < NUM_EPHEMERAL_TX_OUTPUTS; ++i) {
        mtx.vout[i].scriptPubKey = CScript() << OP_TRUE;
-        mtx.vout[i].nValue = (i == 2) ? 0 : 10000;
+        mtx.vout[i].nValue = (i == EPHEMERAL_DUST_INDEX) ? 0 : 10000;
    }
    return MakeTransactionRef(mtx);
 }
@@ -114,99 +117,159 @@ BOOST_FIXTURE_TEST_CASE(ephemeral_tests, RegTestingSetup)
    TestMemPoolEntryHelper entry;
    CTxMemPool::setEntries empty_ancestors;

-    CFeeRate minrelay(1000);
+    TxValidationState child_state;
+    Txid child_txid;
+
+    // Arbitrary non-0 feerate for these tests
+    CFeeRate dustrelay(DUST_RELAY_TX_FEE);

    // Basic transaction with dust
    auto grandparent_tx_1 = make_ephemeral_tx(random_outpoints(1), /*version=*/2);
    const auto dust_txid = grandparent_tx_1->GetHash();

-    uint32_t dust_index = 2;
-
    // Child transaction spending dust
-    auto dust_spend = make_tx({COutPoint{dust_txid, dust_index}}, /*version=*/2);
+    auto dust_spend = make_tx({COutPoint{dust_txid, EPHEMERAL_DUST_INDEX}}, /*version=*/2);

    // We first start with nothing "in the mempool", using package checks

    // Trivial single transaction with no dust
-    BOOST_CHECK(!CheckEphemeralSpends({dust_spend}, minrelay, pool).has_value());
+    BOOST_CHECK(CheckEphemeralSpends({dust_spend}, dustrelay, pool, child_state, child_txid));
+    BOOST_CHECK(child_state.IsValid());
+    BOOST_CHECK_EQUAL(child_txid, Txid());

    // Now with dust, ok because the tx has no dusty parents
-    BOOST_CHECK(!CheckEphemeralSpends({grandparent_tx_1}, minrelay, pool).has_value());
+    BOOST_CHECK(CheckEphemeralSpends({grandparent_tx_1}, dustrelay, pool, child_state, child_txid));
+    BOOST_CHECK(child_state.IsValid());
+    BOOST_CHECK_EQUAL(child_txid, Txid());

    // Dust checks pass
-    BOOST_CHECK(!CheckEphemeralSpends({grandparent_tx_1, dust_spend}, CFeeRate(0), pool).has_value());
-    BOOST_CHECK(!CheckEphemeralSpends({grandparent_tx_1, dust_spend}, minrelay, pool).has_value());
+    BOOST_CHECK(CheckEphemeralSpends({grandparent_tx_1, dust_spend}, CFeeRate(0), pool, child_state, child_txid));
+    BOOST_CHECK(child_state.IsValid());
+    BOOST_CHECK_EQUAL(child_txid, Txid());
+    BOOST_CHECK(CheckEphemeralSpends({grandparent_tx_1, dust_spend}, dustrelay, pool, child_state, child_txid));
+    BOOST_CHECK(child_state.IsValid());
+    BOOST_CHECK_EQUAL(child_txid, Txid());

-    auto dust_non_spend = make_tx({COutPoint{dust_txid, dust_index - 1}}, /*version=*/2);
+    auto dust_non_spend = make_tx({COutPoint{dust_txid, EPHEMERAL_DUST_INDEX - 1}}, /*version=*/2);

    // Child spending non-dust only from parent should be disallowed even if dust otherwise spent
-    BOOST_CHECK(CheckEphemeralSpends({grandparent_tx_1, dust_non_spend, dust_spend}, minrelay, pool).has_value());
-    BOOST_CHECK(CheckEphemeralSpends({grandparent_tx_1, dust_spend, dust_non_spend}, minrelay, pool).has_value());
-    BOOST_CHECK(CheckEphemeralSpends({grandparent_tx_1, dust_non_spend}, minrelay, pool).has_value());
+    const auto dust_non_spend_txid{dust_non_spend->GetHash()};
+    BOOST_CHECK(!CheckEphemeralSpends({grandparent_tx_1, dust_non_spend, dust_spend}, dustrelay, pool, child_state, child_txid));
+    BOOST_CHECK(!child_state.IsValid());
+    BOOST_CHECK_EQUAL(child_txid, dust_non_spend_txid);
+    child_state = TxValidationState();
+    child_txid = Txid();
+
+    BOOST_CHECK(!CheckEphemeralSpends({grandparent_tx_1, dust_spend, dust_non_spend}, dustrelay, pool, child_state, child_txid));
+    BOOST_CHECK(!child_state.IsValid());
+    BOOST_CHECK_EQUAL(child_txid, dust_non_spend_txid);
+    child_state = TxValidationState();
+    child_txid = Txid();
+
+    BOOST_CHECK(!CheckEphemeralSpends({grandparent_tx_1, dust_non_spend}, dustrelay, pool, child_state, child_txid));
+    BOOST_CHECK(!child_state.IsValid());
+    BOOST_CHECK_EQUAL(child_txid, dust_non_spend_txid);
+    child_state = TxValidationState();
+    child_txid = Txid();

    auto grandparent_tx_2 = make_ephemeral_tx(random_outpoints(1), /*version=*/2);
    const auto dust_txid_2 = grandparent_tx_2->GetHash();

    // Spend dust from one but not another is ok, as long as second grandparent has no child
-    BOOST_CHECK(!CheckEphemeralSpends({grandparent_tx_1, grandparent_tx_2, dust_spend}, minrelay, pool).has_value());
+    BOOST_CHECK(CheckEphemeralSpends({grandparent_tx_1, grandparent_tx_2, dust_spend}, dustrelay, pool, child_state, child_txid));
+    BOOST_CHECK(child_state.IsValid());
+    BOOST_CHECK_EQUAL(child_txid, Txid());

-    auto dust_non_spend_both_parents = make_tx({COutPoint{dust_txid, dust_index}, COutPoint{dust_txid_2, dust_index - 1}}, /*version=*/2);
+    auto dust_non_spend_both_parents = make_tx({COutPoint{dust_txid, EPHEMERAL_DUST_INDEX}, COutPoint{dust_txid_2, EPHEMERAL_DUST_INDEX - 1}}, /*version=*/2);
    // But if we spend from the parent, it must spend dust
-    BOOST_CHECK(CheckEphemeralSpends({grandparent_tx_1, grandparent_tx_2, dust_non_spend_both_parents}, minrelay, pool).has_value());
+    BOOST_CHECK(!CheckEphemeralSpends({grandparent_tx_1, grandparent_tx_2, dust_non_spend_both_parents}, dustrelay, pool, child_state, child_txid));
+    BOOST_CHECK(!child_state.IsValid());
+    BOOST_CHECK_EQUAL(child_txid, dust_non_spend_both_parents->GetHash());
+    child_state = TxValidationState();
+    child_txid = Txid();

-    auto dust_spend_both_parents = make_tx({COutPoint{dust_txid, dust_index}, COutPoint{dust_txid_2, dust_index}}, /*version=*/2);
-    BOOST_CHECK(!CheckEphemeralSpends({grandparent_tx_1, grandparent_tx_2, dust_spend_both_parents}, minrelay, pool).has_value());
+    auto dust_spend_both_parents = make_tx({COutPoint{dust_txid, EPHEMERAL_DUST_INDEX}, COutPoint{dust_txid_2, EPHEMERAL_DUST_INDEX}}, /*version=*/2);
+    BOOST_CHECK(CheckEphemeralSpends({grandparent_tx_1, grandparent_tx_2, dust_spend_both_parents}, dustrelay, pool, child_state, child_txid));
+    BOOST_CHECK(child_state.IsValid());
+    BOOST_CHECK_EQUAL(child_txid, Txid());

    // Spending other outputs is also correct, as long as the dusty one is spent
    const std::vector<COutPoint> all_outpoints{COutPoint(dust_txid, 0), COutPoint(dust_txid, 1), COutPoint(dust_txid, 2),
        COutPoint(dust_txid_2, 0), COutPoint(dust_txid_2, 1), COutPoint(dust_txid_2, 2)};
    auto dust_spend_all_outpoints = make_tx(all_outpoints, /*version=*/2);
-    BOOST_CHECK(!CheckEphemeralSpends({grandparent_tx_1, grandparent_tx_2, dust_spend_all_outpoints}, minrelay, pool).has_value());
+    BOOST_CHECK(CheckEphemeralSpends({grandparent_tx_1, grandparent_tx_2, dust_spend_all_outpoints}, dustrelay, pool, child_state, child_txid));
+    BOOST_CHECK(child_state.IsValid());
+    BOOST_CHECK_EQUAL(child_txid, Txid());

    // 2 grandparents with dust <- 1 dust-spending parent with dust <- child with no dust
-    auto parent_with_dust = make_ephemeral_tx({COutPoint{dust_txid, dust_index}, COutPoint{dust_txid_2, dust_index}}, /*version=*/2);
+    auto parent_with_dust = make_ephemeral_tx({COutPoint{dust_txid, EPHEMERAL_DUST_INDEX}, COutPoint{dust_txid_2, EPHEMERAL_DUST_INDEX}}, /*version=*/2);
    // Ok for parent to have dust
-    BOOST_CHECK(!CheckEphemeralSpends({grandparent_tx_1, grandparent_tx_2, parent_with_dust}, minrelay, pool).has_value());
-    auto child_no_dust = make_tx({COutPoint{parent_with_dust->GetHash(), dust_index}}, /*version=*/2);
-    BOOST_CHECK(!CheckEphemeralSpends({grandparent_tx_1, grandparent_tx_2, parent_with_dust, child_no_dust}, minrelay, pool).has_value());
+    BOOST_CHECK(CheckEphemeralSpends({grandparent_tx_1, grandparent_tx_2, parent_with_dust}, dustrelay, pool, child_state, child_txid));
+    BOOST_CHECK(child_state.IsValid());
+    BOOST_CHECK_EQUAL(child_txid, Txid());
+    auto child_no_dust = make_tx({COutPoint{parent_with_dust->GetHash(), EPHEMERAL_DUST_INDEX}}, /*version=*/2);
+    BOOST_CHECK(CheckEphemeralSpends({grandparent_tx_1, grandparent_tx_2, parent_with_dust, child_no_dust}, dustrelay, pool, child_state, child_txid));
+    BOOST_CHECK(child_state.IsValid());
+    BOOST_CHECK_EQUAL(child_txid, Txid());

    // 2 grandparents with dust <- 1 dust-spending parent with dust <- child with dust
-    auto child_with_dust = make_ephemeral_tx({COutPoint{parent_with_dust->GetHash(), dust_index}}, /*version=*/2);
-    BOOST_CHECK(!CheckEphemeralSpends({grandparent_tx_1, grandparent_tx_2, parent_with_dust, child_with_dust}, minrelay, pool).has_value());
+    auto child_with_dust = make_ephemeral_tx({COutPoint{parent_with_dust->GetHash(), EPHEMERAL_DUST_INDEX}}, /*version=*/2);
+    BOOST_CHECK(CheckEphemeralSpends({grandparent_tx_1, grandparent_tx_2, parent_with_dust, child_with_dust}, dustrelay, pool, child_state, child_txid));
+    BOOST_CHECK(child_state.IsValid());
+    BOOST_CHECK_EQUAL(child_txid, Txid());

    // Tests with parents in mempool

    // Nothing in mempool, this should pass for any transaction
-    BOOST_CHECK(!CheckEphemeralSpends({grandparent_tx_1}, minrelay, pool).has_value());
+    BOOST_CHECK(CheckEphemeralSpends({grandparent_tx_1}, dustrelay, pool, child_state, child_txid));
+    BOOST_CHECK(child_state.IsValid());
+    BOOST_CHECK_EQUAL(child_txid, Txid());

    // Add first grandparent to mempool and fetch entry
    AddToMempool(pool, entry.FromTx(grandparent_tx_1));

    // Ignores ancestors that aren't direct parents
-    BOOST_CHECK(!CheckEphemeralSpends({child_no_dust}, minrelay, pool).has_value());
+    BOOST_CHECK(CheckEphemeralSpends({child_no_dust}, dustrelay, pool, child_state, child_txid));
+    BOOST_CHECK(child_state.IsValid());
+    BOOST_CHECK_EQUAL(child_txid, Txid());

    // Valid spend of dust with grandparent in mempool
-    BOOST_CHECK(!CheckEphemeralSpends({parent_with_dust}, minrelay, pool).has_value());
+    BOOST_CHECK(CheckEphemeralSpends({parent_with_dust}, dustrelay, pool, child_state, child_txid));
+    BOOST_CHECK(child_state.IsValid());
+    BOOST_CHECK_EQUAL(child_txid, Txid());

    // Second grandparent in same package
-    BOOST_CHECK(!CheckEphemeralSpends({parent_with_dust, grandparent_tx_2}, minrelay, pool).has_value());
+    BOOST_CHECK(CheckEphemeralSpends({parent_with_dust, grandparent_tx_2}, dustrelay, pool, child_state, child_txid));
+    BOOST_CHECK(child_state.IsValid());
+    BOOST_CHECK_EQUAL(child_txid, Txid());
+
    // Order in package doesn't matter
-    BOOST_CHECK(!CheckEphemeralSpends({grandparent_tx_2, parent_with_dust}, minrelay, pool).has_value());
+    BOOST_CHECK(CheckEphemeralSpends({grandparent_tx_2, parent_with_dust}, dustrelay, pool, child_state, child_txid));
+    BOOST_CHECK(child_state.IsValid());
+    BOOST_CHECK_EQUAL(child_txid, Txid());

    // Add second grandparent to mempool
    AddToMempool(pool, entry.FromTx(grandparent_tx_2));

    // Only spends single dust out of two direct parents
-    BOOST_CHECK(CheckEphemeralSpends({dust_non_spend_both_parents}, minrelay, pool).has_value());
+    BOOST_CHECK(!CheckEphemeralSpends({dust_non_spend_both_parents}, dustrelay, pool, child_state, child_txid));
+    BOOST_CHECK(!child_state.IsValid());
+    BOOST_CHECK_EQUAL(child_txid, dust_non_spend_both_parents->GetHash());
+    child_state = TxValidationState();
+    child_txid = Txid();

    // Spends both parents' dust
-    BOOST_CHECK(!CheckEphemeralSpends({parent_with_dust}, minrelay, pool).has_value());
+    BOOST_CHECK(CheckEphemeralSpends({parent_with_dust}, dustrelay, pool, child_state, child_txid));
+    BOOST_CHECK(child_state.IsValid());
+    BOOST_CHECK_EQUAL(child_txid, Txid());

    // Now add dusty parent to mempool
    AddToMempool(pool, entry.FromTx(parent_with_dust));

    // Passes dust checks even with non-parent ancestors
-    BOOST_CHECK(!CheckEphemeralSpends({child_no_dust}, minrelay, pool).has_value());
+    BOOST_CHECK(CheckEphemeralSpends({child_no_dust}, dustrelay, pool, child_state, child_txid));
+    BOOST_CHECK(child_state.IsValid());
+    BOOST_CHECK_EQUAL(child_txid, Txid());
 }

 BOOST_FIXTURE_TEST_CASE(version3_tests, RegTestingSetup)
--- a/src/test/util/txmempool.cpp
+++ b/src/test/util/txmempool.cpp
@@ -141,24 +141,13 @@ std::optional<std::string> CheckPackageMempoolAcceptResult(const Package& txns,
    return std::nullopt;
 }

-std::vector<uint32_t> GetDustIndexes(const CTransactionRef& tx_ref, CFeeRate dust_relay_rate)
-{
-    std::vector<uint32_t> dust_indexes;
-    for (size_t i = 0; i < tx_ref->vout.size(); ++i) {
-        const auto& output = tx_ref->vout[i];
-        if (IsDust(output, dust_relay_rate)) dust_indexes.push_back(i);
-    }
-
-    return dust_indexes;
-}
-
 void CheckMempoolEphemeralInvariants(const CTxMemPool& tx_pool)
 {
    LOCK(tx_pool.cs);
    for (const auto& tx_info : tx_pool.infoAll()) {
        const auto& entry = *Assert(tx_pool.GetEntry(tx_info.tx->GetHash()));

-        std::vector<uint32_t> dust_indexes = GetDustIndexes(tx_info.tx, tx_pool.m_opts.dust_relay_feerate);
+        std::vector<uint32_t> dust_indexes = GetDust(*tx_info.tx, tx_pool.m_opts.dust_relay_feerate);

        Assert(dust_indexes.size() < 2);

--- a/src/test/util/txmempool.h
+++ b/src/test/util/txmempool.h
@@ -54,11 +54,6 @@ std::optional<std::string>  CheckPackageMempoolAcceptResult(const Package& txns,
 */
 void CheckMempoolEphemeralInvariants(const CTxMemPool& tx_pool);

-/** Return indexes of the transaction's outputs that are considered dust
- * at given dust_relay_rate.
-*/
-std::vector<uint32_t> GetDustIndexes(const CTransactionRef& tx_ref, CFeeRate dust_relay_rate);
-
 /** For every transaction in tx_pool, check TRUC invariants:
 * - a TRUC tx's ancestor count must be within TRUC_ANCESTOR_LIMIT
 * - a TRUC tx's descendant count must be within TRUC_DESCENDANT_LIMIT