diff --git a/test/functional/mempool_ephemeral_dust.py b/test/functional/mempool_ephemeral_dust.py
new file mode 100755
index 00000000000..75c98ce0f89
--- /dev/null
+++ b/test/functional/mempool_ephemeral_dust.py
@@ -0,0 +1,482 @@
+#!/usr/bin/env python3
+# Copyright (c) 2024-present The Bitcoin Core developers
+# Distributed under the MIT software license, see the accompanying
+# file COPYING or http://www.opensource.org/licenses/mit-license.php.
+
+from decimal import Decimal
+
+from test_framework.messages import (
+    COIN,
+    CTxOut,
+)
+from test_framework.test_framework import BitcoinTestFramework
+from test_framework.mempool_util import assert_mempool_contents
+from test_framework.util import (
+    assert_equal,
+    assert_greater_than,
+    assert_raises_rpc_error,
+)
+from test_framework.wallet import (
+    MiniWallet,
+)
+
+class EphemeralDustTest(BitcoinTestFramework):
+    def set_test_params(self):
+        # Mempools should match via 1P1C p2p relay
+        self.num_nodes = 2
+
+        # Don't test trickling logic
+        self.noban_tx_relay = True
+
+    def add_output_to_create_multi_result(self, result, output_value=0):
+        """ Add output without changing absolute tx fee
+        """
+        assert len(result["tx"].vout) > 0
+        assert result["tx"].vout[0].nValue >= output_value
+        result["tx"].vout.append(CTxOut(output_value, result["tx"].vout[0].scriptPubKey))
+        # Take value from first output
+        result["tx"].vout[0].nValue -= output_value
+        result["new_utxos"][0]["value"] = Decimal(result["tx"].vout[0].nValue) / COIN
+        new_txid = result["tx"].rehash()
+        result["txid"]  = new_txid
+        result["wtxid"] = result["tx"].getwtxid()
+        result["hex"] = result["tx"].serialize().hex()
+        for new_utxo in result["new_utxos"]:
+            new_utxo["txid"] = new_txid
+            new_utxo["wtxid"] = result["tx"].getwtxid()
+
+        result["new_utxos"].append({"txid": new_txid, "vout": len(result["tx"].vout) - 1, "value": Decimal(output_value) / COIN, "height": 0, "coinbase": False, "confirmations": 0})
+
+    def run_test(self):
+
+        node = self.nodes[0]
+        self.wallet = MiniWallet(node)
+
+        self.test_normal_dust()
+        self.test_sponsor_cycle()
+        self.test_node_restart()
+        self.test_fee_having_parent()
+        self.test_multidust()
+        self.test_nonzero_dust()
+        self.test_non_truc()
+        self.test_unspent_ephemeral()
+        self.test_reorgs()
+        self.test_free_relay()
+
+    def test_normal_dust(self):
+        self.log.info("Create 0-value dusty output, show that it works inside truc when spent in package")
+
+        assert_equal(self.nodes[0].getrawmempool(), [])
+
+        dusty_tx = self.wallet.create_self_transfer_multi(fee_per_output=0, version=3)
+        self.add_output_to_create_multi_result(dusty_tx)
+
+        sweep_tx = self.wallet.create_self_transfer_multi(utxos_to_spend=dusty_tx["new_utxos"], version=3)
+
+        # Test doesn't work because lack of package feerates
+        test_res = self.nodes[0].testmempoolaccept([dusty_tx["hex"], sweep_tx["hex"]])
+        assert not test_res[0]["allowed"]
+        assert_equal(test_res[0]["reject-reason"], "min relay fee not met")
+
+        # And doesn't work on its own
+        assert_raises_rpc_error(-26, "min relay fee not met", self.nodes[0].sendrawtransaction, dusty_tx["hex"])
+
+        # If we add modified fees, it is still not allowed due to dust check
+        self.nodes[0].prioritisetransaction(txid=dusty_tx["txid"], dummy=0, fee_delta=COIN)
+        test_res = self.nodes[0].testmempoolaccept([dusty_tx["hex"]])
+        assert not test_res[0]["allowed"]
+        assert_equal(test_res[0]["reject-reason"], "dust")
+        # Reset priority
+        self.nodes[0].prioritisetransaction(txid=dusty_tx["txid"], dummy=0, fee_delta=-COIN)
+        assert_equal(self.nodes[0].getprioritisedtransactions(), {})
+
+        # Package evaluation succeeds
+        res = self.nodes[0].submitpackage([dusty_tx["hex"], sweep_tx["hex"]])
+        assert_equal(res["package_msg"], "success")
+        assert_mempool_contents(self, self.nodes[0], expected=[dusty_tx["tx"], sweep_tx["tx"]])
+
+        # Entry is denied when non-0-fee, either base or unmodified.
+        # If in-mempool, we're not allowed to prioritise due to detected dust output
+        assert_raises_rpc_error(-8, "Priority is not supported for transactions with dust outputs.", self.nodes[0].prioritisetransaction, dusty_tx["txid"], 0, 1)
+        assert_equal(self.nodes[0].getprioritisedtransactions(), {})
+
+        self.generate(self.nodes[0], 1)
+        assert_equal(self.nodes[0].getrawmempool(), [])
+
+    def test_node_restart(self):
+        self.log.info("Test that an ephemeral package is rejected on restart due to individual evaluation")
+
+        assert_equal(self.nodes[0].getrawmempool(), [])
+
+        dusty_tx = self.wallet.create_self_transfer_multi(fee_per_output=0, version=3)
+        self.add_output_to_create_multi_result(dusty_tx)
+
+        sweep_tx = self.wallet.create_self_transfer_multi(utxos_to_spend=dusty_tx["new_utxos"], version=3)
+
+        res = self.nodes[0].submitpackage([dusty_tx["hex"], sweep_tx["hex"]])
+        assert_equal(res["package_msg"], "success")
+        assert_equal(len(self.nodes[0].getrawmempool()), 2)
+        assert_mempool_contents(self, self.nodes[0], expected=[dusty_tx["tx"], sweep_tx["tx"]])
+
+        # Node restart; doesn't allow allow ephemeral transaction back in due to individual submission
+        # resulting in 0-fee. Supporting re-submission of CPFP packages on restart is desired but not
+        # yet implemented.
+        self.restart_node(0)
+        self.restart_node(1)
+        self.connect_nodes(0, 1)
+        assert_mempool_contents(self, self.nodes[0], expected=[])
+
+    def test_fee_having_parent(self):
+        self.log.info("Test that a transaction with ephemeral dust may not have non-0 base fee")
+
+        assert_equal(self.nodes[0].getrawmempool(), [])
+
+        sats_fee = 1
+        dusty_tx = self.wallet.create_self_transfer_multi(fee_per_output=sats_fee, version=3)
+        self.add_output_to_create_multi_result(dusty_tx)
+        assert_equal(int(COIN * dusty_tx["fee"]), sats_fee) # has fees
+        assert_greater_than(dusty_tx["tx"].vout[0].nValue, 330) # main output is not dust
+        assert_equal(dusty_tx["tx"].vout[1].nValue, 0) # added one is dust
+
+        sweep_tx = self.wallet.create_self_transfer_multi(utxos_to_spend=dusty_tx["new_utxos"], version=3)
+
+        # When base fee is non-0, we report dust like usual
+        res = self.nodes[0].submitpackage([dusty_tx["hex"], sweep_tx["hex"]])
+        assert_equal(res["package_msg"], "transaction failed")
+        assert_equal(res["tx-results"][dusty_tx["wtxid"]]["error"], "dust, tx with dust output must be 0-fee")
+
+        # Priority is ignored: rejected even if modified fee is 0
+        self.nodes[0].prioritisetransaction(txid=dusty_tx["txid"], dummy=0, fee_delta=-sats_fee)
+        self.nodes[1].prioritisetransaction(txid=dusty_tx["txid"], dummy=0, fee_delta=-sats_fee)
+        res = self.nodes[0].submitpackage([dusty_tx["hex"], sweep_tx["hex"]])
+        assert_equal(res["package_msg"], "transaction failed")
+        assert_equal(res["tx-results"][dusty_tx["wtxid"]]["error"], "dust, tx with dust output must be 0-fee")
+
+        # Will not be accepted if base fee is 0 with modified fee of non-0
+        dusty_tx = self.wallet.create_self_transfer_multi(fee_per_output=0, version=3)
+        self.add_output_to_create_multi_result(dusty_tx)
+
+        sweep_tx = self.wallet.create_self_transfer_multi(utxos_to_spend=dusty_tx["new_utxos"], version=3)
+
+        self.nodes[0].prioritisetransaction(txid=dusty_tx["txid"], dummy=0, fee_delta=1000)
+        self.nodes[1].prioritisetransaction(txid=dusty_tx["txid"], dummy=0, fee_delta=1000)
+
+        # It's rejected submitted alone
+        test_res = self.nodes[0].testmempoolaccept([dusty_tx["hex"]])
+        assert not test_res[0]["allowed"]
+        assert_equal(test_res[0]["reject-reason"], "dust")
+
+        # Or as a package
+        res = self.nodes[0].submitpackage([dusty_tx["hex"], sweep_tx["hex"]])
+        assert_equal(res["package_msg"], "transaction failed")
+        assert_equal(res["tx-results"][dusty_tx["wtxid"]]["error"], "dust, tx with dust output must be 0-fee")
+
+        assert_mempool_contents(self, self.nodes[0], expected=[])
+
+    def test_multidust(self):
+        self.log.info("Test that a transaction with multiple ephemeral dusts is not allowed")
+
+        assert_mempool_contents(self, self.nodes[0], expected=[])
+
+        dusty_tx = self.wallet.create_self_transfer_multi(fee_per_output=0, version=3)
+        self.add_output_to_create_multi_result(dusty_tx)
+        self.add_output_to_create_multi_result(dusty_tx)
+
+        sweep_tx = self.wallet.create_self_transfer_multi(utxos_to_spend=dusty_tx["new_utxos"], version=3)
+
+        res = self.nodes[0].submitpackage([dusty_tx["hex"], sweep_tx["hex"]])
+        assert_equal(res["package_msg"], "transaction failed")
+        assert_equal(res["tx-results"][dusty_tx["wtxid"]]["error"], "dust")
+        assert_equal(self.nodes[0].getrawmempool(), [])
+
+    def test_nonzero_dust(self):
+        self.log.info("Test that a single output of any satoshi amount is allowed, not checking spending")
+
+        # We aren't checking spending, allow it in with no fee
+        self.restart_node(0, extra_args=["-minrelaytxfee=0"])
+        self.restart_node(1, extra_args=["-minrelaytxfee=0"])
+        self.connect_nodes(0, 1)
+
+        # 330 is dust threshold for taproot outputs
+        for value in [1, 329, 330]:
+            assert_equal(self.nodes[0].getrawmempool(), [])
+
+            dusty_tx = self.wallet.create_self_transfer_multi(fee_per_output=0, version=3)
+            self.add_output_to_create_multi_result(dusty_tx, value)
+
+            test_res = self.nodes[0].testmempoolaccept([dusty_tx["hex"]])
+            assert test_res[0]["allowed"]
+
+        self.restart_node(0, extra_args=[])
+        self.restart_node(1, extra_args=[])
+        self.connect_nodes(0, 1)
+        assert_mempool_contents(self, self.nodes[0], expected=[])
+
+    # N.B. If individual minrelay requirement is dropped, this test can be dropped
+    def test_non_truc(self):
+        self.log.info("Test that v2 dust-having transaction is rejected even if spent, because of min relay requirement")
+
+        assert_equal(self.nodes[0].getrawmempool(), [])
+
+        dusty_tx = self.wallet.create_self_transfer_multi(fee_per_output=0, version=2)
+        self.add_output_to_create_multi_result(dusty_tx)
+
+        sweep_tx = self.wallet.create_self_transfer_multi(utxos_to_spend=dusty_tx["new_utxos"], version=2)
+
+        res = self.nodes[0].submitpackage([dusty_tx["hex"], sweep_tx["hex"]])
+        assert_equal(res["package_msg"], "transaction failed")
+        assert_equal(res["tx-results"][dusty_tx["wtxid"]]["error"], "min relay fee not met, 0 < 147")
+
+        assert_equal(self.nodes[0].getrawmempool(), [])
+
+    def test_unspent_ephemeral(self):
+        self.log.info("Test that spending from a tx with ephemeral outputs is only allowed if dust is spent as well")
+
+        assert_equal(self.nodes[0].getrawmempool(), [])
+
+        dusty_tx = self.wallet.create_self_transfer_multi(fee_per_output=0, version=3)
+        self.add_output_to_create_multi_result(dusty_tx, 329)
+
+        # Valid sweep we will RBF incorrectly by not spending dust as well
+        sweep_tx = self.wallet.create_self_transfer_multi(utxos_to_spend=dusty_tx["new_utxos"], version=3)
+        self.nodes[0].submitpackage([dusty_tx["hex"], sweep_tx["hex"]])
+        assert_mempool_contents(self, self.nodes[0], expected=[dusty_tx["tx"], sweep_tx["tx"]])
+
+        # Doesn't spend in-mempool dust output from parent
+        unspent_sweep_tx = self.wallet.create_self_transfer_multi(fee_per_output=2000, utxos_to_spend=[dusty_tx["new_utxos"][0]], version=3)
+        assert_greater_than(unspent_sweep_tx["fee"], sweep_tx["fee"])
+        res = self.nodes[0].submitpackage([dusty_tx["hex"], unspent_sweep_tx["hex"]])
+        assert_equal(res["tx-results"][unspent_sweep_tx["wtxid"]]["error"], f"missing-ephemeral-spends, tx {unspent_sweep_tx['txid']} did not spend parent's ephemeral dust")
+        assert_raises_rpc_error(-26, f"missing-ephemeral-spends, tx {unspent_sweep_tx['txid']} did not spend parent's ephemeral dust", self.nodes[0].sendrawtransaction, unspent_sweep_tx["hex"])
+        assert_mempool_contents(self, self.nodes[0], expected=[dusty_tx["tx"], sweep_tx["tx"]])
+
+        # Spend works with dust spent
+        sweep_tx_2 = self.wallet.create_self_transfer_multi(fee_per_output=2000, utxos_to_spend=dusty_tx["new_utxos"], version=3)
+        assert sweep_tx["hex"] != sweep_tx_2["hex"]
+        res = self.nodes[0].submitpackage([dusty_tx["hex"], sweep_tx_2["hex"]])
+        assert_equal(res["package_msg"], "success")
+
+        # Re-set and test again with nothing from package in mempool this time
+        self.generate(self.nodes[0], 1)
+        assert_equal(self.nodes[0].getrawmempool(), [])
+
+        dusty_tx = self.wallet.create_self_transfer_multi(fee_per_output=0, version=3)
+        self.add_output_to_create_multi_result(dusty_tx, 329)
+
+        # Spend non-dust only
+        unspent_sweep_tx = self.wallet.create_self_transfer_multi(utxos_to_spend=[dusty_tx["new_utxos"][0]], version=3)
+
+        res = self.nodes[0].submitpackage([dusty_tx["hex"], unspent_sweep_tx["hex"]])
+        assert_equal(res["package_msg"], "unspent-dust")
+
+        assert_equal(self.nodes[0].getrawmempool(), [])
+
+        # Now spend dust only which should work
+        second_coin = self.wallet.get_utxo() # another fee-bringing coin
+        sweep_tx = self.wallet.create_self_transfer_multi(utxos_to_spend=[dusty_tx["new_utxos"][1], second_coin], version=3)
+
+        res = self.nodes[0].submitpackage([dusty_tx["hex"], sweep_tx["hex"]])
+        assert_equal(res["package_msg"], "success")
+        assert_mempool_contents(self, self.nodes[0], expected=[dusty_tx["tx"], sweep_tx["tx"]])
+
+        self.generate(self.nodes[0], 1)
+        assert_mempool_contents(self, self.nodes[0], expected=[])
+
+    def test_sponsor_cycle(self):
+        self.log.info("Test that dust txn is not evicted when it becomes childless, but won't be mined")
+
+        assert_equal(self.nodes[0].getrawmempool(), [])
+
+        dusty_tx = self.wallet.create_self_transfer_multi(
+            fee_per_output=0,
+            version=3
+        )
+
+        self.add_output_to_create_multi_result(dusty_tx)
+
+        sponsor_coin = self.wallet.get_utxo()
+
+        # Bring "fee" input that can be double-spend separately
+        sweep_tx = self.wallet.create_self_transfer_multi(utxos_to_spend=dusty_tx["new_utxos"] + [sponsor_coin], version=3)
+
+        res = self.nodes[0].submitpackage([dusty_tx["hex"], sweep_tx["hex"]])
+        assert_equal(res["package_msg"], "success")
+        assert_equal(len(self.nodes[0].getrawmempool()), 2)
+        # sync to make sure unsponsor_tx hits second node's mempool after initial package
+        assert_mempool_contents(self, self.nodes[0], expected=[dusty_tx["tx"], sweep_tx["tx"]])
+
+        # Now we RBF away the child using the sponsor input only
+        unsponsor_tx = self.wallet.create_self_transfer_multi(
+            utxos_to_spend=[sponsor_coin],
+            num_outputs=1,
+            fee_per_output=2000,
+            version=3
+        )
+        self.nodes[0].sendrawtransaction(unsponsor_tx["hex"])
+
+        # Parent is now childless and fee-free, so will not be mined
+        entry_info = self.nodes[0].getmempoolentry(dusty_tx["txid"])
+        assert_equal(entry_info["descendantcount"], 1)
+        assert_equal(entry_info["fees"]["descendant"], Decimal(0))
+
+        assert_mempool_contents(self, self.nodes[0], expected=[dusty_tx["tx"], unsponsor_tx["tx"]])
+
+        # Dust tx is not mined
+        self.generate(self.nodes[0], 1)
+        assert_mempool_contents(self, self.nodes[0], expected=[dusty_tx["tx"]])
+
+        # Create sweep that doesn't spend conflicting sponsor coin
+        sweep_tx = self.wallet.create_self_transfer_multi(utxos_to_spend=dusty_tx["new_utxos"], version=3)
+
+        # Can resweep
+        self.nodes[0].sendrawtransaction(sweep_tx["hex"])
+        assert_mempool_contents(self, self.nodes[0], expected=[dusty_tx["tx"], sweep_tx["tx"]])
+
+        self.generate(self.nodes[0], 1)
+        assert_mempool_contents(self, self.nodes[0], expected=[])
+
+    def test_reorgs(self):
+        self.log.info("Test that reorgs breaking the truc topology doesn't cause issues")
+
+        assert_equal(self.nodes[0].getrawmempool(), [])
+
+        # Many shallow re-orgs confuse block gossiping making test less reliable otherwise
+        self.disconnect_nodes(0, 1)
+
+        # Get dusty tx mined, then check that it makes it back into mempool on reorg
+        # due to bypass_limits allowing 0-fee individually
+        dusty_tx = self.wallet.create_self_transfer_multi(fee_per_output=0, version=3)
+        self.add_output_to_create_multi_result(dusty_tx)
+        assert_raises_rpc_error(-26, "min relay fee not met", self.nodes[0].sendrawtransaction, dusty_tx["hex"])
+
+        block_res = self.nodes[0].rpc.generateblock(self.wallet.get_address(), [dusty_tx["hex"]])
+        self.nodes[0].invalidateblock(block_res["hash"])
+        assert_mempool_contents(self, self.nodes[0], expected=[dusty_tx["tx"]], sync=False)
+
+        # Create a sweep that has dust of its own and leaves dusty_tx's dust unspent
+        sweep_tx = self.wallet.create_self_transfer_multi(fee_per_output=0, utxos_to_spend=[dusty_tx["new_utxos"][0]], version=3)
+        self.add_output_to_create_multi_result(sweep_tx)
+        assert_raises_rpc_error(-26, "min relay fee not met", self.nodes[0].sendrawtransaction, sweep_tx["hex"])
+
+        # Mine the sweep then re-org, the sweep will not make it back in due to spend checks
+        block_res = self.nodes[0].rpc.generateblock(self.wallet.get_address(), [dusty_tx["hex"], sweep_tx["hex"]])
+        self.nodes[0].invalidateblock(block_res["hash"])
+        assert_mempool_contents(self, self.nodes[0], expected=[dusty_tx["tx"]], sync=False)
+
+        # Also should happen if dust is swept
+        sweep_tx_2 = self.wallet.create_self_transfer_multi(fee_per_output=0, utxos_to_spend=dusty_tx["new_utxos"], version=3)
+        self.add_output_to_create_multi_result(sweep_tx_2)
+        assert_raises_rpc_error(-26, "min relay fee not met", self.nodes[0].sendrawtransaction, sweep_tx_2["hex"])
+
+        reconsider_block_res = self.nodes[0].rpc.generateblock(self.wallet.get_address(), [dusty_tx["hex"], sweep_tx_2["hex"]])
+        self.nodes[0].invalidateblock(reconsider_block_res["hash"])
+        assert_mempool_contents(self, self.nodes[0], expected=[dusty_tx["tx"], sweep_tx_2["tx"]], sync=False)
+
+        # TRUC transactions restriction for ephemeral dust disallows further spends of ancestor chains
+        child_tx = self.wallet.create_self_transfer_multi(utxos_to_spend=sweep_tx_2["new_utxos"], version=3)
+        assert_raises_rpc_error(-26, "TRUC-violation", self.nodes[0].sendrawtransaction, child_tx["hex"])
+
+        self.nodes[0].reconsiderblock(reconsider_block_res["hash"])
+        assert_equal(self.nodes[0].getrawmempool(), [])
+
+        self.log.info("Test that ephemeral dust tx with fees or multi dust don't enter mempool via reorg")
+        multi_dusty_tx = self.wallet.create_self_transfer_multi(fee_per_output=0, version=3)
+        self.add_output_to_create_multi_result(multi_dusty_tx)
+        self.add_output_to_create_multi_result(multi_dusty_tx)
+
+        block_res = self.nodes[0].rpc.generateblock(self.wallet.get_address(), [multi_dusty_tx["hex"]])
+        self.nodes[0].invalidateblock(block_res["hash"])
+        assert_equal(self.nodes[0].getrawmempool(), [])
+
+        # With fee and one dust
+        dusty_fee_tx = self.wallet.create_self_transfer_multi(fee_per_output=1, version=3)
+        self.add_output_to_create_multi_result(dusty_fee_tx)
+
+        block_res = self.nodes[0].rpc.generateblock(self.wallet.get_address(), [dusty_fee_tx["hex"]])
+        self.nodes[0].invalidateblock(block_res["hash"])
+        assert_equal(self.nodes[0].getrawmempool(), [])
+
+        # Re-connect and make sure we have same state still
+        self.connect_nodes(0, 1)
+        self.sync_all()
+
+    # N.B. this extra_args can be removed post cluster mempool
+    def test_free_relay(self):
+        self.log.info("Test that ephemeral dust works in non-TRUC contexts when there's no minrelay requirement")
+
+        # Note: since minrelay is 0, it is not testing 1P1C relay
+        self.restart_node(0, extra_args=["-minrelaytxfee=0"])
+        self.restart_node(1, extra_args=["-minrelaytxfee=0"])
+        self.connect_nodes(0, 1)
+
+        assert_equal(self.nodes[0].getrawmempool(), [])
+
+        dusty_tx = self.wallet.create_self_transfer_multi(fee_per_output=0, version=2)
+        self.add_output_to_create_multi_result(dusty_tx)
+
+        sweep_tx = self.wallet.create_self_transfer_multi(utxos_to_spend=dusty_tx["new_utxos"], version=2)
+
+        self.nodes[0].submitpackage([dusty_tx["hex"], sweep_tx["hex"]])
+
+        assert_mempool_contents(self, self.nodes[0], expected=[dusty_tx["tx"], sweep_tx["tx"]])
+
+        # generate coins for next tests
+        self.generate(self.nodes[0], 1)
+        self.wallet.rescan_utxos()
+        assert_equal(self.nodes[0].getrawmempool(), [])
+
+        self.log.info("Test batched ephemeral dust sweep")
+        dusty_txs = []
+        for _ in range(24):
+            dusty_txs.append(self.wallet.create_self_transfer_multi(fee_per_output=0, version=2))
+            self.add_output_to_create_multi_result(dusty_txs[-1])
+
+        all_parent_utxos = [utxo for tx in dusty_txs for utxo in tx["new_utxos"]]
+
+        # Missing one dust spend from a single parent, child rejected
+        insufficient_sweep_tx = self.wallet.create_self_transfer_multi(fee_per_output=25000, utxos_to_spend=all_parent_utxos[:-1], version=2)
+
+        res = self.nodes[0].submitpackage([dusty_tx["hex"] for dusty_tx in dusty_txs] + [insufficient_sweep_tx["hex"]])
+        assert_equal(res['package_msg'], "transaction failed")
+        assert_equal(res['tx-results'][insufficient_sweep_tx['wtxid']]['error'], f"missing-ephemeral-spends, tx {insufficient_sweep_tx['txid']} did not spend parent's ephemeral dust")
+        # Everything got in except for insufficient spend
+        assert_mempool_contents(self, self.nodes[0], expected=[dusty_tx["tx"] for dusty_tx in dusty_txs])
+
+        # Next put some parents in mempool, but not others, and test unspent dust again with all parents spent
+        B_coin = self.wallet.get_utxo() # coin to cycle out CPFP
+        sweep_all_but_one_tx = self.wallet.create_self_transfer_multi(fee_per_output=20000, utxos_to_spend=all_parent_utxos[:-2] + [B_coin], version=2)
+        res = self.nodes[0].submitpackage([dusty_tx["hex"] for dusty_tx in dusty_txs[:-1]] + [sweep_all_but_one_tx["hex"]])
+        assert_equal(res['package_msg'], "success")
+        assert_mempool_contents(self, self.nodes[0], expected=[dusty_tx["tx"] for dusty_tx in dusty_txs] + [sweep_all_but_one_tx["tx"]])
+
+        res = self.nodes[0].submitpackage([dusty_tx["hex"] for dusty_tx in dusty_txs] + [insufficient_sweep_tx["hex"]])
+        assert_equal(res['package_msg'], "transaction failed")
+        assert_equal(res['tx-results'][insufficient_sweep_tx["wtxid"]]["error"], f"missing-ephemeral-spends, tx {insufficient_sweep_tx['txid']} did not spend parent's ephemeral dust")
+        assert_mempool_contents(self, self.nodes[0], expected=[dusty_tx["tx"] for dusty_tx in dusty_txs] + [sweep_all_but_one_tx["tx"]])
+
+        # Cycle out the partial sweep to avoid triggering package RBF behavior which limits package to no in-mempool ancestors
+        cancel_sweep = self.wallet.create_self_transfer_multi(fee_per_output=21000, utxos_to_spend=[B_coin], version=2)
+        self.nodes[0].sendrawtransaction(cancel_sweep["hex"])
+        assert_mempool_contents(self, self.nodes[0], expected=[dusty_tx["tx"] for dusty_tx in dusty_txs] + [cancel_sweep["tx"]])
+
+        # Sweeps all dust, where all dusty txs are already in-mempool
+        sweep_tx = self.wallet.create_self_transfer_multi(fee_per_output=25000, utxos_to_spend=all_parent_utxos, version=2)
+
+        res = self.nodes[0].submitpackage([dusty_tx["hex"] for dusty_tx in dusty_txs] + [sweep_tx["hex"]])
+        assert_equal(res['package_msg'], "success")
+        assert_mempool_contents(self, self.nodes[0], expected=[dusty_tx["tx"] for dusty_tx in dusty_txs] + [sweep_tx["tx"], cancel_sweep["tx"]])
+
+        self.generate(self.nodes[0], 25)
+        self.wallet.rescan_utxos()
+        assert_equal(self.nodes[0].getrawmempool(), [])
+
+        # Other topology tests require relaxation of submitpackage topology
+
+        self.restart_node(0, extra_args=[])
+        self.restart_node(1, extra_args=[])
+        self.connect_nodes(0, 1)
+
+        assert_equal(self.nodes[0].getrawmempool(), [])
+
+if __name__ == "__main__":
+    EphemeralDustTest(__file__).main()
diff --git a/test/functional/test_framework/mempool_util.py b/test/functional/test_framework/mempool_util.py
index 94d58b9e7df..e04ae914ccf 100644
--- a/test/functional/test_framework/mempool_util.py
+++ b/test/functional/test_framework/mempool_util.py
@@ -21,6 +21,20 @@ from .wallet import (
 
 ORPHAN_TX_EXPIRE_TIME = 1200
 
+def assert_mempool_contents(test_framework, node, expected=None, sync=True):
+    """Assert that all transactions in expected are in the mempool,
+    and no additional ones exist. 'expected' is an array of
+    CTransaction objects
+    """
+    if sync:
+        test_framework.sync_mempools()
+    if not expected:
+        expected = []
+    mempool = node.getrawmempool(verbose=False)
+    assert_equal(len(mempool), len(expected))
+    for tx in expected:
+        assert tx.rehash() in mempool
+
 
 def fill_mempool(test_framework, node, *, tx_sync_fun=None):
     """Fill mempool until eviction.
diff --git a/test/functional/test_runner.py b/test/functional/test_runner.py
index dc9053491cc..701d81b9d25 100755
--- a/test/functional/test_runner.py
+++ b/test/functional/test_runner.py
@@ -400,6 +400,7 @@ BASE_SCRIPTS = [
     'rpc_getdescriptorinfo.py',
     'rpc_mempool_info.py',
     'rpc_help.py',
+    'mempool_ephemeral_dust.py',
     'p2p_handshake.py',
     'p2p_handshake.py --v2transport',
     'feature_dirsymlinks.py',