From 51430680ecb722e1d4ee4a26dac5724050f41c9e Mon Sep 17 00:00:00 2001
From: Suhas Daftuar <sdaftuar@chaincode.com>
Date: Thu, 9 Jan 2025 10:28:57 -0500
Subject: [PATCH 01/65] Allow moving an Epoch::Marker

---
 src/util/epochguard.h | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/util/epochguard.h b/src/util/epochguard.h
index 145f4dc132b..25ae3ac798f 100644
--- a/src/util/epochguard.h
+++ b/src/util/epochguard.h
@@ -59,8 +59,8 @@ public:
     public:
         Marker() = default;
         Marker(const Marker&) = default;
-        Marker(Marker&&) = delete;
-        Marker& operator=(Marker&&) = delete;
+        Marker(Marker&&) = default;
+        Marker& operator=(Marker&&) = default;
         ~Marker() = default;
     };
 

From 6c73e4744837a7dc138a9177df3a48f30a1ba6c1 Mon Sep 17 00:00:00 2001
From: Suhas Daftuar <sdaftuar@chaincode.com>
Date: Wed, 5 Feb 2025 18:39:07 -0500
Subject: [PATCH 02/65] mempool: Store iterators into mapTx in mapNextTx

This takes the same amount of space as CTransaction pointers, and saves a map
lookup in many common uses.
---
 src/txmempool.cpp | 25 +++++++++++--------------
 src/txmempool.h   |  2 +-
 2 files changed, 12 insertions(+), 15 deletions(-)

diff --git a/src/txmempool.cpp b/src/txmempool.cpp
index cae16a675bd..a695fbffb86 100644
--- a/src/txmempool.cpp
+++ b/src/txmempool.cpp
@@ -137,12 +137,11 @@ void CTxMemPool::UpdateTransactionsFromBlock(const std::vector<Txid>& vHashesToU
         {
             WITH_FRESH_EPOCH(m_epoch);
             for (; iter != mapNextTx.end() && iter->first->hash == hash; ++iter) {
-                const Txid &childHash = iter->second->GetHash();
-                txiter childIter = mapTx.find(childHash);
+                txiter childIter = iter->second;
                 assert(childIter != mapTx.end());
                 // We can skip updating entries we've encountered before or that
                 // are in the block (which are already accounted for).
-                if (!visited(childIter) && !setAlreadyIncluded.count(childHash)) {
+                if (!visited(childIter) && !setAlreadyIncluded.count(iter->second->GetTx().GetHash())) {
                     UpdateChild(it, childIter, true);
                     UpdateParent(childIter, it, true);
                 }
@@ -486,7 +485,7 @@ void CTxMemPool::addNewTransaction(CTxMemPool::txiter newit, CTxMemPool::setEntr
     const CTransaction& tx = newit->GetTx();
     std::set<Txid> setParentTransactions;
     for (unsigned int i = 0; i < tx.vin.size(); i++) {
-        mapNextTx.insert(std::make_pair(&tx.vin[i].prevout, &tx));
+        mapNextTx.insert(std::make_pair(&tx.vin[i].prevout, newit));
         setParentTransactions.insert(tx.vin[i].prevout.hash);
     }
     // Don't bother worrying about child transactions of this one.
@@ -611,7 +610,7 @@ void CTxMemPool::removeRecursive(const CTransaction &origTx, MemPoolRemovalReaso
                 auto it = mapNextTx.find(COutPoint(origTx.GetHash(), i));
                 if (it == mapNextTx.end())
                     continue;
-                txiter nextit = mapTx.find(it->second->GetHash());
+                txiter nextit = it->second;
                 assert(nextit != mapTx.end());
                 txToRemove.insert(nextit);
             }
@@ -652,7 +651,7 @@ void CTxMemPool::removeConflicts(const CTransaction &tx)
     for (const CTxIn &txin : tx.vin) {
         auto it = mapNextTx.find(txin.prevout);
         if (it != mapNextTx.end()) {
-            const CTransaction &txConflict = *it->second;
+            const CTransaction &txConflict = it->second->GetTx();
             if (Assume(txConflict.GetHash() != tx.GetHash()))
             {
                 ClearPrioritisation(txConflict.GetHash());
@@ -729,7 +728,7 @@ void CTxMemPool::check(const CCoinsViewCache& active_coins_tip, int64_t spendhei
             auto it3 = mapNextTx.find(txin.prevout);
             assert(it3 != mapNextTx.end());
             assert(it3->first == &txin.prevout);
-            assert(it3->second == &tx);
+            assert(&it3->second->GetTx() == &tx);
         }
         auto comp = [](const CTxMemPoolEntry& a, const CTxMemPoolEntry& b) -> bool {
             return a.GetTx().GetHash() == b.GetTx().GetHash();
@@ -762,7 +761,7 @@ void CTxMemPool::check(const CCoinsViewCache& active_coins_tip, int64_t spendhei
         auto iter = mapNextTx.lower_bound(COutPoint(it->GetTx().GetHash(), 0));
         int32_t child_sizes{0};
         for (; iter != mapNextTx.end() && iter->first->hash == it->GetTx().GetHash(); ++iter) {
-            txiter childit = mapTx.find(iter->second->GetHash());
+            txiter childit = iter->second;
             assert(childit != mapTx.end()); // mapNextTx points to in-mempool transactions
             if (setChildrenCheck.insert(*childit).second) {
                 child_sizes += childit->GetTxSize();
@@ -781,11 +780,9 @@ void CTxMemPool::check(const CCoinsViewCache& active_coins_tip, int64_t spendhei
         for (const auto& input: tx.vin) mempoolDuplicate.SpendCoin(input.prevout);
         AddCoins(mempoolDuplicate, tx, std::numeric_limits<int>::max());
     }
-    for (const auto& [_, next_tx] : mapNextTx) {
-        auto it = mapTx.find(next_tx->GetHash());
-        const CTransaction& tx = it->GetTx();
-        assert(it != mapTx.end());
-        assert(&tx == next_tx);
+    for (auto it = mapNextTx.cbegin(); it != mapNextTx.cend(); it++) {
+        indexed_transaction_set::const_iterator it2 = it->second;
+        assert(it2 != mapTx.end());
     }
 
     assert(totalTxSize == checkTotal);
@@ -956,7 +953,7 @@ std::vector<CTxMemPool::delta_info> CTxMemPool::GetPrioritisedTransactions() con
 const CTransaction* CTxMemPool::GetConflictTx(const COutPoint& prevout) const
 {
     const auto it = mapNextTx.find(prevout);
-    return it == mapNextTx.end() ? nullptr : it->second;
+    return it == mapNextTx.end() ? nullptr : &(it->second->GetTx());
 }
 
 std::optional<CTxMemPool::txiter> CTxMemPool::GetIter(const Txid& txid) const
diff --git a/src/txmempool.h b/src/txmempool.h
index a36754810f7..90da90da7db 100644
--- a/src/txmempool.h
+++ b/src/txmempool.h
@@ -413,7 +413,7 @@ private:
     }
 
 public:
-    indirectmap<COutPoint, const CTransaction*> mapNextTx GUARDED_BY(cs);
+    indirectmap<COutPoint, txiter> mapNextTx GUARDED_BY(cs);
     std::map<Txid, CAmount> mapDeltas GUARDED_BY(cs);
 
     using Options = kernel::MemPoolOptions;

From 92b0079fe3863b20b71282aa82341d4b6ee4b337 Mon Sep 17 00:00:00 2001
From: Suhas Daftuar <sdaftuar@chaincode.com>
Date: Thu, 9 Jan 2025 10:30:12 -0500
Subject: [PATCH 03/65] Allow moving CTxMemPoolEntry objects, disallow copying

---
 src/kernel/mempool_entry.h         | 10 ++--------
 src/test/fuzz/policy_estimator.cpp |  2 +-
 2 files changed, 3 insertions(+), 9 deletions(-)

diff --git a/src/kernel/mempool_entry.h b/src/kernel/mempool_entry.h
index 51a1f26642f..40aa77b5769 100644
--- a/src/kernel/mempool_entry.h
+++ b/src/kernel/mempool_entry.h
@@ -71,10 +71,7 @@ public:
     typedef std::set<CTxMemPoolEntryRef, CompareIteratorByHash> Children;
 
 private:
-    CTxMemPoolEntry(const CTxMemPoolEntry&) = default;
-    struct ExplicitCopyTag {
-        explicit ExplicitCopyTag() = default;
-    };
+    CTxMemPoolEntry(const CTxMemPoolEntry&) = delete;
 
     const CTransactionRef tx;
     mutable Parents m_parents;
@@ -127,13 +124,10 @@ public:
           nModFeesWithAncestors{nFee},
           nSigOpCostWithAncestors{sigOpCost} {}
 
-    CTxMemPoolEntry(ExplicitCopyTag, const CTxMemPoolEntry& entry) : CTxMemPoolEntry(entry) {}
     CTxMemPoolEntry& operator=(const CTxMemPoolEntry&) = delete;
-    CTxMemPoolEntry(CTxMemPoolEntry&&) = delete;
+    CTxMemPoolEntry(CTxMemPoolEntry&&) = default;
     CTxMemPoolEntry& operator=(CTxMemPoolEntry&&) = delete;
 
-    static constexpr ExplicitCopyTag ExplicitCopy{};
-
     const CTransaction& GetTx() const { return *this->tx; }
     CTransactionRef GetSharedTx() const { return this->tx; }
     const CAmount& GetFee() const { return nFee; }
diff --git a/src/test/fuzz/policy_estimator.cpp b/src/test/fuzz/policy_estimator.cpp
index 8455a23284d..cfd50cf80d9 100644
--- a/src/test/fuzz/policy_estimator.cpp
+++ b/src/test/fuzz/policy_estimator.cpp
@@ -74,7 +74,7 @@ FUZZ_TARGET(policy_estimator, .init = initialize_policy_estimator)
                         break;
                     }
                     const CTransaction tx{*mtx};
-                    mempool_entries.emplace_back(CTxMemPoolEntry::ExplicitCopy, ConsumeTxMemPoolEntry(fuzzed_data_provider, tx, current_height));
+                    mempool_entries.push_back(ConsumeTxMemPoolEntry(fuzzed_data_provider, tx, current_height));
                 }
                 std::vector<RemovedMempoolTransactionInfo> txs;
                 txs.reserve(mempool_entries.size());

From 29a94d5b2f26a4a8b7464894e4db944ea67241b7 Mon Sep 17 00:00:00 2001
From: Suhas Daftuar <sdaftuar@chaincode.com>
Date: Thu, 9 Jan 2025 10:36:34 -0500
Subject: [PATCH 04/65] Make CTxMemPoolEntry derive from TxGraph::Ref

---
 src/bench/blockencodings.cpp           | 2 +-
 src/bench/mempool_ephemeral_spends.cpp | 2 +-
 src/bench/mempool_eviction.cpp         | 2 +-
 src/bench/mempool_stress.cpp           | 2 +-
 src/bench/rpc_mempool.cpp              | 2 +-
 src/kernel/CMakeLists.txt              | 1 +
 src/kernel/mempool_entry.h             | 9 ++++++---
 src/node/interfaces.cpp                | 2 +-
 src/test/fuzz/util/mempool.cpp         | 2 +-
 src/test/util/txmempool.cpp            | 2 +-
 src/txmempool.cpp                      | 2 +-
 11 files changed, 16 insertions(+), 12 deletions(-)

diff --git a/src/bench/blockencodings.cpp b/src/bench/blockencodings.cpp
index 8f6659919c6..c92ade60d2d 100644
--- a/src/bench/blockencodings.cpp
+++ b/src/bench/blockencodings.cpp
@@ -22,7 +22,7 @@
 static void AddTx(const CTransactionRef& tx, const CAmount& fee, CTxMemPool& pool) EXCLUSIVE_LOCKS_REQUIRED(cs_main, pool.cs)
 {
     LockPoints lp;
-    AddToMempool(pool, CTxMemPoolEntry(tx, fee, /*time=*/0, /*entry_height=*/1, /*entry_sequence=*/0, /*spends_coinbase=*/false, /*sigops_cost=*/4, lp));
+    AddToMempool(pool, CTxMemPoolEntry(TxGraph::Ref(), tx, fee, /*time=*/0, /*entry_height=*/1, /*entry_sequence=*/0, /*spends_coinbase=*/false, /*sigops_cost=*/4, lp));
 }
 
 namespace {
diff --git a/src/bench/mempool_ephemeral_spends.cpp b/src/bench/mempool_ephemeral_spends.cpp
index 8f294113815..ce17650ee4b 100644
--- a/src/bench/mempool_ephemeral_spends.cpp
+++ b/src/bench/mempool_ephemeral_spends.cpp
@@ -29,7 +29,7 @@ static void AddTx(const CTransactionRef& tx, CTxMemPool& pool) EXCLUSIVE_LOCKS_R
     unsigned int sigOpCost{4};
     uint64_t fee{0};
     LockPoints lp;
-    AddToMempool(pool, CTxMemPoolEntry(
+    AddToMempool(pool, CTxMemPoolEntry(TxGraph::Ref(),
         tx, fee, nTime, nHeight, sequence,
         spendsCoinbase, sigOpCost, lp));
 }
diff --git a/src/bench/mempool_eviction.cpp b/src/bench/mempool_eviction.cpp
index aa2e8682e93..72d2356a0b0 100644
--- a/src/bench/mempool_eviction.cpp
+++ b/src/bench/mempool_eviction.cpp
@@ -27,7 +27,7 @@ static void AddTx(const CTransactionRef& tx, const CAmount& nFee, CTxMemPool& po
     bool spendsCoinbase = false;
     unsigned int sigOpCost = 4;
     LockPoints lp;
-    AddToMempool(pool, CTxMemPoolEntry(
+    AddToMempool(pool, CTxMemPoolEntry(TxGraph::Ref(),
         tx, nFee, nTime, nHeight, sequence,
         spendsCoinbase, sigOpCost, lp));
 }
diff --git a/src/bench/mempool_stress.cpp b/src/bench/mempool_stress.cpp
index fbac25db5f5..5095438cd20 100644
--- a/src/bench/mempool_stress.cpp
+++ b/src/bench/mempool_stress.cpp
@@ -29,7 +29,7 @@ static void AddTx(const CTransactionRef& tx, CTxMemPool& pool) EXCLUSIVE_LOCKS_R
     bool spendsCoinbase = false;
     unsigned int sigOpCost = 4;
     LockPoints lp;
-    AddToMempool(pool, CTxMemPoolEntry(tx, 1000, nTime, nHeight, sequence, spendsCoinbase, sigOpCost, lp));
+    AddToMempool(pool, CTxMemPoolEntry(TxGraph::Ref(), tx, 1000, nTime, nHeight, sequence, spendsCoinbase, sigOpCost, lp));
 }
 
 struct Available {
diff --git a/src/bench/rpc_mempool.cpp b/src/bench/rpc_mempool.cpp
index a61c6609bd9..4ad1f0b28a0 100644
--- a/src/bench/rpc_mempool.cpp
+++ b/src/bench/rpc_mempool.cpp
@@ -22,7 +22,7 @@
 static void AddTx(const CTransactionRef& tx, const CAmount& fee, CTxMemPool& pool) EXCLUSIVE_LOCKS_REQUIRED(cs_main, pool.cs)
 {
     LockPoints lp;
-    AddToMempool(pool, CTxMemPoolEntry(tx, fee, /*time=*/0, /*entry_height=*/1, /*entry_sequence=*/0, /*spends_coinbase=*/false, /*sigops_cost=*/4, lp));
+    AddToMempool(pool, CTxMemPoolEntry(TxGraph::Ref(), tx, fee, /*time=*/0, /*entry_height=*/1, /*entry_sequence=*/0, /*spends_coinbase=*/false, /*sigops_cost=*/4, lp));
 }
 
 static void RpcMempool(benchmark::Bench& bench)
diff --git a/src/kernel/CMakeLists.txt b/src/kernel/CMakeLists.txt
index c45ce7819e9..9ab2d67272c 100644
--- a/src/kernel/CMakeLists.txt
+++ b/src/kernel/CMakeLists.txt
@@ -58,6 +58,7 @@ add_library(bitcoinkernel
   ../support/lockedpool.cpp
   ../sync.cpp
   ../txdb.cpp
+  ../txgraph.cpp
   ../txmempool.cpp
   ../uint256.cpp
   ../util/chaintype.cpp
diff --git a/src/kernel/mempool_entry.h b/src/kernel/mempool_entry.h
index 40aa77b5769..cd86f36698b 100644
--- a/src/kernel/mempool_entry.h
+++ b/src/kernel/mempool_entry.h
@@ -11,6 +11,7 @@
 #include <policy/policy.h>
 #include <policy/settings.h>
 #include <primitives/transaction.h>
+#include <txgraph.h>
 #include <util/epochguard.h>
 #include <util/overflow.h>
 
@@ -62,7 +63,7 @@ struct CompareIteratorByHash {
  *
  */
 
-class CTxMemPoolEntry
+class CTxMemPoolEntry : public TxGraph::Ref
 {
 public:
     typedef std::reference_wrapper<const CTxMemPoolEntry> CTxMemPoolEntryRef;
@@ -103,11 +104,13 @@ private:
     int64_t nSigOpCostWithAncestors;
 
 public:
-    CTxMemPoolEntry(const CTransactionRef& tx, CAmount fee,
+    virtual ~CTxMemPoolEntry() = default;
+    CTxMemPoolEntry(TxGraph::Ref&& ref, const CTransactionRef& tx, CAmount fee,
                     int64_t time, unsigned int entry_height, uint64_t entry_sequence,
                     bool spends_coinbase,
                     int64_t sigops_cost, LockPoints lp)
-        : tx{tx},
+        : TxGraph::Ref(std::move(ref)),
+          tx{tx},
           nFee{fee},
           nTxWeight{GetTransactionWeight(*tx)},
           nUsageSize{RecursiveDynamicUsage(tx)},
diff --git a/src/node/interfaces.cpp b/src/node/interfaces.cpp
index fd3fa226cae..0626e2c6837 100644
--- a/src/node/interfaces.cpp
+++ b/src/node/interfaces.cpp
@@ -720,7 +720,7 @@ public:
     {
         if (!m_node.mempool) return {};
         LockPoints lp;
-        CTxMemPoolEntry entry(tx, 0, 0, 0, 0, false, 0, lp);
+        CTxMemPoolEntry entry(TxGraph::Ref(), tx, 0, 0, 0, 0, false, 0, lp);
         LOCK(m_node.mempool->cs);
         return m_node.mempool->CheckPackageLimits({tx}, entry.GetTxSize());
     }
diff --git a/src/test/fuzz/util/mempool.cpp b/src/test/fuzz/util/mempool.cpp
index a6a28f94006..241a4d559c7 100644
--- a/src/test/fuzz/util/mempool.cpp
+++ b/src/test/fuzz/util/mempool.cpp
@@ -27,5 +27,5 @@ CTxMemPoolEntry ConsumeTxMemPoolEntry(FuzzedDataProvider& fuzzed_data_provider,
     const auto entry_height{fuzzed_data_provider.ConsumeIntegralInRange<uint32_t>(0, max_height)};
     const bool spends_coinbase = fuzzed_data_provider.ConsumeBool();
     const unsigned int sig_op_cost = fuzzed_data_provider.ConsumeIntegralInRange<unsigned int>(0, MAX_BLOCK_SIGOPS_COST);
-    return CTxMemPoolEntry{MakeTransactionRef(tx), fee, time, entry_height, entry_sequence, spends_coinbase, sig_op_cost, {}};
+    return CTxMemPoolEntry{TxGraph::Ref(), MakeTransactionRef(tx), fee, time, entry_height, entry_sequence, spends_coinbase, sig_op_cost, {}};
 }
diff --git a/src/test/util/txmempool.cpp b/src/test/util/txmempool.cpp
index 5febb6791c6..0cb15b69420 100644
--- a/src/test/util/txmempool.cpp
+++ b/src/test/util/txmempool.cpp
@@ -37,7 +37,7 @@ CTxMemPoolEntry TestMemPoolEntryHelper::FromTx(const CMutableTransaction& tx) co
 
 CTxMemPoolEntry TestMemPoolEntryHelper::FromTx(const CTransactionRef& tx) const
 {
-    return CTxMemPoolEntry{tx, nFee, TicksSinceEpoch<std::chrono::seconds>(time), nHeight, m_sequence, spendsCoinbase, sigOpCost, lp};
+    return CTxMemPoolEntry{TxGraph::Ref(), tx, nFee, TicksSinceEpoch<std::chrono::seconds>(time), nHeight, m_sequence, spendsCoinbase, sigOpCost, lp};
 }
 
 std::optional<std::string> CheckPackageMempoolAcceptResult(const Package& txns,
diff --git a/src/txmempool.cpp b/src/txmempool.cpp
index a695fbffb86..e6e2042e494 100644
--- a/src/txmempool.cpp
+++ b/src/txmempool.cpp
@@ -1386,7 +1386,7 @@ CTxMemPool::ChangeSet::TxHandle CTxMemPool::ChangeSet::StageAddition(const CTran
 {
     LOCK(m_pool->cs);
     Assume(m_to_add.find(tx->GetHash()) == m_to_add.end());
-    auto newit = m_to_add.emplace(tx, fee, time, entry_height, entry_sequence, spends_coinbase, sigops_cost, lp).first;
+    auto newit = m_to_add.emplace(TxGraph::Ref(), tx, fee, time, entry_height, entry_sequence, spends_coinbase, sigops_cost, lp).first;
     CAmount delta{0};
     m_pool->ApplyDelta(tx->GetHash(), delta);
     if (delta) m_to_add.modify(newit, [&delta](CTxMemPoolEntry& e) { e.UpdateModifiedFee(delta); });

From c18c68a950d3a17e80ad0bc11ac7ee3de1a87f6c Mon Sep 17 00:00:00 2001
From: Suhas Daftuar <sdaftuar@chaincode.com>
Date: Thu, 9 Jan 2025 11:04:14 -0500
Subject: [PATCH 05/65] Create a txgraph inside CTxMemPool

---
 src/txmempool.cpp | 3 ++-
 src/txmempool.h   | 7 +++++++
 2 files changed, 9 insertions(+), 1 deletion(-)

diff --git a/src/txmempool.cpp b/src/txmempool.cpp
index e6e2042e494..c931b361d47 100644
--- a/src/txmempool.cpp
+++ b/src/txmempool.cpp
@@ -413,6 +413,7 @@ static CTxMemPool::Options&& Flatten(CTxMemPool::Options&& opts, bilingual_str&
 CTxMemPool::CTxMemPool(Options opts, bilingual_str& error)
     : m_opts{Flatten(std::move(opts), error)}
 {
+    m_txgraph = MakeTxGraph(64, 101'000, ACCEPTABLE_ITERS);
 }
 
 bool CTxMemPool::isSpent(const COutPoint& outpoint) const
@@ -1042,7 +1043,7 @@ void CCoinsViewMemPool::Reset()
 size_t CTxMemPool::DynamicMemoryUsage() const {
     LOCK(cs);
     // Estimate the overhead of mapTx to be 15 pointers + an allocation, as no exact formula for boost::multi_index_contained is implemented.
-    return memusage::MallocUsage(sizeof(CTxMemPoolEntry) + 15 * sizeof(void*)) * mapTx.size() + memusage::DynamicUsage(mapNextTx) + memusage::DynamicUsage(mapDeltas) + memusage::DynamicUsage(txns_randomized) + cachedInnerUsage;
+    return memusage::MallocUsage(sizeof(CTxMemPoolEntry) + 15 * sizeof(void*)) * mapTx.size() + memusage::DynamicUsage(mapNextTx) + memusage::DynamicUsage(mapDeltas) + memusage::DynamicUsage(txns_randomized) + m_txgraph->GetMainMemoryUsage() + cachedInnerUsage;
 }
 
 void CTxMemPool::RemoveUnbroadcastTx(const Txid& txid, const bool unchecked) {
diff --git a/src/txmempool.h b/src/txmempool.h
index 90da90da7db..bc6eb36c841 100644
--- a/src/txmempool.h
+++ b/src/txmempool.h
@@ -19,6 +19,7 @@
 #include <primitives/transaction.h>
 #include <primitives/transaction_identifier.h>
 #include <sync.h>
+#include <txgraph.h>
 #include <util/epochguard.h>
 #include <util/feefrac.h>
 #include <util/hasher.h>
@@ -49,6 +50,11 @@ struct bilingual_str;
 /** Fake height value used in Coin to signify they are only in the memory pool (since 0.8) */
 static const uint32_t MEMPOOL_HEIGHT = 0x7FFFFFFF;
 
+/** How many linearization iterations required for TxGraph clusters to have
+ * "acceptable" quality, if they cannot be optimally linearized with fewer
+ * iterations. */
+static constexpr uint64_t ACCEPTABLE_ITERS = 1'700;
+
 /**
  * Test whether the LockPoints height and time are still valid on the current chain
  */
@@ -376,6 +382,7 @@ public:
 
     uint64_t CalculateDescendantMaximum(txiter entry) const EXCLUSIVE_LOCKS_REQUIRED(cs);
 private:
+    std::unique_ptr<TxGraph> m_txgraph GUARDED_BY(cs);
     typedef std::map<txiter, setEntries, CompareIteratorByHash> cacheMap;
 
 

From 1bf3b513966e34b45ea359cbe7576383437f5d93 Mon Sep 17 00:00:00 2001
From: Suhas Daftuar <sdaftuar@chaincode.com>
Date: Thu, 30 Jan 2025 13:16:21 -0500
Subject: [PATCH 06/65] Add sigops adjusted weight calculator

---
 src/policy/policy.cpp | 7 ++++++-
 src/policy/policy.h   | 5 +++++
 2 files changed, 11 insertions(+), 1 deletion(-)

diff --git a/src/policy/policy.cpp b/src/policy/policy.cpp
index 3da6cb7489b..b159d616021 100644
--- a/src/policy/policy.cpp
+++ b/src/policy/policy.cpp
@@ -373,9 +373,14 @@ bool SpendsNonAnchorWitnessProg(const CTransaction& tx, const CCoinsViewCache& p
     return false;
 }
 
+int64_t GetSigOpsAdjustedWeight(int64_t weight, int64_t sigop_cost, unsigned int bytes_per_sigop)
+{
+    return std::max(weight, sigop_cost * bytes_per_sigop);
+}
+
 int64_t GetVirtualTransactionSize(int64_t nWeight, int64_t nSigOpCost, unsigned int bytes_per_sigop)
 {
-    return (std::max(nWeight, nSigOpCost * bytes_per_sigop) + WITNESS_SCALE_FACTOR - 1) / WITNESS_SCALE_FACTOR;
+    return (GetSigOpsAdjustedWeight(nWeight, nSigOpCost, bytes_per_sigop) + WITNESS_SCALE_FACTOR - 1) / WITNESS_SCALE_FACTOR;
 }
 
 int64_t GetVirtualTransactionSize(const CTransaction& tx, int64_t nSigOpCost, unsigned int bytes_per_sigop)
diff --git a/src/policy/policy.h b/src/policy/policy.h
index 0131b56b031..0e4314ea9d5 100644
--- a/src/policy/policy.h
+++ b/src/policy/policy.h
@@ -11,6 +11,7 @@
 #include <primitives/transaction.h>
 #include <script/interpreter.h>
 #include <script/solver.h>
+#include <util/feefrac.h>
 
 #include <cstdint>
 #include <string>
@@ -188,4 +189,8 @@ static inline int64_t GetVirtualTransactionInputSize(const CTxIn& tx)
     return GetVirtualTransactionInputSize(tx, 0, 0);
 }
 
+int64_t GetSigOpsAdjustedWeight(int64_t weight, int64_t sigop_cost, unsigned int bytes_per_sigop);
+
+static inline FeePerVSize ToFeePerVSize(FeePerWeight feerate) { return {feerate.fee, (feerate.size + WITNESS_SCALE_FACTOR - 1) / WITNESS_SCALE_FACTOR}; }
+
 #endif // BITCOIN_POLICY_POLICY_H

From d5ed9cb3eb52c33c5ac36421bb2da00290be6087 Mon Sep 17 00:00:00 2001
From: Suhas Daftuar <sdaftuar@chaincode.com>
Date: Tue, 4 Feb 2025 14:54:20 -0500
Subject: [PATCH 07/65] Add accessor for sigops-adjusted weight

---
 src/kernel/mempool_entry.h | 1 +
 1 file changed, 1 insertion(+)

diff --git a/src/kernel/mempool_entry.h b/src/kernel/mempool_entry.h
index cd86f36698b..28c2290cb5d 100644
--- a/src/kernel/mempool_entry.h
+++ b/src/kernel/mempool_entry.h
@@ -138,6 +138,7 @@ public:
     {
         return GetVirtualTransactionSize(nTxWeight, sigOpCost, ::nBytesPerSigOp);
     }
+    int32_t GetAdjustedWeight() const { return GetSigOpsAdjustedWeight(nTxWeight, sigOpCost, ::nBytesPerSigOp); }
     int32_t GetTxWeight() const { return nTxWeight; }
     std::chrono::seconds GetTime() const { return std::chrono::seconds{nTime}; }
     unsigned int GetHeight() const { return entryHeight; }

From 838d7e3553661cb6ba0be32dd872bafb444822d9 Mon Sep 17 00:00:00 2001
From: Suhas Daftuar <sdaftuar@chaincode.com>
Date: Thu, 9 Jan 2025 12:43:43 -0500
Subject: [PATCH 08/65] Add transactions to txgraph, but without cluster
 dependencies

Effectively this is treating all transactions in txgraph as being in a cluster
of size 1.
---
 src/txmempool.cpp  | 22 ++++++++++++++++++++--
 src/txmempool.h    | 15 +++++++++++----
 src/validation.cpp | 35 ++++++++++++++++++++++++-----------
 3 files changed, 55 insertions(+), 17 deletions(-)

diff --git a/src/txmempool.cpp b/src/txmempool.cpp
index c931b361d47..dc8ec8ed5a8 100644
--- a/src/txmempool.cpp
+++ b/src/txmempool.cpp
@@ -435,6 +435,8 @@ void CTxMemPool::AddTransactionsUpdated(unsigned int n)
 void CTxMemPool::Apply(ChangeSet* changeset)
 {
     AssertLockHeld(cs);
+    m_txgraph->CommitStaging();
+
     RemoveStaged(changeset->m_to_remove, false, MemPoolRemovalReason::REPLACED);
 
     for (size_t i=0; i<changeset->m_entry_vec.size(); ++i) {
@@ -891,7 +893,10 @@ void CTxMemPool::PrioritiseTransaction(const Txid& hash, const CAmount& nFeeDelt
         delta = SaturatingAdd(delta, nFeeDelta);
         txiter it = mapTx.find(hash);
         if (it != mapTx.end()) {
+            // PrioritiseTransaction calls stack on previous ones. Set the new
+            // transaction fee to be current modified fee + feedelta.
             mapTx.modify(it, [&nFeeDelta](CTxMemPoolEntry& e) { e.UpdateModifiedFee(nFeeDelta); });
+            m_txgraph->SetTransactionFee(*it, it->GetModifiedFee());
             // Now update all ancestors' modified fees with descendants
             auto ancestors{AssumeCalculateMemPoolAncestors(__func__, *it, Limits::NoLimits(), /*fSearchForParents=*/false)};
             for (txiter ancestorIt : ancestors) {
@@ -1387,15 +1392,28 @@ CTxMemPool::ChangeSet::TxHandle CTxMemPool::ChangeSet::StageAddition(const CTran
 {
     LOCK(m_pool->cs);
     Assume(m_to_add.find(tx->GetHash()) == m_to_add.end());
-    auto newit = m_to_add.emplace(TxGraph::Ref(), tx, fee, time, entry_height, entry_sequence, spends_coinbase, sigops_cost, lp).first;
+
     CAmount delta{0};
     m_pool->ApplyDelta(tx->GetHash(), delta);
-    if (delta) m_to_add.modify(newit, [&delta](CTxMemPoolEntry& e) { e.UpdateModifiedFee(delta); });
+
+    TxGraph::Ref ref(m_pool->m_txgraph->AddTransaction(FeePerWeight(fee, GetSigOpsAdjustedWeight(GetTransactionWeight(*tx), sigops_cost, ::nBytesPerSigOp))));
+    auto newit = m_to_add.emplace(std::move(ref), tx, fee, time, entry_height, entry_sequence, spends_coinbase, sigops_cost, lp).first;
+    if (delta) {
+        m_to_add.modify(newit, [&delta](CTxMemPoolEntry& e) { e.UpdateModifiedFee(delta); });
+        m_pool->m_txgraph->SetTransactionFee(*newit, newit->GetModifiedFee());
+    }
 
     m_entry_vec.push_back(newit);
     return newit;
 }
 
+void CTxMemPool::ChangeSet::StageRemoval(CTxMemPool::txiter it)
+{
+    LOCK(m_pool->cs);
+    m_pool->m_txgraph->RemoveTransaction(*it);
+    m_to_remove.insert(it);
+}
+
 void CTxMemPool::ChangeSet::Apply()
 {
     LOCK(m_pool->cs);
diff --git a/src/txmempool.h b/src/txmempool.h
index bc6eb36c841..acf5598404c 100644
--- a/src/txmempool.h
+++ b/src/txmempool.h
@@ -371,6 +371,7 @@ public:
      * the mempool is consistent with the new chain tip and fully populated.
      */
     mutable RecursiveMutex cs;
+    std::unique_ptr<TxGraph> m_txgraph GUARDED_BY(cs);
     indexed_transaction_set mapTx GUARDED_BY(cs);
 
     using txiter = indexed_transaction_set::nth_index<0>::type::const_iterator;
@@ -382,7 +383,6 @@ public:
 
     uint64_t CalculateDescendantMaximum(txiter entry) const EXCLUSIVE_LOCKS_REQUIRED(cs);
 private:
-    std::unique_ptr<TxGraph> m_txgraph GUARDED_BY(cs);
     typedef std::map<txiter, setEntries, CompareIteratorByHash> cacheMap;
 
 
@@ -822,8 +822,14 @@ public:
      */
     class ChangeSet {
     public:
-        explicit ChangeSet(CTxMemPool* pool) : m_pool(pool) {}
-        ~ChangeSet() EXCLUSIVE_LOCKS_REQUIRED(m_pool->cs) { m_pool->m_have_changeset = false; }
+        explicit ChangeSet(CTxMemPool* pool) : m_pool(pool) { m_pool->m_txgraph->StartStaging(); }
+        ~ChangeSet() EXCLUSIVE_LOCKS_REQUIRED(m_pool->cs) {
+            AssertLockHeld(m_pool->cs);
+            if (m_pool->m_txgraph->HaveStaging()) {
+                m_pool->m_txgraph->AbortStaging();
+            }
+            m_pool->m_have_changeset = false;
+        }
 
         ChangeSet(const ChangeSet&) = delete;
         ChangeSet& operator=(const ChangeSet&) = delete;
@@ -831,7 +837,8 @@ public:
         using TxHandle = CTxMemPool::txiter;
 
         TxHandle StageAddition(const CTransactionRef& tx, const CAmount fee, int64_t time, unsigned int entry_height, uint64_t entry_sequence, bool spends_coinbase, int64_t sigops_cost, LockPoints lp);
-        void StageRemoval(CTxMemPool::txiter it) { m_to_remove.insert(it); }
+
+        void StageRemoval(CTxMemPool::txiter it);
 
         const CTxMemPool::setEntries& GetRemovals() const { return m_to_remove; }
 
diff --git a/src/validation.cpp b/src/validation.cpp
index 7f97f99b479..25831db6fb9 100644
--- a/src/validation.cpp
+++ b/src/validation.cpp
@@ -591,14 +591,26 @@ public:
     void CleanupTemporaryCoins() EXCLUSIVE_LOCKS_REQUIRED(cs_main, m_pool.cs);
 
     // Single transaction acceptance
-    MempoolAcceptResult AcceptSingleTransaction(const CTransactionRef& ptx, ATMPArgs& args) EXCLUSIVE_LOCKS_REQUIRED(cs_main);
+    MempoolAcceptResult AcceptSingleTransactionAndCleanup(const CTransactionRef& ptx, ATMPArgs& args) EXCLUSIVE_LOCKS_REQUIRED(cs_main) {
+        LOCK(m_pool.cs);
+        MempoolAcceptResult result = AcceptSingleTransactionInternal(ptx, args);
+        ClearSubPackageState();
+        return result;
+    }
+    MempoolAcceptResult AcceptSingleTransactionInternal(const CTransactionRef& ptx, ATMPArgs& args) EXCLUSIVE_LOCKS_REQUIRED(cs_main, m_pool.cs);
 
     /**
     * Multiple transaction acceptance. Transactions may or may not be interdependent, but must not
     * conflict with each other, and the transactions cannot already be in the mempool. Parents must
     * come before children if any dependencies exist.
     */
-    PackageMempoolAcceptResult AcceptMultipleTransactions(const std::vector<CTransactionRef>& txns, ATMPArgs& args) EXCLUSIVE_LOCKS_REQUIRED(cs_main);
+    PackageMempoolAcceptResult AcceptMultipleTransactionsAndCleanup(const std::vector<CTransactionRef>& txns, ATMPArgs& args) EXCLUSIVE_LOCKS_REQUIRED(cs_main) {
+        LOCK(m_pool.cs);
+        PackageMempoolAcceptResult result = AcceptMultipleTransactionsInternal(txns, args);
+        ClearSubPackageState();
+        return result;
+    }
+    PackageMempoolAcceptResult AcceptMultipleTransactionsInternal(const std::vector<CTransactionRef>& txns, ATMPArgs& args) EXCLUSIVE_LOCKS_REQUIRED(cs_main, m_pool.cs);
 
     /**
      * Submission of a subpackage.
@@ -1423,10 +1435,10 @@ bool MemPoolAccept::SubmitPackage(const ATMPArgs& args, std::vector<Workspace>&
     return all_submitted;
 }
 
-MempoolAcceptResult MemPoolAccept::AcceptSingleTransaction(const CTransactionRef& ptx, ATMPArgs& args)
+MempoolAcceptResult MemPoolAccept::AcceptSingleTransactionInternal(const CTransactionRef& ptx, ATMPArgs& args)
 {
     AssertLockHeld(cs_main);
-    LOCK(m_pool.cs); // mempool "read lock" (held through m_pool.m_opts.signals->TransactionAddedToMempool())
+    AssertLockHeld(m_pool.cs);
 
     Workspace ws(ptx);
     const std::vector<Wtxid> single_wtxid{ws.m_ptx->GetWitnessHash()};
@@ -1515,9 +1527,10 @@ MempoolAcceptResult MemPoolAccept::AcceptSingleTransaction(const CTransactionRef
                                         effective_feerate, single_wtxid);
 }
 
-PackageMempoolAcceptResult MemPoolAccept::AcceptMultipleTransactions(const std::vector<CTransactionRef>& txns, ATMPArgs& args)
+PackageMempoolAcceptResult MemPoolAccept::AcceptMultipleTransactionsInternal(const std::vector<CTransactionRef>& txns, ATMPArgs& args)
 {
     AssertLockHeld(cs_main);
+    AssertLockHeld(m_pool.cs);
 
     // These context-free package limits can be done before taking the mempool lock.
     PackageValidationState package_state;
@@ -1529,8 +1542,6 @@ PackageMempoolAcceptResult MemPoolAccept::AcceptMultipleTransactions(const std::
                    [](const auto& tx) { return Workspace(tx); });
     std::map<Wtxid, MempoolAcceptResult> results;
 
-    LOCK(m_pool.cs);
-
     // Do all PreChecks first and fail fast to avoid running expensive script checks when unnecessary.
     for (Workspace& ws : workspaces) {
         if (!PreChecks(args, ws)) {
@@ -1681,11 +1692,11 @@ PackageMempoolAcceptResult MemPoolAccept::AcceptSubPackage(const std::vector<CTr
     AssertLockHeld(m_pool.cs);
     auto result = [&]() EXCLUSIVE_LOCKS_REQUIRED(::cs_main, m_pool.cs) {
         if (subpackage.size() > 1) {
-            return AcceptMultipleTransactions(subpackage, args);
+            return AcceptMultipleTransactionsInternal(subpackage, args);
         }
         const auto& tx = subpackage.front();
         ATMPArgs single_args = ATMPArgs::SingleInPackageAccept(args);
-        const auto single_res = AcceptSingleTransaction(tx, single_args);
+        const auto single_res = AcceptSingleTransactionInternal(tx, single_args);
         PackageValidationState package_state_wrapped;
         if (single_res.m_result_type != MempoolAcceptResult::ResultType::VALID) {
             package_state_wrapped.Invalid(PackageValidationResult::PCKG_TX, "transaction failed");
@@ -1863,8 +1874,10 @@ MempoolAcceptResult AcceptToMemoryPool(Chainstate& active_chainstate, const CTra
     CTxMemPool& pool{*active_chainstate.GetMempool()};
 
     std::vector<COutPoint> coins_to_uncache;
+
     auto args = MemPoolAccept::ATMPArgs::SingleAccept(chainparams, accept_time, bypass_limits, coins_to_uncache, test_accept);
-    MempoolAcceptResult result = MemPoolAccept(pool, active_chainstate).AcceptSingleTransaction(tx, args);
+    MempoolAcceptResult result = MemPoolAccept(pool, active_chainstate).AcceptSingleTransactionAndCleanup(tx, args);
+
     if (result.m_result_type != MempoolAcceptResult::ResultType::VALID) {
         // Remove coins that were not present in the coins cache before calling
         // AcceptSingleTransaction(); this is to prevent memory DoS in case we receive a large
@@ -1897,7 +1910,7 @@ PackageMempoolAcceptResult ProcessNewPackage(Chainstate& active_chainstate, CTxM
         AssertLockHeld(cs_main);
         if (test_accept) {
             auto args = MemPoolAccept::ATMPArgs::PackageTestAccept(chainparams, GetTime(), coins_to_uncache);
-            return MemPoolAccept(pool, active_chainstate).AcceptMultipleTransactions(package, args);
+            return MemPoolAccept(pool, active_chainstate).AcceptMultipleTransactionsAndCleanup(package, args);
         } else {
             auto args = MemPoolAccept::ATMPArgs::PackageChildWithParents(chainparams, GetTime(), coins_to_uncache, client_maxfeerate);
             return MemPoolAccept(pool, active_chainstate).AcceptPackage(package, args);

From 34e32985e811607e7566ae7a6caeacdf8bd8384f Mon Sep 17 00:00:00 2001
From: Suhas Daftuar <sdaftuar@chaincode.com>
Date: Thu, 21 Sep 2023 06:17:40 -0400
Subject: [PATCH 09/65] Add new (unused) limits for cluster size/count

---
 src/init.cpp                | 2 ++
 src/kernel/mempool_limits.h | 6 +++++-
 src/node/mempool_args.cpp   | 9 +++++++++
 src/policy/policy.h         | 4 ++++
 4 files changed, 20 insertions(+), 1 deletion(-)

diff --git a/src/init.cpp b/src/init.cpp
index dadd56d2469..732229610b8 100644
--- a/src/init.cpp
+++ b/src/init.cpp
@@ -641,6 +641,8 @@ void SetupServerArgs(ArgsManager& argsman, bool can_listen_ipc)
     argsman.AddArg("-limitdescendantcount=<n>", strprintf("Do not accept transactions if any ancestor would have <n> or more in-mempool descendants (default: %u)", DEFAULT_DESCENDANT_LIMIT), ArgsManager::ALLOW_ANY | ArgsManager::DEBUG_ONLY, OptionsCategory::DEBUG_TEST);
     argsman.AddArg("-limitdescendantsize=<n>", strprintf("Do not accept transactions if any ancestor would have more than <n> kilobytes of in-mempool descendants (default: %u).", DEFAULT_DESCENDANT_SIZE_LIMIT_KVB), ArgsManager::ALLOW_ANY | ArgsManager::DEBUG_ONLY, OptionsCategory::DEBUG_TEST);
     argsman.AddArg("-test=<option>", "Pass a test-only option. Options include : " + Join(TEST_OPTIONS_DOC, ", ") + ".", ArgsManager::ALLOW_ANY | ArgsManager::DEBUG_ONLY, OptionsCategory::DEBUG_TEST);
+    argsman.AddArg("-limitclustercount=<n>", strprintf("Do not accept transactions into mempool which are directly or indirectly connected to <n> or more other unconfirmed transactions (default: %u, maximum: %u)", DEFAULT_CLUSTER_LIMIT, MAX_CLUSTER_COUNT_LIMIT), ArgsManager::ALLOW_ANY | ArgsManager::DEBUG_ONLY, OptionsCategory::DEBUG_TEST);
+    argsman.AddArg("-limitclustersize=<n>", strprintf("Do not accept transactions whose virtual size with all in-mempool connected transactions exceeds <n> kilobytes (default: %u)", DEFAULT_CLUSTER_SIZE_LIMIT_KVB), ArgsManager::ALLOW_ANY | ArgsManager::DEBUG_ONLY, OptionsCategory::DEBUG_TEST);
     argsman.AddArg("-capturemessages", "Capture all P2P messages to disk", ArgsManager::ALLOW_ANY | ArgsManager::DEBUG_ONLY, OptionsCategory::DEBUG_TEST);
     argsman.AddArg("-mocktime=<n>", "Replace actual time with " + UNIX_EPOCH_TIME + " (default: 0)", ArgsManager::ALLOW_ANY | ArgsManager::DEBUG_ONLY, OptionsCategory::DEBUG_TEST);
     argsman.AddArg("-maxsigcachesize=<n>", strprintf("Limit sum of signature cache and script execution cache sizes to <n> MiB (default: %u)", DEFAULT_VALIDATION_CACHE_BYTES >> 20), ArgsManager::ALLOW_ANY | ArgsManager::DEBUG_ONLY, OptionsCategory::DEBUG_TEST);
diff --git a/src/kernel/mempool_limits.h b/src/kernel/mempool_limits.h
index 8d4495c3cb1..cbca17907e9 100644
--- a/src/kernel/mempool_limits.h
+++ b/src/kernel/mempool_limits.h
@@ -16,6 +16,10 @@ namespace kernel {
  * Most of the time, this struct should be referenced as CTxMemPool::Limits.
  */
 struct MemPoolLimits {
+    //! The maximum number of transactions in a cluster
+    unsigned cluster_count{DEFAULT_CLUSTER_LIMIT};
+    //! The maximum allowed size in virtual bytes of a cluster.
+    int64_t cluster_size_vbytes{DEFAULT_CLUSTER_SIZE_LIMIT_KVB * 1'000};
     //! The maximum allowed number of transactions in a package including the entry and its ancestors.
     int64_t ancestor_count{DEFAULT_ANCESTOR_LIMIT};
     //! The maximum allowed size in virtual bytes of an entry and its ancestors within a package.
@@ -31,7 +35,7 @@ struct MemPoolLimits {
     static constexpr MemPoolLimits NoLimits()
     {
         int64_t no_limit{std::numeric_limits<int64_t>::max()};
-        return {no_limit, no_limit, no_limit, no_limit};
+        return {std::numeric_limits<unsigned>::max(), no_limit, no_limit, no_limit, no_limit, no_limit};
     }
 };
 } // namespace kernel
diff --git a/src/node/mempool_args.cpp b/src/node/mempool_args.cpp
index abbe97d9221..93b897d5875 100644
--- a/src/node/mempool_args.cpp
+++ b/src/node/mempool_args.cpp
@@ -15,6 +15,7 @@
 #include <policy/feerate.h>
 #include <policy/policy.h>
 #include <tinyformat.h>
+#include <txgraph.h>
 #include <util/moneystr.h>
 #include <util/translation.h>
 
@@ -31,6 +32,10 @@ static constexpr int MAX_32BIT_MEMPOOL_MB{500};
 namespace {
 void ApplyArgsManOptions(const ArgsManager& argsman, MemPoolLimits& mempool_limits)
 {
+    mempool_limits.cluster_count = argsman.GetIntArg("-limitclustercount", mempool_limits.cluster_count);
+
+    if (auto vkb = argsman.GetIntArg("-limitclustersize")) mempool_limits.cluster_size_vbytes = *vkb * 1'000;
+
     mempool_limits.ancestor_count = argsman.GetIntArg("-limitancestorcount", mempool_limits.ancestor_count);
 
     if (auto vkb = argsman.GetIntArg("-limitancestorsize")) mempool_limits.ancestor_size_vbytes = *vkb * 1'000;
@@ -106,5 +111,9 @@ util::Result<void> ApplyArgsManOptions(const ArgsManager& argsman, const CChainP
 
     ApplyArgsManOptions(argsman, mempool_opts.limits);
 
+    if (mempool_opts.limits.cluster_count > MAX_CLUSTER_COUNT_LIMIT) {
+        return util::Error{Untranslated(strprintf("limitclustercount must be less than or equal to %d", MAX_CLUSTER_COUNT_LIMIT))};
+    }
+
     return {};
 }
diff --git a/src/policy/policy.h b/src/policy/policy.h
index 0e4314ea9d5..2a15f29cffe 100644
--- a/src/policy/policy.h
+++ b/src/policy/policy.h
@@ -65,6 +65,10 @@ static constexpr unsigned int MAX_STANDARD_SCRIPTSIG_SIZE{1650};
 static constexpr unsigned int DUST_RELAY_TX_FEE{3000};
 /** Default for -minrelaytxfee, minimum relay fee for transactions */
 static constexpr unsigned int DEFAULT_MIN_RELAY_TX_FEE{100};
+/** Maximum number of transactions per cluster (default) */
+static constexpr unsigned int DEFAULT_CLUSTER_LIMIT{64};
+/** Maximum size of cluster in virtual kilobytes */
+static constexpr unsigned int DEFAULT_CLUSTER_SIZE_LIMIT_KVB{101};
 /** Default for -limitancestorcount, max number of in-mempool ancestors */
 static constexpr unsigned int DEFAULT_ANCESTOR_LIMIT{25};
 /** Default for -limitancestorsize, maximum kilobytes of tx + all in-mempool ancestors */

From 435fd5671116b990cf3b875b99036606f921a71d Mon Sep 17 00:00:00 2001
From: Suhas Daftuar <sdaftuar@chaincode.com>
Date: Sun, 9 Feb 2025 14:58:41 -0500
Subject: [PATCH 10/65] test: update feature_rbf.py replacement test

Preparatory commit to the rbf functional test, before changes are made to the
rbf rules as part of cluster mempool.
---
 test/functional/feature_rbf.py | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

diff --git a/test/functional/feature_rbf.py b/test/functional/feature_rbf.py
index 443910c0ad5..91d90efef6b 100755
--- a/test/functional/feature_rbf.py
+++ b/test/functional/feature_rbf.py
@@ -21,6 +21,8 @@ from test_framework.wallet import MiniWallet
 from test_framework.address import ADDRESS_BCRT1_UNSPENDABLE
 
 MAX_REPLACEMENT_LIMIT = 100
+MAX_CLUSTER_LIMIT = 64
+
 class ReplaceByFeeTest(BitcoinTestFramework):
     def set_test_params(self):
         self.num_nodes = 2
@@ -216,7 +218,7 @@ class ReplaceByFeeTest(BitcoinTestFramework):
                     yield x
 
         fee = int(0.00001 * COIN)
-        n = MAX_REPLACEMENT_LIMIT
+        n = MAX_CLUSTER_LIMIT
         tree_txs = list(branch(tx0_outpoint, initial_nValue, n, fee=fee))
         assert_equal(len(tree_txs), n)
 

From edb3e7cdf63688058ad2b90bea0d4933d9967be8 Mon Sep 17 00:00:00 2001
From: glozow <gloriajzhao@gmail.com>
Date: Wed, 3 Sep 2025 13:09:47 -0400
Subject: [PATCH 11/65] [test] rework/delete feature_rbf tests requiring large
 clusters

---
 test/functional/feature_rbf.py | 31 +++++++------------------------
 1 file changed, 7 insertions(+), 24 deletions(-)

diff --git a/test/functional/feature_rbf.py b/test/functional/feature_rbf.py
index 91d90efef6b..91a79113d67 100755
--- a/test/functional/feature_rbf.py
+++ b/test/functional/feature_rbf.py
@@ -28,10 +28,8 @@ class ReplaceByFeeTest(BitcoinTestFramework):
         self.num_nodes = 2
         self.extra_args = [
             [
-                "-limitancestorcount=50",
-                "-limitancestorsize=101",
-                "-limitdescendantcount=200",
-                "-limitdescendantsize=101",
+                "-limitancestorcount=64",
+                "-limitdescendantcount=64",
             ],
             # second node has default mempool parameters
             [
@@ -145,7 +143,9 @@ class ReplaceByFeeTest(BitcoinTestFramework):
         prevout = tx0_outpoint
         remaining_value = initial_nValue
         chain_txids = []
-        while remaining_value > 1 * COIN:
+        for _ in range(MAX_CLUSTER_LIMIT):
+            if remaining_value <= 1 * COIN:
+                break
             remaining_value -= int(0.1 * COIN)
             prevout = self.wallet.send_self_transfer(
                 from_node=self.nodes[0],
@@ -244,25 +244,6 @@ class ReplaceByFeeTest(BitcoinTestFramework):
         for txid in tree_txs:
             assert txid not in mempool
 
-        # Try again, but with more total transactions than the "max txs
-        # double-spent at once" anti-DoS limit.
-        for n in (MAX_REPLACEMENT_LIMIT + 1, MAX_REPLACEMENT_LIMIT * 2):
-            fee = int(0.00001 * COIN)
-            tx0_outpoint = self.make_utxo(self.nodes[0], initial_nValue)
-            tree_txs = list(branch(tx0_outpoint, initial_nValue, n, fee=fee))
-            assert_equal(len(tree_txs), n)
-
-            dbl_tx_hex = self.wallet.create_self_transfer(
-                utxo_to_spend=tx0_outpoint,
-                sequence=0,
-                fee=2 * (Decimal(fee) / COIN) * n,
-            )["hex"]
-            # This will raise an exception
-            assert_raises_rpc_error(-26, "too many potential replacements", self.nodes[0].sendrawtransaction, dbl_tx_hex, 0)
-
-            for txid in tree_txs:
-                self.nodes[0].getrawtransaction(txid)
-
     def test_replacement_feeperkb(self):
         """Replacement requires fee-per-KB to be higher"""
         tx0_outpoint = self.make_utxo(self.nodes[0], int(1.1 * COIN))
@@ -380,6 +361,8 @@ class ReplaceByFeeTest(BitcoinTestFramework):
             amount_per_output=split_value,
         )["new_utxos"]
 
+        self.generate(self.nodes[0], 1)
+
         # Now spend each of those outputs individually
         for utxo in splitting_tx_utxos:
             self.wallet.send_self_transfer(

From 95762e6759597d201d685ed6bf6df6eedccf9a00 Mon Sep 17 00:00:00 2001
From: Suhas Daftuar <sdaftuar@chaincode.com>
Date: Thu, 21 Sep 2023 08:58:04 -0400
Subject: [PATCH 12/65] Do not allow mempool clusters to exceed configured
 limits

Include an adjustment to mempool_tests.cpp due to the additional memory used by
txgraph.

Includes a temporary change to the mempool_ephemeral_dust.py functional test,
due to validation checks being reordered. This change will revert once the RBF
rules are changed in a later commit.
---
 src/test/mempool_tests.cpp                 |  2 +-
 src/txmempool.cpp                          | 51 +++++++++++++++++++++-
 src/txmempool.h                            |  6 +++
 src/validation.cpp                         | 27 +++++++++---
 test/functional/mempool_ephemeral_dust.py  |  3 +-
 test/functional/mempool_updatefromblock.py |  8 ++--
 6 files changed, 83 insertions(+), 14 deletions(-)

diff --git a/src/test/mempool_tests.cpp b/src/test/mempool_tests.cpp
index 5f8b63dbdd7..baee31e82e8 100644
--- a/src/test/mempool_tests.cpp
+++ b/src/test/mempool_tests.cpp
@@ -547,7 +547,7 @@ BOOST_AUTO_TEST_CASE(MempoolSizeLimitTest)
         AddToMempool(pool, entry.Fee(100LL).FromTx(tx5));
     AddToMempool(pool, entry.Fee(900LL).FromTx(tx7));
 
-    pool.TrimToSize(pool.DynamicMemoryUsage() / 2); // should maximize mempool size by only removing 5/7
+    pool.TrimToSize(pool.DynamicMemoryUsage() * 0.75); // should maximize mempool size by only removing 5/7
     BOOST_CHECK(pool.exists(tx4.GetHash()));
     BOOST_CHECK(!pool.exists(tx5.GetHash()));
     BOOST_CHECK(pool.exists(tx6.GetHash()));
diff --git a/src/txmempool.cpp b/src/txmempool.cpp
index dc8ec8ed5a8..af3a54cc4aa 100644
--- a/src/txmempool.cpp
+++ b/src/txmempool.cpp
@@ -145,11 +145,20 @@ void CTxMemPool::UpdateTransactionsFromBlock(const std::vector<Txid>& vHashesToU
                     UpdateChild(it, childIter, true);
                     UpdateParent(childIter, it, true);
                 }
+                // Add dependencies that are discovered between transactions in the
+                // block and transactions that were in the mempool to txgraph.
+                m_txgraph->AddDependency(/*parent=*/*it, /*child=*/*childIter);
             }
         } // release epoch guard for UpdateForDescendants
         UpdateForDescendants(it, mapMemPoolDescendantsToUpdate, setAlreadyIncluded, descendants_to_remove);
     }
 
+    auto txs_to_remove = m_txgraph->Trim(); // Enforce cluster size limits.
+    for (auto txptr : txs_to_remove) {
+        const CTxMemPoolEntry& entry = *(static_cast<const CTxMemPoolEntry*>(txptr));
+        descendants_to_remove.insert(entry.GetTx().GetHash());
+    }
+
     for (const auto& txid : descendants_to_remove) {
         // This txid may have been removed already in a prior call to removeRecursive.
         // Therefore we ensure it is not yet removed already.
@@ -229,6 +238,7 @@ util::Result<void> CTxMemPool::CheckPackageLimits(const Package& package,
             }
         }
     }
+
     // When multiple transactions are passed in, the ancestors and descendants of all transactions
     // considered together must be within limits even if they are not interdependent. This may be
     // stricter than the limits for each individual transaction.
@@ -413,7 +423,7 @@ static CTxMemPool::Options&& Flatten(CTxMemPool::Options&& opts, bilingual_str&
 CTxMemPool::CTxMemPool(Options opts, bilingual_str& error)
     : m_opts{Flatten(std::move(opts), error)}
 {
-    m_txgraph = MakeTxGraph(64, 101'000, ACCEPTABLE_ITERS);
+    m_txgraph = MakeTxGraph(m_opts.limits.cluster_count, m_opts.limits.cluster_size_vbytes * WITNESS_SCALE_FACTOR, ACCEPTABLE_ITERS);
 }
 
 bool CTxMemPool::isSpent(const COutPoint& outpoint) const
@@ -1392,6 +1402,10 @@ CTxMemPool::ChangeSet::TxHandle CTxMemPool::ChangeSet::StageAddition(const CTran
 {
     LOCK(m_pool->cs);
     Assume(m_to_add.find(tx->GetHash()) == m_to_add.end());
+    Assume(!m_dependencies_processed);
+
+    // We need to process dependencies after adding a new transaction.
+    m_dependencies_processed = false;
 
     CAmount delta{0};
     m_pool->ApplyDelta(tx->GetHash(), delta);
@@ -1417,9 +1431,44 @@ void CTxMemPool::ChangeSet::StageRemoval(CTxMemPool::txiter it)
 void CTxMemPool::ChangeSet::Apply()
 {
     LOCK(m_pool->cs);
+    if (!m_dependencies_processed) {
+        ProcessDependencies();
+    }
     m_pool->Apply(this);
     m_to_add.clear();
     m_to_remove.clear();
     m_entry_vec.clear();
     m_ancestors.clear();
 }
+
+void CTxMemPool::ChangeSet::ProcessDependencies()
+{
+    LOCK(m_pool->cs);
+    Assume(!m_dependencies_processed); // should only call this once.
+    for (const auto& entryptr : m_entry_vec) {
+        for (const auto &txin : entryptr->GetSharedTx()->vin) {
+            std::optional<txiter> piter = m_pool->GetIter(txin.prevout.hash);
+            if (!piter) {
+                auto it = m_to_add.find(txin.prevout.hash);
+                if (it != m_to_add.end()) {
+                    piter = std::make_optional(it);
+                }
+            }
+            if (piter) {
+                m_pool->m_txgraph->AddDependency(/*parent=*/**piter, /*child=*/*entryptr);
+            }
+        }
+    }
+    m_dependencies_processed = true;
+    return;
+ }
+
+bool CTxMemPool::ChangeSet::CheckMemPoolPolicyLimits()
+{
+    LOCK(m_pool->cs);
+    if (!m_dependencies_processed) {
+        ProcessDependencies();
+    }
+
+    return !m_pool->m_txgraph->IsOversized(TxGraph::Level::TOP);
+}
diff --git a/src/txmempool.h b/src/txmempool.h
index acf5598404c..60087561fea 100644
--- a/src/txmempool.h
+++ b/src/txmempool.h
@@ -842,6 +842,9 @@ public:
 
         const CTxMemPool::setEntries& GetRemovals() const { return m_to_remove; }
 
+        /** Check if any cluster limits are exceeded. Returns true if pass, false if fail. */
+        bool CheckMemPoolPolicyLimits();
+
         util::Result<CTxMemPool::setEntries> CalculateMemPoolAncestors(TxHandle tx, const Limits& limits)
         {
             // Look up transaction in our cache first
@@ -879,12 +882,15 @@ public:
         void Apply() EXCLUSIVE_LOCKS_REQUIRED(cs_main);
 
     private:
+        void ProcessDependencies();
+
         CTxMemPool* m_pool;
         CTxMemPool::indexed_transaction_set m_to_add;
         std::vector<CTxMemPool::txiter> m_entry_vec; // track the added transactions' insertion order
         // map from the m_to_add index to the ancestors for the transaction
         std::map<CTxMemPool::txiter, CTxMemPool::setEntries, CompareIteratorByHash> m_ancestors;
         CTxMemPool::setEntries m_to_remove;
+        bool m_dependencies_processed{false};
 
         friend class CTxMemPool;
     };
diff --git a/src/validation.cpp b/src/validation.cpp
index 25831db6fb9..596f688bb14 100644
--- a/src/validation.cpp
+++ b/src/validation.cpp
@@ -1126,6 +1126,7 @@ bool MemPoolAccept::ReplacementChecks(Workspace& ws)
         return state.Invalid(TxValidationResult::TX_MEMPOOL_POLICY,
                              strprintf("too many potential replacements%s", ws.m_sibling_eviction ? " (including sibling eviction)" : ""), *err_string);
     }
+
     // Enforce Rule #2.
     if (const auto err_string{HasNoNewUnconfirmed(tx, m_pool, all_conflicts)}) {
         // Sibling eviction is only done for TRUC transactions, which cannot have multiple ancestors.
@@ -1460,13 +1461,6 @@ MempoolAcceptResult MemPoolAccept::AcceptSingleTransactionInternal(const CTransa
         return MempoolAcceptResult::Failure(ws.m_state);
     }
 
-    if (m_pool.m_opts.require_standard) {
-        Wtxid dummy_wtxid;
-        if (!CheckEphemeralSpends(/*package=*/{ptx}, m_pool.m_opts.dust_relay_feerate, m_pool, ws.m_state, dummy_wtxid)) {
-            return MempoolAcceptResult::Failure(ws.m_state);
-        }
-    }
-
     if (m_subpackage.m_rbf && !ReplacementChecks(ws)) {
         if (ws.m_state.GetResult() == TxValidationResult::TX_RECONSIDERABLE) {
             // Failed for incentives-based fee reasons. Provide the effective feerate and which tx was included.
@@ -1475,6 +1469,19 @@ MempoolAcceptResult MemPoolAccept::AcceptSingleTransactionInternal(const CTransa
         return MempoolAcceptResult::Failure(ws.m_state);
     }
 
+    // Check if the transaction would exceed the cluster size limit.
+    if (!m_subpackage.m_changeset->CheckMemPoolPolicyLimits()) {
+        ws.m_state.Invalid(TxValidationResult::TX_MEMPOOL_POLICY, "too-large-cluster", "");
+        return MempoolAcceptResult::Failure(ws.m_state);
+    }
+
+    if (m_pool.m_opts.require_standard) {
+        Wtxid dummy_wtxid;
+        if (!CheckEphemeralSpends(/*package=*/{ptx}, m_pool.m_opts.dust_relay_feerate, m_pool, ws.m_state, dummy_wtxid)) {
+            return MempoolAcceptResult::Failure(ws.m_state);
+        }
+    }
+
     // Perform the inexpensive checks first and avoid hashing and signature verification unless
     // those checks pass, to mitigate CPU exhaustion denial-of-service attacks.
     if (!PolicyScriptChecks(args, ws)) return MempoolAcceptResult::Failure(ws.m_state);
@@ -1615,6 +1622,12 @@ PackageMempoolAcceptResult MemPoolAccept::AcceptMultipleTransactionsInternal(con
         return PackageMempoolAcceptResult(package_state, std::move(results));
     }
 
+    // Check if the transactions would exceed the cluster size limit.
+    if (!m_subpackage.m_changeset->CheckMemPoolPolicyLimits()) {
+        package_state.Invalid(PackageValidationResult::PCKG_POLICY, "too-large-cluster", "");
+        return PackageMempoolAcceptResult(package_state, std::move(results));
+    }
+
     // Now that we've bounded the resulting possible ancestry count, check package for dust spends
     if (m_pool.m_opts.require_standard) {
         TxValidationState child_state;
diff --git a/test/functional/mempool_ephemeral_dust.py b/test/functional/mempool_ephemeral_dust.py
index a0308da72ac..712176e9348 100755
--- a/test/functional/mempool_ephemeral_dust.py
+++ b/test/functional/mempool_ephemeral_dust.py
@@ -419,7 +419,8 @@ class EphemeralDustTest(BitcoinTestFramework):
 
         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']} (wtxid={insufficient_sweep_tx['wtxid']}) did not spend parent's ephemeral dust")
+        #assert_equal(res['tx-results'][insufficient_sweep_tx["wtxid"]]["error"], f"missing-ephemeral-spends, tx {insufficient_sweep_tx['txid']} (wtxid={insufficient_sweep_tx['wtxid']}) did not spend parent's ephemeral dust")
+        assert_equal(res['tx-results'][insufficient_sweep_tx["wtxid"]]["error"], f"replacement-adds-unconfirmed, replacement {insufficient_sweep_tx['txid']} adds unconfirmed input, idx 46")
         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
diff --git a/test/functional/mempool_updatefromblock.py b/test/functional/mempool_updatefromblock.py
index fdc6b9a34e1..6ee31ffa650 100755
--- a/test/functional/mempool_updatefromblock.py
+++ b/test/functional/mempool_updatefromblock.py
@@ -28,7 +28,7 @@ class MempoolUpdateFromBlockTest(BitcoinTestFramework):
     def set_test_params(self):
         self.num_nodes = 1
         # Ancestor and descendant limits depend on transaction_graph_test requirements
-        self.extra_args = [['-limitdescendantsize=1000', '-limitancestorsize=1000', f'-limitancestorcount={CUSTOM_ANCESTOR_COUNT}', f'-limitdescendantcount={CUSTOM_DESCENDANT_COUNT}']]
+        self.extra_args = [['-limitdescendantsize=1000', '-limitancestorsize=1000', f'-limitancestorcount={CUSTOM_ANCESTOR_COUNT}', f'-limitdescendantcount={CUSTOM_DESCENDANT_COUNT}', "-limitclustersize=1000"]]
 
     def create_empty_fork(self, fork_length):
         '''
@@ -198,11 +198,11 @@ class MempoolUpdateFromBlockTest(BitcoinTestFramework):
         fork_blocks = self.create_empty_fork(fork_length=10)
 
         # Two higher than descendant count
-        chain = wallet.create_self_transfer_chain(chain_length=CUSTOM_DESCENDANT_COUNT + 2)
+        chain = wallet.create_self_transfer_chain(chain_length=64 + 2)
         for tx in chain[:-2]:
             self.nodes[0].sendrawtransaction(tx["hex"])
 
-        assert_raises_rpc_error(-26, "too-long-mempool-chain, too many unconfirmed ancestors [limit: 100]", self.nodes[0].sendrawtransaction, chain[-2]["hex"])
+        assert_raises_rpc_error(-26, "too-large-cluster", self.nodes[0].sendrawtransaction, chain[-2]["hex"])
 
         # Mine a block with all but last transaction, non-standardly long chain
         self.generateblock(self.nodes[0], output="raw(42)", transactions=[tx["hex"] for tx in chain[:-1]])
@@ -220,7 +220,7 @@ class MempoolUpdateFromBlockTest(BitcoinTestFramework):
 
     def run_test(self):
         # Mine in batches of 25 to test multi-block reorg under chain limits
-        self.transaction_graph_test(size=CUSTOM_ANCESTOR_COUNT, n_tx_to_mine=[25, 50, 75])
+        self.transaction_graph_test(size=64, n_tx_to_mine=[25, 50, 75])
 
         self.test_max_disconnect_pool_bytes()
 

From 95a8297d481e96d65ac81e4dac72b2ebecb9c765 Mon Sep 17 00:00:00 2001
From: Suhas Daftuar <sdaftuar@chaincode.com>
Date: Thu, 23 Jan 2025 09:26:05 -0500
Subject: [PATCH 13/65] Check cluster limits when using -walletrejectlongchains

---
 src/node/interfaces.cpp |  7 ++++---
 src/txmempool.cpp       | 11 +++++++++++
 src/txmempool.h         |  2 ++
 3 files changed, 17 insertions(+), 3 deletions(-)

diff --git a/src/node/interfaces.cpp b/src/node/interfaces.cpp
index 0626e2c6837..8e38ae126ff 100644
--- a/src/node/interfaces.cpp
+++ b/src/node/interfaces.cpp
@@ -719,10 +719,11 @@ public:
     util::Result<void> checkChainLimits(const CTransactionRef& tx) override
     {
         if (!m_node.mempool) return {};
-        LockPoints lp;
-        CTxMemPoolEntry entry(TxGraph::Ref(), tx, 0, 0, 0, 0, false, 0, lp);
+        if (!m_node.mempool->CheckPolicyLimits(tx)) {
+            return util::Error{Untranslated("too many unconfirmed transactions in cluster")};
+        }
         LOCK(m_node.mempool->cs);
-        return m_node.mempool->CheckPackageLimits({tx}, entry.GetTxSize());
+        return m_node.mempool->CheckPackageLimits({tx}, GetVirtualTransactionSize(*tx));
     }
     CFeeRate estimateSmartFee(int num_blocks, bool conservative, FeeCalculation* calc) override
     {
diff --git a/src/txmempool.cpp b/src/txmempool.cpp
index af3a54cc4aa..e5a318524dd 100644
--- a/src/txmempool.cpp
+++ b/src/txmempool.cpp
@@ -1078,6 +1078,17 @@ void CTxMemPool::RemoveStaged(setEntries &stage, bool updateDescendants, MemPool
     }
 }
 
+bool CTxMemPool::CheckPolicyLimits(const CTransactionRef& tx)
+{
+    LOCK(cs);
+    // Use ChangeSet interface to check whether the chain
+    // limits would be violated. Note that the changeset will be destroyed
+    // when it goes out of scope.
+    auto changeset = GetChangeSet();
+    (void) changeset->StageAddition(tx, /*fee=*/0, /*time=*/0, /*entry_height=*/0, /*entry_sequence=*/0, /*spends_coinbase=*/false, /*sigops_cost=*/0, LockPoints{});
+    return changeset->CheckMemPoolPolicyLimits();
+}
+
 int CTxMemPool::Expire(std::chrono::seconds time)
 {
     AssertLockHeld(cs);
diff --git a/src/txmempool.h b/src/txmempool.h
index 60087561fea..2b5882c8a4b 100644
--- a/src/txmempool.h
+++ b/src/txmempool.h
@@ -681,6 +681,8 @@ public:
         if (exists(txid)) m_unbroadcast_txids.insert(txid);
     };
 
+    bool CheckPolicyLimits(const CTransactionRef& tx);
+
     /** Removes a transaction from the unbroadcast set */
     void RemoveUnbroadcastTx(const Txid& txid, const bool unchecked = false);
 

From b11c89cab210c87ebaf34fbd2a73d28353e8c7bd Mon Sep 17 00:00:00 2001
From: Suhas Daftuar <sdaftuar@chaincode.com>
Date: Sat, 8 Feb 2025 13:36:48 -0500
Subject: [PATCH 14/65] Rework miner_tests to not require large cluster limit

---
 src/test/miner_tests.cpp | 115 +++++++++++++++++++++++++++++----------
 1 file changed, 86 insertions(+), 29 deletions(-)

diff --git a/src/test/miner_tests.cpp b/src/test/miner_tests.cpp
index 652ec25fe89..58a535dc453 100644
--- a/src/test/miner_tests.cpp
+++ b/src/test/miner_tests.cpp
@@ -56,7 +56,12 @@ struct MinerTestingSetup : public TestingSetup {
         // instead.
         m_node.mempool.reset();
         bilingual_str error;
-        m_node.mempool = std::make_unique<CTxMemPool>(MemPoolOptionsForTest(m_node), error);
+        auto opts = MemPoolOptionsForTest(m_node);
+        // The "block size > limit" test creates a cluster of 1192590 vbytes,
+        // so set the cluster vbytes limit big enough so that the txgraph
+        // doesn't become oversized.
+        opts.limits.cluster_size_vbytes = 1'200'000;
+        m_node.mempool = std::make_unique<CTxMemPool>(opts, error);
         Assert(error.empty());
         return *m_node.mempool;
     }
@@ -253,6 +258,48 @@ void MinerTestingSetup::TestPackageSelection(const CScript& scriptPubKey, const
     BOOST_CHECK(block.vtx[8]->GetHash() == hashLowFeeTx2);
 }
 
+std::vector<CTransactionRef> CreateBigSigOpsCluster(const CTransactionRef& first_tx)
+{
+    std::vector<CTransactionRef> ret;
+
+    CMutableTransaction tx;
+    // block sigops > limit: 1000 CHECKMULTISIG + 1
+    tx.vin.resize(1);
+    // NOTE: OP_NOP is used to force 20 SigOps for the CHECKMULTISIG
+    tx.vin[0].scriptSig = CScript() << OP_0 << OP_0 << OP_CHECKSIG << OP_1;
+    tx.vin[0].prevout.hash = first_tx->GetHash();
+    tx.vin[0].prevout.n = 0;
+    tx.vout.resize(50);
+    for (auto &out : tx.vout) {
+        out.nValue = first_tx->vout[0].nValue / 50;
+        out.scriptPubKey = CScript() << OP_1;
+    }
+
+    tx.vout[0].nValue -= CENT;
+    CTransactionRef parent_tx = MakeTransactionRef(tx);
+    ret.push_back(parent_tx);
+    assert(GetLegacySigOpCount(*parent_tx) == 1);
+
+    // Tx1 has 1 sigops, 1 input, 50 outputs.
+    // Tx2-51 has 400 sigops: 1 input, 20 CHECKMULTISIG outputs
+    // Total: 1000 CHECKMULTISIG + 1
+    for (unsigned int i = 0; i < 50; ++i) {
+        auto tx2 = tx;
+        tx2.vin.resize(1);
+        tx2.vin[0].prevout.hash = parent_tx->GetHash();
+        tx2.vin[0].prevout.n = i;
+        tx2.vin[0].scriptSig = CScript() << OP_1;
+        tx2.vout.resize(20);
+        tx2.vout[0].nValue = parent_tx->vout[i].nValue - CENT;
+        for (auto &out : tx2.vout) {
+            out.nValue = 0;
+            out.scriptPubKey = CScript() << OP_0 << OP_0 << OP_0 << OP_NOP << OP_CHECKMULTISIG << OP_1;
+        }
+        ret.push_back(MakeTransactionRef(tx2));
+    }
+    return ret;
+}
+
 void MinerTestingSetup::TestBasicMining(const CScript& scriptPubKey, const std::vector<CTransactionRef>& txFirst, int baseheight)
 {
     Txid hash;
@@ -281,23 +328,18 @@ void MinerTestingSetup::TestBasicMining(const CScript& scriptPubKey, const std::
         BOOST_REQUIRE(block_template);
         CBlock block{block_template->getBlock()};
 
-        // block sigops > limit: 1000 CHECKMULTISIG + 1
-        tx.vin.resize(1);
-        // NOTE: OP_NOP is used to force 20 SigOps for the CHECKMULTISIG
-        tx.vin[0].scriptSig = CScript() << OP_0 << OP_0 << OP_0 << OP_NOP << OP_CHECKMULTISIG << OP_1;
-        tx.vin[0].prevout.hash = txFirst[0]->GetHash();
-        tx.vin[0].prevout.n = 0;
-        tx.vout.resize(1);
-        tx.vout[0].nValue = BLOCKSUBSIDY;
-        for (unsigned int i = 0; i < 1001; ++i) {
-            tx.vout[0].nValue -= LOWFEE;
-            hash = tx.GetHash();
-            bool spendsCoinbase = i == 0; // only first tx spends coinbase
-            // If we don't set the # of sig ops in the CTxMemPoolEntry, template creation fails
-            AddToMempool(tx_mempool, entry.Fee(LOWFEE).Time(Now<NodeSeconds>()).SpendsCoinbase(spendsCoinbase).FromTx(tx));
-            tx.vin[0].prevout.hash = hash;
-        }
+        auto txs = CreateBigSigOpsCluster(txFirst[0]);
 
+        int64_t legacy_sigops = 0;
+        for (auto& t : txs) {
+            // If we don't set the number of sigops in the CTxMemPoolEntry,
+            // template creation fails during sanity checks.
+            AddToMempool(tx_mempool, entry.Fee(LOWFEE).Time(Now<NodeSeconds>()).SpendsCoinbase(true).FromTx(t));
+            legacy_sigops += GetLegacySigOpCount(*t);
+            BOOST_CHECK(tx_mempool.GetIter(t->GetHash()).has_value());
+        }
+        assert(tx_mempool.mapTx.size() == 51);
+        assert(legacy_sigops == 20001);
         BOOST_CHECK_EXCEPTION(mining->createNewBlock(options), std::runtime_error, HasReason("bad-blk-sigops"));
     }
 
@@ -305,16 +347,25 @@ void MinerTestingSetup::TestBasicMining(const CScript& scriptPubKey, const std::
         CTxMemPool& tx_mempool{MakeMempool()};
         LOCK(tx_mempool.cs);
 
-        tx.vin[0].prevout.hash = txFirst[0]->GetHash();
-        tx.vout[0].nValue = BLOCKSUBSIDY;
-        for (unsigned int i = 0; i < 1001; ++i) {
-            tx.vout[0].nValue -= LOWFEE;
-            hash = tx.GetHash();
-            bool spendsCoinbase = i == 0; // only first tx spends coinbase
-            // If we do set the # of sig ops in the CTxMemPoolEntry, template creation passes
-            AddToMempool(tx_mempool, entry.Fee(LOWFEE).Time(Now<NodeSeconds>()).SpendsCoinbase(spendsCoinbase).SigOpsCost(80).FromTx(tx));
-            tx.vin[0].prevout.hash = hash;
+        // Check that the mempool is empty.
+        assert(tx_mempool.mapTx.empty());
+
+        // Just to make sure we can still make simple blocks
+        auto block_template{mining->createNewBlock(options)};
+        BOOST_REQUIRE(block_template);
+        CBlock block{block_template->getBlock()};
+
+        auto txs = CreateBigSigOpsCluster(txFirst[0]);
+
+        int64_t legacy_sigops = 0;
+        for (auto& t : txs) {
+            AddToMempool(tx_mempool, entry.Fee(LOWFEE).Time(Now<NodeSeconds>()).SpendsCoinbase(true).SigOpsCost(GetLegacySigOpCount(*t)*WITNESS_SCALE_FACTOR).FromTx(t));
+            legacy_sigops += GetLegacySigOpCount(*t);
+            BOOST_CHECK(tx_mempool.GetIter(t->GetHash()).has_value());
         }
+        assert(tx_mempool.mapTx.size() == 51);
+        assert(legacy_sigops == 20001);
+
         BOOST_REQUIRE(mining->createNewBlock(options));
     }
 
@@ -323,20 +374,26 @@ void MinerTestingSetup::TestBasicMining(const CScript& scriptPubKey, const std::
         LOCK(tx_mempool.cs);
 
         // block size > limit
-        tx.vin[0].scriptSig = CScript();
-        // 18 * (520char + DROP) + OP_1 = 9433 bytes
+        tx.vin.resize(1);
+        tx.vout.resize(1);
+        tx.vout[0].nValue = BLOCKSUBSIDY;
+        // 36 * (520char + DROP) + OP_1 = 18757 bytes
         std::vector<unsigned char> vchData(520);
         for (unsigned int i = 0; i < 18; ++i) {
             tx.vin[0].scriptSig << vchData << OP_DROP;
+            tx.vout[0].scriptPubKey << vchData << OP_DROP;
         }
         tx.vin[0].scriptSig << OP_1;
+        tx.vout[0].scriptPubKey << OP_1;
         tx.vin[0].prevout.hash = txFirst[0]->GetHash();
+        tx.vin[0].prevout.n = 0;
         tx.vout[0].nValue = BLOCKSUBSIDY;
-        for (unsigned int i = 0; i < 128; ++i) {
+        for (unsigned int i = 0; i < 63; ++i) {
             tx.vout[0].nValue -= LOWFEE;
             hash = tx.GetHash();
             bool spendsCoinbase = i == 0; // only first tx spends coinbase
             AddToMempool(tx_mempool, entry.Fee(LOWFEE).Time(Now<NodeSeconds>()).SpendsCoinbase(spendsCoinbase).FromTx(tx));
+            BOOST_CHECK(tx_mempool.GetIter(hash).has_value());
             tx.vin[0].prevout.hash = hash;
         }
         BOOST_REQUIRE(mining->createNewBlock(options));

From 1ad4590f63855e856d59616d41a87873315c3a2e Mon Sep 17 00:00:00 2001
From: Suhas Daftuar <sdaftuar@chaincode.com>
Date: Wed, 20 Sep 2023 20:55:50 -0400
Subject: [PATCH 15/65] Limit mempool size based on chunk feerate

Rather than evicting the transactions with the lowest descendant feerate,
instead evict transactions that have the lowest chunk feerate.

Once mining is implemented based on choosing transactions with highest chunk
feerate (see next commit), mining and eviction will be opposites, so that we
will evict the transactions that would be mined last.
---
 src/test/mempool_tests.cpp | 18 ++++++++++++++----
 src/txmempool.cpp          | 27 ++++++++++++++++++---------
 2 files changed, 32 insertions(+), 13 deletions(-)

diff --git a/src/test/mempool_tests.cpp b/src/test/mempool_tests.cpp
index baee31e82e8..ec3bbd158fe 100644
--- a/src/test/mempool_tests.cpp
+++ b/src/test/mempool_tests.cpp
@@ -533,27 +533,37 @@ BOOST_AUTO_TEST_CASE(MempoolSizeLimitTest)
     tx7.vout[1].nValue = 10 * COIN;
 
     AddToMempool(pool, entry.Fee(700LL).FromTx(tx4));
+    auto usage_with_tx4_only = pool.DynamicMemoryUsage();
     AddToMempool(pool, entry.Fee(100LL).FromTx(tx5));
     AddToMempool(pool, entry.Fee(110LL).FromTx(tx6));
     AddToMempool(pool, entry.Fee(900LL).FromTx(tx7));
 
-    // we only require this to remove, at max, 2 txn, because it's not clear what we're really optimizing for aside from that
+    // From the topology above, tx7 must be sorted last, so it should
+    // definitely evicted first if we must trim. tx4 should definitely remain
+    // in the mempool since it has a higher feerate than its descendants and
+    // should be in its own chunk.
     pool.TrimToSize(pool.DynamicMemoryUsage() - 1);
     BOOST_CHECK(pool.exists(tx4.GetHash()));
-    BOOST_CHECK(pool.exists(tx6.GetHash()));
     BOOST_CHECK(!pool.exists(tx7.GetHash()));
 
+    // Tx5 and Tx6 may be removed as well because they're in the same chunk as
+    // tx7, but this behavior need not be guaranteed.
+
     if (!pool.exists(tx5.GetHash()))
         AddToMempool(pool, entry.Fee(100LL).FromTx(tx5));
+    if (!pool.exists(tx6.GetHash()))
+        AddToMempool(pool, entry.Fee(110LL).FromTx(tx6));
     AddToMempool(pool, entry.Fee(900LL).FromTx(tx7));
 
-    pool.TrimToSize(pool.DynamicMemoryUsage() * 0.75); // should maximize mempool size by only removing 5/7
+    // If we trim sufficiently, everything but tx4 should be removed.
+    pool.TrimToSize(usage_with_tx4_only + 1);
     BOOST_CHECK(pool.exists(tx4.GetHash()));
     BOOST_CHECK(!pool.exists(tx5.GetHash()));
-    BOOST_CHECK(pool.exists(tx6.GetHash()));
+    BOOST_CHECK(!pool.exists(tx6.GetHash()));
     BOOST_CHECK(!pool.exists(tx7.GetHash()));
 
     AddToMempool(pool, entry.Fee(100LL).FromTx(tx5));
+    AddToMempool(pool, entry.Fee(110LL).FromTx(tx6));
     AddToMempool(pool, entry.Fee(900LL).FromTx(tx7));
 
     std::vector<CTransactionRef> vtx;
diff --git a/src/txmempool.cpp b/src/txmempool.cpp
index e5a318524dd..672198ec2ea 100644
--- a/src/txmempool.cpp
+++ b/src/txmempool.cpp
@@ -1167,29 +1167,38 @@ void CTxMemPool::TrimToSize(size_t sizelimit, std::vector<COutPoint>* pvNoSpends
 
     unsigned nTxnRemoved = 0;
     CFeeRate maxFeeRateRemoved(0);
+
     while (!mapTx.empty() && DynamicMemoryUsage() > sizelimit) {
-        indexed_transaction_set::index<descendant_score>::type::iterator it = mapTx.get<descendant_score>().begin();
+        const auto &[worst_chunk, feeperweight] = m_txgraph->GetWorstMainChunk();
+        FeePerVSize feerate = ToFeePerVSize(feeperweight);
+        CFeeRate removed{feerate.fee, feerate.size};
 
         // We set the new mempool min fee to the feerate of the removed set, plus the
         // "minimum reasonable fee rate" (ie some value under which we consider txn
         // to have 0 fee). This way, we don't allow txn to enter mempool with feerate
         // equal to txn which were removed with no block in between.
-        CFeeRate removed(it->GetModFeesWithDescendants(), it->GetSizeWithDescendants());
         removed += m_opts.incremental_relay_feerate;
         trackPackageRemoved(removed);
         maxFeeRateRemoved = std::max(maxFeeRateRemoved, removed);
 
-        setEntries stage;
-        CalculateDescendants(mapTx.project<0>(it), stage);
-        nTxnRemoved += stage.size();
+        nTxnRemoved += worst_chunk.size();
 
         std::vector<CTransaction> txn;
         if (pvNoSpendsRemaining) {
-            txn.reserve(stage.size());
-            for (txiter iter : stage)
-                txn.push_back(iter->GetTx());
+            txn.reserve(worst_chunk.size());
+            for (auto ref : worst_chunk) {
+                txn.emplace_back(static_cast<const CTxMemPoolEntry&>(*ref).GetTx());
+            }
+        }
+
+        setEntries stage;
+        for (auto ref : worst_chunk) {
+            stage.insert(mapTx.iterator_to(static_cast<const CTxMemPoolEntry&>(*ref)));
+        }
+        UpdateForRemoveFromMempool(stage, false);
+        for (auto e : stage) {
+            removeUnchecked(e, MemPoolRemovalReason::SIZELIMIT);
         }
-        RemoveStaged(stage, false, MemPoolRemovalReason::SIZELIMIT);
         if (pvNoSpendsRemaining) {
             for (const CTransaction& tx : txn) {
                 for (const CTxIn& txin : tx.vin) {

From 6c2bceb200aa7206d44b551d42ad3e70943f1425 Mon Sep 17 00:00:00 2001
From: Suhas Daftuar <sdaftuar@chaincode.com>
Date: Thu, 9 Oct 2025 10:35:55 -0400
Subject: [PATCH 16/65] bench: rewrite ComplexMemPool to not create oversized
 clusters

---
 src/bench/mempool_stress.cpp | 42 +++++++++++++++++++++++++++++-------
 1 file changed, 34 insertions(+), 8 deletions(-)

diff --git a/src/bench/mempool_stress.cpp b/src/bench/mempool_stress.cpp
index 5095438cd20..49ff17c1b02 100644
--- a/src/bench/mempool_stress.cpp
+++ b/src/bench/mempool_stress.cpp
@@ -39,15 +39,17 @@ struct Available {
     Available(CTransactionRef& ref, size_t tx_count) : ref(ref), tx_count(tx_count){}
 };
 
-static std::vector<CTransactionRef> CreateOrderedCoins(FastRandomContext& det_rand, int childTxs, int min_ancestors)
+// Create a cluster of transactions, randomly.
+static std::vector<CTransactionRef> CreateCoinCluster(FastRandomContext& det_rand, int childTxs, int min_ancestors)
 {
     std::vector<Available> available_coins;
     std::vector<CTransactionRef> ordered_coins;
     // Create some base transactions
     size_t tx_counter = 1;
-    for (auto x = 0; x < 100; ++x) {
+    for (auto x = 0; x < 10; ++x) {
         CMutableTransaction tx = CMutableTransaction();
         tx.vin.resize(1);
+        tx.vin[0].prevout = COutPoint(Txid::FromUint256(GetRandHash()), 1);
         tx.vin[0].scriptSig = CScript() << CScriptNum(tx_counter);
         tx.vin[0].scriptWitness.stack.push_back(CScriptNum(x).getvch());
         tx.vout.resize(det_rand.randrange(10)+2);
@@ -94,20 +96,44 @@ static std::vector<CTransactionRef> CreateOrderedCoins(FastRandomContext& det_ra
 static void ComplexMemPool(benchmark::Bench& bench)
 {
     FastRandomContext det_rand{true};
-    int childTxs = 800;
+    int childTxs = 50;
     if (bench.complexityN() > 1) {
         childTxs = static_cast<int>(bench.complexityN());
     }
-    std::vector<CTransactionRef> ordered_coins = CreateOrderedCoins(det_rand, childTxs, /*min_ancestors=*/1);
     const auto testing_setup = MakeNoLogFileContext<const TestingSetup>(ChainType::MAIN);
     CTxMemPool& pool = *testing_setup.get()->m_node.mempool;
+
+    std::vector<CTransactionRef> tx_remove_for_block;
+    std::vector<Txid> hashes_remove_for_block;
+
     LOCK2(cs_main, pool.cs);
-    bench.run([&]() NO_THREAD_SAFETY_ANALYSIS {
-        for (auto& tx : ordered_coins) {
+
+    for (int i=0; i<1000; i++) {
+        std::vector<CTransactionRef> transactions = CreateCoinCluster(det_rand, childTxs, /*min_ancestors=*/1);
+
+        // Add all transactions to the mempool.
+        // Also store the first 10 transactions from each cluster as the
+        // transactions we'll "mine" in the the benchmark.
+        int tx_count = 0;
+        for (auto& tx : transactions) {
+            if (tx_count < 10) {
+                tx_remove_for_block.push_back(tx);
+                ++tx_count;
+                hashes_remove_for_block.emplace_back(tx->GetHash());
+            }
             AddTx(tx, pool);
         }
-        pool.TrimToSize(pool.DynamicMemoryUsage() * 3 / 4);
-        pool.TrimToSize(GetVirtualTransactionSize(*ordered_coins.front()));
+    }
+
+    // Since the benchmark will be run repeatedly, we have to leave the mempool
+    // in the same state at the end of the function, so we benchmark both
+    // mining a block and reorging the block's contents back into the mempool.
+    bench.run([&]() NO_THREAD_SAFETY_ANALYSIS {
+        pool.removeForBlock(tx_remove_for_block, /*nBlockHeight*/100);
+        for (auto& tx: tx_remove_for_block) {
+            AddTx(tx, pool);
+        }
+        pool.UpdateTransactionsFromBlock(hashes_remove_for_block);
     });
 }
 

From dec138d1ddc79cc3a06e53ed255f0931ce46e684 Mon Sep 17 00:00:00 2001
From: Suhas Daftuar <sdaftuar@chaincode.com>
Date: Sun, 28 Apr 2024 07:34:48 -0400
Subject: [PATCH 17/65] fuzz: remove comparison between mini_miner block
 construction and miner

After cluster mempool, the mini_miner will no longer match the miner's block
construction. Eventually mini_miner should be reworked to directly use
linearizations done in the mempool.
---
 src/test/fuzz/mini_miner.cpp | 91 ------------------------------------
 1 file changed, 91 deletions(-)

diff --git a/src/test/fuzz/mini_miner.cpp b/src/test/fuzz/mini_miner.cpp
index a0c16c51f15..226c47d827e 100644
--- a/src/test/fuzz/mini_miner.cpp
+++ b/src/test/fuzz/mini_miner.cpp
@@ -116,95 +116,4 @@ FUZZ_TARGET(mini_miner, .init = initialize_miner)
     // Overlapping ancestry across multiple outpoints can only reduce the total bump fee.
     assert (sum_fees >= *total_bumpfee);
 }
-
-// Test that MiniMiner and BlockAssembler build the same block given the same transactions and constraints.
-FUZZ_TARGET(mini_miner_selection, .init = initialize_miner)
-{
-    SeedRandomStateForTest(SeedRand::ZEROS);
-    FuzzedDataProvider fuzzed_data_provider{buffer.data(), buffer.size()};
-    SetMockTime(ConsumeTime(fuzzed_data_provider));
-    bilingual_str error;
-    CTxMemPool pool{CTxMemPool::Options{}, error};
-    Assert(error.empty());
-    // Make a copy to preserve determinism.
-    std::deque<COutPoint> available_coins = g_available_coins;
-    std::vector<CTransactionRef> transactions;
-
-    LOCK2(::cs_main, pool.cs);
-    LIMITED_WHILE(fuzzed_data_provider.ConsumeBool(), 100)
-    {
-        CMutableTransaction mtx = CMutableTransaction();
-        assert(!available_coins.empty());
-        const size_t num_inputs = std::min(size_t{2}, available_coins.size());
-        const size_t num_outputs = fuzzed_data_provider.ConsumeIntegralInRange<size_t>(2, 5);
-        for (size_t n{0}; n < num_inputs; ++n) {
-            auto prevout = available_coins.at(0);
-            mtx.vin.emplace_back(prevout, CScript());
-            available_coins.pop_front();
-        }
-        for (uint32_t n{0}; n < num_outputs; ++n) {
-            mtx.vout.emplace_back(100, P2WSH_OP_TRUE);
-        }
-        CTransactionRef tx = MakeTransactionRef(mtx);
-
-        // First 2 outputs are available to spend. The rest are added to outpoints to calculate bumpfees.
-        // There is no overlap between spendable coins and outpoints passed to MiniMiner because the
-        // MiniMiner interprets spent coins as to-be-replaced and excludes them.
-        for (uint32_t n{0}; n < num_outputs - 1; ++n) {
-            if (fuzzed_data_provider.ConsumeBool()) {
-                available_coins.emplace_front(tx->GetHash(), n);
-            } else {
-                available_coins.emplace_back(tx->GetHash(), n);
-            }
-        }
-
-        const auto block_adjusted_max_weight = MAX_BLOCK_WEIGHT - DEFAULT_BLOCK_RESERVED_WEIGHT;
-        // Stop if pool reaches block_adjusted_max_weight because BlockAssembler will stop when the
-        // block template reaches that, but the MiniMiner will keep going.
-        if (pool.GetTotalTxSize() + GetVirtualTransactionSize(*tx) >= block_adjusted_max_weight) break;
-        TestMemPoolEntryHelper entry;
-        const CAmount fee{ConsumeMoney(fuzzed_data_provider, /*max=*/MAX_MONEY/100000)};
-        assert(MoneyRange(fee));
-        AddToMempool(pool, entry.Fee(fee).FromTx(tx));
-        transactions.push_back(tx);
-    }
-    std::vector<COutPoint> outpoints;
-    for (const auto& coin : g_available_coins) {
-        if (!pool.GetConflictTx(coin)) outpoints.push_back(coin);
-    }
-    for (const auto& tx : transactions) {
-        assert(pool.exists(tx->GetHash()));
-        for (uint32_t n{0}; n < tx->vout.size(); ++n) {
-            COutPoint coin{tx->GetHash(), n};
-            if (!pool.GetConflictTx(coin)) outpoints.push_back(coin);
-        }
-    }
-    const CFeeRate target_feerate{ConsumeMoney(fuzzed_data_provider, /*max=*/MAX_MONEY/100000)};
-
-    node::BlockAssembler::Options miner_options;
-    miner_options.blockMinFeeRate = target_feerate;
-    miner_options.nBlockMaxWeight = MAX_BLOCK_WEIGHT;
-    miner_options.test_block_validity = false;
-    miner_options.coinbase_output_script = CScript() << OP_0;
-
-    node::BlockAssembler miner{g_setup->m_node.chainman->ActiveChainstate(), &pool, miner_options};
-    node::MiniMiner mini_miner{pool, outpoints};
-    assert(mini_miner.IsReadyToCalculate());
-
-    // Use BlockAssembler as oracle. BlockAssembler and MiniMiner should select the same
-    // transactions, stopping once packages do not meet target_feerate.
-    const auto blocktemplate{miner.CreateNewBlock()};
-    mini_miner.BuildMockTemplate(target_feerate);
-    assert(!mini_miner.IsReadyToCalculate());
-    auto mock_template_txids = mini_miner.GetMockTemplateTxids();
-    // MiniMiner doesn't add a coinbase tx.
-    assert(mock_template_txids.count(blocktemplate->block.vtx[0]->GetHash()) == 0);
-    auto [iter, new_entry] = mock_template_txids.emplace(blocktemplate->block.vtx[0]->GetHash());
-    assert(new_entry);
-
-    assert(mock_template_txids.size() == blocktemplate->block.vtx.size());
-    for (const auto& tx : blocktemplate->block.vtx) {
-        assert(mock_template_txids.count(tx->GetHash()));
-    }
-}
 } // namespace

From 47ab32fdb158069d4422e0f92078603c6df070a6 Mon Sep 17 00:00:00 2001
From: Suhas Daftuar <sdaftuar@chaincode.com>
Date: Wed, 20 Sep 2023 21:16:36 -0400
Subject: [PATCH 18/65] Select transactions for blocks based on chunk feerate

Co-Authored-By: Gregory Sanders <gsanders87@gmail.com>
---
 src/node/miner.cpp | 251 +++++++++------------------------------------
 src/node/miner.h   | 115 ++-------------------
 src/txmempool.h    |  19 ++++
 3 files changed, 76 insertions(+), 309 deletions(-)

diff --git a/src/node/miner.cpp b/src/node/miner.cpp
index e75bc3a603b..fce0afb140e 100644
--- a/src/node/miner.cpp
+++ b/src/node/miner.cpp
@@ -106,8 +106,6 @@ void ApplyArgsManOptions(const ArgsManager& args, BlockAssembler::Options& optio
 
 void BlockAssembler::resetBlock()
 {
-    inBlock.clear();
-
     // Reserve space for fixed-size block header, txs count, and coinbase tx.
     nBlockWeight = m_options.block_reserved_weight;
     nBlockSigOpsCost = m_options.coinbase_output_max_additional_sigops;
@@ -145,10 +143,11 @@ std::unique_ptr<CBlockTemplate> BlockAssembler::CreateNewBlock()
     pblock->nTime = TicksSinceEpoch<std::chrono::seconds>(NodeClock::now());
     m_lock_time_cutoff = pindexPrev->GetMedianTimePast();
 
-    int nPackagesSelected = 0;
-    int nDescendantsUpdated = 0;
     if (m_mempool) {
-        addPackageTxs(nPackagesSelected, nDescendantsUpdated);
+        LOCK(m_mempool->cs);
+        m_mempool->StartBlockBuilding();
+        addChunks();
+        m_mempool->StopBlockBuilding();
     }
 
     const auto time_1{SteadyClock::now()};
@@ -185,30 +184,17 @@ std::unique_ptr<CBlockTemplate> BlockAssembler::CreateNewBlock()
     }
     const auto time_2{SteadyClock::now()};
 
-    LogDebug(BCLog::BENCH, "CreateNewBlock() packages: %.2fms (%d packages, %d updated descendants), validity: %.2fms (total %.2fms)\n",
-             Ticks<MillisecondsDouble>(time_1 - time_start), nPackagesSelected, nDescendantsUpdated,
+    LogDebug(BCLog::BENCH, "CreateNewBlock() chunks: %.2fms, validity: %.2fms (total %.2fms)\n",
+             Ticks<MillisecondsDouble>(time_1 - time_start),
              Ticks<MillisecondsDouble>(time_2 - time_1),
              Ticks<MillisecondsDouble>(time_2 - time_start));
 
     return std::move(pblocktemplate);
 }
 
-void BlockAssembler::onlyUnconfirmed(CTxMemPool::setEntries& testSet)
+bool BlockAssembler::TestPackage(FeePerWeight package_feerate, int64_t packageSigOpsCost) const
 {
-    for (CTxMemPool::setEntries::iterator iit = testSet.begin(); iit != testSet.end(); ) {
-        // Only test txs not already in the block
-        if (inBlock.count((*iit)->GetSharedTx()->GetHash())) {
-            testSet.erase(iit++);
-        } else {
-            iit++;
-        }
-    }
-}
-
-bool BlockAssembler::TestPackage(uint64_t packageSize, int64_t packageSigOpsCost) const
-{
-    // TODO: switch to weight-based accounting for packages instead of vsize-based accounting.
-    if (nBlockWeight + WITNESS_SCALE_FACTOR * packageSize >= m_options.nBlockMaxWeight) {
+    if (nBlockWeight + package_feerate.size >= m_options.nBlockMaxWeight) {
         return false;
     }
     if (nBlockSigOpsCost + packageSigOpsCost >= MAX_BLOCK_SIGOPS_COST) {
@@ -219,99 +205,35 @@ bool BlockAssembler::TestPackage(uint64_t packageSize, int64_t packageSigOpsCost
 
 // Perform transaction-level checks before adding to block:
 // - transaction finality (locktime)
-bool BlockAssembler::TestPackageTransactions(const CTxMemPool::setEntries& package) const
+bool BlockAssembler::TestPackageTransactions(const std::vector<CTxMemPoolEntryRef>& txs) const
 {
-    for (CTxMemPool::txiter it : package) {
-        if (!IsFinalTx(it->GetTx(), nHeight, m_lock_time_cutoff)) {
+    for (const auto tx : txs) {
+        if (!IsFinalTx(tx.get().GetTx(), nHeight, m_lock_time_cutoff)) {
             return false;
         }
     }
     return true;
 }
 
-void BlockAssembler::AddToBlock(CTxMemPool::txiter iter)
+void BlockAssembler::AddToBlock(const CTxMemPoolEntry& entry)
 {
-    pblocktemplate->block.vtx.emplace_back(iter->GetSharedTx());
-    pblocktemplate->vTxFees.push_back(iter->GetFee());
-    pblocktemplate->vTxSigOpsCost.push_back(iter->GetSigOpCost());
-    nBlockWeight += iter->GetTxWeight();
+    pblocktemplate->block.vtx.emplace_back(entry.GetSharedTx());
+    pblocktemplate->vTxFees.push_back(entry.GetFee());
+    pblocktemplate->vTxSigOpsCost.push_back(entry.GetSigOpCost());
+    nBlockWeight += entry.GetTxWeight();
     ++nBlockTx;
-    nBlockSigOpsCost += iter->GetSigOpCost();
-    nFees += iter->GetFee();
-    inBlock.insert(iter->GetSharedTx()->GetHash());
+    nBlockSigOpsCost += entry.GetSigOpCost();
+    nFees += entry.GetFee();
 
     if (m_options.print_modified_fee) {
         LogPrintf("fee rate %s txid %s\n",
-                  CFeeRate(iter->GetModifiedFee(), iter->GetTxSize()).ToString(),
-                  iter->GetTx().GetHash().ToString());
+                  CFeeRate(entry.GetModifiedFee(), entry.GetTxSize()).ToString(),
+                  entry.GetTx().GetHash().ToString());
     }
 }
 
-/** Add descendants of given transactions to mapModifiedTx with ancestor
- * state updated assuming given transactions are inBlock. Returns number
- * of updated descendants. */
-static int UpdatePackagesForAdded(const CTxMemPool& mempool,
-                                  const CTxMemPool::setEntries& alreadyAdded,
-                                  indexed_modified_transaction_set& mapModifiedTx) EXCLUSIVE_LOCKS_REQUIRED(mempool.cs)
+void BlockAssembler::addChunks()
 {
-    AssertLockHeld(mempool.cs);
-
-    int nDescendantsUpdated = 0;
-    for (CTxMemPool::txiter it : alreadyAdded) {
-        CTxMemPool::setEntries descendants;
-        mempool.CalculateDescendants(it, descendants);
-        // Insert all descendants (not yet in block) into the modified set
-        for (CTxMemPool::txiter desc : descendants) {
-            if (alreadyAdded.count(desc)) {
-                continue;
-            }
-            ++nDescendantsUpdated;
-            modtxiter mit = mapModifiedTx.find(desc);
-            if (mit == mapModifiedTx.end()) {
-                CTxMemPoolModifiedEntry modEntry(desc);
-                mit = mapModifiedTx.insert(modEntry).first;
-            }
-            mapModifiedTx.modify(mit, update_for_parent_inclusion(it));
-        }
-    }
-    return nDescendantsUpdated;
-}
-
-void BlockAssembler::SortForBlock(const CTxMemPool::setEntries& package, std::vector<CTxMemPool::txiter>& sortedEntries)
-{
-    // Sort package by ancestor count
-    // If a transaction A depends on transaction B, then A's ancestor count
-    // must be greater than B's.  So this is sufficient to validly order the
-    // transactions for block inclusion.
-    sortedEntries.clear();
-    sortedEntries.insert(sortedEntries.begin(), package.begin(), package.end());
-    std::sort(sortedEntries.begin(), sortedEntries.end(), CompareTxIterByAncestorCount());
-}
-
-// This transaction selection algorithm orders the mempool based
-// on feerate of a transaction including all unconfirmed ancestors.
-// Since we don't remove transactions from the mempool as we select them
-// for block inclusion, we need an alternate method of updating the feerate
-// of a transaction with its not-yet-selected ancestors as we go.
-// This is accomplished by walking the in-mempool descendants of selected
-// transactions and storing a temporary modified state in mapModifiedTxs.
-// Each time through the loop, we compare the best transaction in
-// mapModifiedTxs with the next transaction in the mempool to decide what
-// transaction package to work on next.
-void BlockAssembler::addPackageTxs(int& nPackagesSelected, int& nDescendantsUpdated)
-{
-    const auto& mempool{*Assert(m_mempool)};
-    LOCK(mempool.cs);
-
-    // mapModifiedTx will store sorted packages after they are modified
-    // because some of their txs are already in the block
-    indexed_modified_transaction_set mapModifiedTx;
-    // Keep track of entries that failed inclusion, to avoid duplicate work
-    std::set<Txid> failedTx;
-
-    CTxMemPool::indexed_transaction_set::index<ancestor_score>::type::iterator mi = mempool.mapTx.get<ancestor_score>().begin();
-    CTxMemPool::txiter iter;
-
     // Limit the number of attempts to add transactions to the block when it is
     // close to full; this is just a simple heuristic to finish quickly if the
     // mempool has a lot of entries.
@@ -319,124 +241,51 @@ void BlockAssembler::addPackageTxs(int& nPackagesSelected, int& nDescendantsUpda
     constexpr int32_t BLOCK_FULL_ENOUGH_WEIGHT_DELTA = 4000;
     int64_t nConsecutiveFailed = 0;
 
-    while (mi != mempool.mapTx.get<ancestor_score>().end() || !mapModifiedTx.empty()) {
-        // First try to find a new transaction in mapTx to evaluate.
-        //
-        // Skip entries in mapTx that are already in a block or are present
-        // in mapModifiedTx (which implies that the mapTx ancestor state is
-        // stale due to ancestor inclusion in the block)
-        // Also skip transactions that we've already failed to add. This can happen if
-        // we consider a transaction in mapModifiedTx and it fails: we can then
-        // potentially consider it again while walking mapTx.  It's currently
-        // guaranteed to fail again, but as a belt-and-suspenders check we put it in
-        // failedTx and avoid re-evaluation, since the re-evaluation would be using
-        // cached size/sigops/fee values that are not actually correct.
-        /** Return true if given transaction from mapTx has already been evaluated,
-         * or if the transaction's cached data in mapTx is incorrect. */
-        if (mi != mempool.mapTx.get<ancestor_score>().end()) {
-            auto it = mempool.mapTx.project<0>(mi);
-            assert(it != mempool.mapTx.end());
-            if (mapModifiedTx.count(it) || inBlock.count(it->GetSharedTx()->GetHash()) || failedTx.count(it->GetSharedTx()->GetHash())) {
-                ++mi;
-                continue;
-            }
-        }
+    std::vector<CTxMemPoolEntry::CTxMemPoolEntryRef> selected_transactions;
+    selected_transactions.reserve(MAX_CLUSTER_COUNT_LIMIT);
+    FeePerWeight chunk_feerate;
 
-        // Now that mi is not stale, determine which transaction to evaluate:
-        // the next entry from mapTx, or the best from mapModifiedTx?
-        bool fUsingModified = false;
+    // This fills selected_transactions
+    chunk_feerate = m_mempool->GetBlockBuilderChunk(selected_transactions);
+    FeePerVSize chunk_feerate_vsize = ToFeePerVSize(chunk_feerate);
 
-        modtxscoreiter modit = mapModifiedTx.get<ancestor_score>().begin();
-        if (mi == mempool.mapTx.get<ancestor_score>().end()) {
-            // We're out of entries in mapTx; use the entry from mapModifiedTx
-            iter = modit->iter;
-            fUsingModified = true;
-        } else {
-            // Try to compare the mapTx entry to the mapModifiedTx entry
-            iter = mempool.mapTx.project<0>(mi);
-            if (modit != mapModifiedTx.get<ancestor_score>().end() &&
-                    CompareTxMemPoolEntryByAncestorFee()(*modit, CTxMemPoolModifiedEntry(iter))) {
-                // The best entry in mapModifiedTx has higher score
-                // than the one from mapTx.
-                // Switch which transaction (package) to consider
-                iter = modit->iter;
-                fUsingModified = true;
-            } else {
-                // Either no entry in mapModifiedTx, or it's worse than mapTx.
-                // Increment mi for the next loop iteration.
-                ++mi;
-            }
-        }
-
-        // We skip mapTx entries that are inBlock, and mapModifiedTx shouldn't
-        // contain anything that is inBlock.
-        assert(!inBlock.count(iter->GetSharedTx()->GetHash()));
-
-        uint64_t packageSize = iter->GetSizeWithAncestors();
-        CAmount packageFees = iter->GetModFeesWithAncestors();
-        int64_t packageSigOpsCost = iter->GetSigOpCostWithAncestors();
-        if (fUsingModified) {
-            packageSize = modit->nSizeWithAncestors;
-            packageFees = modit->nModFeesWithAncestors;
-            packageSigOpsCost = modit->nSigOpCostWithAncestors;
-        }
-
-        if (packageFees < m_options.blockMinFeeRate.GetFee(packageSize)) {
-            // Everything else we might consider has a lower fee rate
+    while (selected_transactions.size() > 0) {
+        // Check to see if min fee rate is still respected.
+        if (chunk_feerate.fee < m_options.blockMinFeeRate.GetFee(chunk_feerate_vsize.size)) {
+            // Everything else we might consider has a lower feerate
             return;
         }
 
-        if (!TestPackage(packageSize, packageSigOpsCost)) {
-            if (fUsingModified) {
-                // Since we always look at the best entry in mapModifiedTx,
-                // we must erase failed entries so that we can consider the
-                // next best entry on the next loop iteration
-                mapModifiedTx.get<ancestor_score>().erase(modit);
-                failedTx.insert(iter->GetSharedTx()->GetHash());
-            }
+        int64_t package_sig_ops = 0;
+        for (const auto& tx : selected_transactions) {
+            package_sig_ops += tx.get().GetSigOpCost();
+        }
 
+        // Check to see if this chunk will fit.
+        if (!TestPackage(chunk_feerate, package_sig_ops) || !TestPackageTransactions(selected_transactions)) {
+            // This chunk won't fit, so we skip it and will try the next best one.
+            m_mempool->SkipBuilderChunk();
             ++nConsecutiveFailed;
 
             if (nConsecutiveFailed > MAX_CONSECUTIVE_FAILURES && nBlockWeight +
                     BLOCK_FULL_ENOUGH_WEIGHT_DELTA > m_options.nBlockMaxWeight) {
                 // Give up if we're close to full and haven't succeeded in a while
-                break;
+                return;
             }
-            continue;
-        }
+        } else {
+            m_mempool->IncludeBuilderChunk();
 
-        auto ancestors{mempool.AssumeCalculateMemPoolAncestors(__func__, *iter, CTxMemPool::Limits::NoLimits(), /*fSearchForParents=*/false)};
-
-        onlyUnconfirmed(ancestors);
-        ancestors.insert(iter);
-
-        // Test if all tx's are Final
-        if (!TestPackageTransactions(ancestors)) {
-            if (fUsingModified) {
-                mapModifiedTx.get<ancestor_score>().erase(modit);
-                failedTx.insert(iter->GetSharedTx()->GetHash());
+            // This chunk will fit, so add it to the block.
+            nConsecutiveFailed = 0;
+            for (const auto& tx : selected_transactions) {
+                AddToBlock(tx);
             }
-            continue;
+            pblocktemplate->m_package_feerates.emplace_back(chunk_feerate_vsize);
         }
 
-        // This transaction will make it in; reset the failed counter.
-        nConsecutiveFailed = 0;
-
-        // Package can be added. Sort the entries in a valid order.
-        std::vector<CTxMemPool::txiter> sortedEntries;
-        SortForBlock(ancestors, sortedEntries);
-
-        for (size_t i = 0; i < sortedEntries.size(); ++i) {
-            AddToBlock(sortedEntries[i]);
-            // Erase from the modified set, if present
-            mapModifiedTx.erase(sortedEntries[i]);
-        }
-
-        ++nPackagesSelected;
-        pblocktemplate->m_package_feerates.emplace_back(packageFees, static_cast<int32_t>(packageSize));
-
-        // Update transactions that depend on each of these
-        nDescendantsUpdated += UpdatePackagesForAdded(mempool, ancestors, mapModifiedTx);
+        selected_transactions.clear();
+        chunk_feerate = m_mempool->GetBlockBuilderChunk(selected_transactions);
+        chunk_feerate_vsize = ToFeePerVSize(chunk_feerate);
     }
 }
 
diff --git a/src/node/miner.h b/src/node/miner.h
index a9a88b39cf2..83e7c6b751f 100644
--- a/src/node/miner.h
+++ b/src/node/miner.h
@@ -49,101 +49,7 @@ struct CBlockTemplate
     std::vector<unsigned char> vchCoinbaseCommitment;
     /* A vector of package fee rates, ordered by the sequence in which
      * packages are selected for inclusion in the block template.*/
-    std::vector<FeeFrac> m_package_feerates;
-};
-
-// Container for tracking updates to ancestor feerate as we include (parent)
-// transactions in a block
-struct CTxMemPoolModifiedEntry {
-    explicit CTxMemPoolModifiedEntry(CTxMemPool::txiter entry)
-    {
-        iter = entry;
-        nSizeWithAncestors = entry->GetSizeWithAncestors();
-        nModFeesWithAncestors = entry->GetModFeesWithAncestors();
-        nSigOpCostWithAncestors = entry->GetSigOpCostWithAncestors();
-    }
-
-    CAmount GetModifiedFee() const { return iter->GetModifiedFee(); }
-    uint64_t GetSizeWithAncestors() const { return nSizeWithAncestors; }
-    CAmount GetModFeesWithAncestors() const { return nModFeesWithAncestors; }
-    size_t GetTxSize() const { return iter->GetTxSize(); }
-    const CTransaction& GetTx() const { return iter->GetTx(); }
-
-    CTxMemPool::txiter iter;
-    uint64_t nSizeWithAncestors;
-    CAmount nModFeesWithAncestors;
-    int64_t nSigOpCostWithAncestors;
-};
-
-/** Comparator for CTxMemPool::txiter objects.
- *  It simply compares the internal memory address of the CTxMemPoolEntry object
- *  pointed to. This means it has no meaning, and is only useful for using them
- *  as key in other indexes.
- */
-struct CompareCTxMemPoolIter {
-    bool operator()(const CTxMemPool::txiter& a, const CTxMemPool::txiter& b) const
-    {
-        return &(*a) < &(*b);
-    }
-};
-
-struct modifiedentry_iter {
-    typedef CTxMemPool::txiter result_type;
-    result_type operator() (const CTxMemPoolModifiedEntry &entry) const
-    {
-        return entry.iter;
-    }
-};
-
-// A comparator that sorts transactions based on number of ancestors.
-// This is sufficient to sort an ancestor package in an order that is valid
-// to appear in a block.
-struct CompareTxIterByAncestorCount {
-    bool operator()(const CTxMemPool::txiter& a, const CTxMemPool::txiter& b) const
-    {
-        if (a->GetCountWithAncestors() != b->GetCountWithAncestors()) {
-            return a->GetCountWithAncestors() < b->GetCountWithAncestors();
-        }
-        return CompareIteratorByHash()(a, b);
-    }
-};
-
-
-struct CTxMemPoolModifiedEntry_Indices final : boost::multi_index::indexed_by<
-    boost::multi_index::ordered_unique<
-        modifiedentry_iter,
-        CompareCTxMemPoolIter
-    >,
-    // sorted by modified ancestor fee rate
-    boost::multi_index::ordered_non_unique<
-        // Reuse same tag from CTxMemPool's similar index
-        boost::multi_index::tag<ancestor_score>,
-        boost::multi_index::identity<CTxMemPoolModifiedEntry>,
-        CompareTxMemPoolEntryByAncestorFee
-    >
->
-{};
-
-typedef boost::multi_index_container<
-    CTxMemPoolModifiedEntry,
-    CTxMemPoolModifiedEntry_Indices
-> indexed_modified_transaction_set;
-
-typedef indexed_modified_transaction_set::nth_index<0>::type::iterator modtxiter;
-typedef indexed_modified_transaction_set::index<ancestor_score>::type::iterator modtxscoreiter;
-
-struct update_for_parent_inclusion
-{
-    explicit update_for_parent_inclusion(CTxMemPool::txiter it) : iter(it) {}
-
-    void operator() (CTxMemPoolModifiedEntry &e)
-    {
-        e.nModFeesWithAncestors -= iter->GetModifiedFee();
-        e.nSizeWithAncestors -= iter->GetTxSize();
-        e.nSigOpCostWithAncestors -= iter->GetSigOpCost();
-    }
-
-    CTxMemPool::txiter iter;
+    std::vector<FeePerVSize> m_package_feerates;
 };
 
 /** Generate a new block, without valid proof-of-work */
@@ -158,7 +64,6 @@ private:
     uint64_t nBlockTx;
     uint64_t nBlockSigOpsCost;
     CAmount nFees;
-    std::unordered_set<Txid, SaltedTxidHasher> inBlock;
 
     // Chain context for the block
     int nHeight;
@@ -195,29 +100,23 @@ private:
     /** Clear the block's state and prepare for assembling a new block */
     void resetBlock();
     /** Add a tx to the block */
-    void AddToBlock(CTxMemPool::txiter iter);
+    void AddToBlock(const CTxMemPoolEntry& entry);
 
     // Methods for how to add transactions to a block.
-    /** Add transactions based on feerate including unconfirmed ancestors
-      * Increments nPackagesSelected / nDescendantsUpdated with corresponding
-      * statistics from the package selection (for logging statistics).
+    /** Add transactions based on chunk feerate
       *
       * @pre BlockAssembler::m_mempool must not be nullptr
     */
-    void addPackageTxs(int& nPackagesSelected, int& nDescendantsUpdated) EXCLUSIVE_LOCKS_REQUIRED(!m_mempool->cs);
+    void addChunks() EXCLUSIVE_LOCKS_REQUIRED(m_mempool->cs);
 
-    // helper functions for addPackageTxs()
-    /** Remove confirmed (inBlock) entries from given set */
-    void onlyUnconfirmed(CTxMemPool::setEntries& testSet);
+    // helper functions for addChunks()
     /** Test if a new package would "fit" in the block */
-    bool TestPackage(uint64_t packageSize, int64_t packageSigOpsCost) const;
+    bool TestPackage(FeePerWeight package_feerate, int64_t packageSigOpsCost) const;
     /** Perform checks on each transaction in a package:
       * locktime, premature-witness, serialized size (if necessary)
       * These checks should always succeed, and they're here
       * only as an extra check in case of suboptimal node configuration */
-    bool TestPackageTransactions(const CTxMemPool::setEntries& package) const;
-    /** Sort the package in an order that is valid to appear in a block */
-    void SortForBlock(const CTxMemPool::setEntries& package, std::vector<CTxMemPool::txiter>& sortedEntries);
+    bool TestPackageTransactions(const std::vector<CTxMemPoolEntryRef>& txs) const;
 };
 
 /**
diff --git a/src/txmempool.h b/src/txmempool.h
index 2b5882c8a4b..04f2fdd4f5a 100644
--- a/src/txmempool.h
+++ b/src/txmempool.h
@@ -372,6 +372,7 @@ public:
      */
     mutable RecursiveMutex cs;
     std::unique_ptr<TxGraph> m_txgraph GUARDED_BY(cs);
+    mutable std::unique_ptr<TxGraph::BlockBuilder> m_builder GUARDED_BY(cs);
     indexed_transaction_set mapTx GUARDED_BY(cs);
 
     using txiter = indexed_transaction_set::nth_index<0>::type::const_iterator;
@@ -922,6 +923,24 @@ private:
     // callbacks).
     void addNewTransaction(CTxMemPool::txiter it) EXCLUSIVE_LOCKS_REQUIRED(cs);
     void addNewTransaction(CTxMemPool::txiter it, CTxMemPool::setEntries& setAncestors) EXCLUSIVE_LOCKS_REQUIRED(cs);
+public:
+    void StartBlockBuilding() const EXCLUSIVE_LOCKS_REQUIRED(cs) { assert(!m_builder); m_builder = m_txgraph->GetBlockBuilder(); }
+    FeePerWeight GetBlockBuilderChunk(std::vector<CTxMemPoolEntry::CTxMemPoolEntryRef>& entries) const EXCLUSIVE_LOCKS_REQUIRED(cs)
+    {
+        if (!m_builder) { return {}; }
+
+        auto res = m_builder->GetCurrentChunk();
+        if (!res) { return {}; }
+
+        auto [chunk_entries, chunk_feerate] = *res;
+        for (TxGraph::Ref* ref : chunk_entries) {
+            entries.emplace_back(static_cast<const CTxMemPoolEntry&>(*ref));
+        }
+        return chunk_feerate;
+    }
+    void IncludeBuilderChunk() const EXCLUSIVE_LOCKS_REQUIRED(cs) { m_builder->Include(); }
+    void SkipBuilderChunk() const EXCLUSIVE_LOCKS_REQUIRED(cs) { m_builder->Skip(); }
+    void StopBlockBuilding() const EXCLUSIVE_LOCKS_REQUIRED(cs) { m_builder.reset(); }
 };
 
 /**

From c3f1afc934e69a9849625924f72a5886a85eb833 Mon Sep 17 00:00:00 2001
From: Suhas Daftuar <sdaftuar@chaincode.com>
Date: Thu, 9 Oct 2025 10:43:11 -0400
Subject: [PATCH 19/65] test: rewrite PopulateMempool to not violate mempool
 policy (cluster size) limits

---
 src/test/util/setup_common.cpp | 47 ++++++++++++++++++++++------------
 1 file changed, 31 insertions(+), 16 deletions(-)

diff --git a/src/test/util/setup_common.cpp b/src/test/util/setup_common.cpp
index dec985b2c45..775a958b845 100644
--- a/src/test/util/setup_common.cpp
+++ b/src/test/util/setup_common.cpp
@@ -535,22 +535,24 @@ CMutableTransaction TestChain100Setup::CreateValidMempoolTransaction(CTransactio
 std::vector<CTransactionRef> TestChain100Setup::PopulateMempool(FastRandomContext& det_rand, size_t num_transactions, bool submit)
 {
     std::vector<CTransactionRef> mempool_transactions;
-    std::deque<std::pair<COutPoint, CAmount>> unspent_prevouts;
+    std::deque<std::pair<COutPoint, CAmount>> unspent_prevouts, undo_info;
     std::transform(m_coinbase_txns.begin(), m_coinbase_txns.end(), std::back_inserter(unspent_prevouts),
         [](const auto& tx){ return std::make_pair(COutPoint(tx->GetHash(), 0), tx->vout[0].nValue); });
     while (num_transactions > 0 && !unspent_prevouts.empty()) {
-        // The number of inputs and outputs are random, between 1 and 24.
+        // The number of inputs and outputs are randomly chosen, between 1-5
+        // and 1-25 respectively.
         CMutableTransaction mtx = CMutableTransaction();
-        const size_t num_inputs = det_rand.randrange(24) + 1;
+        const size_t num_inputs = det_rand.randrange(5) + 1;
         CAmount total_in{0};
         for (size_t n{0}; n < num_inputs; ++n) {
             if (unspent_prevouts.empty()) break;
             const auto& [prevout, amount] = unspent_prevouts.front();
+            undo_info.emplace_back(prevout, amount);
             mtx.vin.emplace_back(prevout, CScript());
             total_in += amount;
             unspent_prevouts.pop_front();
         }
-        const size_t num_outputs = det_rand.randrange(24) + 1;
+        const size_t num_outputs = det_rand.randrange(25) + 1;
         const CAmount fee = 100 * det_rand.randrange(30);
         const CAmount amount_per_output = (total_in - fee) / num_outputs;
         for (size_t n{0}; n < num_outputs; ++n) {
@@ -558,16 +560,7 @@ std::vector<CTransactionRef> TestChain100Setup::PopulateMempool(FastRandomContex
             mtx.vout.emplace_back(amount_per_output, spk);
         }
         CTransactionRef ptx = MakeTransactionRef(mtx);
-        mempool_transactions.push_back(ptx);
-        if (amount_per_output > 3000) {
-            // If the value is high enough to fund another transaction + fees, keep track of it so
-            // it can be used to build a more complex transaction graph. Insert randomly into
-            // unspent_prevouts for extra randomness in the resulting structures.
-            for (size_t n{0}; n < num_outputs; ++n) {
-                unspent_prevouts.emplace_back(COutPoint(ptx->GetHash(), n), amount_per_output);
-                std::swap(unspent_prevouts.back(), unspent_prevouts[det_rand.randrange(unspent_prevouts.size())]);
-            }
-        }
+        bool success{true};
         if (submit) {
             LOCK2(cs_main, m_node.mempool->cs);
             LockPoints lp;
@@ -575,9 +568,31 @@ std::vector<CTransactionRef> TestChain100Setup::PopulateMempool(FastRandomContex
             changeset->StageAddition(ptx, /*fee=*/(total_in - num_outputs * amount_per_output),
                     /*time=*/0, /*entry_height=*/1, /*entry_sequence=*/0,
                     /*spends_coinbase=*/false, /*sigops_cost=*/4, lp);
-            changeset->Apply();
+            if (changeset->CheckMemPoolPolicyLimits()) {
+                changeset->Apply();
+                --num_transactions;
+            } else {
+                success = false;
+                // Add the inputs back to unspent prevouts
+                for (const auto& [prevout, amount] : undo_info) {
+                    unspent_prevouts.emplace_back(prevout, amount);
+                    std::swap(unspent_prevouts.back(), unspent_prevouts[det_rand.randrange(unspent_prevouts.size())]);
+                }
+            }
         }
-        --num_transactions;
+        if (success) {
+            mempool_transactions.push_back(ptx);
+            if (amount_per_output > 3000) {
+                // If the value is high enough to fund another transaction + fees, keep track of it so
+                // it can be used to build a more complex transaction graph. Insert randomly into
+                // unspent_prevouts for extra randomness in the resulting structures.
+                for (size_t n{0}; n < num_outputs; ++n) {
+                    unspent_prevouts.emplace_back(COutPoint(ptx->GetHash(), n), amount_per_output);
+                    std::swap(unspent_prevouts.back(), unspent_prevouts[det_rand.randrange(unspent_prevouts.size())]);
+                }
+            }
+        }
+        undo_info.clear();
     }
     return mempool_transactions;
 }

From ff8f115dec6eb41f739e6e6738dd60becfa168fd Mon Sep 17 00:00:00 2001
From: Suhas Daftuar <sdaftuar@chaincode.com>
Date: Tue, 3 Oct 2023 10:54:30 -0400
Subject: [PATCH 20/65] policy: Remove CPFP carveout rule

The addition of a cluster size limit makes the CPFP carveout rule useless,
because carveout cannot be used to bypass the cluster size limit. Remove this
policy rule and update tests to no longer rely on the behavior.
---
 src/validation.cpp                         | 35 +---------
 test/functional/mempool_package_onemore.py | 80 ----------------------
 test/functional/mempool_packages.py        |  9 ++-
 test/functional/test_runner.py             |  1 -
 4 files changed, 7 insertions(+), 118 deletions(-)
 delete mode 100755 test/functional/mempool_package_onemore.py

diff --git a/src/validation.cpp b/src/validation.cpp
index 596f688bb14..50660ca75b7 100644
--- a/src/validation.cpp
+++ b/src/validation.cpp
@@ -1014,40 +1014,7 @@ bool MemPoolAccept::PreChecks(ATMPArgs& args, Workspace& ws)
     if (auto ancestors{m_subpackage.m_changeset->CalculateMemPoolAncestors(ws.m_tx_handle, maybe_rbf_limits)}) {
         ws.m_ancestors = std::move(*ancestors);
     } else {
-        // If CalculateMemPoolAncestors fails second time, we want the original error string.
-        const auto error_message{util::ErrorString(ancestors).original};
-
-        // Carve-out is not allowed in this context; fail
-        if (!args.m_allow_carveouts) {
-            return state.Invalid(TxValidationResult::TX_MEMPOOL_POLICY, "too-long-mempool-chain", error_message);
-        }
-
-        // Contracting/payment channels CPFP carve-out:
-        // If the new transaction is relatively small (up to 40k weight)
-        // and has at most one ancestor (ie ancestor limit of 2, including
-        // the new transaction), allow it if its parent has exactly the
-        // descendant limit descendants. The transaction also cannot be TRUC,
-        // as its topology restrictions do not allow a second child.
-        //
-        // This allows protocols which rely on distrusting counterparties
-        // being able to broadcast descendants of an unconfirmed transaction
-        // to be secure by simply only having two immediately-spendable
-        // outputs - one for each counterparty. For more info on the uses for
-        // this, see https://lists.linuxfoundation.org/pipermail/bitcoin-dev/2018-November/016518.html
-        CTxMemPool::Limits cpfp_carve_out_limits{
-            .ancestor_count = 2,
-            .ancestor_size_vbytes = maybe_rbf_limits.ancestor_size_vbytes,
-            .descendant_count = maybe_rbf_limits.descendant_count + 1,
-            .descendant_size_vbytes = maybe_rbf_limits.descendant_size_vbytes + EXTRA_DESCENDANT_TX_SIZE_LIMIT,
-        };
-        if (ws.m_vsize > EXTRA_DESCENDANT_TX_SIZE_LIMIT || ws.m_ptx->version == TRUC_VERSION) {
-            return state.Invalid(TxValidationResult::TX_MEMPOOL_POLICY, "too-long-mempool-chain", error_message);
-        }
-        if (auto ancestors_retry{m_subpackage.m_changeset->CalculateMemPoolAncestors(ws.m_tx_handle, cpfp_carve_out_limits)}) {
-            ws.m_ancestors = std::move(*ancestors_retry);
-        } else {
-            return state.Invalid(TxValidationResult::TX_MEMPOOL_POLICY, "too-long-mempool-chain", error_message);
-        }
+        return state.Invalid(TxValidationResult::TX_MEMPOOL_POLICY, "too-long-mempool-chain", util::ErrorString(ancestors).original);
     }
 
     // Even though just checking direct mempool parents for inheritance would be sufficient, we
diff --git a/test/functional/mempool_package_onemore.py b/test/functional/mempool_package_onemore.py
deleted file mode 100755
index 74c5e345202..00000000000
--- a/test/functional/mempool_package_onemore.py
+++ /dev/null
@@ -1,80 +0,0 @@
-#!/usr/bin/env python3
-# Copyright (c) 2014-2022 The Bitcoin Core developers
-# Distributed under the MIT software license, see the accompanying
-# file COPYING or http://www.opensource.org/licenses/mit-license.php.
-"""Test descendant package tracking carve-out allowing one final transaction in
-   an otherwise-full package as long as it has only one parent and is <= 10k in
-   size.
-"""
-
-from test_framework.messages import (
-    DEFAULT_ANCESTOR_LIMIT,
-)
-from test_framework.test_framework import BitcoinTestFramework
-from test_framework.util import (
-    assert_equal,
-    assert_raises_rpc_error,
-)
-from test_framework.wallet import MiniWallet
-
-
-class MempoolPackagesTest(BitcoinTestFramework):
-    def set_test_params(self):
-        self.num_nodes = 1
-
-    def chain_tx(self, utxos_to_spend, *, num_outputs=1):
-        return self.wallet.send_self_transfer_multi(
-            from_node=self.nodes[0],
-            utxos_to_spend=utxos_to_spend,
-            num_outputs=num_outputs)['new_utxos']
-
-    def run_test(self):
-        self.wallet = MiniWallet(self.nodes[0])
-
-        # DEFAULT_ANCESTOR_LIMIT transactions off a confirmed tx should be fine
-        chain = []
-        utxo = self.wallet.get_utxo()
-        for _ in range(4):
-            utxo, utxo2 = self.chain_tx([utxo], num_outputs=2)
-            chain.append(utxo2)
-        for _ in range(DEFAULT_ANCESTOR_LIMIT - 4):
-            utxo, = self.chain_tx([utxo])
-            chain.append(utxo)
-        second_chain, = self.chain_tx([self.wallet.get_utxo(confirmed_only=True)])
-
-        # Check mempool has DEFAULT_ANCESTOR_LIMIT + 1 transactions in it
-        assert_equal(len(self.nodes[0].getrawmempool()), DEFAULT_ANCESTOR_LIMIT + 1)
-
-        # Adding one more transaction on to the chain should fail.
-        assert_raises_rpc_error(-26, "too-long-mempool-chain, too many unconfirmed ancestors [limit: 25]", self.chain_tx, [utxo])
-        # ... or if it chains on from some point in the middle of the chain.
-        assert_raises_rpc_error(-26, "too-long-mempool-chain, too many descendants", self.chain_tx, [chain[2]])
-        assert_raises_rpc_error(-26, "too-long-mempool-chain, too many descendants", self.chain_tx, [chain[1]])
-        # ...even if it chains on to two parent transactions with one in the chain.
-        assert_raises_rpc_error(-26, "too-long-mempool-chain, too many descendants", self.chain_tx, [chain[0], second_chain])
-        # ...especially if its > 40k weight
-        assert_raises_rpc_error(-26, "too-long-mempool-chain, too many descendants", self.chain_tx, [chain[0]], num_outputs=350)
-        # ...even if it's submitted with other transactions
-        replaceable_tx = self.wallet.create_self_transfer_multi(utxos_to_spend=[chain[0]])
-        txns = [replaceable_tx["tx"], self.wallet.create_self_transfer_multi(utxos_to_spend=replaceable_tx["new_utxos"])["tx"]]
-        txns_hex = [tx.serialize().hex() for tx in txns]
-        assert_equal(self.nodes[0].testmempoolaccept(txns_hex)[0]["reject-reason"], "too-long-mempool-chain")
-        pkg_result = self.nodes[0].submitpackage(txns_hex)
-        assert "too-long-mempool-chain" in pkg_result["tx-results"][txns[0].wtxid_hex]["error"]
-        assert_equal(pkg_result["tx-results"][txns[1].wtxid_hex]["error"], "bad-txns-inputs-missingorspent")
-        # But not if it chains directly off the first transaction
-        self.nodes[0].sendrawtransaction(replaceable_tx["hex"])
-        # and the second chain should work just fine
-        self.chain_tx([second_chain])
-
-        # Ensure an individual transaction with single direct conflict can RBF the chain which used our carve-out rule
-        replacement_tx = replaceable_tx["tx"]
-        replacement_tx.vout[0].nValue -= 1000000
-        self.nodes[0].sendrawtransaction(replacement_tx.serialize().hex())
-
-        # Finally, check that we added two transactions
-        assert_equal(len(self.nodes[0].getrawmempool()), DEFAULT_ANCESTOR_LIMIT + 3)
-
-
-if __name__ == '__main__':
-    MempoolPackagesTest(__file__).main()
diff --git a/test/functional/mempool_packages.py b/test/functional/mempool_packages.py
index a844a2a1d8f..b5f994e8030 100755
--- a/test/functional/mempool_packages.py
+++ b/test/functional/mempool_packages.py
@@ -20,7 +20,7 @@ from test_framework.wallet import MiniWallet
 
 # custom limits for node1
 CUSTOM_ANCESTOR_LIMIT = 5
-CUSTOM_DESCENDANT_LIMIT = 10
+CUSTOM_DESCENDANT_LIMIT = 11
 assert CUSTOM_DESCENDANT_LIMIT >= CUSTOM_ANCESTOR_LIMIT
 
 
@@ -240,12 +240,15 @@ class MempoolPackagesTest(BitcoinTestFramework):
         # - parent tx for descendant test
         # - txs chained off parent tx (-> custom descendant limit)
         self.wait_until(lambda: len(self.nodes[1].getrawmempool()) ==
-                                CUSTOM_ANCESTOR_LIMIT + 1 + CUSTOM_DESCENDANT_LIMIT, timeout=10)
+                                CUSTOM_ANCESTOR_LIMIT + CUSTOM_DESCENDANT_LIMIT, timeout=10)
         mempool0 = self.nodes[0].getrawmempool(False)
         mempool1 = self.nodes[1].getrawmempool(False)
         assert set(mempool1).issubset(set(mempool0))
         assert parent_transaction in mempool1
-        for tx in chain[:CUSTOM_DESCENDANT_LIMIT]:
+        # Note: this test is brittle, because it relies on the relay sort order
+        # of node0 to be based on ancestor count (so that the first 10
+        # descendants of parent_transaction relay before the later ones).
+        for tx in chain[:CUSTOM_DESCENDANT_LIMIT-1]:
             assert tx in mempool1
         for tx in chain[CUSTOM_DESCENDANT_LIMIT:]:
             assert tx not in mempool1
diff --git a/test/functional/test_runner.py b/test/functional/test_runner.py
index 5e820e43ab6..97b23921653 100755
--- a/test/functional/test_runner.py
+++ b/test/functional/test_runner.py
@@ -254,7 +254,6 @@ BASE_SCRIPTS = [
     'feature_utxo_set_hash.py',
     'feature_rbf.py',
     'mempool_packages.py',
-    'mempool_package_onemore.py',
     'mempool_package_limits.py',
     'mempool_package_rbf.py',
     'tool_utxo_to_sqlite.py',

From 216e6937290338950215795291dbf0a533e234cf Mon Sep 17 00:00:00 2001
From: Suhas Daftuar <sdaftuar@chaincode.com>
Date: Thu, 21 Sep 2023 13:19:32 -0400
Subject: [PATCH 21/65] Implement new RBF logic for cluster mempool

With a total ordering on mempool transactions, we are now able to calculate a
transaction's mining score at all times. Use this to improve the RBF logic:

- we no longer enforce a "no new unconfirmed parents" rule

- we now require that the mempool's feerate diagram must improve in order
  to accept a replacement

- the topology restrictions for conflicts in the package rbf setting have been
  eliminated

Revert the temporary change to mempool_ephemeral_dust.py that were previously
made due to RBF validation checks being reordered.

Co-authored-by: Gregory Sanders <gsanders87@gmail.com>, glozow <gloriajzhao@gmail.com>
---
 src/policy/rbf.cpp                        |  84 +-----
 src/policy/rbf.h                          |  26 +-
 src/test/fuzz/rbf.cpp                     |   4 +-
 src/test/rbf_tests.cpp                    | 310 ++++++----------------
 src/txmempool.cpp                         | 129 +--------
 src/txmempool.h                           |  15 +-
 src/validation.cpp                        |  44 ++-
 test/functional/feature_rbf.py            | 134 +++-------
 test/functional/mempool_ephemeral_dust.py |   3 +-
 test/functional/mempool_package_rbf.py    | 182 +------------
 test/functional/mempool_truc.py           |   9 +-
 11 files changed, 182 insertions(+), 758 deletions(-)

diff --git a/src/policy/rbf.cpp b/src/policy/rbf.cpp
index 210b94915cc..6852cd52a33 100644
--- a/src/policy/rbf.cpp
+++ b/src/policy/rbf.cpp
@@ -62,59 +62,27 @@ std::optional<std::string> GetEntriesForConflicts(const CTransaction& tx,
                                                   CTxMemPool::setEntries& all_conflicts)
 {
     AssertLockHeld(pool.cs);
-    uint64_t nConflictingCount = 0;
-    for (const auto& mi : iters_conflicting) {
-        nConflictingCount += mi->GetCountWithDescendants();
-        // Rule #5: don't consider replacing more than MAX_REPLACEMENT_CANDIDATES
-        // entries from the mempool. This potentially overestimates the number of actual
-        // descendants (i.e. if multiple conflicts share a descendant, it will be counted multiple
-        // times), but we just want to be conservative to avoid doing too much work.
-        if (nConflictingCount > MAX_REPLACEMENT_CANDIDATES) {
-            return strprintf("rejecting replacement %s; too many potential replacements (%d > %d)",
-                             tx.GetHash().ToString(),
-                             nConflictingCount,
-                             MAX_REPLACEMENT_CANDIDATES);
-        }
+    // Rule #5: don't consider replacements that conflict directly with more
+    // than MAX_REPLACEMENT_CANDIDATES distinct clusters. This implies a bound
+    // on how many mempool clusters might need to be re-sorted in order to
+    // process the replacement (though the actual number of clusters we
+    // relinearize may be greater than this number, due to cluster splitting).
+    auto num_clusters = pool.GetUniqueClusterCount(iters_conflicting);
+    if (num_clusters > MAX_REPLACEMENT_CANDIDATES) {
+        return strprintf("rejecting replacement %s; too many conflicting clusters (%u > %d)",
+                tx.GetHash().ToString(),
+                num_clusters,
+                MAX_REPLACEMENT_CANDIDATES);
     }
     // Calculate the set of all transactions that would have to be evicted.
     for (CTxMemPool::txiter it : iters_conflicting) {
+        // The cluster count limit ensures that we won't do too much work on a
+        // single invocation of this function.
         pool.CalculateDescendants(it, all_conflicts);
     }
     return std::nullopt;
 }
 
-std::optional<std::string> HasNoNewUnconfirmed(const CTransaction& tx,
-                                               const CTxMemPool& pool,
-                                               const CTxMemPool::setEntries& iters_conflicting)
-{
-    AssertLockHeld(pool.cs);
-    std::set<Txid> parents_of_conflicts;
-    for (const auto& mi : iters_conflicting) {
-        for (const CTxIn& txin : mi->GetTx().vin) {
-            parents_of_conflicts.insert(txin.prevout.hash);
-        }
-    }
-
-    for (unsigned int j = 0; j < tx.vin.size(); j++) {
-        // Rule #2: We don't want to accept replacements that require low feerate junk to be
-        // mined first.  Ideally we'd keep track of the ancestor feerates and make the decision
-        // based on that, but for now requiring all new inputs to be confirmed works.
-        //
-        // Note that if you relax this to make RBF a little more useful, this may break the
-        // CalculateMempoolAncestors RBF relaxation which subtracts the conflict count/size from the
-        // descendant limit.
-        if (!parents_of_conflicts.count(tx.vin[j].prevout.hash)) {
-            // Rather than check the UTXO set - potentially expensive - it's cheaper to just check
-            // if the new input refers to a tx that's in the mempool.
-            if (pool.exists(tx.vin[j].prevout.hash)) {
-                return strprintf("replacement %s adds unconfirmed input, idx %d",
-                                 tx.GetHash().ToString(), j);
-            }
-        }
-    }
-    return std::nullopt;
-}
-
 std::optional<std::string> EntriesAndTxidsDisjoint(const CTxMemPool::setEntries& ancestors,
                                                    const std::set<Txid>& direct_conflicts,
                                                    const Txid& txid)
@@ -130,32 +98,6 @@ std::optional<std::string> EntriesAndTxidsDisjoint(const CTxMemPool::setEntries&
     return std::nullopt;
 }
 
-std::optional<std::string> PaysMoreThanConflicts(const CTxMemPool::setEntries& iters_conflicting,
-                                                 CFeeRate replacement_feerate,
-                                                 const Txid& txid)
-{
-    for (const auto& mi : iters_conflicting) {
-        // Don't allow the replacement to reduce the feerate of the mempool.
-        //
-        // We usually don't want to accept replacements with lower feerates than what they replaced
-        // as that would lower the feerate of the next block. Requiring that the feerate always be
-        // increased is also an easy-to-reason about way to prevent DoS attacks via replacements.
-        //
-        // We only consider the feerates of transactions being directly replaced, not their indirect
-        // descendants. While that does mean high feerate children are ignored when deciding whether
-        // or not to replace, we do require the replacement to pay more overall fees too, mitigating
-        // most cases.
-        CFeeRate original_feerate(mi->GetModifiedFee(), mi->GetTxSize());
-        if (replacement_feerate <= original_feerate) {
-            return strprintf("rejecting replacement %s; new feerate %s <= old feerate %s",
-                             txid.ToString(),
-                             replacement_feerate.ToString(),
-                             original_feerate.ToString());
-        }
-    }
-    return std::nullopt;
-}
-
 std::optional<std::string> PaysForRBF(CAmount original_fees,
                                       CAmount replacement_fees,
                                       size_t replacement_vsize,
diff --git a/src/policy/rbf.h b/src/policy/rbf.h
index cc397b463dc..b135ecf2dc2 100644
--- a/src/policy/rbf.h
+++ b/src/policy/rbf.h
@@ -21,8 +21,8 @@
 class CFeeRate;
 class uint256;
 
-/** Maximum number of transactions that can be replaced by RBF (Rule #5). This includes all
- * mempool conflicts and their descendants. */
+/** Maximum number of unique clusters that can be affected by an RBF (Rule #5);
+ * see GetEntriesForConflicts() */
 static constexpr uint32_t MAX_REPLACEMENT_CANDIDATES{100};
 
 /** The rbf state of unconfirmed transactions */
@@ -57,28 +57,20 @@ RBFTransactionState IsRBFOptIn(const CTransaction& tx, const CTxMemPool& pool) E
 RBFTransactionState IsRBFOptInEmptyMempool(const CTransaction& tx);
 
 /** Get all descendants of iters_conflicting. Checks that there are no more than
- * MAX_REPLACEMENT_CANDIDATES potential entries. May overestimate if the entries in
- * iters_conflicting have overlapping descendants.
+ * MAX_REPLACEMENT_CANDIDATES distinct clusters affected.
+ *
  * @param[in]   iters_conflicting   The set of iterators to mempool entries.
  * @param[out]  all_conflicts       Populated with all the mempool entries that would be replaced,
  *                                  which includes iters_conflicting and all entries' descendants.
  *                                  Not cleared at the start; any existing mempool entries will
  *                                  remain in the set.
- * @returns an error message if MAX_REPLACEMENT_CANDIDATES may be exceeded, otherwise a std::nullopt.
+ * @returns an error message if the number of affected clusters would exceed MAX_REPLACEMENT_CANDIDATES, std::nullopt otherwise
  */
 std::optional<std::string> GetEntriesForConflicts(const CTransaction& tx, CTxMemPool& pool,
                                                   const CTxMemPool::setEntries& iters_conflicting,
                                                   CTxMemPool::setEntries& all_conflicts)
     EXCLUSIVE_LOCKS_REQUIRED(pool.cs);
 
-/** The replacement transaction may only include an unconfirmed input if that input was included in
- * one of the original transactions.
- * @returns error message if tx spends unconfirmed inputs not also spent by iters_conflicting,
- * otherwise std::nullopt. */
-std::optional<std::string> HasNoNewUnconfirmed(const CTransaction& tx, const CTxMemPool& pool,
-                                               const CTxMemPool::setEntries& iters_conflicting)
-    EXCLUSIVE_LOCKS_REQUIRED(pool.cs);
-
 /** Check the intersection between two sets of transactions (a set of mempool entries and a set of
  * txids) to make sure they are disjoint.
  * @param[in]   ancestors           Set of mempool entries corresponding to ancestors of the
@@ -92,14 +84,6 @@ std::optional<std::string> EntriesAndTxidsDisjoint(const CTxMemPool::setEntries&
                                                    const std::set<Txid>& direct_conflicts,
                                                    const Txid& txid);
 
-/** Check that the feerate of the replacement transaction(s) is higher than the feerate of each
- * of the transactions in iters_conflicting.
- * @param[in]   iters_conflicting  The set of mempool entries.
- * @returns error message if fees insufficient, otherwise std::nullopt.
- */
-std::optional<std::string> PaysMoreThanConflicts(const CTxMemPool::setEntries& iters_conflicting,
-                                                 CFeeRate replacement_feerate, const Txid& txid);
-
 /** The replacement transaction must pay more fees than the original transactions. The additional
  * fees must pay for the replacement's bandwidth at or above the incremental relay feerate.
  * @param[in]   original_fees       Total modified fees of original transaction(s).
diff --git a/src/test/fuzz/rbf.cpp b/src/test/fuzz/rbf.cpp
index 300f31d4408..2ca57341533 100644
--- a/src/test/fuzz/rbf.cpp
+++ b/src/test/fuzz/rbf.cpp
@@ -144,9 +144,7 @@ FUZZ_TARGET(package_rbf, .init = initialize_package_rbf)
         }
         assert(!pool.GetIter(parent_entry.GetTx().GetHash()));
         AddToMempool(pool, parent_entry);
-        if (fuzzed_data_provider.ConsumeBool()) {
-            child.vin[0].prevout = COutPoint{mempool_txs.back().GetHash(), 0};
-        }
+        child.vin[0].prevout = COutPoint{mempool_txs.back().GetHash(), 0};
         mempool_txs.emplace_back(child);
         const auto child_entry = ConsumeTxMemPoolEntry(fuzzed_data_provider, mempool_txs.back());
         running_vsize_total += child_entry.GetTxSize();
diff --git a/src/test/rbf_tests.cpp b/src/test/rbf_tests.cpp
index 31cf994c875..45dd8bcb120 100644
--- a/src/test/rbf_tests.cpp
+++ b/src/test/rbf_tests.cpp
@@ -37,37 +37,6 @@ static inline CTransactionRef make_tx(const std::vector<CTransactionRef>& inputs
     return MakeTransactionRef(tx);
 }
 
-// Make two child transactions from parent (which must have at least 2 outputs).
-// Each tx will have the same outputs, using the amounts specified in output_values.
-static inline std::pair<CTransactionRef, CTransactionRef> make_two_siblings(const CTransactionRef parent,
-                                      const std::vector<CAmount>& output_values)
-{
-    assert(parent->vout.size() >= 2);
-
-    // First tx takes first parent output
-    CMutableTransaction tx1 = CMutableTransaction();
-    tx1.vin.resize(1);
-    tx1.vout.resize(output_values.size());
-
-    tx1.vin[0].prevout.hash = parent->GetHash();
-    tx1.vin[0].prevout.n = 0;
-    // Add a witness so wtxid != txid
-    CScriptWitness witness;
-    witness.stack.emplace_back(10);
-    tx1.vin[0].scriptWitness = witness;
-
-    for (size_t i = 0; i < output_values.size(); ++i) {
-        tx1.vout[i].scriptPubKey = CScript() << OP_11 << OP_EQUAL;
-        tx1.vout[i].nValue = output_values[i];
-    }
-
-    // Second tx takes second parent output
-    CMutableTransaction tx2 = tx1;
-    tx2.vin[0].prevout.n = 1;
-
-    return std::make_pair(MakeTransactionRef(tx1), MakeTransactionRef(tx2));
-}
-
 static CTransactionRef add_descendants(const CTransactionRef& tx, int32_t num_descendants, CTxMemPool& pool)
     EXCLUSIVE_LOCKS_REQUIRED(::cs_main, pool.cs)
 {
@@ -79,39 +48,13 @@ static CTransactionRef add_descendants(const CTransactionRef& tx, int32_t num_de
     for (int32_t i{0}; i < num_descendants; ++i) {
         auto next_tx = make_tx(/*inputs=*/{tx_to_spend}, /*output_values=*/{(50 - i) * CENT});
         AddToMempool(pool, entry.FromTx(next_tx));
+        BOOST_CHECK(pool.GetIter(next_tx->GetHash()).has_value());
         tx_to_spend = next_tx;
     }
     // Return last created tx
     return tx_to_spend;
 }
 
-static CTransactionRef add_descendant_to_parents(const std::vector<CTransactionRef>& parents, CTxMemPool& pool)
-    EXCLUSIVE_LOCKS_REQUIRED(::cs_main, pool.cs)
-{
-    AssertLockHeld(::cs_main);
-    AssertLockHeld(pool.cs);
-    TestMemPoolEntryHelper entry;
-    // Assumes this isn't already spent in mempool
-    auto child_tx = make_tx(/*inputs=*/parents, /*output_values=*/{50 * CENT});
-    AddToMempool(pool, entry.FromTx(child_tx));
-    // Return last created tx
-    return child_tx;
-}
-
-// Makes two children for a single parent
-static std::pair<CTransactionRef, CTransactionRef> add_children_to_parent(const CTransactionRef parent, CTxMemPool& pool)
-    EXCLUSIVE_LOCKS_REQUIRED(::cs_main, pool.cs)
-{
-    AssertLockHeld(::cs_main);
-    AssertLockHeld(pool.cs);
-    TestMemPoolEntryHelper entry;
-    // Assumes this isn't already spent in mempool
-    auto children_tx = make_two_siblings(/*parent=*/parent, /*output_values=*/{50 * CENT});
-    AddToMempool(pool, entry.FromTx(children_tx.first));
-    AddToMempool(pool, entry.FromTx(children_tx.second));
-    return children_tx;
-}
-
 BOOST_FIXTURE_TEST_CASE(rbf_helper_functions, TestChain100Setup)
 {
     CTxMemPool& pool = *Assert(m_node.mempool);
@@ -149,12 +92,6 @@ BOOST_FIXTURE_TEST_CASE(rbf_helper_functions, TestChain100Setup)
     const auto tx8 = make_tx(/*inputs=*/ {m_coinbase_txns[4]}, /*output_values=*/ {999 * CENT});
     AddToMempool(pool, entry.Fee(high_fee).FromTx(tx8));
 
-    // Normal txs, will chain txns right before CheckConflictTopology test
-    const auto tx9 = make_tx(/*inputs=*/ {m_coinbase_txns[5]}, /*output_values=*/ {995 * CENT});
-    AddToMempool(pool, entry.Fee(normal_fee).FromTx(tx9));
-    const auto tx10 = make_tx(/*inputs=*/ {m_coinbase_txns[6]}, /*output_values=*/ {995 * CENT});
-    AddToMempool(pool, entry.Fee(normal_fee).FromTx(tx10));
-
     // Will make these two parents of single child
     const auto tx11 = make_tx(/*inputs=*/ {m_coinbase_txns[7]}, /*output_values=*/ {995 * CENT});
     AddToMempool(pool, entry.Fee(normal_fee).FromTx(tx11));
@@ -173,11 +110,6 @@ BOOST_FIXTURE_TEST_CASE(rbf_helper_functions, TestChain100Setup)
     const auto entry6_low_prioritised = pool.GetIter(tx6->GetHash()).value();
     const auto entry7_high = pool.GetIter(tx7->GetHash()).value();
     const auto entry8_high = pool.GetIter(tx8->GetHash()).value();
-    const auto entry9_unchained = pool.GetIter(tx9->GetHash()).value();
-    const auto entry10_unchained = pool.GetIter(tx10->GetHash()).value();
-    const auto entry11_unchained = pool.GetIter(tx11->GetHash()).value();
-    const auto entry12_unchained = pool.GetIter(tx12->GetHash()).value();
-    const auto entry13_unchained = pool.GetIter(tx13->GetHash()).value();
 
     BOOST_CHECK_EQUAL(entry1_normal->GetFee(), normal_fee);
     BOOST_CHECK_EQUAL(entry2_normal->GetFee(), normal_fee);
@@ -198,23 +130,6 @@ BOOST_FIXTURE_TEST_CASE(rbf_helper_functions, TestChain100Setup)
 
     const auto unused_txid = Txid::FromUint256(GetRandHash());
 
-    // Tests for PaysMoreThanConflicts
-    // These tests use feerate, not absolute fee.
-    BOOST_CHECK(PaysMoreThanConflicts(/*iters_conflicting=*/set_12_normal,
-                                      /*replacement_feerate=*/CFeeRate(entry1_normal->GetModifiedFee() + 1, entry1_normal->GetTxSize() + 2),
-                                      /*txid=*/unused_txid).has_value());
-    // Replacement must be strictly greater than the originals.
-    BOOST_CHECK(PaysMoreThanConflicts(set_12_normal, CFeeRate(entry1_normal->GetModifiedFee(), entry1_normal->GetTxSize()), unused_txid).has_value());
-    BOOST_CHECK(PaysMoreThanConflicts(set_12_normal, CFeeRate(entry1_normal->GetModifiedFee() + 1, entry1_normal->GetTxSize()), unused_txid) == std::nullopt);
-    // These tests use modified fees (including prioritisation), not base fees.
-    BOOST_CHECK(PaysMoreThanConflicts({entry5_low}, CFeeRate(entry5_low->GetModifiedFee() + 1, entry5_low->GetTxSize()), unused_txid) == std::nullopt);
-    BOOST_CHECK(PaysMoreThanConflicts({entry6_low_prioritised}, CFeeRate(entry6_low_prioritised->GetFee() + 1, entry6_low_prioritised->GetTxSize()), unused_txid).has_value());
-    BOOST_CHECK(PaysMoreThanConflicts({entry6_low_prioritised}, CFeeRate(entry6_low_prioritised->GetModifiedFee() + 1, entry6_low_prioritised->GetTxSize()), unused_txid) == std::nullopt);
-    // PaysMoreThanConflicts checks individual feerate, not ancestor feerate. This test compares
-    // replacement_feerate and entry4_high's feerate, which are the same. The replacement_feerate is
-    // considered too low even though entry4_high has a low ancestor feerate.
-    BOOST_CHECK(PaysMoreThanConflicts(set_34_cpfp, CFeeRate(entry4_high->GetModifiedFee(), entry4_high->GetTxSize()), unused_txid).has_value());
-
     // Tests for EntriesAndTxidsDisjoint
     BOOST_CHECK(EntriesAndTxidsDisjoint(empty_set, {tx1->GetHash()}, unused_txid) == std::nullopt);
     BOOST_CHECK(EntriesAndTxidsDisjoint(set_12_normal, {tx3->GetHash()}, unused_txid) == std::nullopt);
@@ -244,112 +159,91 @@ BOOST_FIXTURE_TEST_CASE(rbf_helper_functions, TestChain100Setup)
     BOOST_CHECK(PaysForRBF(high_fee, high_fee + 4, 20, higher_relay_feerate, unused_txid) == std::nullopt);
     BOOST_CHECK(PaysForRBF(low_fee, high_fee, 99999999, incremental_relay_feerate, unused_txid).has_value());
     BOOST_CHECK(PaysForRBF(low_fee, high_fee + 99999999, 99999999, incremental_relay_feerate, unused_txid) == std::nullopt);
+}
 
-    // Tests for GetEntriesForConflicts
-    CTxMemPool::setEntries all_parents{entry1_normal, entry3_low, entry5_low, entry7_high, entry8_high};
-    CTxMemPool::setEntries all_children{entry2_normal, entry4_high, entry6_low_prioritised};
-    const std::vector<CTransactionRef> parent_inputs({m_coinbase_txns[0], m_coinbase_txns[1], m_coinbase_txns[2],
-                                                m_coinbase_txns[3], m_coinbase_txns[4]});
-    const auto conflicts_with_parents = make_tx(parent_inputs, {50 * CENT});
-    CTxMemPool::setEntries all_conflicts;
-    BOOST_CHECK(GetEntriesForConflicts(/*tx=*/ *conflicts_with_parents.get(),
-                                       /*pool=*/ pool,
-                                       /*iters_conflicting=*/ all_parents,
-                                       /*all_conflicts=*/ all_conflicts) == std::nullopt);
-    BOOST_CHECK(all_conflicts == all_entries);
-    auto conflicts_size = all_conflicts.size();
-    all_conflicts.clear();
+BOOST_FIXTURE_TEST_CASE(rbf_conflicts_calculator, TestChain100Setup)
+{
+    CTxMemPool& pool = *Assert(m_node.mempool);
+    LOCK2(::cs_main, pool.cs);
+    TestMemPoolEntryHelper entry;
 
-    add_descendants(tx2, 23, pool);
-    BOOST_CHECK(GetEntriesForConflicts(*conflicts_with_parents.get(), pool, all_parents, all_conflicts) == std::nullopt);
-    conflicts_size += 23;
-    BOOST_CHECK_EQUAL(all_conflicts.size(), conflicts_size);
-    all_conflicts.clear();
+    const CAmount normal_fee{CENT/10};
 
-    add_descendants(tx4, 23, pool);
-    BOOST_CHECK(GetEntriesForConflicts(*conflicts_with_parents.get(), pool, all_parents, all_conflicts) == std::nullopt);
-    conflicts_size += 23;
-    BOOST_CHECK_EQUAL(all_conflicts.size(), conflicts_size);
-    all_conflicts.clear();
-
-    add_descendants(tx6, 23, pool);
-    BOOST_CHECK(GetEntriesForConflicts(*conflicts_with_parents.get(), pool, all_parents, all_conflicts) == std::nullopt);
-    conflicts_size += 23;
-    BOOST_CHECK_EQUAL(all_conflicts.size(), conflicts_size);
-    all_conflicts.clear();
-
-    add_descendants(tx7, 23, pool);
-    BOOST_CHECK(GetEntriesForConflicts(*conflicts_with_parents.get(), pool, all_parents, all_conflicts) == std::nullopt);
-    conflicts_size += 23;
-    BOOST_CHECK_EQUAL(all_conflicts.size(), conflicts_size);
-    BOOST_CHECK_EQUAL(all_conflicts.size(), 100);
-    all_conflicts.clear();
-
-    // Exceeds maximum number of conflicts.
-    add_descendants(tx8, 1, pool);
-    BOOST_CHECK(GetEntriesForConflicts(*conflicts_with_parents.get(), pool, all_parents, all_conflicts).has_value());
-
-    // Tests for HasNoNewUnconfirmed
-    const auto spends_unconfirmed = make_tx({tx1}, {36 * CENT});
-    for (const auto& input : spends_unconfirmed->vin) {
-        // Spends unconfirmed inputs.
-        BOOST_CHECK(pool.exists(input.prevout.hash));
+    // Create two parent transactions with 51 outputs each
+    const int NUM_OUTPUTS = 51;
+    std::vector<CAmount> output_values;
+    output_values.reserve(NUM_OUTPUTS);
+    for (int i = 0; i < NUM_OUTPUTS; ++i) {
+        output_values.push_back(1 * COIN);
     }
-    BOOST_CHECK(HasNoNewUnconfirmed(/*tx=*/ *spends_unconfirmed.get(),
-                                    /*pool=*/ pool,
-                                    /*iters_conflicting=*/ all_entries) == std::nullopt);
-    BOOST_CHECK(HasNoNewUnconfirmed(*spends_unconfirmed.get(), pool, {entry2_normal}) == std::nullopt);
-    BOOST_CHECK(HasNoNewUnconfirmed(*spends_unconfirmed.get(), pool, empty_set).has_value());
 
-    const auto spends_new_unconfirmed = make_tx({tx1, tx8}, {36 * CENT});
-    BOOST_CHECK(HasNoNewUnconfirmed(*spends_new_unconfirmed.get(), pool, {entry2_normal}).has_value());
-    BOOST_CHECK(HasNoNewUnconfirmed(*spends_new_unconfirmed.get(), pool, all_entries).has_value());
+    const auto parent_tx_1 = make_tx(/*inputs=*/ {m_coinbase_txns[0]}, /*output_values=*/ output_values);
+    const auto parent_tx_2 = make_tx(/*inputs=*/ {m_coinbase_txns[1]}, /*output_values=*/ output_values);
+    AddToMempool(pool, entry.Fee(normal_fee).FromTx(parent_tx_1));
+    AddToMempool(pool, entry.Fee(normal_fee).FromTx(parent_tx_2));
 
-    const auto spends_conflicting_confirmed = make_tx({m_coinbase_txns[0], m_coinbase_txns[1]}, {45 * CENT});
-    BOOST_CHECK(HasNoNewUnconfirmed(*spends_conflicting_confirmed.get(), pool, {entry1_normal, entry3_low}) == std::nullopt);
+    std::vector<CTransactionRef> direct_children;
 
-    // Tests for CheckConflictTopology
+    // Create individual spends of these outputs
+    for (const auto& parent_tx : {parent_tx_1, parent_tx_2}) {
+        for (auto i = 0; i < NUM_OUTPUTS; ++i) {
+            auto pretx = make_tx(/*inputs=*/ {parent_tx}, /*output_values=*/ {995 * CENT});
+            CMutableTransaction tx(*pretx);
+            tx.vin[0].prevout.n = i;
+            AddToMempool(pool, entry.Fee(normal_fee).FromTx(tx));
+            BOOST_CHECK(pool.GetIter(tx.GetHash()).has_value());
+            direct_children.push_back(MakeTransactionRef(tx));
+        }
+    }
 
-    // Tx4 has 23 descendants
-    BOOST_CHECK_EQUAL(pool.CheckConflictTopology(set_34_cpfp).value(), strprintf("%s has 24 descendants, max 1 allowed", entry3_low->GetSharedTx()->GetHash().ToString()));
+    // At this point, we should have 2 clusters in the mempool, each with 52
+    // transactions.
 
-    // No descendants yet
-    BOOST_CHECK(pool.CheckConflictTopology({entry9_unchained}) == std::nullopt);
+    // parent_tx and all children are in one cluster, so we can have as many
+    // conflicts within this cluster as we want without violating the RBF conflicts
+    // limit.
+    const auto parent_entry_1 = pool.GetIter(parent_tx_1->GetHash()).value();
+    const auto parent_entry_2 = pool.GetIter(parent_tx_2->GetHash()).value();
+    const auto conflicting_transaction = make_tx({parent_tx_1, parent_tx_2}, {50 * CENT});
+    CTxMemPool::setEntries all_conflicts, dummy;
+    BOOST_CHECK(GetEntriesForConflicts(/*tx=*/ *conflicting_transaction.get(),
+                                       /*pool=*/ pool,
+                                       /*iters_conflicting=*/ {parent_entry_1, parent_entry_2},
+                                       /*all_conflicts=*/ all_conflicts) == std::nullopt);
 
-    // Add 1 descendant, still ok
-    add_descendants(tx9, 1, pool);
-    BOOST_CHECK(pool.CheckConflictTopology({entry9_unchained}) == std::nullopt);
+    dummy.clear();
+    // Conflicting directly with all those conflicts doesn't change anything.
+    BOOST_CHECK(GetEntriesForConflicts(/*tx=*/ *conflicting_transaction.get(),
+                                       /*pool=*/ pool,
+                                       /*iters_conflicting=*/ all_conflicts,
+                                       /*all_conflicts=*/ dummy) == std::nullopt);
+    BOOST_CHECK_EQUAL(all_conflicts.size(), dummy.size());
+    dummy.clear();
 
-    // N direct conflicts; ok
-    BOOST_CHECK(pool.CheckConflictTopology({entry9_unchained, entry10_unchained, entry11_unchained}) == std::nullopt);
+    // If we mine the parent_tx's, then the clusters split (102 clusters).
+    pool.removeForBlock({parent_tx_1, parent_tx_2}, /* dummy */ 1);
 
-    // Add 1 descendant, still ok, even if it's considered a direct conflict as well
-    const auto child_tx = add_descendants(tx10, 1, pool);
-    const auto entry10_child = pool.GetIter(child_tx->GetHash()).value();
-    BOOST_CHECK(pool.CheckConflictTopology({entry9_unchained, entry10_unchained, entry11_unchained}) == std::nullopt);
-    BOOST_CHECK(pool.CheckConflictTopology({entry9_unchained, entry10_unchained, entry11_unchained, entry10_child}) == std::nullopt);
+    // Add some descendants now to each of the direct children (we can do this now that the clusters have split).
+    for (const auto& child : direct_children) {
+        add_descendants(child, 10, pool);
+    }
 
-    // One more, size 3 cluster too much
-    const auto grand_child_tx = add_descendants(child_tx, 1, pool);
-    const auto entry10_grand_child = pool.GetIter(grand_child_tx->GetHash()).value();
-    BOOST_CHECK_EQUAL(pool.CheckConflictTopology({entry9_unchained, entry10_unchained, entry11_unchained}).value(), strprintf("%s has 2 descendants, max 1 allowed", entry10_unchained->GetSharedTx()->GetHash().ToString()));
-    // even if direct conflict is descendent itself
-    BOOST_CHECK_EQUAL(pool.CheckConflictTopology({entry9_unchained, entry10_grand_child, entry11_unchained}).value(), strprintf("%s has 2 ancestors, max 1 allowed", entry10_grand_child->GetSharedTx()->GetHash().ToString()));
-
-    // Make a single child from two singleton parents
-    const auto two_parent_child_tx = add_descendant_to_parents({tx11, tx12}, pool);
-    const auto entry_two_parent_child = pool.GetIter(two_parent_child_tx->GetHash()).value();
-    BOOST_CHECK_EQUAL(pool.CheckConflictTopology({entry11_unchained}).value(), strprintf("%s is not the only parent of child %s", entry11_unchained->GetSharedTx()->GetHash().ToString(), entry_two_parent_child->GetSharedTx()->GetHash().ToString()));
-    BOOST_CHECK_EQUAL(pool.CheckConflictTopology({entry12_unchained}).value(), strprintf("%s is not the only parent of child %s", entry12_unchained->GetSharedTx()->GetHash().ToString(), entry_two_parent_child->GetSharedTx()->GetHash().ToString()));
-    BOOST_CHECK_EQUAL(pool.CheckConflictTopology({entry_two_parent_child}).value(), strprintf("%s has 2 ancestors, max 1 allowed", entry_two_parent_child->GetSharedTx()->GetHash().ToString()));
-
-    // Single parent with two children, we will conflict with the siblings directly only
-    const auto two_siblings = add_children_to_parent(tx13, pool);
-    const auto entry_sibling_1 = pool.GetIter(two_siblings.first->GetHash()).value();
-    const auto entry_sibling_2 = pool.GetIter(two_siblings.second->GetHash()).value();
-    BOOST_CHECK_EQUAL(pool.CheckConflictTopology({entry_sibling_1}).value(), strprintf("%s is not the only child of parent %s", entry_sibling_1->GetSharedTx()->GetHash().ToString(), entry13_unchained->GetSharedTx()->GetHash().ToString()));
-    BOOST_CHECK_EQUAL(pool.CheckConflictTopology({entry_sibling_2}).value(), strprintf("%s is not the only child of parent %s", entry_sibling_2->GetSharedTx()->GetHash().ToString(), entry13_unchained->GetSharedTx()->GetHash().ToString()));
+    // We can conflict with 100 different clusters, even if they have lots of transactions.
+    CTxMemPool::setEntries conflicts;
+    for (auto i = 0; i < 100; ++i) {
+        conflicts.insert(pool.GetIter(direct_children[i]->GetHash()).value());
+    }
+    BOOST_CHECK(GetEntriesForConflicts(/*tx=*/ *conflicting_transaction.get(),
+                                       /*pool=*/ pool,
+                                       /*iters_conflicting=*/ conflicts,
+                                       /*all_conflicts=*/ dummy) == std::nullopt);
 
+    // Conflicting with 1 more distinct cluster causes failure, however.
+    conflicts.insert(pool.GetIter(direct_children[100]->GetHash()).value());
+    BOOST_CHECK(GetEntriesForConflicts(/*tx=*/ *conflicting_transaction.get(),
+                                       /*pool=*/ pool,
+                                       /*iters_conflicting=*/ conflicts,
+                                       /*all_conflicts=*/ dummy).has_value());
 }
 
 BOOST_FIXTURE_TEST_CASE(improves_feerate, TestChain100Setup)
@@ -427,7 +321,7 @@ BOOST_FIXTURE_TEST_CASE(improves_feerate, TestChain100Setup)
     BOOST_CHECK(ImprovesFeerateDiagram(*changeset) == std::nullopt);
     changeset.reset();
 
-    // Adding a grandchild makes the cluster size 3, which is uncalculable
+    // Adding a grandchild makes the cluster size 3, which is also calculable
     const auto tx5 = make_tx(/*inputs=*/ {tx2}, /*output_values=*/ {995 * CENT});
     AddToMempool(pool, entry.Fee(normal_fee).FromTx(tx5));
     const auto entry5 = pool.GetIter(tx5->GetHash()).value();
@@ -439,9 +333,7 @@ BOOST_FIXTURE_TEST_CASE(improves_feerate, TestChain100Setup)
     changeset->StageAddition(tx1_conflict, tx1_fee, 0, 1, 0, false, 4, LockPoints());
     changeset->StageAddition(entry4.GetSharedTx(), tx2_fee + entry5->GetModifiedFee() + 1, 0, 1, 0, false, 4, LockPoints());
     const auto res3 = ImprovesFeerateDiagram(*changeset);
-    BOOST_CHECK(res3.has_value());
-    BOOST_CHECK(res3.value().first == DiagramCheckError::UNCALCULABLE);
-    BOOST_CHECK_MESSAGE(res3.value().second == strprintf("%s has 2 descendants, max 1 allowed", tx1->GetHash().GetHex()), res3.value().second);
+    BOOST_CHECK(res3 == std::nullopt);
 }
 
 BOOST_FIXTURE_TEST_CASE(calc_feerate_diagram_rbf, TestChain100Setup)
@@ -451,7 +343,6 @@ BOOST_FIXTURE_TEST_CASE(calc_feerate_diagram_rbf, TestChain100Setup)
     TestMemPoolEntryHelper entry;
 
     const CAmount low_fee{CENT/100};
-    const CAmount normal_fee{CENT/10};
     const CAmount high_fee{CENT};
 
     // low -> high -> medium fee transactions that would result in two chunks together since they
@@ -460,7 +351,7 @@ BOOST_FIXTURE_TEST_CASE(calc_feerate_diagram_rbf, TestChain100Setup)
     AddToMempool(pool, entry.Fee(low_fee).FromTx(low_tx));
 
     const auto entry_low = pool.GetIter(low_tx->GetHash()).value();
-    const auto low_size = entry_low->GetTxSize();
+    const auto low_size = entry_low->GetAdjustedWeight();
 
     const auto replacement_tx = make_tx(/*inputs=*/ {m_coinbase_txns[0]}, /*output_values=*/ {9 * COIN});
     auto entry_replacement = entry.FromTx(replacement_tx);
@@ -474,7 +365,7 @@ BOOST_FIXTURE_TEST_CASE(calc_feerate_diagram_rbf, TestChain100Setup)
         BOOST_CHECK(replace_one.has_value());
         std::vector<FeeFrac> expected_old_chunks{{low_fee, low_size}};
         BOOST_CHECK(replace_one->first == expected_old_chunks);
-        std::vector<FeeFrac> expected_new_chunks{{0, int32_t(entry_replacement.GetTxSize())}};
+        std::vector<FeeFrac> expected_new_chunks{{0, entry_replacement.GetAdjustedWeight()}};
         BOOST_CHECK(replace_one->second == expected_new_chunks);
     }
 
@@ -487,7 +378,7 @@ BOOST_FIXTURE_TEST_CASE(calc_feerate_diagram_rbf, TestChain100Setup)
         BOOST_CHECK(replace_one_fee.has_value());
         std::vector<FeeFrac> expected_old_diagram{{low_fee, low_size}};
         BOOST_CHECK(replace_one_fee->first == expected_old_diagram);
-        std::vector<FeeFrac> expected_new_diagram{{high_fee, low_size}};
+        std::vector<FeeFrac> expected_new_diagram{{high_fee, entry_replacement.GetAdjustedWeight()}};
         BOOST_CHECK(replace_one_fee->second == expected_new_diagram);
     }
 
@@ -495,7 +386,7 @@ BOOST_FIXTURE_TEST_CASE(calc_feerate_diagram_rbf, TestChain100Setup)
     const auto high_tx = make_tx(/*inputs=*/ {low_tx}, /*output_values=*/ {995 * CENT});
     AddToMempool(pool, entry.Fee(high_fee).FromTx(high_tx));
     const auto entry_high = pool.GetIter(high_tx->GetHash()).value();
-    const auto high_size = entry_high->GetTxSize();
+    const auto high_size = entry_high->GetAdjustedWeight();
 
     {
         auto changeset = pool.GetChangeSet();
@@ -506,7 +397,7 @@ BOOST_FIXTURE_TEST_CASE(calc_feerate_diagram_rbf, TestChain100Setup)
         BOOST_CHECK(replace_single_chunk.has_value());
         std::vector<FeeFrac> expected_old_chunks{{low_fee + high_fee, low_size + high_size}};
         BOOST_CHECK(replace_single_chunk->first == expected_old_chunks);
-        std::vector<FeeFrac> expected_new_chunks{{high_fee, low_size}};
+        std::vector<FeeFrac> expected_new_chunks{{high_fee, entry_replacement.GetAdjustedWeight()}};
         BOOST_CHECK(replace_single_chunk->second == expected_new_chunks);
     }
 
@@ -519,36 +410,20 @@ BOOST_FIXTURE_TEST_CASE(calc_feerate_diagram_rbf, TestChain100Setup)
         BOOST_CHECK(replace_cpfp_child.has_value());
         std::vector<FeeFrac> expected_old_chunks{{low_fee + high_fee, low_size + high_size}};
         BOOST_CHECK(replace_cpfp_child->first == expected_old_chunks);
-        std::vector<FeeFrac> expected_new_chunks{{high_fee, low_size}, {low_fee, low_size}};
+        std::vector<FeeFrac> expected_new_chunks{{high_fee, entry_replacement.GetAdjustedWeight()}, {low_fee, low_size}};
         BOOST_CHECK(replace_cpfp_child->second == expected_new_chunks);
     }
 
-    // third transaction causes the topology check to fail
-    const auto normal_tx = make_tx(/*inputs=*/ {high_tx}, /*output_values=*/ {995 * CENT});
-    AddToMempool(pool, entry.Fee(normal_fee).FromTx(normal_tx));
-    const auto entry_normal = pool.GetIter(normal_tx->GetHash()).value();
-
-    {
-        auto changeset = pool.GetChangeSet();
-        changeset->StageRemoval(entry_low);
-        changeset->StageRemoval(entry_high);
-        changeset->StageRemoval(entry_normal);
-        changeset->StageAddition(replacement_tx, high_fee, 0, 1, 0, false, 4, LockPoints());
-        const auto replace_too_large{changeset->CalculateChunksForRBF()};
-        BOOST_CHECK(!replace_too_large.has_value());
-        BOOST_CHECK_EQUAL(util::ErrorString(replace_too_large).original, strprintf("%s has both ancestor and descendant, exceeding cluster limit of 2", high_tx->GetHash().GetHex()));
-    }
-
     // Make a size 2 cluster that is itself two chunks; evict both txns
     const auto high_tx_2 = make_tx(/*inputs=*/ {m_coinbase_txns[1]}, /*output_values=*/ {10 * COIN});
     AddToMempool(pool, entry.Fee(high_fee).FromTx(high_tx_2));
     const auto entry_high_2 = pool.GetIter(high_tx_2->GetHash()).value();
-    const auto high_size_2 = entry_high_2->GetTxSize();
+    const auto high_size_2 = entry_high_2->GetAdjustedWeight();
 
     const auto low_tx_2 = make_tx(/*inputs=*/ {high_tx_2}, /*output_values=*/ {9 * COIN});
     AddToMempool(pool, entry.Fee(low_fee).FromTx(low_tx_2));
     const auto entry_low_2 = pool.GetIter(low_tx_2->GetHash()).value();
-    const auto low_size_2 = entry_low_2->GetTxSize();
+    const auto low_size_2 = entry_low_2->GetAdjustedWeight();
 
     {
         auto changeset = pool.GetChangeSet();
@@ -563,7 +438,7 @@ BOOST_FIXTURE_TEST_CASE(calc_feerate_diagram_rbf, TestChain100Setup)
         BOOST_CHECK(replace_two_chunks_single_cluster->second == expected_new_chunks);
     }
 
-    // You can have more than two direct conflicts if there are multiple affected clusters, all of size 2 or less
+    // You can have more than two direct conflicts
     const auto conflict_1 = make_tx(/*inputs=*/ {m_coinbase_txns[2]}, /*output_values=*/ {10 * COIN});
     AddToMempool(pool, entry.Fee(low_fee).FromTx(conflict_1));
     const auto conflict_1_entry = pool.GetIter(conflict_1->GetHash()).value();
@@ -606,25 +481,6 @@ BOOST_FIXTURE_TEST_CASE(calc_feerate_diagram_rbf, TestChain100Setup)
         BOOST_CHECK(replace_multiple_clusters_2->first.size() == 4);
         BOOST_CHECK(replace_multiple_clusters_2->second.size() == 1);
     }
-
-    // Add another descendant to conflict_1, making the cluster size > 2 should fail at this point.
-    const auto conflict_1_grand_child = make_tx(/*inputs=*/{conflict_1_child}, /*output_values=*/ {995 * CENT});
-    AddToMempool(pool, entry.Fee(high_fee).FromTx(conflict_1_grand_child));
-    const auto conflict_1_grand_child_entry = pool.GetIter(conflict_1_child->GetHash()).value();
-
-    {
-        auto changeset = pool.GetChangeSet();
-        changeset->StageRemoval(conflict_1_entry);
-        changeset->StageRemoval(conflict_2_entry);
-        changeset->StageRemoval(conflict_3_entry);
-        changeset->StageRemoval(conflict_1_child_entry);
-        changeset->StageRemoval(conflict_1_grand_child_entry);
-        changeset->StageAddition(replacement_tx, high_fee, 0, 1, 0, false, 4, LockPoints());
-        const auto replace_cluster_size_3{changeset->CalculateChunksForRBF()};
-
-        BOOST_CHECK(!replace_cluster_size_3.has_value());
-        BOOST_CHECK_EQUAL(util::ErrorString(replace_cluster_size_3).original, strprintf("%s has 2 descendants, max 1 allowed", conflict_1->GetHash().GetHex()));
-    }
 }
 
 BOOST_AUTO_TEST_CASE(feerate_chunks_utilities)
diff --git a/src/txmempool.cpp b/src/txmempool.cpp
index 672198ec2ea..15b2508119c 100644
--- a/src/txmempool.cpp
+++ b/src/txmempool.cpp
@@ -1287,135 +1287,15 @@ std::vector<CTxMemPool::txiter> CTxMemPool::GatherClusters(const std::vector<Txi
     return clustered_txs;
 }
 
-std::optional<std::string> CTxMemPool::CheckConflictTopology(const setEntries& direct_conflicts)
-{
-    for (const auto& direct_conflict : direct_conflicts) {
-        // Ancestor and descendant counts are inclusive of the tx itself.
-        const auto ancestor_count{direct_conflict->GetCountWithAncestors()};
-        const auto descendant_count{direct_conflict->GetCountWithDescendants()};
-        const bool has_ancestor{ancestor_count > 1};
-        const bool has_descendant{descendant_count > 1};
-        const auto& txid_string{direct_conflict->GetSharedTx()->GetHash().ToString()};
-        // The only allowed configurations are:
-        // 1 ancestor and 0 descendant
-        // 0 ancestor and 1 descendant
-        // 0 ancestor and 0 descendant
-        if (ancestor_count > 2) {
-            return strprintf("%s has %u ancestors, max 1 allowed", txid_string, ancestor_count - 1);
-        } else if (descendant_count > 2) {
-            return strprintf("%s has %u descendants, max 1 allowed", txid_string, descendant_count - 1);
-        } else if (has_ancestor && has_descendant) {
-            return strprintf("%s has both ancestor and descendant, exceeding cluster limit of 2", txid_string);
-        }
-        // Additionally enforce that:
-        // If we have a child,  we are its only parent.
-        // If we have a parent, we are its only child.
-        if (has_descendant) {
-            const auto& our_child = direct_conflict->GetMemPoolChildrenConst().begin();
-            if (our_child->get().GetCountWithAncestors() > 2) {
-                return strprintf("%s is not the only parent of child %s",
-                                 txid_string, our_child->get().GetSharedTx()->GetHash().ToString());
-            }
-        } else if (has_ancestor) {
-            const auto& our_parent = direct_conflict->GetMemPoolParentsConst().begin();
-            if (our_parent->get().GetCountWithDescendants() > 2) {
-                return strprintf("%s is not the only child of parent %s",
-                                 txid_string, our_parent->get().GetSharedTx()->GetHash().ToString());
-            }
-        }
-    }
-    return std::nullopt;
-}
-
 util::Result<std::pair<std::vector<FeeFrac>, std::vector<FeeFrac>>> CTxMemPool::ChangeSet::CalculateChunksForRBF()
 {
     LOCK(m_pool->cs);
-    FeeFrac replacement_feerate{0, 0};
-    for (auto it : m_entry_vec) {
-        replacement_feerate += {it->GetModifiedFee(), it->GetTxSize()};
+
+    if (!CheckMemPoolPolicyLimits()) {
+        return util::Error{Untranslated("cluster size limit exceeded")};
     }
 
-    auto err_string{m_pool->CheckConflictTopology(m_to_remove)};
-    if (err_string.has_value()) {
-        // Unsupported topology for calculating a feerate diagram
-        return util::Error{Untranslated(err_string.value())};
-    }
-
-    // new diagram will have chunks that consist of each ancestor of
-    // direct_conflicts that is at its own fee/size, along with the replacement
-    // tx/package at its own fee/size
-
-    // old diagram will consist of the ancestors and descendants of each element of
-    // all_conflicts.  every such transaction will either be at its own feerate (followed
-    // by any descendant at its own feerate), or as a single chunk at the descendant's
-    // ancestor feerate.
-
-    std::vector<FeeFrac> old_chunks;
-    // Step 1: build the old diagram.
-
-    // The above clusters are all trivially linearized;
-    // they have a strict topology of 1 or two connected transactions.
-
-    // OLD: Compute existing chunks from all affected clusters
-    for (auto txiter : m_to_remove) {
-        // Does this transaction have descendants?
-        if (txiter->GetCountWithDescendants() > 1) {
-            // Consider this tx when we consider the descendant.
-            continue;
-        }
-        // Does this transaction have ancestors?
-        FeeFrac individual{txiter->GetModifiedFee(), txiter->GetTxSize()};
-        if (txiter->GetCountWithAncestors() > 1) {
-            // We'll add chunks for either the ancestor by itself and this tx
-            // by itself, or for a combined package.
-            FeeFrac package{txiter->GetModFeesWithAncestors(), static_cast<int32_t>(txiter->GetSizeWithAncestors())};
-            if (individual >> package) {
-                // The individual feerate is higher than the package, and
-                // therefore higher than the parent's fee. Chunk these
-                // together.
-                old_chunks.emplace_back(package);
-            } else {
-                // Add two points, one for the parent and one for this child.
-                old_chunks.emplace_back(package - individual);
-                old_chunks.emplace_back(individual);
-            }
-        } else {
-            old_chunks.emplace_back(individual);
-        }
-    }
-
-    // No topology restrictions post-chunking; sort
-    std::sort(old_chunks.begin(), old_chunks.end(), std::greater());
-
-    std::vector<FeeFrac> new_chunks;
-
-    /* Step 2: build the NEW diagram
-     * CON = Conflicts of proposed chunk
-     * CNK = Proposed chunk
-     * NEW = OLD - CON + CNK: New diagram includes all chunks in OLD, minus
-     * the conflicts, plus the proposed chunk
-     */
-
-    // OLD - CON: Add any parents of direct conflicts that are not conflicted themselves
-    for (auto direct_conflict : m_to_remove) {
-        // If a direct conflict has an ancestor that is not in all_conflicts,
-        // it can be affected by the replacement of the child.
-        if (direct_conflict->GetMemPoolParentsConst().size() > 0) {
-            // Grab the parent.
-            const CTxMemPoolEntry& parent = direct_conflict->GetMemPoolParentsConst().begin()->get();
-            if (!m_to_remove.contains(m_pool->mapTx.iterator_to(parent))) {
-                // This transaction would be left over, so add to the NEW
-                // diagram.
-                new_chunks.emplace_back(parent.GetModifiedFee(), parent.GetTxSize());
-            }
-        }
-    }
-    // + CNK: Add the proposed chunk itself
-    new_chunks.emplace_back(replacement_feerate);
-
-    // No topology restrictions post-chunking; sort
-    std::sort(new_chunks.begin(), new_chunks.end(), std::greater());
-    return std::make_pair(old_chunks, new_chunks);
+    return m_pool->m_txgraph->GetMainStagingDiagrams();
 }
 
 CTxMemPool::ChangeSet::TxHandle CTxMemPool::ChangeSet::StageAddition(const CTransactionRef& tx, const CAmount fee, int64_t time, unsigned int entry_height, uint64_t entry_sequence, bool spends_coinbase, int64_t sigops_cost, LockPoints lp)
@@ -1438,6 +1318,7 @@ CTxMemPool::ChangeSet::TxHandle CTxMemPool::ChangeSet::StageAddition(const CTran
     }
 
     m_entry_vec.push_back(newit);
+
     return newit;
 }
 
diff --git a/src/txmempool.h b/src/txmempool.h
index 04f2fdd4f5a..1750596c0cf 100644
--- a/src/txmempool.h
+++ b/src/txmempool.h
@@ -516,6 +516,16 @@ public:
      */
     void UpdateTransactionsFromBlock(const std::vector<Txid>& vHashesToUpdate) EXCLUSIVE_LOCKS_REQUIRED(cs, cs_main) LOCKS_EXCLUDED(m_epoch);
 
+    size_t GetUniqueClusterCount(const setEntries& iters_conflicting) const EXCLUSIVE_LOCKS_REQUIRED(cs) {
+        std::vector<const TxGraph::Ref *> entries;
+        entries.reserve(iters_conflicting.size());
+        for (auto it : iters_conflicting) {
+            entries.emplace_back(&*it);
+        }
+        Assume(!m_txgraph->IsOversized(TxGraph::Level::MAIN));
+        return m_txgraph->CountDistinctClusters(entries, TxGraph::Level::MAIN);
+    }
+
     /**
      * Try to calculate all in-mempool ancestors of entry.
      * (these are all calculated including the tx itself)
@@ -710,11 +720,6 @@ public:
         return m_sequence_number;
     }
 
-    /* Check that all direct conflicts are in a cluster size of two or less. Each
-     * direct conflict may be in a separate cluster.
-     */
-    std::optional<std::string> CheckConflictTopology(const setEntries& direct_conflicts);
-
 private:
     /** Remove a set of transactions from the mempool.
      *  If a transaction is in this set, then all in-mempool descendants must
diff --git a/src/validation.cpp b/src/validation.cpp
index 50660ca75b7..3e00958f39d 100644
--- a/src/validation.cpp
+++ b/src/validation.cpp
@@ -1070,21 +1070,6 @@ bool MemPoolAccept::ReplacementChecks(Workspace& ws)
     TxValidationState& state = ws.m_state;
 
     CFeeRate newFeeRate(ws.m_modified_fees, ws.m_vsize);
-    // Enforce Rule #6. The replacement transaction must have a higher feerate than its direct conflicts.
-    // - The motivation for this check is to ensure that the replacement transaction is preferable for
-    //   block-inclusion, compared to what would be removed from the mempool.
-    // - This logic predates ancestor feerate-based transaction selection, which is why it doesn't
-    //   consider feerates of descendants.
-    // - Note: Ancestor feerate-based transaction selection has made this comparison insufficient to
-    //   guarantee that this is incentive-compatible for miners, because it is possible for a
-    //   descendant transaction of a direct conflict to pay a higher feerate than the transaction that
-    //   might replace them, under these rules.
-    if (const auto err_string{PaysMoreThanConflicts(ws.m_iters_conflicting, newFeeRate, hash)}) {
-        // This fee-related failure is TX_RECONSIDERABLE because validating in a package may change
-        // the result.
-        return state.Invalid(TxValidationResult::TX_RECONSIDERABLE,
-                             strprintf("insufficient fee%s", ws.m_sibling_eviction ? " (including sibling eviction)" : ""), *err_string);
-    }
 
     CTxMemPool::setEntries all_conflicts;
 
@@ -1094,20 +1079,13 @@ bool MemPoolAccept::ReplacementChecks(Workspace& ws)
                              strprintf("too many potential replacements%s", ws.m_sibling_eviction ? " (including sibling eviction)" : ""), *err_string);
     }
 
-    // Enforce Rule #2.
-    if (const auto err_string{HasNoNewUnconfirmed(tx, m_pool, all_conflicts)}) {
-        // Sibling eviction is only done for TRUC transactions, which cannot have multiple ancestors.
-        Assume(!ws.m_sibling_eviction);
-        return state.Invalid(TxValidationResult::TX_MEMPOOL_POLICY,
-                             strprintf("replacement-adds-unconfirmed%s", ws.m_sibling_eviction ? " (including sibling eviction)" : ""), *err_string);
-    }
-
     // Check if it's economically rational to mine this transaction rather than the ones it
     // replaces and pays for its own relay fees. Enforce Rules #3 and #4.
     for (CTxMemPool::txiter it : all_conflicts) {
         m_subpackage.m_conflicting_fees += it->GetModifiedFee();
         m_subpackage.m_conflicting_size += it->GetTxSize();
     }
+
     if (const auto err_string{PaysForRBF(m_subpackage.m_conflicting_fees, ws.m_modified_fees, ws.m_vsize,
                                          m_pool.m_opts.incremental_relay_feerate, hash)}) {
         // Result may change in a package context
@@ -1119,6 +1097,19 @@ bool MemPoolAccept::ReplacementChecks(Workspace& ws)
     for (auto it : all_conflicts) {
         m_subpackage.m_changeset->StageRemoval(it);
     }
+
+    // Run cluster size limit checks and fail if we exceed them.
+    if (!m_subpackage.m_changeset->CheckMemPoolPolicyLimits()) {
+        return state.Invalid(TxValidationResult::TX_MEMPOOL_POLICY, "too-large-cluster", "");
+    }
+
+    if (const auto err_string{ImprovesFeerateDiagram(*m_subpackage.m_changeset)}) {
+        // We checked above for the cluster size limits being respected, so a
+        // failure here can only be due to an insufficient fee.
+        Assume(err_string->first == DiagramCheckError::FAILURE);
+        return state.Invalid(TxValidationResult::TX_RECONSIDERABLE, "replacement-failed", err_string->second);
+    }
+
     return true;
 }
 
@@ -1205,9 +1196,14 @@ bool MemPoolAccept::PackageMempoolChecks(const std::vector<CTransactionRef>& txn
                                      strprintf("package feerate %s <= parent feerate is %s", package_feerate.ToString(), parent_feerate.ToString()));
     }
 
+    // Run cluster size limit checks and fail if we exceed them.
+    if (!m_subpackage.m_changeset->CheckMemPoolPolicyLimits()) {
+        return package_state.Invalid(PackageValidationResult::PCKG_POLICY, "too-large-cluster", "");
+    }
+
     // Check if it's economically rational to mine this package rather than the ones it replaces.
-    // This takes the place of ReplacementChecks()'s PaysMoreThanConflicts() in the package RBF setting.
     if (const auto err_tup{ImprovesFeerateDiagram(*m_subpackage.m_changeset)}) {
+        Assume(err_tup->first == DiagramCheckError::FAILURE);
         return package_state.Invalid(PackageValidationResult::PCKG_POLICY,
                                      "package RBF failed: " + err_tup.value().second, "");
     }
diff --git a/test/functional/feature_rbf.py b/test/functional/feature_rbf.py
index 91a79113d67..81ecef540ef 100755
--- a/test/functional/feature_rbf.py
+++ b/test/functional/feature_rbf.py
@@ -13,6 +13,7 @@ from test_framework.messages import (
 from test_framework.test_framework import BitcoinTestFramework
 from test_framework.util import (
     assert_equal,
+    assert_greater_than,
     assert_greater_than_or_equal,
     assert_raises_rpc_error,
     get_fee,
@@ -39,6 +40,7 @@ class ReplaceByFeeTest(BitcoinTestFramework):
 
     def run_test(self):
         self.wallet = MiniWallet(self.nodes[0])
+        self.generate(self.nodes[0], 100)
 
         self.log.info("Running test simple doublespend...")
         self.test_simple_doublespend()
@@ -58,12 +60,12 @@ class ReplaceByFeeTest(BitcoinTestFramework):
         self.log.info("Running test new unconfirmed inputs...")
         self.test_new_unconfirmed_inputs()
 
+        self.log.info("Running test new unconfirmed input from low feerate tx...")
+        self.test_new_unconfirmed_input_with_low_feerate()
+
         self.log.info("Running test too many replacements...")
         self.test_too_many_replacements()
 
-        self.log.info("Running test too many replacements using default mempool params...")
-        self.test_too_many_replacements_with_default_mempool_params()
-
         self.log.info("Running test RPC...")
         self.test_rpc()
 
@@ -114,7 +116,7 @@ class ReplaceByFeeTest(BitcoinTestFramework):
 
         # This will raise an exception due to insufficient fee
         reject_reason = "insufficient fee"
-        reject_details = f"{reject_reason}, rejecting replacement {tx.txid_hex}; new feerate 0.00300000 BTC/kvB <= old feerate 0.00300000 BTC/kvB"
+        reject_details = f"{reject_reason}, rejecting replacement {tx.txid_hex}, not enough additional fees to relay; 0.00 < 0.00000011"
         res = self.nodes[0].testmempoolaccept(rawtxs=[tx_hex])[0]
         assert_equal(res["reject-reason"], reject_reason)
         assert_equal(res["reject-details"], reject_details)
@@ -265,7 +267,7 @@ class ReplaceByFeeTest(BitcoinTestFramework):
         )["hex"]
 
         # This will raise an exception due to insufficient fee
-        assert_raises_rpc_error(-26, "insufficient fee", self.nodes[0].sendrawtransaction, tx1b_hex, 0)
+        assert_raises_rpc_error(-26, "does not improve feerate diagram", self.nodes[0].sendrawtransaction, tx1b_hex, 0)
 
     def test_spends_of_conflicting_outputs(self):
         """Replacements that spend conflicting tx outputs are rejected"""
@@ -315,9 +317,9 @@ class ReplaceByFeeTest(BitcoinTestFramework):
         assert_raises_rpc_error(-26, "bad-txns-spends-conflicting-tx", self.nodes[0].sendrawtransaction, tx2_hex, 0)
 
     def test_new_unconfirmed_inputs(self):
-        """Replacements that add new unconfirmed inputs are rejected"""
+        """Replacements that add new unconfirmed inputs may be accepted"""
         confirmed_utxo = self.make_utxo(self.nodes[0], int(1.1 * COIN))
-        unconfirmed_utxo = self.make_utxo(self.nodes[0], int(0.1 * COIN), confirmed=False)
+        unconfirmed_utxo = self.make_utxo(self.nodes[0], int(0.2 * COIN), confirmed=False)
 
         self.wallet.send_self_transfer(
             from_node=self.nodes[0],
@@ -333,19 +335,30 @@ class ReplaceByFeeTest(BitcoinTestFramework):
         )["tx"]
         tx2_hex = tx2.serialize().hex()
 
-        # This will raise an exception
-        reject_reason = "replacement-adds-unconfirmed"
-        reject_details = f"{reject_reason}, replacement {tx2.txid_hex} adds unconfirmed input, idx 1"
-        res = self.nodes[0].testmempoolaccept(rawtxs=[tx2_hex])[0]
-        assert_equal(res["reject-reason"], reject_reason)
-        assert_equal(res["reject-details"], reject_details)
-        assert_raises_rpc_error(-26, f"{reject_details}", self.nodes[0].sendrawtransaction, tx2_hex, 0)
+        # This will not raise an exception
+        tx2_id = self.nodes[0].sendrawtransaction(tx2_hex, 0)
+        assert tx2_id in self.nodes[0].getrawmempool()
+
+    def test_new_unconfirmed_input_with_low_feerate(self):
+        """Replacements that add new unconfirmed inputs are allowed, but must pass the feerate diagram check"""
+        confirmed_utxos = [self.make_utxo(self.nodes[0], int(1.1 * COIN)) for _ in range(3)]
+        large_low_feerate = self.wallet.create_self_transfer(utxo_to_spend=confirmed_utxos[0], target_vsize=10000, fee=Decimal("0.00001000"))
+        self.nodes[0].sendrawtransaction(large_low_feerate['hex'])
+        unconfirmed_utxo = large_low_feerate['new_utxo']
+
+        # These two transactions are approximately the same size. The replacement tx pays twice the fee.
+        tx_to_replace = self.wallet.create_self_transfer_multi(utxos_to_spend=[confirmed_utxos[1], confirmed_utxos[2]], fee_per_output=2000)
+        tx_replacement = self.wallet.create_self_transfer_multi(utxos_to_spend=[confirmed_utxos[1], unconfirmed_utxo], fee_per_output=4000)
+        assert_greater_than(tx_replacement['fee']*tx_to_replace['tx'].get_vsize(), tx_to_replace['fee']*tx_replacement['tx'].get_vsize())
+
+        self.nodes[0].sendrawtransaction(tx_to_replace['hex'])
+        assert_raises_rpc_error(-26, "insufficient feerate: does not improve feerate diagram", self.nodes[0].sendrawtransaction, tx_replacement['hex'])
 
 
     def test_too_many_replacements(self):
-        """Replacements that evict too many transactions are rejected"""
-        # Try directly replacing more than MAX_REPLACEMENT_LIMIT
-        # transactions
+        """Replacements that conflict with too many clusters are rejected"""
+        # Try directly replacing transactions in more than MAX_REPLACEMENT_LIMIT
+        # distinct clusters
 
         # Start by creating a single transaction with many outputs
         initial_nValue = 10 * COIN
@@ -385,7 +398,7 @@ class ReplaceByFeeTest(BitcoinTestFramework):
 
         # This will raise an exception
         reject_reason = "too many potential replacements"
-        reject_details = f"{reject_reason}, rejecting replacement {double_tx.txid_hex}; too many potential replacements ({MAX_REPLACEMENT_LIMIT + 1} > {MAX_REPLACEMENT_LIMIT})"
+        reject_details = f"{reject_reason}, rejecting replacement {double_tx.txid_hex}; too many conflicting clusters ({MAX_REPLACEMENT_LIMIT + 1} > {MAX_REPLACEMENT_LIMIT})"
         res = self.nodes[0].testmempoolaccept(rawtxs=[double_tx_hex])[0]
         assert_equal(res["reject-reason"], reject_reason)
         assert_equal(res["reject-details"], reject_details)
@@ -397,89 +410,6 @@ class ReplaceByFeeTest(BitcoinTestFramework):
         double_tx_hex = double_tx.serialize().hex()
         self.nodes[0].sendrawtransaction(double_tx_hex, 0)
 
-    def test_too_many_replacements_with_default_mempool_params(self):
-        """
-        Test rule 5 (do not allow replacements that cause more than 100
-        evictions) without having to rely on non-default mempool parameters.
-
-        In order to do this, create a number of "root" UTXOs, and then hang
-        enough transactions off of each root UTXO to exceed the MAX_REPLACEMENT_LIMIT.
-        Then create a conflicting RBF replacement transaction.
-        """
-        # Clear mempools to avoid cross-node sync failure.
-        for node in self.nodes:
-            self.generate(node, 1)
-        normal_node = self.nodes[1]
-        wallet = MiniWallet(normal_node)
-
-        # This has to be chosen so that the total number of transactions can exceed
-        # MAX_REPLACEMENT_LIMIT without having any one tx graph run into the descendant
-        # limit; 10 works.
-        num_tx_graphs = 10
-
-        # (Number of transactions per graph, rule 5 failure expected)
-        cases = [
-            # Test the base case of evicting fewer than MAX_REPLACEMENT_LIMIT
-            # transactions.
-            ((MAX_REPLACEMENT_LIMIT // num_tx_graphs) - 1, False),
-
-            # Test hitting the rule 5 eviction limit.
-            (MAX_REPLACEMENT_LIMIT // num_tx_graphs, True),
-        ]
-
-        for (txs_per_graph, failure_expected) in cases:
-            self.log.debug(f"txs_per_graph: {txs_per_graph}, failure: {failure_expected}")
-            # "Root" utxos of each txn graph that we will attempt to double-spend with
-            # an RBF replacement.
-            root_utxos = []
-
-            # For each root UTXO, create a package that contains the spend of that
-            # UTXO and `txs_per_graph` children tx.
-            for graph_num in range(num_tx_graphs):
-                root_utxos.append(wallet.get_utxo())
-
-                parent_tx = wallet.send_self_transfer_multi(
-                    from_node=normal_node,
-                    utxos_to_spend=[root_utxos[graph_num]],
-                    num_outputs=txs_per_graph,
-                )
-                new_utxos = parent_tx['new_utxos']
-
-                for utxo in new_utxos:
-                    # Create spends for each output from the "root" of this graph.
-                    child_tx = wallet.send_self_transfer(
-                        from_node=normal_node,
-                        utxo_to_spend=utxo,
-                    )
-
-                    assert normal_node.getmempoolentry(child_tx['txid'])
-
-            num_txs_invalidated = len(root_utxos) + (num_tx_graphs * txs_per_graph)
-
-            if failure_expected:
-                assert num_txs_invalidated > MAX_REPLACEMENT_LIMIT
-            else:
-                assert num_txs_invalidated <= MAX_REPLACEMENT_LIMIT
-
-            # Now attempt to submit a tx that double-spends all the root tx inputs, which
-            # would invalidate `num_txs_invalidated` transactions.
-            tx_hex = wallet.create_self_transfer_multi(
-                utxos_to_spend=root_utxos,
-                fee_per_output=10_000_000,  # absurdly high feerate
-            )["hex"]
-
-            if failure_expected:
-                assert_raises_rpc_error(
-                    -26, "too many potential replacements", normal_node.sendrawtransaction, tx_hex, 0)
-            else:
-                txid = normal_node.sendrawtransaction(tx_hex, 0)
-                assert normal_node.getmempoolentry(txid)
-
-        # Clear the mempool once finished, and rescan the other nodes' wallet
-        # to account for the spends we've made on `normal_node`.
-        self.generate(normal_node, 1)
-        self.wallet.rescan_utxos()
-
     def test_prioritised_transactions(self):
         # Ensure that fee deltas used via prioritisetransaction are
         # correctly used by replacement logic
@@ -503,7 +433,7 @@ class ReplaceByFeeTest(BitcoinTestFramework):
         )["hex"]
 
         # Verify tx1b cannot replace tx1a.
-        assert_raises_rpc_error(-26, "insufficient fee", self.nodes[0].sendrawtransaction, tx1b_hex, 0)
+        assert_raises_rpc_error(-26, "does not improve feerate diagram", self.nodes[0].sendrawtransaction, tx1b_hex, 0)
 
         # Use prioritisetransaction to set tx1a's fee to 0.
         self.nodes[0].prioritisetransaction(txid=tx1a_txid, fee_delta=int(-0.1 * COIN))
diff --git a/test/functional/mempool_ephemeral_dust.py b/test/functional/mempool_ephemeral_dust.py
index 712176e9348..a0308da72ac 100755
--- a/test/functional/mempool_ephemeral_dust.py
+++ b/test/functional/mempool_ephemeral_dust.py
@@ -419,8 +419,7 @@ class EphemeralDustTest(BitcoinTestFramework):
 
         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']} (wtxid={insufficient_sweep_tx['wtxid']}) did not spend parent's ephemeral dust")
-        assert_equal(res['tx-results'][insufficient_sweep_tx["wtxid"]]["error"], f"replacement-adds-unconfirmed, replacement {insufficient_sweep_tx['txid']} adds unconfirmed input, idx 46")
+        assert_equal(res['tx-results'][insufficient_sweep_tx["wtxid"]]["error"], f"missing-ephemeral-spends, tx {insufficient_sweep_tx['txid']} (wtxid={insufficient_sweep_tx['wtxid']}) 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
diff --git a/test/functional/mempool_package_rbf.py b/test/functional/mempool_package_rbf.py
index 3eb0abd37e3..759e3cb07d3 100755
--- a/test/functional/mempool_package_rbf.py
+++ b/test/functional/mempool_package_rbf.py
@@ -89,9 +89,6 @@ class PackageRBFTest(BitcoinTestFramework):
         self.test_too_numerous_ancestors()
         self.test_package_rbf_with_wrong_pkg_size()
         self.test_insufficient_feerate()
-        self.test_wrong_conflict_cluster_size_linear()
-        self.test_wrong_conflict_cluster_size_parents_child()
-        self.test_wrong_conflict_cluster_size_parent_children()
         self.test_0fee_package_rbf()
         self.test_child_conflicts_parent_mempool_ancestor()
 
@@ -193,12 +190,12 @@ class PackageRBFTest(BitcoinTestFramework):
 
     def test_package_rbf_max_conflicts(self):
         node = self.nodes[0]
-        self.log.info("Check Package RBF cannot replace more than MAX_REPLACEMENT_CANDIDATES transactions")
-        num_coins = 51
+        self.log.info("Check Package RBF cannot conflict with  more than MAX_REPLACEMENT_CANDIDATES clusters")
+        num_coins = 101
         parent_coins = self.coins[:num_coins]
         del self.coins[:num_coins]
 
-        # Original transactions: 51 transactions with 1 descendants each -> 102 total transactions
+        # Original transactions: 101 transactions with 1 descendants each -> 202 total transactions, 101 clusters
         size_two_clusters = []
         for coin in parent_coins:
             size_two_clusters.append(self.wallet.send_self_transfer_chain(from_node=node, chain_length=2, utxo_to_spend=coin))
@@ -213,12 +210,13 @@ class PackageRBFTest(BitcoinTestFramework):
         parent_fee_per_conflict = 10000
         child_feerate = 10000 * DEFAULT_FEE
 
-        # Conflict against all transactions by double-spending each parent, causing 102 evictions
+        # Conflict against all transactions by double-spending each parent, causing 101 cluster conflicts
         package_parent = self.wallet.create_self_transfer_multi(utxos_to_spend=parent_coins, fee_per_output=parent_fee_per_conflict)
         package_child = self.wallet.create_self_transfer(fee_rate=child_feerate, utxo_to_spend=package_parent["new_utxos"][0])
 
         pkg_results = node.submitpackage([package_parent["hex"], package_child["hex"]], maxfeerate=0)
-        assert_equal(f"package RBF failed: too many potential replacements, rejecting replacement {package_child['tx'].txid_hex}; too many potential replacements (102 > 100)", pkg_results["package_msg"])
+        assert_equal("transaction failed", pkg_results["package_msg"])
+        assert_equal(f"too many potential replacements, rejecting replacement {package_parent['txid']}; too many conflicting clusters (101 > 100)", pkg_results["tx-results"][package_parent["wtxid"]]["error"])
         self.assert_mempool_contents(expected=expected_txns)
 
         # Make singleton tx to conflict with in next batch
@@ -227,16 +225,17 @@ class PackageRBFTest(BitcoinTestFramework):
         node.sendrawtransaction(singleton_tx["hex"])
         expected_txns.append(singleton_tx["tx"])
 
-        # Double-spend same set minus last, and double-spend singleton. This hits 101 evictions; should still fail.
+        # Double-spend same set minus last, and double-spend singleton. This is still too many conflicted clusters.
         # N.B. we can't RBF just a child tx in the clusters, as that would make resulting cluster of size 3.
         double_spending_coins = parent_coins[:-1] + [singleton_coin]
         package_parent = self.wallet.create_self_transfer_multi(utxos_to_spend=double_spending_coins, fee_per_output=parent_fee_per_conflict)
         package_child = self.wallet.create_self_transfer(fee_rate=child_feerate, utxo_to_spend=package_parent["new_utxos"][0])
         pkg_results = node.submitpackage([package_parent["hex"], package_child["hex"]], maxfeerate=0)
-        assert_equal(f"package RBF failed: too many potential replacements, rejecting replacement {package_child['tx'].txid_hex}; too many potential replacements (101 > 100)", pkg_results["package_msg"])
+        assert_equal("transaction failed", pkg_results["package_msg"])
+        assert_equal(f"too many potential replacements, rejecting replacement {package_parent['txid']}; too many conflicting clusters (101 > 100)", pkg_results["tx-results"][package_parent["wtxid"]]["error"])
         self.assert_mempool_contents(expected=expected_txns)
 
-        # Finally, evict MAX_REPLACEMENT_CANDIDATES
+        # Finally, conflict with MAX_REPLACEMENT_CANDIDATES clusters
         package_parent = self.wallet.create_self_transfer_multi(utxos_to_spend=parent_coins[:-1], fee_per_output=parent_fee_per_conflict)
         package_child = self.wallet.create_self_transfer(fee_rate=child_feerate, utxo_to_spend=package_parent["new_utxos"][0])
         pkg_results = node.submitpackage([package_parent["hex"], package_child["hex"]], maxfeerate=0)
@@ -290,167 +289,6 @@ class PackageRBFTest(BitcoinTestFramework):
         self.assert_mempool_contents(expected=package_txns1 + package_txns2_succeed)
         self.generate(node, 1)
 
-    def test_wrong_conflict_cluster_size_linear(self):
-        self.log.info("Test that conflicting with a cluster not sized two is rejected: linear chain")
-        node = self.nodes[0]
-
-        # Coins we will conflict with
-        coin1 = self.coins.pop()
-        coin2 = self.coins.pop()
-        coin3 = self.coins.pop()
-
-        # Three transactions chained; package RBF against any of these
-        # should be rejected
-        self.ctr += 1
-        parent_result = self.wallet.create_self_transfer(
-            fee=DEFAULT_FEE,
-            utxo_to_spend=coin1,
-            sequence=MAX_BIP125_RBF_SEQUENCE - self.ctr,
-        )
-
-        self.ctr += 1
-        child_result = self.wallet.create_self_transfer_multi(
-            fee_per_output=int(DEFAULT_FEE * COIN),
-            utxos_to_spend=[parent_result["new_utxo"], coin2],
-            sequence=MAX_BIP125_RBF_SEQUENCE - self.ctr,
-        )
-
-        self.ctr += 1
-        grandchild_result = self.wallet.create_self_transfer_multi(
-            fee_per_output=int(DEFAULT_FEE * COIN),
-            utxos_to_spend=[child_result["new_utxos"][0], coin3],
-            sequence=MAX_BIP125_RBF_SEQUENCE - self.ctr,
-        )
-
-        expected_txns = [parent_result["tx"], child_result["tx"], grandchild_result["tx"]]
-        for tx in expected_txns:
-            node.sendrawtransaction(tx.serialize().hex())
-        self.assert_mempool_contents(expected=expected_txns)
-
-        # Now make conflicting packages for each coin
-        package_hex1, _package_txns1 = self.create_simple_package(coin1, DEFAULT_FEE, DEFAULT_CHILD_FEE)
-
-        package_result = node.submitpackage(package_hex1)
-        assert_equal(f"package RBF failed: {parent_result['tx'].txid_hex} has 2 descendants, max 1 allowed", package_result["package_msg"])
-
-        package_hex2, _package_txns2 = self.create_simple_package(coin2, DEFAULT_FEE, DEFAULT_CHILD_FEE)
-        package_result = node.submitpackage(package_hex2)
-        assert_equal(f"package RBF failed: {child_result['tx'].txid_hex} has both ancestor and descendant, exceeding cluster limit of 2", package_result["package_msg"])
-
-        package_hex3, _package_txns3 = self.create_simple_package(coin3, DEFAULT_FEE, DEFAULT_CHILD_FEE)
-        package_result = node.submitpackage(package_hex3)
-        assert_equal(f"package RBF failed: {grandchild_result['tx'].txid_hex} has 2 ancestors, max 1 allowed", package_result["package_msg"])
-
-        # Check that replacements were actually rejected
-        self.assert_mempool_contents(expected=expected_txns)
-        self.generate(node, 1)
-
-    def test_wrong_conflict_cluster_size_parents_child(self):
-        self.log.info("Test that conflicting with a cluster not sized two is rejected: two parents one child")
-        node = self.nodes[0]
-
-        # Coins we will conflict with
-        coin1 = self.coins.pop()
-        coin2 = self.coins.pop()
-        coin3 = self.coins.pop()
-
-        self.ctr += 1
-        parent1_result = self.wallet.create_self_transfer(
-            fee=DEFAULT_FEE,
-            utxo_to_spend=coin1,
-            sequence=MAX_BIP125_RBF_SEQUENCE - self.ctr,
-        )
-
-        self.ctr += 1
-        parent2_result = self.wallet.create_self_transfer_multi(
-            fee_per_output=int(DEFAULT_FEE * COIN),
-            utxos_to_spend=[coin2],
-            sequence=MAX_BIP125_RBF_SEQUENCE - self.ctr,
-        )
-
-        self.ctr += 1
-        child_result = self.wallet.create_self_transfer_multi(
-            fee_per_output=int(DEFAULT_FEE * COIN),
-            utxos_to_spend=[parent1_result["new_utxo"], parent2_result["new_utxos"][0], coin3],
-            sequence=MAX_BIP125_RBF_SEQUENCE - self.ctr,
-        )
-
-        expected_txns = [parent1_result["tx"], parent2_result["tx"], child_result["tx"]]
-        for tx in expected_txns:
-            node.sendrawtransaction(tx.serialize().hex())
-        self.assert_mempool_contents(expected=expected_txns)
-
-        # Now make conflicting packages for each coin
-        package_hex1, _package_txns1 = self.create_simple_package(coin1, DEFAULT_FEE, DEFAULT_CHILD_FEE)
-        package_result = node.submitpackage(package_hex1)
-        assert_equal(f"package RBF failed: {parent1_result['tx'].txid_hex} is not the only parent of child {child_result['tx'].txid_hex}", package_result["package_msg"])
-
-        package_hex2, _package_txns2 = self.create_simple_package(coin2, DEFAULT_FEE, DEFAULT_CHILD_FEE)
-        package_result = node.submitpackage(package_hex2)
-        assert_equal(f"package RBF failed: {child_result['tx'].txid_hex} has 2 ancestors, max 1 allowed", package_result["package_msg"])
-
-        package_hex3, _package_txns3 = self.create_simple_package(coin3, DEFAULT_FEE, DEFAULT_CHILD_FEE)
-        package_result = node.submitpackage(package_hex3)
-        assert_equal(f"package RBF failed: {child_result['tx'].txid_hex} has 2 ancestors, max 1 allowed", package_result["package_msg"])
-
-        # Check that replacements were actually rejected
-        self.assert_mempool_contents(expected=expected_txns)
-        self.generate(node, 1)
-
-    def test_wrong_conflict_cluster_size_parent_children(self):
-        self.log.info("Test that conflicting with a cluster not sized two is rejected: one parent two children")
-        node = self.nodes[0]
-
-        # Coins we will conflict with
-        coin1 = self.coins.pop()
-        coin2 = self.coins.pop()
-        coin3 = self.coins.pop()
-
-        self.ctr += 1
-        parent_result = self.wallet.create_self_transfer_multi(
-            fee_per_output=int(DEFAULT_FEE * COIN),
-            num_outputs=2,
-            utxos_to_spend=[coin1],
-            sequence=MAX_BIP125_RBF_SEQUENCE - self.ctr,
-        )
-
-        self.ctr += 1
-        child1_result = self.wallet.create_self_transfer_multi(
-            fee_per_output=int(DEFAULT_FEE * COIN),
-            utxos_to_spend=[parent_result["new_utxos"][0], coin2],
-            sequence=MAX_BIP125_RBF_SEQUENCE - self.ctr,
-        )
-
-        self.ctr += 1
-        child2_result = self.wallet.create_self_transfer_multi(
-            fee_per_output=int(DEFAULT_FEE * COIN),
-            utxos_to_spend=[parent_result["new_utxos"][1], coin3],
-            sequence=MAX_BIP125_RBF_SEQUENCE - self.ctr,
-        )
-
-        # Submit them to mempool
-        expected_txns = [parent_result["tx"], child1_result["tx"], child2_result["tx"]]
-        for tx in expected_txns:
-            node.sendrawtransaction(tx.serialize().hex())
-        self.assert_mempool_contents(expected=expected_txns)
-
-        # Now make conflicting packages for each coin
-        package_hex1, _package_txns1 = self.create_simple_package(coin1, DEFAULT_FEE, DEFAULT_CHILD_FEE)
-        package_result = node.submitpackage(package_hex1)
-        assert_equal(f"package RBF failed: {child1_result['tx'].txid_hex} is not the only child of parent {parent_result['tx'].txid_hex}", package_result["package_msg"])
-
-        package_hex2, _package_txns2 = self.create_simple_package(coin2, DEFAULT_FEE, DEFAULT_CHILD_FEE)
-        package_result = node.submitpackage(package_hex2)
-        assert_equal(f"package RBF failed: {child1_result['tx'].txid_hex} is not the only child of parent {parent_result['tx'].txid_hex}", package_result["package_msg"])
-
-        package_hex3, _package_txns3 = self.create_simple_package(coin3, DEFAULT_FEE, DEFAULT_CHILD_FEE)
-        package_result = node.submitpackage(package_hex3)
-        assert_equal(f"package RBF failed: {child2_result['tx'].txid_hex} is not the only child of parent {parent_result['tx'].txid_hex}", package_result["package_msg"])
-
-        # Check that replacements were actually rejected
-        self.assert_mempool_contents(expected=expected_txns)
-        self.generate(node, 1)
-
     def test_package_rbf_with_wrong_pkg_size(self):
         self.log.info("Test that package RBF doesn't work with packages larger than 2 due to pkg size")
         node = self.nodes[0]
diff --git a/test/functional/mempool_truc.py b/test/functional/mempool_truc.py
index 098631b5c41..23726330cc7 100755
--- a/test/functional/mempool_truc.py
+++ b/test/functional/mempool_truc.py
@@ -513,7 +513,7 @@ class MempoolTRUC(BitcoinTestFramework):
         tx_v3_child_2_rule6 = self.wallet.create_self_transfer(
             utxo_to_spend=tx_v3_parent["new_utxos"][1], fee_rate=DEFAULT_FEE, version=3
         )
-        rule6_str = f"insufficient fee (including sibling eviction), rejecting replacement {tx_v3_child_2_rule6['txid']}; new feerate"
+        rule6_str = f"insufficient fee (including sibling eviction), rejecting replacement {tx_v3_child_2_rule6['txid']}"
         assert_raises_rpc_error(-26, rule6_str, node.sendrawtransaction, tx_v3_child_2_rule6["hex"])
         self.check_mempool([tx_v3_parent['txid'], tx_v3_child_1['txid']])
 
@@ -544,11 +544,6 @@ class MempoolTRUC(BitcoinTestFramework):
         tx_v3_replacement_only = self.wallet.create_self_transfer_multi(utxos_to_spend=utxos_for_conflict, fee_per_output=4000000)
         # Override maxfeerate - it costs a lot to replace these 100 transactions.
         assert node.testmempoolaccept([tx_v3_replacement_only["hex"]], maxfeerate=0)[0]["allowed"]
-        # Adding another one exceeds the limit.
-        utxos_for_conflict.append(tx_v3_parent["new_utxos"][1])
-        tx_v3_child_2_rule5 = self.wallet.create_self_transfer_multi(utxos_to_spend=utxos_for_conflict, fee_per_output=4000000, version=3)
-        rule5_str = f"too many potential replacements (including sibling eviction), rejecting replacement {tx_v3_child_2_rule5['txid']}; too many potential replacements (101 > 100)"
-        assert_raises_rpc_error(-26, rule5_str, node.sendrawtransaction, tx_v3_child_2_rule5["hex"])
         self.check_mempool(txids_v2_100 + [tx_v3_parent["txid"], tx_v3_child_1["txid"]])
 
         self.log.info("Test sibling eviction is successful if it meets all RBF rules")
@@ -566,7 +561,7 @@ class MempoolTRUC(BitcoinTestFramework):
         fee_to_beat = max(int(tx_v3_child_2["fee"] * COIN), int(tx_unrelated_replacee["fee"]*COIN))
 
         tx_v3_child_3 = self.wallet.create_self_transfer_multi(
-            utxos_to_spend=[tx_v3_parent["new_utxos"][0], utxo_unrelated_conflict], fee_per_output=fee_to_beat*2, version=3
+            utxos_to_spend=[tx_v3_parent["new_utxos"][0], utxo_unrelated_conflict], fee_per_output=fee_to_beat*4, version=3
         )
         node.sendrawtransaction(tx_v3_child_3["hex"])
         self.check_mempool(txids_v2_100 + [tx_v3_parent["txid"], tx_v3_child_3["txid"]])

From 6445aa7d97551ec5d501d91f6829071c67169122 Mon Sep 17 00:00:00 2001
From: Suhas Daftuar <sdaftuar@chaincode.com>
Date: Thu, 21 Sep 2023 14:45:20 -0400
Subject: [PATCH 22/65] Remove the ancestor and descendant indices from the
 mempool

---
 src/test/mempool_tests.cpp | 316 -------------------------------------
 src/txmempool.cpp          |   4 +-
 src/txmempool.h            |  77 ---------
 3 files changed, 2 insertions(+), 395 deletions(-)

diff --git a/src/test/mempool_tests.cpp b/src/test/mempool_tests.cpp
index ec3bbd158fe..2271e7b88db 100644
--- a/src/test/mempool_tests.cpp
+++ b/src/test/mempool_tests.cpp
@@ -115,322 +115,6 @@ BOOST_AUTO_TEST_CASE(MempoolRemoveTest)
     BOOST_CHECK_EQUAL(testPool.size(), 0U);
 }
 
-template <typename name>
-static void CheckSort(CTxMemPool& pool, std::vector<std::string>& sortedOrder) EXCLUSIVE_LOCKS_REQUIRED(pool.cs)
-{
-    BOOST_CHECK_EQUAL(pool.size(), sortedOrder.size());
-    typename CTxMemPool::indexed_transaction_set::index<name>::type::iterator it = pool.mapTx.get<name>().begin();
-    int count = 0;
-    for (; it != pool.mapTx.get<name>().end(); ++it, ++count) {
-        BOOST_CHECK_EQUAL(it->GetTx().GetHash().ToString(), sortedOrder[count]);
-    }
-}
-
-BOOST_AUTO_TEST_CASE(MempoolIndexingTest)
-{
-    CTxMemPool& pool = *Assert(m_node.mempool);
-    LOCK2(cs_main, pool.cs);
-    TestMemPoolEntryHelper entry;
-
-    /* 3rd highest fee */
-    CMutableTransaction tx1 = CMutableTransaction();
-    tx1.vout.resize(1);
-    tx1.vout[0].scriptPubKey = CScript() << OP_11 << OP_EQUAL;
-    tx1.vout[0].nValue = 10 * COIN;
-    AddToMempool(pool, entry.Fee(10000LL).FromTx(tx1));
-
-    /* highest fee */
-    CMutableTransaction tx2 = CMutableTransaction();
-    tx2.vout.resize(1);
-    tx2.vout[0].scriptPubKey = CScript() << OP_11 << OP_EQUAL;
-    tx2.vout[0].nValue = 2 * COIN;
-    AddToMempool(pool, entry.Fee(20000LL).FromTx(tx2));
-
-    /* lowest fee */
-    CMutableTransaction tx3 = CMutableTransaction();
-    tx3.vout.resize(1);
-    tx3.vout[0].scriptPubKey = CScript() << OP_11 << OP_EQUAL;
-    tx3.vout[0].nValue = 5 * COIN;
-    AddToMempool(pool, entry.Fee(0LL).FromTx(tx3));
-
-    /* 2nd highest fee */
-    CMutableTransaction tx4 = CMutableTransaction();
-    tx4.vout.resize(1);
-    tx4.vout[0].scriptPubKey = CScript() << OP_11 << OP_EQUAL;
-    tx4.vout[0].nValue = 6 * COIN;
-    AddToMempool(pool, entry.Fee(15000LL).FromTx(tx4));
-
-    /* equal fee rate to tx1, but newer */
-    CMutableTransaction tx5 = CMutableTransaction();
-    tx5.vout.resize(1);
-    tx5.vout[0].scriptPubKey = CScript() << OP_11 << OP_EQUAL;
-    tx5.vout[0].nValue = 11 * COIN;
-    entry.time = NodeSeconds{1s};
-    AddToMempool(pool, entry.Fee(10000LL).FromTx(tx5));
-    BOOST_CHECK_EQUAL(pool.size(), 5U);
-
-    std::vector<std::string> sortedOrder;
-    sortedOrder.resize(5);
-    sortedOrder[0] = tx3.GetHash().ToString(); // 0
-    sortedOrder[1] = tx5.GetHash().ToString(); // 10000
-    sortedOrder[2] = tx1.GetHash().ToString(); // 10000
-    sortedOrder[3] = tx4.GetHash().ToString(); // 15000
-    sortedOrder[4] = tx2.GetHash().ToString(); // 20000
-    CheckSort<descendant_score>(pool, sortedOrder);
-
-    /* low fee but with high fee child */
-    /* tx6 -> tx7 -> tx8, tx9 -> tx10 */
-    CMutableTransaction tx6 = CMutableTransaction();
-    tx6.vout.resize(1);
-    tx6.vout[0].scriptPubKey = CScript() << OP_11 << OP_EQUAL;
-    tx6.vout[0].nValue = 20 * COIN;
-    AddToMempool(pool, entry.Fee(0LL).FromTx(tx6));
-    BOOST_CHECK_EQUAL(pool.size(), 6U);
-    // Check that at this point, tx6 is sorted low
-    sortedOrder.insert(sortedOrder.begin(), tx6.GetHash().ToString());
-    CheckSort<descendant_score>(pool, sortedOrder);
-
-    CTxMemPool::setEntries setAncestors;
-    setAncestors.insert(pool.GetIter(tx6.GetHash()).value());
-    CMutableTransaction tx7 = CMutableTransaction();
-    tx7.vin.resize(1);
-    tx7.vin[0].prevout = COutPoint(tx6.GetHash(), 0);
-    tx7.vin[0].scriptSig = CScript() << OP_11;
-    tx7.vout.resize(2);
-    tx7.vout[0].scriptPubKey = CScript() << OP_11 << OP_EQUAL;
-    tx7.vout[0].nValue = 10 * COIN;
-    tx7.vout[1].scriptPubKey = CScript() << OP_11 << OP_EQUAL;
-    tx7.vout[1].nValue = 1 * COIN;
-
-    {
-        auto ancestors_calculated{pool.CalculateMemPoolAncestors(entry.Fee(2000000LL).FromTx(tx7), CTxMemPool::Limits::NoLimits())};
-        BOOST_REQUIRE(ancestors_calculated.has_value());
-        BOOST_CHECK(*ancestors_calculated == setAncestors);
-    }
-
-    AddToMempool(pool, entry.FromTx(tx7));
-    BOOST_CHECK_EQUAL(pool.size(), 7U);
-
-    // Now tx6 should be sorted higher (high fee child): tx7, tx6, tx2, ...
-    sortedOrder.erase(sortedOrder.begin());
-    sortedOrder.push_back(tx6.GetHash().ToString());
-    sortedOrder.push_back(tx7.GetHash().ToString());
-    CheckSort<descendant_score>(pool, sortedOrder);
-
-    /* low fee child of tx7 */
-    CMutableTransaction tx8 = CMutableTransaction();
-    tx8.vin.resize(1);
-    tx8.vin[0].prevout = COutPoint(tx7.GetHash(), 0);
-    tx8.vin[0].scriptSig = CScript() << OP_11;
-    tx8.vout.resize(1);
-    tx8.vout[0].scriptPubKey = CScript() << OP_11 << OP_EQUAL;
-    tx8.vout[0].nValue = 10 * COIN;
-    setAncestors.insert(pool.GetIter(tx7.GetHash()).value());
-    AddToMempool(pool, entry.Fee(0LL).Time(NodeSeconds{2s}).FromTx(tx8));
-
-    // Now tx8 should be sorted low, but tx6/tx both high
-    sortedOrder.insert(sortedOrder.begin(), tx8.GetHash().ToString());
-    CheckSort<descendant_score>(pool, sortedOrder);
-
-    /* low fee child of tx7 */
-    CMutableTransaction tx9 = CMutableTransaction();
-    tx9.vin.resize(1);
-    tx9.vin[0].prevout = COutPoint(tx7.GetHash(), 1);
-    tx9.vin[0].scriptSig = CScript() << OP_11;
-    tx9.vout.resize(1);
-    tx9.vout[0].scriptPubKey = CScript() << OP_11 << OP_EQUAL;
-    tx9.vout[0].nValue = 1 * COIN;
-    AddToMempool(pool, entry.Fee(0LL).Time(NodeSeconds{3s}).FromTx(tx9));
-
-    // tx9 should be sorted low
-    BOOST_CHECK_EQUAL(pool.size(), 9U);
-    sortedOrder.insert(sortedOrder.begin(), tx9.GetHash().ToString());
-    CheckSort<descendant_score>(pool, sortedOrder);
-
-    std::vector<std::string> snapshotOrder = sortedOrder;
-
-    setAncestors.insert(pool.GetIter(tx8.GetHash()).value());
-    setAncestors.insert(pool.GetIter(tx9.GetHash()).value());
-    /* tx10 depends on tx8 and tx9 and has a high fee*/
-    CMutableTransaction tx10 = CMutableTransaction();
-    tx10.vin.resize(2);
-    tx10.vin[0].prevout = COutPoint(tx8.GetHash(), 0);
-    tx10.vin[0].scriptSig = CScript() << OP_11;
-    tx10.vin[1].prevout = COutPoint(tx9.GetHash(), 0);
-    tx10.vin[1].scriptSig = CScript() << OP_11;
-    tx10.vout.resize(1);
-    tx10.vout[0].scriptPubKey = CScript() << OP_11 << OP_EQUAL;
-    tx10.vout[0].nValue = 10 * COIN;
-
-    {
-        auto ancestors_calculated{pool.CalculateMemPoolAncestors(entry.Fee(200000LL).Time(NodeSeconds{4s}).FromTx(tx10), CTxMemPool::Limits::NoLimits())};
-        BOOST_REQUIRE(ancestors_calculated);
-        BOOST_CHECK(*ancestors_calculated == setAncestors);
-    }
-
-    AddToMempool(pool, entry.FromTx(tx10));
-
-    /**
-     *  tx8 and tx9 should both now be sorted higher
-     *  Final order after tx10 is added:
-     *
-     *  tx3 = 0 (1)
-     *  tx5 = 10000 (1)
-     *  tx1 = 10000 (1)
-     *  tx4 = 15000 (1)
-     *  tx2 = 20000 (1)
-     *  tx9 = 200k (2 txs)
-     *  tx8 = 200k (2 txs)
-     *  tx10 = 200k (1 tx)
-     *  tx6 = 2.2M (5 txs)
-     *  tx7 = 2.2M (4 txs)
-     */
-    sortedOrder.erase(sortedOrder.begin(), sortedOrder.begin()+2); // take out tx9, tx8 from the beginning
-    sortedOrder.insert(sortedOrder.begin()+5, tx9.GetHash().ToString());
-    sortedOrder.insert(sortedOrder.begin()+6, tx8.GetHash().ToString());
-    sortedOrder.insert(sortedOrder.begin()+7, tx10.GetHash().ToString()); // tx10 is just before tx6
-    CheckSort<descendant_score>(pool, sortedOrder);
-
-    // there should be 10 transactions in the mempool
-    BOOST_CHECK_EQUAL(pool.size(), 10U);
-
-    // Now try removing tx10 and verify the sort order returns to normal
-    pool.removeRecursive(*Assert(pool.get(tx10.GetHash())), REMOVAL_REASON_DUMMY);
-    CheckSort<descendant_score>(pool, snapshotOrder);
-
-    pool.removeRecursive(*Assert(pool.get(tx9.GetHash())), REMOVAL_REASON_DUMMY);
-    pool.removeRecursive(*Assert(pool.get(tx8.GetHash())), REMOVAL_REASON_DUMMY);
-}
-
-BOOST_AUTO_TEST_CASE(MempoolAncestorIndexingTest)
-{
-    CTxMemPool& pool = *Assert(m_node.mempool);
-    LOCK2(cs_main, pool.cs);
-    TestMemPoolEntryHelper entry;
-
-    /* 3rd highest fee */
-    CMutableTransaction tx1 = CMutableTransaction();
-    tx1.vout.resize(1);
-    tx1.vout[0].scriptPubKey = CScript() << OP_11 << OP_EQUAL;
-    tx1.vout[0].nValue = 10 * COIN;
-    AddToMempool(pool, entry.Fee(10000LL).FromTx(tx1));
-
-    /* highest fee */
-    CMutableTransaction tx2 = CMutableTransaction();
-    tx2.vout.resize(1);
-    tx2.vout[0].scriptPubKey = CScript() << OP_11 << OP_EQUAL;
-    tx2.vout[0].nValue = 2 * COIN;
-    AddToMempool(pool, entry.Fee(20000LL).FromTx(tx2));
-    uint64_t tx2Size = GetVirtualTransactionSize(CTransaction(tx2));
-
-    /* lowest fee */
-    CMutableTransaction tx3 = CMutableTransaction();
-    tx3.vout.resize(1);
-    tx3.vout[0].scriptPubKey = CScript() << OP_11 << OP_EQUAL;
-    tx3.vout[0].nValue = 5 * COIN;
-    AddToMempool(pool, entry.Fee(0LL).FromTx(tx3));
-
-    /* 2nd highest fee */
-    CMutableTransaction tx4 = CMutableTransaction();
-    tx4.vout.resize(1);
-    tx4.vout[0].scriptPubKey = CScript() << OP_11 << OP_EQUAL;
-    tx4.vout[0].nValue = 6 * COIN;
-    AddToMempool(pool, entry.Fee(15000LL).FromTx(tx4));
-
-    /* equal fee rate to tx1, but newer */
-    CMutableTransaction tx5 = CMutableTransaction();
-    tx5.vout.resize(1);
-    tx5.vout[0].scriptPubKey = CScript() << OP_11 << OP_EQUAL;
-    tx5.vout[0].nValue = 11 * COIN;
-    AddToMempool(pool, entry.Fee(10000LL).FromTx(tx5));
-    BOOST_CHECK_EQUAL(pool.size(), 5U);
-
-    std::vector<std::string> sortedOrder;
-    sortedOrder.resize(5);
-    sortedOrder[0] = tx2.GetHash().ToString(); // 20000
-    sortedOrder[1] = tx4.GetHash().ToString(); // 15000
-    // tx1 and tx5 are both 10000
-    // Ties are broken by hash, not timestamp, so determine which
-    // hash comes first.
-    if (tx1.GetHash() < tx5.GetHash()) {
-        sortedOrder[2] = tx1.GetHash().ToString();
-        sortedOrder[3] = tx5.GetHash().ToString();
-    } else {
-        sortedOrder[2] = tx5.GetHash().ToString();
-        sortedOrder[3] = tx1.GetHash().ToString();
-    }
-    sortedOrder[4] = tx3.GetHash().ToString(); // 0
-
-    CheckSort<ancestor_score>(pool, sortedOrder);
-
-    /* low fee parent with high fee child */
-    /* tx6 (0) -> tx7 (high) */
-    CMutableTransaction tx6 = CMutableTransaction();
-    tx6.vout.resize(1);
-    tx6.vout[0].scriptPubKey = CScript() << OP_11 << OP_EQUAL;
-    tx6.vout[0].nValue = 20 * COIN;
-    uint64_t tx6Size = GetVirtualTransactionSize(CTransaction(tx6));
-
-    AddToMempool(pool, entry.Fee(0LL).FromTx(tx6));
-    BOOST_CHECK_EQUAL(pool.size(), 6U);
-    // Ties are broken by hash
-    if (tx3.GetHash() < tx6.GetHash())
-        sortedOrder.push_back(tx6.GetHash().ToString());
-    else
-        sortedOrder.insert(sortedOrder.end()-1,tx6.GetHash().ToString());
-
-    CheckSort<ancestor_score>(pool, sortedOrder);
-
-    CMutableTransaction tx7 = CMutableTransaction();
-    tx7.vin.resize(1);
-    tx7.vin[0].prevout = COutPoint(tx6.GetHash(), 0);
-    tx7.vin[0].scriptSig = CScript() << OP_11;
-    tx7.vout.resize(1);
-    tx7.vout[0].scriptPubKey = CScript() << OP_11 << OP_EQUAL;
-    tx7.vout[0].nValue = 10 * COIN;
-    uint64_t tx7Size = GetVirtualTransactionSize(CTransaction(tx7));
-
-    /* set the fee to just below tx2's feerate when including ancestor */
-    CAmount fee = (20000/tx2Size)*(tx7Size + tx6Size) - 1;
-
-    AddToMempool(pool, entry.Fee(fee).FromTx(tx7));
-    BOOST_CHECK_EQUAL(pool.size(), 7U);
-    sortedOrder.insert(sortedOrder.begin()+1, tx7.GetHash().ToString());
-    CheckSort<ancestor_score>(pool, sortedOrder);
-
-    /* after tx6 is mined, tx7 should move up in the sort */
-    std::vector<CTransactionRef> vtx;
-    vtx.push_back(MakeTransactionRef(tx6));
-    pool.removeForBlock(vtx, 1);
-
-    sortedOrder.erase(sortedOrder.begin()+1);
-    // Ties are broken by hash
-    if (tx3.GetHash() < tx6.GetHash())
-        sortedOrder.pop_back();
-    else
-        sortedOrder.erase(sortedOrder.end()-2);
-    sortedOrder.insert(sortedOrder.begin(), tx7.GetHash().ToString());
-    CheckSort<ancestor_score>(pool, sortedOrder);
-
-    // High-fee parent, low-fee child
-    // tx7 -> tx8
-    CMutableTransaction tx8 = CMutableTransaction();
-    tx8.vin.resize(1);
-    tx8.vin[0].prevout  = COutPoint(tx7.GetHash(), 0);
-    tx8.vin[0].scriptSig = CScript() << OP_11;
-    tx8.vout.resize(1);
-    tx8.vout[0].scriptPubKey = CScript() << OP_11 << OP_EQUAL;
-    tx8.vout[0].nValue = 10*COIN;
-
-    // Check that we sort by min(feerate, ancestor_feerate):
-    // set the fee so that the ancestor feerate is above tx1/5,
-    // but the transaction's own feerate is lower
-    AddToMempool(pool, entry.Fee(5000LL).FromTx(tx8));
-    sortedOrder.insert(sortedOrder.end()-1, tx8.GetHash().ToString());
-    CheckSort<ancestor_score>(pool, sortedOrder);
-}
-
-
 BOOST_AUTO_TEST_CASE(MempoolSizeLimitTest)
 {
     auto& pool = static_cast<MemPoolTest&>(*Assert(m_node.mempool));
diff --git a/src/txmempool.cpp b/src/txmempool.cpp
index 15b2508119c..f2a63c26d26 100644
--- a/src/txmempool.cpp
+++ b/src/txmempool.cpp
@@ -1057,8 +1057,8 @@ void CCoinsViewMemPool::Reset()
 
 size_t CTxMemPool::DynamicMemoryUsage() const {
     LOCK(cs);
-    // Estimate the overhead of mapTx to be 15 pointers + an allocation, as no exact formula for boost::multi_index_contained is implemented.
-    return memusage::MallocUsage(sizeof(CTxMemPoolEntry) + 15 * sizeof(void*)) * mapTx.size() + memusage::DynamicUsage(mapNextTx) + memusage::DynamicUsage(mapDeltas) + memusage::DynamicUsage(txns_randomized) + m_txgraph->GetMainMemoryUsage() + cachedInnerUsage;
+    // Estimate the overhead of mapTx to be 9 pointers (3 pointers per index) + an allocation, as no exact formula for boost::multi_index_contained is implemented.
+    return memusage::MallocUsage(sizeof(CTxMemPoolEntry) + 9 * sizeof(void*)) * mapTx.size() + memusage::DynamicUsage(mapNextTx) + memusage::DynamicUsage(mapDeltas) + memusage::DynamicUsage(txns_randomized) + m_txgraph->GetMainMemoryUsage() + cachedInnerUsage;
 }
 
 void CTxMemPool::RemoveUnbroadcastTx(const Txid& txid, const bool unchecked) {
diff --git a/src/txmempool.h b/src/txmempool.h
index 1750596c0cf..5834cd0065a 100644
--- a/src/txmempool.h
+++ b/src/txmempool.h
@@ -90,37 +90,6 @@ struct mempoolentry_wtxid
     }
 };
 
-
-/** \class CompareTxMemPoolEntryByDescendantScore
- *
- *  Sort an entry by max(score/size of entry's tx, score/size with all descendants).
- */
-class CompareTxMemPoolEntryByDescendantScore
-{
-public:
-    bool operator()(const CTxMemPoolEntry& a, const CTxMemPoolEntry& b) const
-    {
-        FeeFrac f1 = GetModFeeAndSize(a);
-        FeeFrac f2 = GetModFeeAndSize(b);
-
-        if (FeeRateCompare(f1, f2) == 0) {
-            return a.GetTime() >= b.GetTime();
-        }
-        return f1 < f2;
-    }
-
-    // Return the fee/size we're using for sorting this entry.
-    FeeFrac GetModFeeAndSize(const CTxMemPoolEntry &a) const
-    {
-        // Compare feerate with descendants to feerate of the transaction, and
-        // return the fee/size for the max.
-        return std::max<FeeFrac>(
-            FeeFrac(a.GetModFeesWithDescendants(), a.GetSizeWithDescendants()),
-            FeeFrac(a.GetModifiedFee(), a.GetTxSize())
-        );
-    }
-};
-
 /** \class CompareTxMemPoolEntryByScore
  *
  *  Sort by feerate of entry (fee/size) in descending order
@@ -151,42 +120,8 @@ public:
     }
 };
 
-/** \class CompareTxMemPoolEntryByAncestorScore
- *
- *  Sort an entry by min(score/size of entry's tx, score/size with all ancestors).
- */
-class CompareTxMemPoolEntryByAncestorFee
-{
-public:
-    template<typename T>
-    bool operator()(const T& a, const T& b) const
-    {
-        FeeFrac f1 = GetModFeeAndSize(a);
-        FeeFrac f2 = GetModFeeAndSize(b);
-
-        if (FeeRateCompare(f1, f2) == 0) {
-            return a.GetTx().GetHash() < b.GetTx().GetHash();
-        }
-        return f1 > f2;
-    }
-
-    // Return the fee/size we're using for sorting this entry.
-    template <typename T>
-    FeeFrac GetModFeeAndSize(const T &a) const
-    {
-        // Compare feerate with ancestors to feerate of the transaction, and
-        // return the fee/size for the min.
-        return std::min<FeeFrac>(
-            FeeFrac(a.GetModFeesWithAncestors(), a.GetSizeWithAncestors()),
-            FeeFrac(a.GetModifiedFee(), a.GetTxSize())
-        );
-    }
-};
-
 // Multi_index tag names
-struct descendant_score {};
 struct entry_time {};
-struct ancestor_score {};
 struct index_by_wtxid {};
 
 /**
@@ -321,23 +256,11 @@ public:
                 mempoolentry_wtxid,
                 SaltedWtxidHasher
             >,
-            // sorted by fee rate
-            boost::multi_index::ordered_non_unique<
-                boost::multi_index::tag<descendant_score>,
-                boost::multi_index::identity<CTxMemPoolEntry>,
-                CompareTxMemPoolEntryByDescendantScore
-            >,
             // sorted by entry time
             boost::multi_index::ordered_non_unique<
                 boost::multi_index::tag<entry_time>,
                 boost::multi_index::identity<CTxMemPoolEntry>,
                 CompareTxMemPoolEntryByEntryTime
-            >,
-            // sorted by fee rate with ancestors
-            boost::multi_index::ordered_non_unique<
-                boost::multi_index::tag<ancestor_score>,
-                boost::multi_index::identity<CTxMemPoolEntry>,
-                CompareTxMemPoolEntryByAncestorFee
             >
         >
         {};

From 21b5cea588a7bfe758a8d14efe90046b111db428 Mon Sep 17 00:00:00 2001
From: Suhas Daftuar <sdaftuar@chaincode.com>
Date: Wed, 27 Sep 2023 14:47:42 -0400
Subject: [PATCH 23/65] Use cluster linearization for transaction relay sort
 order

Previously, transaction batches were first sorted by ancestor count and then
feerate, to ensure transactions are announced in a topologically valid order,
while prioritizing higher feerate transactions. Ancestor count is a crude
topological sort criteria, so replace this with linearization order so that the
highest feerate transactions (as would be observed by the mining algorithm) are
relayed before lower feerate ones, in a topologically valid way.

This also fixes a test that only worked due to the ancestor-count-based sort
order.
---
 src/net_processing.cpp              |  4 ++--
 src/txmempool.cpp                   | 18 +++++++-----------
 src/txmempool.h                     |  2 +-
 test/functional/mempool_packages.py | 26 +++++++++++---------------
 4 files changed, 21 insertions(+), 29 deletions(-)

diff --git a/src/net_processing.cpp b/src/net_processing.cpp
index 37778322151..f60ab27b187 100644
--- a/src/net_processing.cpp
+++ b/src/net_processing.cpp
@@ -5425,8 +5425,8 @@ public:
     bool operator()(std::set<Wtxid>::iterator a, std::set<Wtxid>::iterator b)
     {
         /* As std::make_heap produces a max-heap, we want the entries with the
-         * fewest ancestors/highest fee to sort later. */
-        return m_mempool->CompareDepthAndScore(*b, *a);
+         * higher mining score to sort later. */
+        return m_mempool->CompareMiningScoreWithTopology(*b, *a);
     }
 };
 } // namespace
diff --git a/src/txmempool.cpp b/src/txmempool.cpp
index f2a63c26d26..fa7da083a14 100644
--- a/src/txmempool.cpp
+++ b/src/txmempool.cpp
@@ -803,24 +803,20 @@ void CTxMemPool::check(const CCoinsViewCache& active_coins_tip, int64_t spendhei
     assert(innerUsage == cachedInnerUsage);
 }
 
-bool CTxMemPool::CompareDepthAndScore(const Wtxid& hasha, const Wtxid& hashb) const
+bool CTxMemPool::CompareMiningScoreWithTopology(const Wtxid& hasha, const Wtxid& hashb) const
 {
-    /* Return `true` if hasha should be considered sooner than hashb. Namely when:
-     *   a is not in the mempool, but b is
-     *   both are in the mempool and a has fewer ancestors than b
-     *   both are in the mempool and a has a higher score than b
+    /* Return `true` if hasha should be considered sooner than hashb, namely when:
+     *     a is not in the mempool but b is, or
+     *     both are in the mempool but a is sorted before b in the total mempool ordering
+     *     (which takes dependencies and (chunk) feerates into account).
      */
     LOCK(cs);
     auto j{GetIter(hashb)};
     if (!j.has_value()) return false;
     auto i{GetIter(hasha)};
     if (!i.has_value()) return true;
-    uint64_t counta = i.value()->GetCountWithAncestors();
-    uint64_t countb = j.value()->GetCountWithAncestors();
-    if (counta == countb) {
-        return CompareTxMemPoolEntryByScore()(*i.value(), *j.value());
-    }
-    return counta < countb;
+
+    return m_txgraph->CompareMainOrder(*i.value(), *j.value()) < 0;
 }
 
 namespace {
diff --git a/src/txmempool.h b/src/txmempool.h
index 5834cd0065a..232538aec36 100644
--- a/src/txmempool.h
+++ b/src/txmempool.h
@@ -379,7 +379,7 @@ public:
     void removeConflicts(const CTransaction& tx) EXCLUSIVE_LOCKS_REQUIRED(cs);
     void removeForBlock(const std::vector<CTransactionRef>& vtx, unsigned int nBlockHeight) EXCLUSIVE_LOCKS_REQUIRED(cs);
 
-    bool CompareDepthAndScore(const Wtxid& hasha, const Wtxid& hashb) const;
+    bool CompareMiningScoreWithTopology(const Wtxid& hasha, const Wtxid& hashb) const;
     bool isSpent(const COutPoint& outpoint) const;
     unsigned int GetTransactionsUpdated() const;
     void AddTransactionsUpdated(unsigned int n);
diff --git a/test/functional/mempool_packages.py b/test/functional/mempool_packages.py
index b5f994e8030..8f53d913c96 100755
--- a/test/functional/mempool_packages.py
+++ b/test/functional/mempool_packages.py
@@ -245,21 +245,17 @@ class MempoolPackagesTest(BitcoinTestFramework):
         mempool1 = self.nodes[1].getrawmempool(False)
         assert set(mempool1).issubset(set(mempool0))
         assert parent_transaction in mempool1
-        # Note: this test is brittle, because it relies on the relay sort order
-        # of node0 to be based on ancestor count (so that the first 10
-        # descendants of parent_transaction relay before the later ones).
-        for tx in chain[:CUSTOM_DESCENDANT_LIMIT-1]:
-            assert tx in mempool1
-        for tx in chain[CUSTOM_DESCENDANT_LIMIT:]:
-            assert tx not in mempool1
-        for tx in mempool1:
-            entry0 = self.nodes[0].getmempoolentry(tx)
-            entry1 = self.nodes[1].getmempoolentry(tx)
-            assert not entry0['unbroadcast']
-            assert not entry1['unbroadcast']
-            assert_equal(entry1['fees']['base'], entry0['fees']['base'])
-            assert_equal(entry1['vsize'], entry0['vsize'])
-            assert_equal(entry1['depends'], entry0['depends'])
+        for tx in chain:
+            if tx in mempool1:
+                entry0 = self.nodes[0].getmempoolentry(tx)
+                entry1 = self.nodes[1].getmempoolentry(tx)
+                assert not entry0['unbroadcast']
+                assert not entry1['unbroadcast']
+                assert entry1["descendantcount"] <= CUSTOM_DESCENDANT_LIMIT
+                assert_equal(entry1['fees']['base'], entry0['fees']['base'])
+                assert_equal(entry1['vsize'], entry0['vsize'])
+                assert_equal(entry1['depends'], entry0['depends'])
+
         # Test reorg handling
         # First, the basics:
         self.generate(self.nodes[0], 1)

From feceaa42e8eb43344ced33d94187e93268d45187 Mon Sep 17 00:00:00 2001
From: Suhas Daftuar <sdaftuar@chaincode.com>
Date: Thu, 28 Sep 2023 10:20:04 -0400
Subject: [PATCH 24/65] Remove CTxMemPool::GetSortedDepthAndScore

The mempool clusters and linearization permit sorting the mempool topologically
without making use of ancestor counts (as long as the graph is not oversized).

Co-authored-by: Pieter Wuille <pieter@wuille.net>
---
 src/txmempool.cpp | 41 +++++++++++++----------------------------
 src/txmempool.h   | 23 +----------------------
 2 files changed, 14 insertions(+), 50 deletions(-)

diff --git a/src/txmempool.cpp b/src/txmempool.cpp
index fa7da083a14..326ff79f3ef 100644
--- a/src/txmempool.cpp
+++ b/src/txmempool.cpp
@@ -714,11 +714,12 @@ void CTxMemPool::check(const CCoinsViewCache& active_coins_tip, int64_t spendhei
     uint64_t checkTotal = 0;
     CAmount check_total_fee{0};
     uint64_t innerUsage = 0;
-    uint64_t prev_ancestor_count{0};
+
+    assert(!m_txgraph->IsOversized(TxGraph::Level::MAIN));
 
     CCoinsViewCache mempoolDuplicate(const_cast<CCoinsViewCache*>(&active_coins_tip));
 
-    for (const auto& it : GetSortedDepthAndScore()) {
+    for (const auto& it : GetSortedScoreWithTopology()) {
         checkTotal += it->GetTxSize();
         check_total_fee += it->GetFee();
         innerUsage += it->DynamicMemoryUsage();
@@ -733,9 +734,10 @@ void CTxMemPool::check(const CCoinsViewCache& active_coins_tip, int64_t spendhei
                 assert(tx2.vout.size() > txin.prevout.n && !tx2.vout[txin.prevout.n].IsNull());
                 setParentCheck.insert(*it2);
             }
-            // We are iterating through the mempool entries sorted in order by ancestor count.
-            // All parents must have been checked before their children and their coins added to
-            // the mempoolDuplicate coins cache.
+            // We are iterating through the mempool entries sorted
+            // topologically and by mining score. All parents must have been
+            // checked before their children and their coins added to the
+            // mempoolDuplicate coins cache.
             assert(mempoolDuplicate.HaveCoin(txin.prevout));
             // Check whether its inputs are marked in mapNextTx.
             auto it3 = mapNextTx.find(txin.prevout);
@@ -765,9 +767,6 @@ void CTxMemPool::check(const CCoinsViewCache& active_coins_tip, int64_t spendhei
         assert(it->GetSizeWithAncestors() == nSizeCheck);
         assert(it->GetSigOpCostWithAncestors() == nSigOpCheck);
         assert(it->GetModFeesWithAncestors() == nFeesCheck);
-        // Sanity check: we are walking in ascending ancestor count order.
-        assert(prev_ancestor_count <= it->GetCountWithAncestors());
-        prev_ancestor_count = it->GetCountWithAncestors();
 
         // Check children against mapNextTx
         CTxMemPoolEntry::Children setChildrenCheck;
@@ -819,23 +818,7 @@ bool CTxMemPool::CompareMiningScoreWithTopology(const Wtxid& hasha, const Wtxid&
     return m_txgraph->CompareMainOrder(*i.value(), *j.value()) < 0;
 }
 
-namespace {
-class DepthAndScoreComparator
-{
-public:
-    bool operator()(const CTxMemPool::indexed_transaction_set::const_iterator& a, const CTxMemPool::indexed_transaction_set::const_iterator& b)
-    {
-        uint64_t counta = a->GetCountWithAncestors();
-        uint64_t countb = b->GetCountWithAncestors();
-        if (counta == countb) {
-            return CompareTxMemPoolEntryByScore()(*a, *b);
-        }
-        return counta < countb;
-    }
-};
-} // namespace
-
-std::vector<CTxMemPool::indexed_transaction_set::const_iterator> CTxMemPool::GetSortedDepthAndScore() const
+std::vector<CTxMemPool::indexed_transaction_set::const_iterator> CTxMemPool::GetSortedScoreWithTopology() const
 {
     std::vector<indexed_transaction_set::const_iterator> iters;
     AssertLockHeld(cs);
@@ -845,7 +828,9 @@ std::vector<CTxMemPool::indexed_transaction_set::const_iterator> CTxMemPool::Get
     for (indexed_transaction_set::iterator mi = mapTx.begin(); mi != mapTx.end(); ++mi) {
         iters.push_back(mi);
     }
-    std::sort(iters.begin(), iters.end(), DepthAndScoreComparator());
+    std::sort(iters.begin(), iters.end(), [this](const auto& a, const auto& b) EXCLUSIVE_LOCKS_REQUIRED(cs) noexcept {
+        return m_txgraph->CompareMainOrder(*a, *b) < 0;
+    });
     return iters;
 }
 
@@ -855,7 +840,7 @@ std::vector<CTxMemPoolEntryRef> CTxMemPool::entryAll() const
 
     std::vector<CTxMemPoolEntryRef> ret;
     ret.reserve(mapTx.size());
-    for (const auto& it : GetSortedDepthAndScore()) {
+    for (const auto& it : GetSortedScoreWithTopology()) {
         ret.emplace_back(*it);
     }
     return ret;
@@ -864,7 +849,7 @@ std::vector<CTxMemPoolEntryRef> CTxMemPool::entryAll() const
 std::vector<TxMempoolInfo> CTxMemPool::infoAll() const
 {
     LOCK(cs);
-    auto iters = GetSortedDepthAndScore();
+    auto iters = GetSortedScoreWithTopology();
 
     std::vector<TxMempoolInfo> ret;
     ret.reserve(mapTx.size());
diff --git a/src/txmempool.h b/src/txmempool.h
index 232538aec36..fb2a4669bae 100644
--- a/src/txmempool.h
+++ b/src/txmempool.h
@@ -90,27 +90,6 @@ struct mempoolentry_wtxid
     }
 };
 
-/** \class CompareTxMemPoolEntryByScore
- *
- *  Sort by feerate of entry (fee/size) in descending order
- *  This is only used for transaction relay, so we use GetFee()
- *  instead of GetModifiedFee() to avoid leaking prioritization
- *  information via the sort order.
- */
-class CompareTxMemPoolEntryByScore
-{
-public:
-    bool operator()(const CTxMemPoolEntry& a, const CTxMemPoolEntry& b) const
-    {
-        FeeFrac f1(a.GetFee(), a.GetTxSize());
-        FeeFrac f2(b.GetFee(), b.GetTxSize());
-        if (FeeRateCompare(f1, f2) == 0) {
-            return b.GetTx().GetHash() < a.GetTx().GetHash();
-        }
-        return f1 > f2;
-    }
-};
-
 class CompareTxMemPoolEntryByEntryTime
 {
 public:
@@ -313,7 +292,7 @@ private:
     void UpdateParent(txiter entry, txiter parent, bool add) EXCLUSIVE_LOCKS_REQUIRED(cs);
     void UpdateChild(txiter entry, txiter child, bool add) EXCLUSIVE_LOCKS_REQUIRED(cs);
 
-    std::vector<indexed_transaction_set::const_iterator> GetSortedDepthAndScore() const EXCLUSIVE_LOCKS_REQUIRED(cs);
+    std::vector<indexed_transaction_set::const_iterator> GetSortedScoreWithTopology() const EXCLUSIVE_LOCKS_REQUIRED(cs);
 
     /**
      * Track locally submitted transactions to periodically retry initial broadcast.

From 7961496dda2eb24a3f09d661005f06611558a20a Mon Sep 17 00:00:00 2001
From: Suhas Daftuar <sdaftuar@chaincode.com>
Date: Thu, 28 Sep 2023 14:47:40 -0400
Subject: [PATCH 25/65] Reimplement GetTransactionAncestry() to not rely on
 cached data

In preparation for removing ancestor data from CTxMemPoolEntry, recalculate the
ancestor statistics on demand wherever needed.
---
 src/txmempool.cpp | 22 +++++++++++++++++++---
 src/txmempool.h   |  3 +++
 2 files changed, 22 insertions(+), 3 deletions(-)

diff --git a/src/txmempool.cpp b/src/txmempool.cpp
index 326ff79f3ef..85feb8b29c0 100644
--- a/src/txmempool.cpp
+++ b/src/txmempool.cpp
@@ -1217,15 +1217,31 @@ uint64_t CTxMemPool::CalculateDescendantMaximum(txiter entry) const {
     return maximum;
 }
 
+std::tuple<size_t, size_t, CAmount> CTxMemPool::CalculateAncestorData(const CTxMemPoolEntry& entry) const
+{
+    auto ancestors = m_txgraph->GetAncestors(entry, TxGraph::Level::MAIN);
+
+    size_t ancestor_count = ancestors.size();
+    size_t ancestor_size = 0;
+    CAmount ancestor_fees = 0;
+    for (auto tx: ancestors) {
+        const CTxMemPoolEntry& anc = static_cast<const CTxMemPoolEntry&>(*tx);
+        ancestor_size += anc.GetTxSize();
+        ancestor_fees += anc.GetModifiedFee();
+    }
+    return {ancestor_count, ancestor_size, ancestor_fees};
+}
+
 void CTxMemPool::GetTransactionAncestry(const Txid& txid, size_t& ancestors, size_t& descendants, size_t* const ancestorsize, CAmount* const ancestorfees) const {
     LOCK(cs);
     auto it = mapTx.find(txid);
     ancestors = descendants = 0;
     if (it != mapTx.end()) {
-        ancestors = it->GetCountWithAncestors();
-        if (ancestorsize) *ancestorsize = it->GetSizeWithAncestors();
-        if (ancestorfees) *ancestorfees = it->GetModFeesWithAncestors();
+        auto [ancestor_count, ancestor_size, ancestor_fees] = CalculateAncestorData(*it);
         descendants = CalculateDescendantMaximum(it);
+        ancestors = ancestor_count;
+        if (ancestorsize) *ancestorsize = ancestor_size;
+        if (ancestorfees) *ancestorfees = ancestor_fees;
     }
 }
 
diff --git a/src/txmempool.h b/src/txmempool.h
index fb2a4669bae..df4d50a4e67 100644
--- a/src/txmempool.h
+++ b/src/txmempool.h
@@ -285,6 +285,9 @@ public:
     using Limits = kernel::MemPoolLimits;
 
     uint64_t CalculateDescendantMaximum(txiter entry) const EXCLUSIVE_LOCKS_REQUIRED(cs);
+
+    std::tuple<size_t, size_t, CAmount> CalculateAncestorData(const CTxMemPoolEntry& entry) const EXCLUSIVE_LOCKS_REQUIRED(cs);
+
 private:
     typedef std::map<txiter, setEntries, CompareIteratorByHash> cacheMap;
 

From 9fbe0a4ac26c2fddaa3201cdfd8b69bf1f5ffa01 Mon Sep 17 00:00:00 2001
From: Suhas Daftuar <sdaftuar@chaincode.com>
Date: Thu, 28 Sep 2023 15:07:05 -0400
Subject: [PATCH 26/65] rpc: Calculate ancestor data from scratch for mempool
 rpc calls

---
 src/rpc/mempool.cpp | 8 +++++---
 1 file changed, 5 insertions(+), 3 deletions(-)

diff --git a/src/rpc/mempool.cpp b/src/rpc/mempool.cpp
index 147af369d34..fa70758a61f 100644
--- a/src/rpc/mempool.cpp
+++ b/src/rpc/mempool.cpp
@@ -290,20 +290,22 @@ static void entryToJSON(const CTxMemPool& pool, UniValue& info, const CTxMemPool
 {
     AssertLockHeld(pool.cs);
 
+    auto [ancestor_count, ancestor_size, ancestor_fees] = pool.CalculateAncestorData(e);
+
     info.pushKV("vsize", (int)e.GetTxSize());
     info.pushKV("weight", (int)e.GetTxWeight());
     info.pushKV("time", count_seconds(e.GetTime()));
     info.pushKV("height", (int)e.GetHeight());
     info.pushKV("descendantcount", e.GetCountWithDescendants());
     info.pushKV("descendantsize", e.GetSizeWithDescendants());
-    info.pushKV("ancestorcount", e.GetCountWithAncestors());
-    info.pushKV("ancestorsize", e.GetSizeWithAncestors());
+    info.pushKV("ancestorcount", ancestor_count);
+    info.pushKV("ancestorsize", ancestor_size);
     info.pushKV("wtxid", e.GetTx().GetWitnessHash().ToString());
 
     UniValue fees(UniValue::VOBJ);
     fees.pushKV("base", ValueFromAmount(e.GetFee()));
     fees.pushKV("modified", ValueFromAmount(e.GetModifiedFee()));
-    fees.pushKV("ancestor", ValueFromAmount(e.GetModFeesWithAncestors()));
+    fees.pushKV("ancestor", ValueFromAmount(ancestor_fees));
     fees.pushKV("descendant", ValueFromAmount(e.GetModFeesWithDescendants()));
     info.pushKV("fees", std::move(fees));
 

From 1f93227a84a54397699ca40d889f98913e4d5868 Mon Sep 17 00:00:00 2001
From: Suhas Daftuar <sdaftuar@chaincode.com>
Date: Thu, 28 Sep 2023 17:55:16 -0400
Subject: [PATCH 27/65] Remove dependency on cached ancestor data in mini-miner

---
 src/node/mini_miner.cpp | 5 +++--
 1 file changed, 3 insertions(+), 2 deletions(-)

diff --git a/src/node/mini_miner.cpp b/src/node/mini_miner.cpp
index a1c2edcb7bb..b70c7503b6d 100644
--- a/src/node/mini_miner.cpp
+++ b/src/node/mini_miner.cpp
@@ -74,12 +74,13 @@ MiniMiner::MiniMiner(const CTxMemPool& mempool, const std::vector<COutPoint>& ou
     // Add every entry to m_entries_by_txid and m_entries, except the ones that will be replaced.
     for (const auto& txiter : cluster) {
         if (!m_to_be_replaced.count(txiter->GetTx().GetHash())) {
+            auto [ancestor_count, ancestor_size, ancestor_fee] = mempool.CalculateAncestorData(*txiter);
             auto [mapiter, success] = m_entries_by_txid.emplace(txiter->GetTx().GetHash(),
                 MiniMinerMempoolEntry{/*tx_in=*/txiter->GetSharedTx(),
                                       /*vsize_self=*/txiter->GetTxSize(),
-                                      /*vsize_ancestor=*/txiter->GetSizeWithAncestors(),
+                                      /*vsize_ancestor=*/int64_t(ancestor_size),
                                       /*fee_self=*/txiter->GetModifiedFee(),
-                                      /*fee_ancestor=*/txiter->GetModFeesWithAncestors()});
+                                      /*fee_ancestor=*/ancestor_fee});
             m_entries.push_back(mapiter);
         } else {
             auto outpoints_it = m_requested_outpoints_by_txid.find(txiter->GetTx().GetHash());

From 9cda64b86c593f0d6ff8f17e483e6566f436b200 Mon Sep 17 00:00:00 2001
From: Suhas Daftuar <sdaftuar@chaincode.com>
Date: Thu, 28 Sep 2023 17:59:15 -0400
Subject: [PATCH 28/65] Stop enforcing ancestor size/count limits

The cluster limits should be sufficient.

Co-Authored-By: Gregory Sanders <gsanders87@gmail.com>
---
 src/txmempool.cpp                          |  29 +----
 src/txmempool.h                            |   7 +-
 test/functional/mempool_package_limits.py  | 142 ---------------------
 test/functional/mempool_packages.py        |  22 ++--
 test/functional/mempool_sigoplimit.py      |   2 +-
 test/functional/mempool_truc.py            |  21 ---
 test/functional/test_framework/messages.py |   1 +
 test/functional/wallet_balance.py          |   4 +-
 test/functional/wallet_basic.py            |  10 +-
 9 files changed, 22 insertions(+), 216 deletions(-)

diff --git a/src/txmempool.cpp b/src/txmempool.cpp
index 85feb8b29c0..7fd5a470053 100644
--- a/src/txmempool.cpp
+++ b/src/txmempool.cpp
@@ -55,7 +55,7 @@ bool TestLockPointValidity(CChain& active_chain, const LockPoints& lp)
 }
 
 void CTxMemPool::UpdateForDescendants(txiter updateIt, cacheMap& cachedDescendants,
-                                      const std::set<Txid>& setExclude, std::set<Txid>& descendants_to_remove)
+                                      const std::set<Txid>& setExclude)
 {
     CTxMemPoolEntry::Children stageEntries, descendants;
     stageEntries = updateIt->GetMemPoolChildrenConst();
@@ -94,12 +94,6 @@ void CTxMemPool::UpdateForDescendants(txiter updateIt, cacheMap& cachedDescendan
             mapTx.modify(mapTx.iterator_to(descendant), [=](CTxMemPoolEntry& e) {
               e.UpdateAncestorState(updateIt->GetTxSize(), updateIt->GetModifiedFee(), 1, updateIt->GetSigOpCost());
             });
-            // Don't directly remove the transaction here -- doing so would
-            // invalidate iterators in cachedDescendants. Mark it for removal
-            // by inserting into descendants_to_remove.
-            if (descendant.GetCountWithAncestors() > uint64_t(m_opts.limits.ancestor_count) || descendant.GetSizeWithAncestors() > m_opts.limits.ancestor_size_vbytes) {
-                descendants_to_remove.insert(descendant.GetTx().GetHash());
-            }
         }
     }
     mapTx.modify(updateIt, [=](CTxMemPoolEntry& e) { e.UpdateDescendantState(modifySize, modifyFee, modifyCount); });
@@ -150,7 +144,7 @@ void CTxMemPool::UpdateTransactionsFromBlock(const std::vector<Txid>& vHashesToU
                 m_txgraph->AddDependency(/*parent=*/*it, /*child=*/*childIter);
             }
         } // release epoch guard for UpdateForDescendants
-        UpdateForDescendants(it, mapMemPoolDescendantsToUpdate, setAlreadyIncluded, descendants_to_remove);
+        UpdateForDescendants(it, mapMemPoolDescendantsToUpdate, setAlreadyIncluded);
     }
 
     auto txs_to_remove = m_txgraph->Trim(); // Enforce cluster size limits.
@@ -174,7 +168,6 @@ util::Result<CTxMemPool::setEntries> CTxMemPool::CalculateAncestorsAndCheckLimit
     CTxMemPoolEntry::Parents& staged_ancestors,
     const Limits& limits) const
 {
-    int64_t totalSizeWithAncestors = entry_size;
     setEntries ancestors;
 
     while (!staged_ancestors.empty()) {
@@ -183,14 +176,11 @@ util::Result<CTxMemPool::setEntries> CTxMemPool::CalculateAncestorsAndCheckLimit
 
         ancestors.insert(stageit);
         staged_ancestors.erase(stage);
-        totalSizeWithAncestors += stageit->GetTxSize();
 
         if (stageit->GetSizeWithDescendants() + entry_size > limits.descendant_size_vbytes) {
             return util::Error{Untranslated(strprintf("exceeds descendant size limit for tx %s [limit: %u]", stageit->GetTx().GetHash().ToString(), limits.descendant_size_vbytes))};
         } else if (stageit->GetCountWithDescendants() + entry_count > static_cast<uint64_t>(limits.descendant_count)) {
             return util::Error{Untranslated(strprintf("too many descendants for tx %s [limit: %u]", stageit->GetTx().GetHash().ToString(), limits.descendant_count))};
-        } else if (totalSizeWithAncestors > limits.ancestor_size_vbytes) {
-            return util::Error{Untranslated(strprintf("exceeds ancestor size limit [limit: %u]", limits.ancestor_size_vbytes))};
         }
 
         const CTxMemPoolEntry::Parents& parents = stageit->GetMemPoolParentsConst();
@@ -201,9 +191,6 @@ util::Result<CTxMemPool::setEntries> CTxMemPool::CalculateAncestorsAndCheckLimit
             if (ancestors.count(parent_it) == 0) {
                 staged_ancestors.insert(parent);
             }
-            if (staged_ancestors.size() + ancestors.size() + entry_count > static_cast<uint64_t>(limits.ancestor_count)) {
-                return util::Error{Untranslated(strprintf("too many unconfirmed ancestors [limit: %u]", limits.ancestor_count))};
-            }
         }
     }
 
@@ -216,12 +203,8 @@ util::Result<void> CTxMemPool::CheckPackageLimits(const Package& package,
     size_t pack_count = package.size();
 
     // Package itself is busting mempool limits; should be rejected even if no staged_ancestors exist
-    if (pack_count > static_cast<uint64_t>(m_opts.limits.ancestor_count)) {
-        return util::Error{Untranslated(strprintf("package count %u exceeds ancestor count limit [limit: %u]", pack_count, m_opts.limits.ancestor_count))};
-    } else if (pack_count > static_cast<uint64_t>(m_opts.limits.descendant_count)) {
+    if (pack_count > static_cast<uint64_t>(m_opts.limits.descendant_count)) {
         return util::Error{Untranslated(strprintf("package count %u exceeds descendant count limit [limit: %u]", pack_count, m_opts.limits.descendant_count))};
-    } else if (total_vsize > m_opts.limits.ancestor_size_vbytes) {
-        return util::Error{Untranslated(strprintf("package size %u exceeds ancestor size limit [limit: %u]", total_vsize, m_opts.limits.ancestor_size_vbytes))};
     } else if (total_vsize > m_opts.limits.descendant_size_vbytes) {
         return util::Error{Untranslated(strprintf("package size %u exceeds descendant size limit [limit: %u]", total_vsize, m_opts.limits.descendant_size_vbytes))};
     }
@@ -232,9 +215,6 @@ util::Result<void> CTxMemPool::CheckPackageLimits(const Package& package,
             std::optional<txiter> piter = GetIter(input.prevout.hash);
             if (piter) {
                 staged_ancestors.insert(**piter);
-                if (staged_ancestors.size() + package.size() > static_cast<uint64_t>(m_opts.limits.ancestor_count)) {
-                    return util::Error{Untranslated(strprintf("too many unconfirmed parents [limit: %u]", m_opts.limits.ancestor_count))};
-                }
             }
         }
     }
@@ -265,9 +245,6 @@ util::Result<CTxMemPool::setEntries> CTxMemPool::CalculateMemPoolAncestors(
             std::optional<txiter> piter = GetIter(tx.vin[i].prevout.hash);
             if (piter) {
                 staged_ancestors.insert(**piter);
-                if (staged_ancestors.size() + 1 > static_cast<uint64_t>(limits.ancestor_count)) {
-                    return util::Error{Untranslated(strprintf("too many unconfirmed parents [limit: %u]", limits.ancestor_count))};
-                }
             }
         }
     } else {
diff --git a/src/txmempool.h b/src/txmempool.h
index df4d50a4e67..475a39966d8 100644
--- a/src/txmempool.h
+++ b/src/txmempool.h
@@ -647,8 +647,6 @@ private:
      *      be removed for violation of ancestor limits.
      * @post if updateIt has any non-excluded descendants, cachedDescendants has
      *       a new cache line for updateIt.
-     * @post descendants_to_remove has a new entry for any descendant which exceeded
-     *       ancestor limits relative to updateIt.
      *
      * @param[in] updateIt the entry to update for its descendants
      * @param[in,out] cachedDescendants a cache where each line corresponds to all
@@ -659,12 +657,9 @@ private:
      *     that must not be accounted for (because any descendants in setExclude
      *     were added to the mempool after the transaction being updated and hence
      *     their state is already reflected in the parent state).
-     * @param[out] descendants_to_remove Populated with the txids of entries that
-     *     exceed ancestor limits. It's the responsibility of the caller to
-     *     removeRecursive them.
      */
     void UpdateForDescendants(txiter updateIt, cacheMap& cachedDescendants,
-                              const std::set<Txid>& setExclude, std::set<Txid>& descendants_to_remove) EXCLUSIVE_LOCKS_REQUIRED(cs);
+                              const std::set<Txid>& setExclude) EXCLUSIVE_LOCKS_REQUIRED(cs);
     /** Update ancestors of hash to add/remove it as a descendant transaction. */
     void UpdateAncestorsOf(bool add, txiter hash, setEntries &setAncestors) EXCLUSIVE_LOCKS_REQUIRED(cs);
     /** Set ancestor state for an entry */
diff --git a/test/functional/mempool_package_limits.py b/test/functional/mempool_package_limits.py
index 63106f346f3..5e402ede4fb 100755
--- a/test/functional/mempool_package_limits.py
+++ b/test/functional/mempool_package_limits.py
@@ -48,10 +48,6 @@ class MempoolPackageLimitsTest(BitcoinTestFramework):
         self.test_chain_limits()
         self.test_desc_count_limits()
         self.test_desc_count_limits_2()
-        self.test_anc_count_limits()
-        self.test_anc_count_limits_2()
-        self.test_anc_count_limits_bushy()
-        self.test_anc_size_limits()
         self.test_desc_size_limits()
 
     @check_package_limits
@@ -162,144 +158,6 @@ class MempoolPackageLimitsTest(BitcoinTestFramework):
         assert_equal(2, len(package_hex))
         return package_hex
 
-    @check_package_limits
-    def test_anc_count_limits(self):
-        """Create a 'V' shaped chain with 24 transactions in the mempool and 3 in the package:
-        M1a                    M1b
-         ^                     ^
-          M2a                M2b
-           .                 .
-            .               .
-             .             .
-             M12a        M12b
-               ^         ^
-                Pa     Pb
-                 ^    ^
-                   Pc
-        The lowest descendant, Pc, exceeds ancestor limits, but only if the in-mempool
-        and in-package ancestors are all considered together.
-        """
-        node = self.nodes[0]
-        package_hex = []
-        pc_parent_utxos = []
-
-        self.log.info("Check that in-mempool and in-package ancestors are calculated properly in packages")
-
-        # Two chains of 13 transactions each
-        for _ in range(2):
-            chain_tip_utxo = self.wallet.send_self_transfer_chain(from_node=node, chain_length=12)[-1]["new_utxo"]
-            # Save the 13th transaction for the package
-            tx = self.wallet.create_self_transfer(utxo_to_spend=chain_tip_utxo)
-            package_hex.append(tx["hex"])
-            pc_parent_utxos.append(tx["new_utxo"])
-
-        # Child Pc
-        pc_hex = self.wallet.create_self_transfer_multi(utxos_to_spend=pc_parent_utxos)["hex"]
-        package_hex.append(pc_hex)
-
-        assert_equal(24, node.getmempoolinfo()["size"])
-        assert_equal(3, len(package_hex))
-        return package_hex
-
-    @check_package_limits
-    def test_anc_count_limits_2(self):
-        """Create a 'Y' shaped chain with 24 transactions in the mempool and 2 in the package:
-        M1a                M1b
-         ^                ^
-          M2a            M2b
-           .            .
-            .          .
-             .        .
-            M12a    M12b
-               ^    ^
-                 Pc
-                 ^
-                 Pd
-        The lowest descendant, Pd, exceeds ancestor limits, but only if the in-mempool
-        and in-package ancestors are all considered together.
-        """
-        node = self.nodes[0]
-        pc_parent_utxos = []
-
-        self.log.info("Check that in-mempool and in-package ancestors are calculated properly in packages")
-        # Two chains of 12 transactions each
-        for _ in range(2):
-            chaintip_utxo = self.wallet.send_self_transfer_chain(from_node=node, chain_length=12)[-1]["new_utxo"]
-            # last 2 transactions will be the parents of Pc
-            pc_parent_utxos.append(chaintip_utxo)
-
-        # Child Pc
-        pc_tx = self.wallet.create_self_transfer_multi(utxos_to_spend=pc_parent_utxos)
-
-        # Child Pd
-        pd_tx = self.wallet.create_self_transfer(utxo_to_spend=pc_tx["new_utxos"][0])
-
-        assert_equal(24, node.getmempoolinfo()["size"])
-        return [pc_tx["hex"], pd_tx["hex"]]
-
-    @check_package_limits
-    def test_anc_count_limits_bushy(self):
-        """Create a tree with 20 transactions in the mempool and 6 in the package:
-        M1...M4 M5...M8 M9...M12 M13...M16 M17...M20
-            ^      ^       ^        ^         ^             (each with 4 parents)
-            P0     P1      P2      P3        P4
-             ^     ^       ^       ^         ^              (5 parents)
-                           PC
-        Where M(4i+1)...M+(4i+4) are the parents of Pi and P0, P1, P2, P3, and P4 are the parents of PC.
-        P0... P4 individually only have 4 parents each, and PC has no in-mempool parents. But
-        combined, PC has 25 in-mempool and in-package parents.
-        """
-        node = self.nodes[0]
-        package_hex = []
-        pc_parent_utxos = []
-        for _ in range(5): # Make package transactions P0 ... P4
-            pc_grandparent_utxos = []
-            for _ in range(4): # Make mempool transactions M(4i+1)...M(4i+4)
-                pc_grandparent_utxos.append(self.wallet.send_self_transfer(from_node=node)["new_utxo"])
-            # Package transaction Pi
-            pi_tx = self.wallet.create_self_transfer_multi(utxos_to_spend=pc_grandparent_utxos)
-            package_hex.append(pi_tx["hex"])
-            pc_parent_utxos.append(pi_tx["new_utxos"][0])
-        # Package transaction PC
-        pc_hex = self.wallet.create_self_transfer_multi(utxos_to_spend=pc_parent_utxos)["hex"]
-        package_hex.append(pc_hex)
-
-        assert_equal(20, node.getmempoolinfo()["size"])
-        assert_equal(6, len(package_hex))
-        return package_hex
-
-    @check_package_limits
-    def test_anc_size_limits(self):
-        """Test Case with 2 independent transactions in the mempool and a parent + child in the
-        package, where the package parent is the child of both mempool transactions (30KvB each):
-              A     B
-               ^   ^
-                 C
-                 ^
-                 D
-        The lowest descendant, D, exceeds ancestor size limits, but only if the in-mempool
-        and in-package ancestors are all considered together.
-        """
-        node = self.nodes[0]
-        parent_utxos = []
-        target_vsize = 30_000
-        high_fee = 10 * target_vsize  # 10 sats/vB
-        self.log.info("Check that in-mempool and in-package ancestor size limits are calculated properly in packages")
-        # Mempool transactions A and B
-        for _ in range(2):
-            bulked_tx = self.wallet.create_self_transfer(target_vsize=target_vsize)
-            self.wallet.sendrawtransaction(from_node=node, tx_hex=bulked_tx["hex"])
-            parent_utxos.append(bulked_tx["new_utxo"])
-
-        # Package transaction C
-        pc_tx = self.wallet.create_self_transfer_multi(utxos_to_spend=parent_utxos, fee_per_output=high_fee, target_vsize=target_vsize)
-
-        # Package transaction D
-        pd_tx = self.wallet.create_self_transfer(utxo_to_spend=pc_tx["new_utxos"][0], target_vsize=target_vsize)
-
-        assert_equal(2, node.getmempoolinfo()["size"])
-        return [pc_tx["hex"], pd_tx["hex"]]
-
     @check_package_limits
     def test_desc_size_limits(self):
         """Create 3 mempool transactions and 2 package transactions (21KvB each):
diff --git a/test/functional/mempool_packages.py b/test/functional/mempool_packages.py
index 8f53d913c96..74d04f077f9 100755
--- a/test/functional/mempool_packages.py
+++ b/test/functional/mempool_packages.py
@@ -7,8 +7,8 @@
 from decimal import Decimal
 
 from test_framework.messages import (
-    DEFAULT_ANCESTOR_LIMIT,
     DEFAULT_DESCENDANT_LIMIT,
+    DEFAULT_CLUSTER_LIMIT,
 )
 from test_framework.p2p import P2PTxInvStore
 from test_framework.test_framework import BitcoinTestFramework
@@ -19,10 +19,7 @@ from test_framework.util import (
 from test_framework.wallet import MiniWallet
 
 # custom limits for node1
-CUSTOM_ANCESTOR_LIMIT = 5
 CUSTOM_DESCENDANT_LIMIT = 11
-assert CUSTOM_DESCENDANT_LIMIT >= CUSTOM_ANCESTOR_LIMIT
-
 
 class MempoolPackagesTest(BitcoinTestFramework):
     def set_test_params(self):
@@ -33,7 +30,6 @@ class MempoolPackagesTest(BitcoinTestFramework):
             [
             ],
             [
-                "-limitancestorcount={}".format(CUSTOM_ANCESTOR_LIMIT),
                 "-limitdescendantcount={}".format(CUSTOM_DESCENDANT_LIMIT),
             ],
         ]
@@ -44,8 +40,8 @@ class MempoolPackagesTest(BitcoinTestFramework):
 
         peer_inv_store = self.nodes[0].add_p2p_connection(P2PTxInvStore()) # keep track of invs
 
-        # DEFAULT_ANCESTOR_LIMIT transactions off a confirmed tx should be fine
-        chain = self.wallet.create_self_transfer_chain(chain_length=DEFAULT_ANCESTOR_LIMIT)
+        # DEFAULT_DESCENDANT_LIMIT transactions off a confirmed tx should be fine
+        chain = self.wallet.create_self_transfer_chain(chain_length=DEFAULT_DESCENDANT_LIMIT)
         witness_chain = [t["wtxid"] for t in chain]
         ancestor_vsize = 0
         ancestor_fees = Decimal(0)
@@ -59,16 +55,16 @@ class MempoolPackagesTest(BitcoinTestFramework):
         # Otherwise, getrawmempool may be inconsistent with getmempoolentry if unbroadcast changes in between
         peer_inv_store.wait_for_broadcast(witness_chain)
 
-        # Check mempool has DEFAULT_ANCESTOR_LIMIT transactions in it, and descendant and ancestor
+        # Check mempool has DEFAULT_DESCENDANT_LIMIT transactions in it, and descendant and ancestor
         # count and fees should look correct
         mempool = self.nodes[0].getrawmempool(True)
-        assert_equal(len(mempool), DEFAULT_ANCESTOR_LIMIT)
+        assert_equal(len(mempool), DEFAULT_DESCENDANT_LIMIT)
         descendant_count = 1
         descendant_fees = 0
         descendant_vsize = 0
 
         assert_equal(ancestor_vsize, sum([mempool[tx]['vsize'] for tx in mempool]))
-        ancestor_count = DEFAULT_ANCESTOR_LIMIT
+        ancestor_count = DEFAULT_DESCENDANT_LIMIT
         assert_equal(ancestor_fees, sum([mempool[tx]['fees']['base'] for tx in mempool]))
 
         # Adding one more transaction on to the chain should fail.
@@ -193,9 +189,9 @@ class MempoolPackagesTest(BitcoinTestFramework):
         # Check that node1's mempool is as expected (-> custom ancestor limit)
         mempool0 = self.nodes[0].getrawmempool(False)
         mempool1 = self.nodes[1].getrawmempool(False)
-        assert_equal(len(mempool1), CUSTOM_ANCESTOR_LIMIT)
+        assert_equal(len(mempool1), CUSTOM_DESCENDANT_LIMIT)
         assert set(mempool1).issubset(set(mempool0))
-        for tx in chain[:CUSTOM_ANCESTOR_LIMIT]:
+        for tx in chain[:CUSTOM_DESCENDANT_LIMIT]:
             assert tx in mempool1
             entry0 = self.nodes[0].getmempoolentry(tx)
             entry1 = self.nodes[1].getmempoolentry(tx)
@@ -240,7 +236,7 @@ class MempoolPackagesTest(BitcoinTestFramework):
         # - parent tx for descendant test
         # - txs chained off parent tx (-> custom descendant limit)
         self.wait_until(lambda: len(self.nodes[1].getrawmempool()) ==
-                                CUSTOM_ANCESTOR_LIMIT + CUSTOM_DESCENDANT_LIMIT, timeout=10)
+                                2*CUSTOM_DESCENDANT_LIMIT, timeout=10)
         mempool0 = self.nodes[0].getrawmempool(False)
         mempool1 = self.nodes[1].getrawmempool(False)
         assert set(mempool1).issubset(set(mempool0))
diff --git a/test/functional/mempool_sigoplimit.py b/test/functional/mempool_sigoplimit.py
index 6b2a0268c4d..965f9a5c56d 100755
--- a/test/functional/mempool_sigoplimit.py
+++ b/test/functional/mempool_sigoplimit.py
@@ -171,7 +171,7 @@ class BytesPerSigOpTest(BitcoinTestFramework):
         # But together, it's exceeding limits in the *package* context. If sigops adjusted vsize wasn't being checked
         # here, it would get further in validation and give too-long-mempool-chain error instead.
         packet_test = self.nodes[0].testmempoolaccept([tx_parent.serialize().hex(), tx_child.serialize().hex()])
-        expected_package_error = f"package-mempool-limits, package size {2*max_multisig_vsize} exceeds ancestor size limit [limit: 101000]"
+        expected_package_error = f"package-mempool-limits, package size {2*max_multisig_vsize} exceeds descendant size limit [limit: 101000]"
         assert_equal([x["package-error"] for x in packet_test], [expected_package_error] * 2)
 
         # When we actually try to submit, the parent makes it into the mempool, but the child would exceed ancestor vsize limits
diff --git a/test/functional/mempool_truc.py b/test/functional/mempool_truc.py
index 23726330cc7..70b9d0e2364 100755
--- a/test/functional/mempool_truc.py
+++ b/test/functional/mempool_truc.py
@@ -228,27 +228,6 @@ class MempoolTRUC(BitcoinTestFramework):
         assert_equal(node.getmempoolentry(tx_v3_parent_large1["txid"])["descendantcount"], 1)
         self.generate(node, 1)
 
-        self.log.info("Test that a decreased limitancestorsize also applies to v3 parent")
-        self.restart_node(0, extra_args=["-limitancestorsize=10"])
-        tx_v3_parent_large2 = self.wallet.send_self_transfer(
-            from_node=node,
-            target_vsize=parent_target_vsize,
-            version=3
-        )
-        tx_v3_child_large2 = self.wallet.create_self_transfer(
-            utxo_to_spend=tx_v3_parent_large2["new_utxo"],
-            target_vsize=child_target_vsize,
-            version=3
-        )
-
-        # Parent and child are within TRUC limits
-        assert_greater_than_or_equal(TRUC_MAX_VSIZE, tx_v3_parent_large2["tx"].get_vsize())
-        assert_greater_than_or_equal(TRUC_CHILD_MAX_VSIZE, tx_v3_child_large2["tx"].get_vsize())
-        assert_greater_than(tx_v3_parent_large2["tx"].get_vsize() + tx_v3_child_large2["tx"].get_vsize(), 10000)
-
-        assert_raises_rpc_error(-26, "too-long-mempool-chain, exceeds ancestor size limit", node.sendrawtransaction, tx_v3_child_large2["hex"])
-        self.check_mempool([tx_v3_parent_large2["txid"]])
-
     @cleanup()
     def test_truc_ancestors_package(self):
         self.log.info("Test that TRUC ancestor limits are checked within the package")
diff --git a/test/functional/test_framework/messages.py b/test/functional/test_framework/messages.py
index ebb306a8234..94365c8142e 100755
--- a/test/functional/test_framework/messages.py
+++ b/test/functional/test_framework/messages.py
@@ -72,6 +72,7 @@ WITNESS_SCALE_FACTOR = 4
 
 DEFAULT_ANCESTOR_LIMIT = 25    # default max number of in-mempool ancestors
 DEFAULT_DESCENDANT_LIMIT = 25  # default max number of in-mempool descendants
+DEFAULT_CLUSTER_LIMIT = 64     # default max number of transactions in a cluster
 
 
 # Default setting for -datacarriersize.
diff --git a/test/functional/wallet_balance.py b/test/functional/wallet_balance.py
index 8c83f42ecfd..a76cc223b7b 100755
--- a/test/functional/wallet_balance.py
+++ b/test/functional/wallet_balance.py
@@ -55,9 +55,9 @@ class WalletTest(BitcoinTestFramework):
         # whitelist peers to speed up tx relay / mempool sync
         self.noban_tx_relay = True
         self.extra_args = [
-            # Limit mempool descendants as a hack to have wallet txs rejected from the mempool.
+            # Limit mempool clusters as a hack to have wallet txs rejected from the mempool.
             # Set walletrejectlongchains=0 so the wallet still creates the transactions.
-            ['-limitdescendantcount=3', '-walletrejectlongchains=0'],
+            ['-limitclustercount=3', '-walletrejectlongchains=0'],
             [],
         ]
 
diff --git a/test/functional/wallet_basic.py b/test/functional/wallet_basic.py
index 7d94df2f4dc..012656036f1 100755
--- a/test/functional/wallet_basic.py
+++ b/test/functional/wallet_basic.py
@@ -467,9 +467,9 @@ class WalletTest(BitcoinTestFramework):
         self.log.info("Test -reindex")
         self.stop_nodes()
         # set lower ancestor limit for later
-        self.start_node(0, ['-reindex', "-walletrejectlongchains=0", "-limitancestorcount=" + str(chainlimit)])
-        self.start_node(1, ['-reindex', "-limitancestorcount=" + str(chainlimit)])
-        self.start_node(2, ['-reindex', "-limitancestorcount=" + str(chainlimit)])
+        self.start_node(0, ['-reindex', "-walletrejectlongchains=0", "-limitancestorcount=" + str(chainlimit), "-limitclustercount=" + str(chainlimit)])
+        self.start_node(1, ['-reindex', "-limitclustercount=" + str(chainlimit)])
+        self.start_node(2, ['-reindex', "-limitclustercount=" + str(chainlimit)])
         # reindex will leave rpc warm up "early"; Wait for it to finish
         self.wait_until(lambda: [block_count] * 3 == [self.nodes[i].getblockcount() for i in range(3)])
         assert_equal(balance_nodes, [self.nodes[i].getbalance() for i in range(3)])
@@ -510,7 +510,7 @@ class WalletTest(BitcoinTestFramework):
         # Try with walletrejectlongchains
         # Double chain limit but require combining inputs, so we pass AttemptSelection
         self.stop_node(0)
-        extra_args = ["-walletrejectlongchains", "-limitancestorcount=" + str(2 * chainlimit)]
+        extra_args = ["-walletrejectlongchains", "-limitclustercount=" + str(2 * chainlimit), "-limitancestorcount=" + str(2*chainlimit)]
         self.start_node(0, extra_args=extra_args)
 
         # wait until the wallet has submitted all transactions to the mempool
@@ -521,7 +521,7 @@ class WalletTest(BitcoinTestFramework):
 
         node0_balance = self.nodes[0].getbalance()
         # With walletrejectlongchains we will not create the tx and store it in our wallet.
-        assert_raises_rpc_error(-6, f"too many unconfirmed ancestors [limit: {chainlimit * 2}]", self.nodes[0].sendtoaddress, sending_addr, node0_balance - Decimal('0.01'))
+        assert_raises_rpc_error(-6, "too many unconfirmed transactions in cluster", self.nodes[0].sendtoaddress, sending_addr, node0_balance - Decimal('0.01'))
 
         # Verify nothing new in wallet
         assert_equal(total_txs, len(self.nodes[0].listtransactions("*", 99999)))

From 69e1eaa6ed22f542ab48da755fa63f7694a15533 Mon Sep 17 00:00:00 2001
From: Suhas Daftuar <sdaftuar@gmail.com>
Date: Sun, 14 Apr 2024 06:59:01 -0400
Subject: [PATCH 29/65] Add test case for cluster size limits to TRUC logic

---
 test/functional/mempool_truc.py | 13 +++++++++++++
 1 file changed, 13 insertions(+)

diff --git a/test/functional/mempool_truc.py b/test/functional/mempool_truc.py
index 70b9d0e2364..687b707297f 100755
--- a/test/functional/mempool_truc.py
+++ b/test/functional/mempool_truc.py
@@ -228,6 +228,19 @@ class MempoolTRUC(BitcoinTestFramework):
         assert_equal(node.getmempoolentry(tx_v3_parent_large1["txid"])["descendantcount"], 1)
         self.generate(node, 1)
 
+        self.log.info("Test that a decreased limitclustersize also applies to TRUC child")
+        self.restart_node(0, extra_args=["-limitclustersize=10", "-acceptnonstdtxn=1"])
+        tx_v3_parent_large2 = self.wallet.send_self_transfer(from_node=node, target_vsize=parent_target_vsize, version=3)
+        tx_v3_child_large2 = self.wallet.create_self_transfer(utxo_to_spend=tx_v3_parent_large2["new_utxo"], target_vsize=child_target_vsize, version=3)
+        # Parent and child are within TRUC limits
+        assert_greater_than_or_equal(TRUC_MAX_VSIZE, tx_v3_parent_large2["tx"].get_vsize())
+        assert_greater_than_or_equal(TRUC_CHILD_MAX_VSIZE, tx_v3_child_large2["tx"].get_vsize())
+        assert_raises_rpc_error(-26, "too-large-cluster", node.sendrawtransaction, tx_v3_child_large2["hex"])
+        self.log.info("Test that a decreased limitclustercount also applies to TRUC transactions")
+        self.restart_node(0, extra_args=["-limitclustercount=1", "-acceptnonstdtxn=1"])
+        assert_raises_rpc_error(-26, "too-large-cluster", node.sendrawtransaction, tx_v3_child_large2["hex"])
+        self.check_mempool([tx_v3_parent_large2["txid"]])
+
     @cleanup()
     def test_truc_ancestors_package(self):
         self.log.info("Test that TRUC ancestor limits are checked within the package")

From bdcefb8a8b0667539744eae63e9eb5b7dc1c51da Mon Sep 17 00:00:00 2001
From: Suhas Daftuar <sdaftuar@chaincode.com>
Date: Tue, 3 Oct 2023 11:19:15 -0400
Subject: [PATCH 30/65] Use mempool/txgraph to determine if a tx has
 descendants

Remove a reference to GetCountWithDescendants() in preparation for removing
this function and the associated cached state from the mempool.
---
 src/node/interfaces.cpp | 5 +----
 src/txmempool.cpp       | 8 ++++++++
 src/txmempool.h         | 2 ++
 3 files changed, 11 insertions(+), 4 deletions(-)

diff --git a/src/node/interfaces.cpp b/src/node/interfaces.cpp
index 8e38ae126ff..c3e57291794 100644
--- a/src/node/interfaces.cpp
+++ b/src/node/interfaces.cpp
@@ -665,10 +665,7 @@ public:
     bool hasDescendantsInMempool(const Txid& txid) override
     {
         if (!m_node.mempool) return false;
-        LOCK(m_node.mempool->cs);
-        const auto entry{m_node.mempool->GetEntry(txid)};
-        if (entry == nullptr) return false;
-        return entry->GetCountWithDescendants() > 1;
+        return m_node.mempool->HasDescendants(txid);
     }
     bool broadcastTransaction(const CTransactionRef& tx,
         const CAmount& max_tx_fee,
diff --git a/src/txmempool.cpp b/src/txmempool.cpp
index 7fd5a470053..f7bdbf94e3c 100644
--- a/src/txmempool.cpp
+++ b/src/txmempool.cpp
@@ -229,6 +229,14 @@ util::Result<void> CTxMemPool::CheckPackageLimits(const Package& package,
     return {};
 }
 
+bool CTxMemPool::HasDescendants(const Txid& txid) const
+{
+    LOCK(cs);
+    auto entry = GetEntry(txid);
+    if (!entry) return false;
+    return m_txgraph->GetDescendants(*entry, TxGraph::Level::MAIN).size() > 1;
+}
+
 util::Result<CTxMemPool::setEntries> CTxMemPool::CalculateMemPoolAncestors(
     const CTxMemPoolEntry &entry,
     const Limits& limits,
diff --git a/src/txmempool.h b/src/txmempool.h
index 475a39966d8..b65333cc3b3 100644
--- a/src/txmempool.h
+++ b/src/txmempool.h
@@ -467,6 +467,8 @@ public:
         const Limits& limits,
         bool fSearchForParents = true) const EXCLUSIVE_LOCKS_REQUIRED(cs);
 
+    bool HasDescendants(const Txid& txid) const;
+
     /** Collect the entire cluster of connected transactions for each transaction in txids.
      * All txids must correspond to transaction entries in the mempool, otherwise this returns an
      * empty vector. This call will also exit early and return an empty vector if it collects 500 or

From c0bd04d18fdf77a2f20f3c32f8eee4f1d71afd79 Mon Sep 17 00:00:00 2001
From: Suhas Daftuar <sdaftuar@chaincode.com>
Date: Tue, 3 Oct 2023 11:57:16 -0400
Subject: [PATCH 31/65] Calculate descendant information for mempool RPC output
 on-the-fly

This is in preparation for removing the cached descendant state from the
mempool.
---
 src/rpc/mempool.cpp |  7 ++++---
 src/txmempool.cpp   | 15 +++++++++++++++
 src/txmempool.h     |  1 +
 3 files changed, 20 insertions(+), 3 deletions(-)

diff --git a/src/rpc/mempool.cpp b/src/rpc/mempool.cpp
index fa70758a61f..b5373697e7a 100644
--- a/src/rpc/mempool.cpp
+++ b/src/rpc/mempool.cpp
@@ -291,13 +291,14 @@ static void entryToJSON(const CTxMemPool& pool, UniValue& info, const CTxMemPool
     AssertLockHeld(pool.cs);
 
     auto [ancestor_count, ancestor_size, ancestor_fees] = pool.CalculateAncestorData(e);
+    auto [descendant_count, descendant_size, descendant_fees] = pool.CalculateDescendantData(e);
 
     info.pushKV("vsize", (int)e.GetTxSize());
     info.pushKV("weight", (int)e.GetTxWeight());
     info.pushKV("time", count_seconds(e.GetTime()));
     info.pushKV("height", (int)e.GetHeight());
-    info.pushKV("descendantcount", e.GetCountWithDescendants());
-    info.pushKV("descendantsize", e.GetSizeWithDescendants());
+    info.pushKV("descendantcount", descendant_count);
+    info.pushKV("descendantsize", descendant_size);
     info.pushKV("ancestorcount", ancestor_count);
     info.pushKV("ancestorsize", ancestor_size);
     info.pushKV("wtxid", e.GetTx().GetWitnessHash().ToString());
@@ -306,7 +307,7 @@ static void entryToJSON(const CTxMemPool& pool, UniValue& info, const CTxMemPool
     fees.pushKV("base", ValueFromAmount(e.GetFee()));
     fees.pushKV("modified", ValueFromAmount(e.GetModifiedFee()));
     fees.pushKV("ancestor", ValueFromAmount(ancestor_fees));
-    fees.pushKV("descendant", ValueFromAmount(e.GetModFeesWithDescendants()));
+    fees.pushKV("descendant", ValueFromAmount(descendant_fees));
     info.pushKV("fees", std::move(fees));
 
     const CTransaction& tx = e.GetTx();
diff --git a/src/txmempool.cpp b/src/txmempool.cpp
index f7bdbf94e3c..ce9218f9111 100644
--- a/src/txmempool.cpp
+++ b/src/txmempool.cpp
@@ -1217,6 +1217,21 @@ std::tuple<size_t, size_t, CAmount> CTxMemPool::CalculateAncestorData(const CTxM
     return {ancestor_count, ancestor_size, ancestor_fees};
 }
 
+std::tuple<size_t, size_t, CAmount> CTxMemPool::CalculateDescendantData(const CTxMemPoolEntry& entry) const
+{
+    auto descendants = m_txgraph->GetDescendants(entry, TxGraph::Level::MAIN);
+    size_t descendant_count = descendants.size();
+    size_t descendant_size = 0;
+    CAmount descendant_fees = 0;
+
+    for (auto tx: descendants) {
+        const CTxMemPoolEntry &desc = static_cast<const CTxMemPoolEntry&>(*tx);
+        descendant_size += desc.GetTxSize();
+        descendant_fees += desc.GetModifiedFee();
+    }
+    return {descendant_count, descendant_size, descendant_fees};
+}
+
 void CTxMemPool::GetTransactionAncestry(const Txid& txid, size_t& ancestors, size_t& descendants, size_t* const ancestorsize, CAmount* const ancestorfees) const {
     LOCK(cs);
     auto it = mapTx.find(txid);
diff --git a/src/txmempool.h b/src/txmempool.h
index b65333cc3b3..49ee510a4f0 100644
--- a/src/txmempool.h
+++ b/src/txmempool.h
@@ -287,6 +287,7 @@ public:
     uint64_t CalculateDescendantMaximum(txiter entry) const EXCLUSIVE_LOCKS_REQUIRED(cs);
 
     std::tuple<size_t, size_t, CAmount> CalculateAncestorData(const CTxMemPoolEntry& entry) const EXCLUSIVE_LOCKS_REQUIRED(cs);
+    std::tuple<size_t, size_t, CAmount> CalculateDescendantData(const CTxMemPoolEntry& entry) const EXCLUSIVE_LOCKS_REQUIRED(cs);
 
 private:
     typedef std::map<txiter, setEntries, CompareIteratorByHash> cacheMap;

From 89ae38f48965ec0d6c0600ce4269fdc797274161 Mon Sep 17 00:00:00 2001
From: Suhas Daftuar <sdaftuar@chaincode.com>
Date: Wed, 18 Oct 2023 13:22:09 -0400
Subject: [PATCH 32/65] test: remove rbf carveout test from mempool_limit.py

---
 test/functional/mempool_limit.py | 52 --------------------------------
 1 file changed, 52 deletions(-)

diff --git a/test/functional/mempool_limit.py b/test/functional/mempool_limit.py
index 72696062457..8b9fd3810e4 100755
--- a/test/functional/mempool_limit.py
+++ b/test/functional/mempool_limit.py
@@ -32,57 +32,6 @@ class MempoolLimitTest(BitcoinTestFramework):
             "-maxmempool=5",
         ]]
 
-    def test_rbf_carveout_disallowed(self):
-        node = self.nodes[0]
-
-        self.log.info("Check that individually-evaluated transactions in a package don't increase package limits for other subpackage parts")
-
-        # We set chain limits to 2 ancestors, 1 descendant, then try to get a parents-and-child chain of 2 in mempool
-        #
-        # A: Solo transaction to be RBF'd (to bump descendant limit for package later)
-        # B: First transaction in package, RBFs A by itself under individual evaluation, which would give it +1 descendant limit
-        # C: Second transaction in package, spends B. If the +1 descendant limit persisted, would make it into mempool
-
-        self.restart_node(0, extra_args=self.extra_args[0] + ["-limitancestorcount=2", "-limitdescendantcount=1"])
-
-        # Generate a confirmed utxo we will double-spend
-        rbf_utxo = self.wallet.send_self_transfer(
-            from_node=node,
-            confirmed_only=True
-        )["new_utxo"]
-        self.generate(node, 1)
-
-        # tx_A needs to be RBF'd, set minfee at set size
-        A_vsize = 250
-        mempoolmin_feerate = node.getmempoolinfo()["mempoolminfee"]
-        tx_A = self.wallet.send_self_transfer(
-            from_node=node,
-            fee_rate=mempoolmin_feerate,
-            target_vsize=A_vsize,
-            utxo_to_spend=rbf_utxo,
-            confirmed_only=True
-        )
-
-        # RBF's tx_A, is not yet submitted
-        tx_B = self.wallet.create_self_transfer(
-            fee=tx_A["fee"] * 4,
-            target_vsize=A_vsize,
-            utxo_to_spend=rbf_utxo,
-            confirmed_only=True
-        )
-
-        # Spends tx_B's output, too big for cpfp carveout (because that would also increase the descendant limit by 1)
-        non_cpfp_carveout_vsize = 10001  # EXTRA_DESCENDANT_TX_SIZE_LIMIT + 1
-        tx_C = self.wallet.create_self_transfer(
-            target_vsize=non_cpfp_carveout_vsize,
-            fee_rate=mempoolmin_feerate,
-            utxo_to_spend=tx_B["new_utxo"],
-            confirmed_only=True
-        )
-        res = node.submitpackage([tx_B["hex"], tx_C["hex"]])
-        assert_equal(res["package_msg"], "transaction failed")
-        assert "too-long-mempool-chain" in res["tx-results"][tx_C["wtxid"]]["error"]
-
     def test_mid_package_eviction_success(self):
         node = self.nodes[0]
         self.log.info("Check a package where each parent passes the current mempoolminfee but a parent could be evicted before getting child's descendant feerate")
@@ -336,7 +285,6 @@ class MempoolLimitTest(BitcoinTestFramework):
 
         self.test_mid_package_eviction_success()
         self.test_mid_package_replacement()
-        self.test_rbf_carveout_disallowed()
 
 
 if __name__ == '__main__':

From cf3ab8e1d0a2f2bdf72e61e2c2dcb35987e5b9bd Mon Sep 17 00:00:00 2001
From: Suhas Daftuar <sdaftuar@chaincode.com>
Date: Tue, 3 Oct 2023 13:56:22 -0400
Subject: [PATCH 33/65] Stop enforcing descendant size/count limits

Cluster size limits should be enough.
---
 src/txmempool.cpp                          | 15 -------
 test/functional/feature_rbf.py             |  9 ----
 test/functional/mempool_package_limits.py  |  5 ++-
 test/functional/mempool_packages.py        | 51 +++++-----------------
 test/functional/mempool_sigoplimit.py      |  8 ++--
 test/functional/mempool_truc.py            | 13 +++---
 test/functional/mempool_updatefromblock.py |  3 +-
 7 files changed, 26 insertions(+), 78 deletions(-)

diff --git a/src/txmempool.cpp b/src/txmempool.cpp
index ce9218f9111..ab6d3ed229f 100644
--- a/src/txmempool.cpp
+++ b/src/txmempool.cpp
@@ -177,12 +177,6 @@ util::Result<CTxMemPool::setEntries> CTxMemPool::CalculateAncestorsAndCheckLimit
         ancestors.insert(stageit);
         staged_ancestors.erase(stage);
 
-        if (stageit->GetSizeWithDescendants() + entry_size > limits.descendant_size_vbytes) {
-            return util::Error{Untranslated(strprintf("exceeds descendant size limit for tx %s [limit: %u]", stageit->GetTx().GetHash().ToString(), limits.descendant_size_vbytes))};
-        } else if (stageit->GetCountWithDescendants() + entry_count > static_cast<uint64_t>(limits.descendant_count)) {
-            return util::Error{Untranslated(strprintf("too many descendants for tx %s [limit: %u]", stageit->GetTx().GetHash().ToString(), limits.descendant_count))};
-        }
-
         const CTxMemPoolEntry::Parents& parents = stageit->GetMemPoolParentsConst();
         for (const CTxMemPoolEntry& parent : parents) {
             txiter parent_it = mapTx.iterator_to(parent);
@@ -200,15 +194,6 @@ util::Result<CTxMemPool::setEntries> CTxMemPool::CalculateAncestorsAndCheckLimit
 util::Result<void> CTxMemPool::CheckPackageLimits(const Package& package,
                                                   const int64_t total_vsize) const
 {
-    size_t pack_count = package.size();
-
-    // Package itself is busting mempool limits; should be rejected even if no staged_ancestors exist
-    if (pack_count > static_cast<uint64_t>(m_opts.limits.descendant_count)) {
-        return util::Error{Untranslated(strprintf("package count %u exceeds descendant count limit [limit: %u]", pack_count, m_opts.limits.descendant_count))};
-    } else if (total_vsize > m_opts.limits.descendant_size_vbytes) {
-        return util::Error{Untranslated(strprintf("package size %u exceeds descendant size limit [limit: %u]", total_vsize, m_opts.limits.descendant_size_vbytes))};
-    }
-
     CTxMemPoolEntry::Parents staged_ancestors;
     for (const auto& tx : package) {
         for (const auto& input : tx->vin) {
diff --git a/test/functional/feature_rbf.py b/test/functional/feature_rbf.py
index 81ecef540ef..0590af129dd 100755
--- a/test/functional/feature_rbf.py
+++ b/test/functional/feature_rbf.py
@@ -27,15 +27,6 @@ MAX_CLUSTER_LIMIT = 64
 class ReplaceByFeeTest(BitcoinTestFramework):
     def set_test_params(self):
         self.num_nodes = 2
-        self.extra_args = [
-            [
-                "-limitancestorcount=64",
-                "-limitdescendantcount=64",
-            ],
-            # second node has default mempool parameters
-            [
-            ],
-        ]
         self.uses_wallet = None
 
     def run_test(self):
diff --git a/test/functional/mempool_package_limits.py b/test/functional/mempool_package_limits.py
index 5e402ede4fb..3f26777941d 100755
--- a/test/functional/mempool_package_limits.py
+++ b/test/functional/mempool_package_limits.py
@@ -15,7 +15,7 @@ from test_framework.wallet import MiniWallet
 # 2) run the subtest, which may submit some transaction(s) to the mempool and
 #    create a list of hex transactions
 # 3) testmempoolaccept the package hex and check that it fails with the error
-#    "package-mempool-limits" for each tx
+#    "too-large-cluster" for each tx
 # 4) after mining a block, clearing the pre-submitted transactions from mempool,
 #    check that submitting the created package succeeds
 def check_package_limits(func):
@@ -26,7 +26,7 @@ def check_package_limits(func):
         testres_error_expected = node.testmempoolaccept(rawtxs=package_hex)
         assert_equal(len(testres_error_expected), len(package_hex))
         for txres in testres_error_expected:
-            assert "package-mempool-limits" in txres["package-error"]
+            assert "too-large-cluster" in txres["package-error"]
 
         # Clear mempool and check that the package passes now
         self.generate(node, 1)
@@ -39,6 +39,7 @@ class MempoolPackageLimitsTest(BitcoinTestFramework):
     def set_test_params(self):
         self.num_nodes = 1
         self.setup_clean_chain = True
+        self.extra_args = [["-limitclustercount=25"]]
 
     def run_test(self):
         self.wallet = MiniWallet(self.nodes[0])
diff --git a/test/functional/mempool_packages.py b/test/functional/mempool_packages.py
index 74d04f077f9..9cf1aa01f56 100755
--- a/test/functional/mempool_packages.py
+++ b/test/functional/mempool_packages.py
@@ -7,19 +7,18 @@
 from decimal import Decimal
 
 from test_framework.messages import (
-    DEFAULT_DESCENDANT_LIMIT,
     DEFAULT_CLUSTER_LIMIT,
 )
 from test_framework.p2p import P2PTxInvStore
 from test_framework.test_framework import BitcoinTestFramework
 from test_framework.util import (
     assert_equal,
-    assert_raises_rpc_error,
 )
 from test_framework.wallet import MiniWallet
 
 # custom limits for node1
-CUSTOM_DESCENDANT_LIMIT = 11
+CUSTOM_CLUSTER_LIMIT = 10
+assert CUSTOM_CLUSTER_LIMIT < DEFAULT_CLUSTER_LIMIT
 
 class MempoolPackagesTest(BitcoinTestFramework):
     def set_test_params(self):
@@ -30,7 +29,7 @@ class MempoolPackagesTest(BitcoinTestFramework):
             [
             ],
             [
-                "-limitdescendantcount={}".format(CUSTOM_DESCENDANT_LIMIT),
+                "-limitclustercount={}".format(CUSTOM_CLUSTER_LIMIT),
             ],
         ]
 
@@ -40,8 +39,8 @@ class MempoolPackagesTest(BitcoinTestFramework):
 
         peer_inv_store = self.nodes[0].add_p2p_connection(P2PTxInvStore()) # keep track of invs
 
-        # DEFAULT_DESCENDANT_LIMIT transactions off a confirmed tx should be fine
-        chain = self.wallet.create_self_transfer_chain(chain_length=DEFAULT_DESCENDANT_LIMIT)
+        # DEFAULT_CLUSTER_LIMIT transactions off a confirmed tx should be fine for default node
+        chain = self.wallet.create_self_transfer_chain(chain_length=DEFAULT_CLUSTER_LIMIT)
         witness_chain = [t["wtxid"] for t in chain]
         ancestor_vsize = 0
         ancestor_fees = Decimal(0)
@@ -55,22 +54,18 @@ class MempoolPackagesTest(BitcoinTestFramework):
         # Otherwise, getrawmempool may be inconsistent with getmempoolentry if unbroadcast changes in between
         peer_inv_store.wait_for_broadcast(witness_chain)
 
-        # Check mempool has DEFAULT_DESCENDANT_LIMIT transactions in it, and descendant and ancestor
+        # Check mempool has DEFAULT_CLUSTER_LIMIT transactions in it, and descendant and ancestor
         # count and fees should look correct
         mempool = self.nodes[0].getrawmempool(True)
-        assert_equal(len(mempool), DEFAULT_DESCENDANT_LIMIT)
+        assert_equal(len(mempool), DEFAULT_CLUSTER_LIMIT)
         descendant_count = 1
         descendant_fees = 0
         descendant_vsize = 0
 
         assert_equal(ancestor_vsize, sum([mempool[tx]['vsize'] for tx in mempool]))
-        ancestor_count = DEFAULT_DESCENDANT_LIMIT
+        ancestor_count = DEFAULT_CLUSTER_LIMIT
         assert_equal(ancestor_fees, sum([mempool[tx]['fees']['base'] for tx in mempool]))
 
-        # Adding one more transaction on to the chain should fail.
-        next_hop = self.wallet.create_self_transfer(utxo_to_spend=chain[-1]["new_utxo"])["hex"]
-        assert_raises_rpc_error(-26, "too-long-mempool-chain", lambda: self.nodes[0].sendrawtransaction(next_hop))
-
         descendants = []
         ancestors = [t["txid"] for t in chain]
         chain = [t["txid"] for t in chain]
@@ -186,23 +181,7 @@ class MempoolPackagesTest(BitcoinTestFramework):
                 assert_equal(entry['fees']['modified'], entry['fees']['base'] + Decimal("0.00002"))
             assert_equal(entry['fees']['descendant'], descendant_fees + Decimal("0.00002"))
 
-        # Check that node1's mempool is as expected (-> custom ancestor limit)
-        mempool0 = self.nodes[0].getrawmempool(False)
-        mempool1 = self.nodes[1].getrawmempool(False)
-        assert_equal(len(mempool1), CUSTOM_DESCENDANT_LIMIT)
-        assert set(mempool1).issubset(set(mempool0))
-        for tx in chain[:CUSTOM_DESCENDANT_LIMIT]:
-            assert tx in mempool1
-            entry0 = self.nodes[0].getmempoolentry(tx)
-            entry1 = self.nodes[1].getmempoolentry(tx)
-            assert not entry0['unbroadcast']
-            assert not entry1['unbroadcast']
-            assert_equal(entry1['fees']['base'], entry0['fees']['base'])
-            assert_equal(entry1['vsize'], entry0['vsize'])
-            assert_equal(entry1['depends'], entry0['depends'])
-
         # Now test descendant chain limits
-
         tx_children = []
         # First create one parent tx with 10 children
         tx_with_children = self.wallet.send_self_transfer_multi(from_node=self.nodes[0], num_outputs=10)
@@ -211,7 +190,7 @@ class MempoolPackagesTest(BitcoinTestFramework):
 
         # Sign and send up to MAX_DESCENDANT transactions chained off the parent tx
         chain = [] # save sent txs for the purpose of checking node1's mempool later (see below)
-        for _ in range(DEFAULT_DESCENDANT_LIMIT - 1):
+        for _ in range(DEFAULT_CLUSTER_LIMIT - 1):
             utxo = transaction_package.pop(0)
             new_tx = self.wallet.send_self_transfer_multi(from_node=self.nodes[0], num_outputs=10, utxos_to_spend=[utxo])
             txid = new_tx["txid"]
@@ -221,22 +200,16 @@ class MempoolPackagesTest(BitcoinTestFramework):
             transaction_package.extend(new_tx["new_utxos"])
 
         mempool = self.nodes[0].getrawmempool(True)
-        assert_equal(mempool[parent_transaction]['descendantcount'], DEFAULT_DESCENDANT_LIMIT)
+        assert_equal(mempool[parent_transaction]['descendantcount'], DEFAULT_CLUSTER_LIMIT)
         assert_equal(sorted(mempool[parent_transaction]['spentby']), sorted(tx_children))
 
         for child in tx_children:
             assert_equal(mempool[child]['depends'], [parent_transaction])
 
-        # Sending one more chained transaction will fail
-        next_hop = self.wallet.create_self_transfer(utxo_to_spend=transaction_package.pop(0))["hex"]
-        assert_raises_rpc_error(-26, "too-long-mempool-chain", lambda: self.nodes[0].sendrawtransaction(next_hop))
-
         # Check that node1's mempool is as expected, containing:
-        # - txs from previous ancestor test (-> custom ancestor limit)
         # - parent tx for descendant test
         # - txs chained off parent tx (-> custom descendant limit)
-        self.wait_until(lambda: len(self.nodes[1].getrawmempool()) ==
-                                2*CUSTOM_DESCENDANT_LIMIT, timeout=10)
+        self.wait_until(lambda: len(self.nodes[1].getrawmempool()) == 2*CUSTOM_CLUSTER_LIMIT, timeout=10)
         mempool0 = self.nodes[0].getrawmempool(False)
         mempool1 = self.nodes[1].getrawmempool(False)
         assert set(mempool1).issubset(set(mempool0))
@@ -247,7 +220,7 @@ class MempoolPackagesTest(BitcoinTestFramework):
                 entry1 = self.nodes[1].getmempoolentry(tx)
                 assert not entry0['unbroadcast']
                 assert not entry1['unbroadcast']
-                assert entry1["descendantcount"] <= CUSTOM_DESCENDANT_LIMIT
+                assert entry1["descendantcount"] <= CUSTOM_CLUSTER_LIMIT
                 assert_equal(entry1['fees']['base'], entry0['fees']['base'])
                 assert_equal(entry1['vsize'], entry0['vsize'])
                 assert_equal(entry1['depends'], entry0['depends'])
diff --git a/test/functional/mempool_sigoplimit.py b/test/functional/mempool_sigoplimit.py
index 965f9a5c56d..3b2d737302e 100755
--- a/test/functional/mempool_sigoplimit.py
+++ b/test/functional/mempool_sigoplimit.py
@@ -169,14 +169,14 @@ class BytesPerSigOpTest(BitcoinTestFramework):
         assert_equal(parent_individual_testres["vsize"], max_multisig_vsize)
 
         # But together, it's exceeding limits in the *package* context. If sigops adjusted vsize wasn't being checked
-        # here, it would get further in validation and give too-long-mempool-chain error instead.
+        # here, it would get further in validation and give too-large-cluster error instead.
         packet_test = self.nodes[0].testmempoolaccept([tx_parent.serialize().hex(), tx_child.serialize().hex()])
-        expected_package_error = f"package-mempool-limits, package size {2*max_multisig_vsize} exceeds descendant size limit [limit: 101000]"
+        expected_package_error = "too-large-cluster"
         assert_equal([x["package-error"] for x in packet_test], [expected_package_error] * 2)
 
-        # When we actually try to submit, the parent makes it into the mempool, but the child would exceed ancestor vsize limits
+        # When we actually try to submit, the parent makes it into the mempool, but the child would exceed cluster vsize limits
         res = self.nodes[0].submitpackage([tx_parent.serialize().hex(), tx_child.serialize().hex()])
-        assert "too-long-mempool-chain" in res["tx-results"][tx_child.wtxid_hex]["error"]
+        assert "too-large-cluster" in res["tx-results"][tx_child.wtxid_hex]["error"]
         assert tx_parent.txid_hex in self.nodes[0].getrawmempool()
 
         # Transactions are tiny in weight
diff --git a/test/functional/mempool_truc.py b/test/functional/mempool_truc.py
index 687b707297f..6ba8cbffef0 100755
--- a/test/functional/mempool_truc.py
+++ b/test/functional/mempool_truc.py
@@ -196,15 +196,15 @@ class MempoolTRUC(BitcoinTestFramework):
         node.invalidateblock(block["hash"])
         self.check_mempool([tx_v3_block["txid"], tx_v2_block["txid"], tx_v3_block2["txid"], tx_v2_from_v3["txid"], tx_v3_from_v2["txid"], tx_v3_child_large["txid"], tx_chain_1["txid"], tx_chain_2["txid"], tx_chain_3["txid"], tx_chain_4["txid"]])
 
-    @cleanup(extra_args=["-limitdescendantsize=10"])
+    @cleanup(extra_args=["-limitclustercount=1"])
     def test_nondefault_package_limits(self):
         """
-        Max standard tx size + TRUC rules imply the ancestor/descendant rules (at their default
+        Max standard tx size + TRUC rules imply the cluster rules (at their default
         values), but those checks must not be skipped. Ensure both sets of checks are done by
-        changing the ancestor/descendant limit configurations.
+        changing the cluster limit configurations.
         """
         node = self.nodes[0]
-        self.log.info("Test that a decreased limitdescendantsize also applies to TRUC child")
+        self.log.info("Test that a decreased cluster count limit also applies to TRUC child")
         parent_target_vsize = 9990
         child_target_vsize = 500
         tx_v3_parent_large1 = self.wallet.send_self_transfer(
@@ -218,12 +218,11 @@ class MempoolTRUC(BitcoinTestFramework):
             version=3
         )
 
-        # Parent and child are within v3 limits, but parent's 10kvB descendant limit is exceeded
+        # Parent and child are within v3 limits, but cluster count limit is exceeded.
         assert_greater_than_or_equal(TRUC_MAX_VSIZE, tx_v3_parent_large1["tx"].get_vsize())
         assert_greater_than_or_equal(TRUC_CHILD_MAX_VSIZE, tx_v3_child_large1["tx"].get_vsize())
-        assert_greater_than(tx_v3_parent_large1["tx"].get_vsize() + tx_v3_child_large1["tx"].get_vsize(), 10000)
 
-        assert_raises_rpc_error(-26, f"too-long-mempool-chain, exceeds descendant size limit for tx {tx_v3_parent_large1['txid']}", node.sendrawtransaction, tx_v3_child_large1["hex"])
+        assert_raises_rpc_error(-26, "too-large-cluster", node.sendrawtransaction, tx_v3_child_large1["hex"])
         self.check_mempool([tx_v3_parent_large1["txid"]])
         assert_equal(node.getmempoolentry(tx_v3_parent_large1["txid"])["descendantcount"], 1)
         self.generate(node, 1)
diff --git a/test/functional/mempool_updatefromblock.py b/test/functional/mempool_updatefromblock.py
index 6ee31ffa650..bf0b8778b64 100755
--- a/test/functional/mempool_updatefromblock.py
+++ b/test/functional/mempool_updatefromblock.py
@@ -27,8 +27,7 @@ CUSTOM_DESCENDANT_COUNT = CUSTOM_ANCESTOR_COUNT
 class MempoolUpdateFromBlockTest(BitcoinTestFramework):
     def set_test_params(self):
         self.num_nodes = 1
-        # Ancestor and descendant limits depend on transaction_graph_test requirements
-        self.extra_args = [['-limitdescendantsize=1000', '-limitancestorsize=1000', f'-limitancestorcount={CUSTOM_ANCESTOR_COUNT}', f'-limitdescendantcount={CUSTOM_DESCENDANT_COUNT}', "-limitclustersize=1000"]]
+        self.extra_args = [['-limitclustersize=1000']]
 
     def create_empty_fork(self, fork_length):
         '''

From e031085fd464b528c186948d3cbf1c08a5a8d624 Mon Sep 17 00:00:00 2001
From: Suhas Daftuar <sdaftuar@chaincode.com>
Date: Wed, 12 Jun 2024 14:50:47 -0400
Subject: [PATCH 34/65] Eliminate Single-Conflict RBF Carve Out

The new cluster mempool RBF rules take into account clusters sizes exactly, so
with the removal of descendant count enforcement this idea is obsolete.
---
 src/validation.cpp | 63 ++++++----------------------------------------
 1 file changed, 7 insertions(+), 56 deletions(-)

diff --git a/src/validation.cpp b/src/validation.cpp
index 3e00958f39d..ac8205528a5 100644
--- a/src/validation.cpp
+++ b/src/validation.cpp
@@ -479,9 +479,6 @@ public:
          */
         const std::optional<CFeeRate> m_client_maxfeerate;
 
-        /** Whether CPFP carveout and RBF carveout are granted. */
-        const bool m_allow_carveouts;
-
         /** Parameters for single transaction mempool validation. */
         static ATMPArgs SingleAccept(const CChainParams& chainparams, int64_t accept_time,
                                      bool bypass_limits, std::vector<COutPoint>& coins_to_uncache,
@@ -496,7 +493,6 @@ public:
                             /* m_package_submission */ false,
                             /* m_package_feerates */ false,
                             /* m_client_maxfeerate */ {}, // checked by caller
-                            /* m_allow_carveouts */ true,
             };
         }
 
@@ -513,7 +509,6 @@ public:
                             /* m_package_submission */ false, // not submitting to mempool
                             /* m_package_feerates */ false,
                             /* m_client_maxfeerate */ {}, // checked by caller
-                            /* m_allow_carveouts */ false,
             };
         }
 
@@ -530,7 +525,6 @@ public:
                             /* m_package_submission */ true,
                             /* m_package_feerates */ true,
                             /* m_client_maxfeerate */ client_maxfeerate,
-                            /* m_allow_carveouts */ false,
             };
         }
 
@@ -546,7 +540,6 @@ public:
                             /* m_package_submission */ true, // trim at the end of AcceptPackage()
                             /* m_package_feerates */ false, // only 1 transaction
                             /* m_client_maxfeerate */ package_args.m_client_maxfeerate,
-                            /* m_allow_carveouts */ false,
             };
         }
 
@@ -562,8 +555,7 @@ public:
                  bool allow_sibling_eviction,
                  bool package_submission,
                  bool package_feerates,
-                 std::optional<CFeeRate> client_maxfeerate,
-                 bool allow_carveouts)
+                 std::optional<CFeeRate> client_maxfeerate)
             : m_chainparams{chainparams},
               m_accept_time{accept_time},
               m_bypass_limits{bypass_limits},
@@ -573,14 +565,12 @@ public:
               m_allow_sibling_eviction{allow_sibling_eviction},
               m_package_submission{package_submission},
               m_package_feerates{package_feerates},
-              m_client_maxfeerate{client_maxfeerate},
-              m_allow_carveouts{allow_carveouts}
+              m_client_maxfeerate{client_maxfeerate}
         {
             // If we are using package feerates, we must be doing package submission.
-            // It also means carveouts and sibling eviction are not permitted.
+            // It also means sibling eviction is not permitted.
             if (m_package_feerates) {
                 Assume(m_package_submission);
-                Assume(!m_allow_carveouts);
                 Assume(!m_allow_sibling_eviction);
             }
             if (m_allow_sibling_eviction) Assume(m_allow_replacement);
@@ -614,9 +604,9 @@ public:
 
     /**
      * Submission of a subpackage.
-     * If subpackage size == 1, calls AcceptSingleTransaction() with adjusted ATMPArgs to avoid
-     * package policy restrictions like no CPFP carve out (PackageMempoolChecks)
-     * and creates a PackageMempoolAcceptResult wrapping the result.
+     * If subpackage size == 1, calls AcceptSingleTransaction() with adjusted ATMPArgs to
+     * enable sibling eviction and creates a PackageMempoolAcceptResult
+     * wrapping the result.
      *
      * If subpackage size > 1, calls AcceptMultipleTransactions() with the provided ATMPArgs.
      *
@@ -971,47 +961,8 @@ bool MemPoolAccept::PreChecks(ATMPArgs& args, Workspace& ws)
 
     ws.m_iters_conflicting = m_pool.GetIterSet(ws.m_conflicts);
 
-    // Note that these modifications are only applicable to single transaction scenarios;
-    // carve-outs are disabled for multi-transaction evaluations.
-    CTxMemPool::Limits maybe_rbf_limits = m_pool.m_opts.limits;
-
     // Calculate in-mempool ancestors, up to a limit.
-    if (ws.m_conflicts.size() == 1 && args.m_allow_carveouts) {
-        // In general, when we receive an RBF transaction with mempool conflicts, we want to know whether we
-        // would meet the chain limits after the conflicts have been removed. However, there isn't a practical
-        // way to do this short of calculating the ancestor and descendant sets with an overlay cache of
-        // changed mempool entries. Due to both implementation and runtime complexity concerns, this isn't
-        // very realistic, thus we only ensure a limited set of transactions are RBF'able despite mempool
-        // conflicts here. Importantly, we need to ensure that some transactions which were accepted using
-        // the below carve-out are able to be RBF'ed, without impacting the security the carve-out provides
-        // for off-chain contract systems (see link in the comment below).
-        //
-        // Specifically, the subset of RBF transactions which we allow despite chain limits are those which
-        // conflict directly with exactly one other transaction (but may evict children of said transaction),
-        // and which are not adding any new mempool dependencies. Note that the "no new mempool dependencies"
-        // check is accomplished later, so we don't bother doing anything about it here, but if our
-        // policy changes, we may need to move that check to here instead of removing it wholesale.
-        //
-        // Such transactions are clearly not merging any existing packages, so we are only concerned with
-        // ensuring that (a) no package is growing past the package size (not count) limits and (b) we are
-        // not allowing something to effectively use the (below) carve-out spot when it shouldn't be allowed
-        // to.
-        //
-        // To check these we first check if we meet the RBF criteria, above, and increment the descendant
-        // limits by the direct conflict and its descendants (as these are recalculated in
-        // CalculateMempoolAncestors by assuming the new transaction being added is a new descendant, with no
-        // removals, of each parent's existing dependent set). The ancestor count limits are unmodified (as
-        // the ancestor limits should be the same for both our new transaction and any conflicts).
-        // We don't bother incrementing m_limit_descendants by the full removal count as that limit never comes
-        // into force here (as we're only adding a single transaction).
-        assert(ws.m_iters_conflicting.size() == 1);
-        CTxMemPool::txiter conflict = *ws.m_iters_conflicting.begin();
-
-        maybe_rbf_limits.descendant_count += 1;
-        maybe_rbf_limits.descendant_size_vbytes += conflict->GetSizeWithDescendants();
-    }
-
-    if (auto ancestors{m_subpackage.m_changeset->CalculateMemPoolAncestors(ws.m_tx_handle, maybe_rbf_limits)}) {
+    if (auto ancestors{m_subpackage.m_changeset->CalculateMemPoolAncestors(ws.m_tx_handle, m_pool.m_opts.limits)}) {
         ws.m_ancestors = std::move(*ancestors);
     } else {
         return state.Invalid(TxValidationResult::TX_MEMPOOL_POLICY, "too-long-mempool-chain", util::ErrorString(ancestors).original);

From 8e49477e86b3089ea70d1f2659b9fd3a8a1f7db4 Mon Sep 17 00:00:00 2001
From: Suhas Daftuar <sdaftuar@chaincode.com>
Date: Tue, 3 Oct 2023 15:00:00 -0400
Subject: [PATCH 35/65] wallet: Replace max descendant count with cluster_count

With the descendant size limits removed, replace the concept of "max number of
descendants of any ancestor of a given tx" with the cluster count of the cluster
that the transaction belongs to.
---
 src/node/interfaces.cpp    |   6 +-
 src/test/mempool_tests.cpp | 124 ++++++++++++++++++-------------------
 src/txmempool.cpp          |   6 +-
 src/txmempool.h            |   4 +-
 4 files changed, 70 insertions(+), 70 deletions(-)

diff --git a/src/node/interfaces.cpp b/src/node/interfaces.cpp
index c3e57291794..65997267652 100644
--- a/src/node/interfaces.cpp
+++ b/src/node/interfaces.cpp
@@ -678,11 +678,11 @@ public:
         // that Chain clients do not need to know about.
         return TransactionError::OK == err;
     }
-    void getTransactionAncestry(const Txid& txid, size_t& ancestors, size_t& descendants, size_t* ancestorsize, CAmount* ancestorfees) override
+    void getTransactionAncestry(const Txid& txid, size_t& ancestors, size_t& cluster_count, size_t* ancestorsize, CAmount* ancestorfees) override
     {
-        ancestors = descendants = 0;
+        ancestors = cluster_count = 0;
         if (!m_node.mempool) return;
-        m_node.mempool->GetTransactionAncestry(txid, ancestors, descendants, ancestorsize, ancestorfees);
+        m_node.mempool->GetTransactionAncestry(txid, ancestors, cluster_count, ancestorsize, ancestorfees);
     }
 
     std::map<COutPoint, CAmount> calculateIndividualBumpFees(const std::vector<COutPoint>& outpoints, const CFeeRate& target_feerate) override
diff --git a/src/test/mempool_tests.cpp b/src/test/mempool_tests.cpp
index 2271e7b88db..d0cbdea717e 100644
--- a/src/test/mempool_tests.cpp
+++ b/src/test/mempool_tests.cpp
@@ -296,7 +296,7 @@ inline CTransactionRef make_tx(std::vector<CAmount>&& output_values, std::vector
 
 BOOST_AUTO_TEST_CASE(MempoolAncestryTests)
 {
-    size_t ancestors, descendants;
+    size_t ancestors, clustersize;
 
     CTxMemPool& pool = *Assert(m_node.mempool);
     LOCK2(cs_main, pool.cs);
@@ -309,10 +309,10 @@ BOOST_AUTO_TEST_CASE(MempoolAncestryTests)
     CTransactionRef tx1 = make_tx(/*output_values=*/{10 * COIN});
     AddToMempool(pool, entry.Fee(10000LL).FromTx(tx1));
 
-    // Ancestors / descendants should be 1 / 1 (itself / itself)
-    pool.GetTransactionAncestry(tx1->GetHash(), ancestors, descendants);
+    // Ancestors / clustersize should be 1 / 1 (itself / itself)
+    pool.GetTransactionAncestry(tx1->GetHash(), ancestors, clustersize);
     BOOST_CHECK_EQUAL(ancestors, 1ULL);
-    BOOST_CHECK_EQUAL(descendants, 1ULL);
+    BOOST_CHECK_EQUAL(clustersize, 1ULL);
 
     /* Child transaction */
     //
@@ -321,17 +321,17 @@ BOOST_AUTO_TEST_CASE(MempoolAncestryTests)
     CTransactionRef tx2 = make_tx(/*output_values=*/{495 * CENT, 5 * COIN}, /*inputs=*/{tx1});
     AddToMempool(pool, entry.Fee(10000LL).FromTx(tx2));
 
-    // Ancestors / descendants should be:
-    // transaction  ancestors   descendants
+    // Ancestors / clustersize should be:
+    // transaction  ancestors   clustersize
     // ============ =========== ===========
     // tx1          1 (tx1)     2 (tx1,2)
     // tx2          2 (tx1,2)   2 (tx1,2)
-    pool.GetTransactionAncestry(tx1->GetHash(), ancestors, descendants);
+    pool.GetTransactionAncestry(tx1->GetHash(), ancestors, clustersize);
     BOOST_CHECK_EQUAL(ancestors, 1ULL);
-    BOOST_CHECK_EQUAL(descendants, 2ULL);
-    pool.GetTransactionAncestry(tx2->GetHash(), ancestors, descendants);
+    BOOST_CHECK_EQUAL(clustersize, 2ULL);
+    pool.GetTransactionAncestry(tx2->GetHash(), ancestors, clustersize);
     BOOST_CHECK_EQUAL(ancestors, 2ULL);
-    BOOST_CHECK_EQUAL(descendants, 2ULL);
+    BOOST_CHECK_EQUAL(clustersize, 2ULL);
 
     /* Grand-child 1 */
     //
@@ -340,21 +340,21 @@ BOOST_AUTO_TEST_CASE(MempoolAncestryTests)
     CTransactionRef tx3 = make_tx(/*output_values=*/{290 * CENT, 200 * CENT}, /*inputs=*/{tx2});
     AddToMempool(pool, entry.Fee(10000LL).FromTx(tx3));
 
-    // Ancestors / descendants should be:
-    // transaction  ancestors   descendants
+    // Ancestors / clustersize should be:
+    // transaction  ancestors   clustersize
     // ============ =========== ===========
     // tx1          1 (tx1)     3 (tx1,2,3)
     // tx2          2 (tx1,2)   3 (tx1,2,3)
     // tx3          3 (tx1,2,3) 3 (tx1,2,3)
-    pool.GetTransactionAncestry(tx1->GetHash(), ancestors, descendants);
+    pool.GetTransactionAncestry(tx1->GetHash(), ancestors, clustersize);
     BOOST_CHECK_EQUAL(ancestors, 1ULL);
-    BOOST_CHECK_EQUAL(descendants, 3ULL);
-    pool.GetTransactionAncestry(tx2->GetHash(), ancestors, descendants);
+    BOOST_CHECK_EQUAL(clustersize, 3ULL);
+    pool.GetTransactionAncestry(tx2->GetHash(), ancestors, clustersize);
     BOOST_CHECK_EQUAL(ancestors, 2ULL);
-    BOOST_CHECK_EQUAL(descendants, 3ULL);
-    pool.GetTransactionAncestry(tx3->GetHash(), ancestors, descendants);
+    BOOST_CHECK_EQUAL(clustersize, 3ULL);
+    pool.GetTransactionAncestry(tx3->GetHash(), ancestors, clustersize);
     BOOST_CHECK_EQUAL(ancestors, 3ULL);
-    BOOST_CHECK_EQUAL(descendants, 3ULL);
+    BOOST_CHECK_EQUAL(clustersize, 3ULL);
 
     /* Grand-child 2 */
     //
@@ -365,25 +365,25 @@ BOOST_AUTO_TEST_CASE(MempoolAncestryTests)
     CTransactionRef tx4 = make_tx(/*output_values=*/{290 * CENT, 250 * CENT}, /*inputs=*/{tx2}, /*input_indices=*/{1});
     AddToMempool(pool, entry.Fee(10000LL).FromTx(tx4));
 
-    // Ancestors / descendants should be:
-    // transaction  ancestors   descendants
+    // Ancestors / clustersize should be:
+    // transaction  ancestors   clustersize
     // ============ =========== ===========
     // tx1          1 (tx1)     4 (tx1,2,3,4)
     // tx2          2 (tx1,2)   4 (tx1,2,3,4)
     // tx3          3 (tx1,2,3) 4 (tx1,2,3,4)
     // tx4          3 (tx1,2,4) 4 (tx1,2,3,4)
-    pool.GetTransactionAncestry(tx1->GetHash(), ancestors, descendants);
+    pool.GetTransactionAncestry(tx1->GetHash(), ancestors, clustersize);
     BOOST_CHECK_EQUAL(ancestors, 1ULL);
-    BOOST_CHECK_EQUAL(descendants, 4ULL);
-    pool.GetTransactionAncestry(tx2->GetHash(), ancestors, descendants);
+    BOOST_CHECK_EQUAL(clustersize, 4ULL);
+    pool.GetTransactionAncestry(tx2->GetHash(), ancestors, clustersize);
     BOOST_CHECK_EQUAL(ancestors, 2ULL);
-    BOOST_CHECK_EQUAL(descendants, 4ULL);
-    pool.GetTransactionAncestry(tx3->GetHash(), ancestors, descendants);
+    BOOST_CHECK_EQUAL(clustersize, 4ULL);
+    pool.GetTransactionAncestry(tx3->GetHash(), ancestors, clustersize);
     BOOST_CHECK_EQUAL(ancestors, 3ULL);
-    BOOST_CHECK_EQUAL(descendants, 4ULL);
-    pool.GetTransactionAncestry(tx4->GetHash(), ancestors, descendants);
+    BOOST_CHECK_EQUAL(clustersize, 4ULL);
+    pool.GetTransactionAncestry(tx4->GetHash(), ancestors, clustersize);
     BOOST_CHECK_EQUAL(ancestors, 3ULL);
-    BOOST_CHECK_EQUAL(descendants, 4ULL);
+    BOOST_CHECK_EQUAL(clustersize, 4ULL);
 
     /* Make an alternate branch that is longer and connect it to tx3 */
     //
@@ -401,56 +401,56 @@ BOOST_AUTO_TEST_CASE(MempoolAncestryTests)
         tyi = make_tx(/*output_values=*/{v}, /*inputs=*/i > 0 ? std::vector<CTransactionRef>{*ty[i - 1]} : std::vector<CTransactionRef>{});
         v -= 50 * CENT;
         AddToMempool(pool, entry.Fee(10000LL).FromTx(tyi));
-        pool.GetTransactionAncestry(tyi->GetHash(), ancestors, descendants);
+        pool.GetTransactionAncestry(tyi->GetHash(), ancestors, clustersize);
         BOOST_CHECK_EQUAL(ancestors, i+1);
-        BOOST_CHECK_EQUAL(descendants, i+1);
+        BOOST_CHECK_EQUAL(clustersize, i+1);
     }
     CTransactionRef ty6 = make_tx(/*output_values=*/{5 * COIN}, /*inputs=*/{tx3, ty5});
     AddToMempool(pool, entry.Fee(10000LL).FromTx(ty6));
 
-    // Ancestors / descendants should be:
-    // transaction  ancestors           descendants
+    // Ancestors / clustersize should be:
+    // transaction  ancestors           clustersize
     // ============ =================== ===========
-    // tx1          1 (tx1)             5 (tx1,2,3,4, ty6)
-    // tx2          2 (tx1,2)           5 (tx1,2,3,4, ty6)
-    // tx3          3 (tx1,2,3)         5 (tx1,2,3,4, ty6)
-    // tx4          3 (tx1,2,4)         5 (tx1,2,3,4, ty6)
-    // ty1          1 (ty1)             6 (ty1,2,3,4,5,6)
-    // ty2          2 (ty1,2)           6 (ty1,2,3,4,5,6)
-    // ty3          3 (ty1,2,3)         6 (ty1,2,3,4,5,6)
-    // ty4          4 (y1234)           6 (ty1,2,3,4,5,6)
-    // ty5          5 (y12345)          6 (ty1,2,3,4,5,6)
-    // ty6          9 (tx123, ty123456) 6 (ty1,2,3,4,5,6)
-    pool.GetTransactionAncestry(tx1->GetHash(), ancestors, descendants);
+    // tx1          1 (tx1)             10 (tx1-5, ty1-5)
+    // tx2          2 (tx1,2)           10
+    // tx3          3 (tx1,2,3)         10
+    // tx4          3 (tx1,2,4)         10
+    // ty1          1 (ty1)             10
+    // ty2          2 (ty1,2)           10
+    // ty3          3 (ty1,2,3)         10
+    // ty4          4 (y1234)           10
+    // ty5          5 (y12345)          10
+    // ty6          9 (tx123, ty123456) 10
+    pool.GetTransactionAncestry(tx1->GetHash(), ancestors, clustersize);
     BOOST_CHECK_EQUAL(ancestors, 1ULL);
-    BOOST_CHECK_EQUAL(descendants, 5ULL);
-    pool.GetTransactionAncestry(tx2->GetHash(), ancestors, descendants);
+    BOOST_CHECK_EQUAL(clustersize, 10ULL);
+    pool.GetTransactionAncestry(tx2->GetHash(), ancestors, clustersize);
     BOOST_CHECK_EQUAL(ancestors, 2ULL);
-    BOOST_CHECK_EQUAL(descendants, 5ULL);
-    pool.GetTransactionAncestry(tx3->GetHash(), ancestors, descendants);
+    BOOST_CHECK_EQUAL(clustersize, 10ULL);
+    pool.GetTransactionAncestry(tx3->GetHash(), ancestors, clustersize);
     BOOST_CHECK_EQUAL(ancestors, 3ULL);
-    BOOST_CHECK_EQUAL(descendants, 5ULL);
-    pool.GetTransactionAncestry(tx4->GetHash(), ancestors, descendants);
+    BOOST_CHECK_EQUAL(clustersize, 10ULL);
+    pool.GetTransactionAncestry(tx4->GetHash(), ancestors, clustersize);
     BOOST_CHECK_EQUAL(ancestors, 3ULL);
-    BOOST_CHECK_EQUAL(descendants, 5ULL);
-    pool.GetTransactionAncestry(ty1->GetHash(), ancestors, descendants);
+    BOOST_CHECK_EQUAL(clustersize, 10ULL);
+    pool.GetTransactionAncestry(ty1->GetHash(), ancestors, clustersize);
     BOOST_CHECK_EQUAL(ancestors, 1ULL);
-    BOOST_CHECK_EQUAL(descendants, 6ULL);
-    pool.GetTransactionAncestry(ty2->GetHash(), ancestors, descendants);
+    BOOST_CHECK_EQUAL(clustersize, 10ULL);
+    pool.GetTransactionAncestry(ty2->GetHash(), ancestors, clustersize);
     BOOST_CHECK_EQUAL(ancestors, 2ULL);
-    BOOST_CHECK_EQUAL(descendants, 6ULL);
-    pool.GetTransactionAncestry(ty3->GetHash(), ancestors, descendants);
+    BOOST_CHECK_EQUAL(clustersize, 10ULL);
+    pool.GetTransactionAncestry(ty3->GetHash(), ancestors, clustersize);
     BOOST_CHECK_EQUAL(ancestors, 3ULL);
-    BOOST_CHECK_EQUAL(descendants, 6ULL);
-    pool.GetTransactionAncestry(ty4->GetHash(), ancestors, descendants);
+    BOOST_CHECK_EQUAL(clustersize, 10ULL);
+    pool.GetTransactionAncestry(ty4->GetHash(), ancestors, clustersize);
     BOOST_CHECK_EQUAL(ancestors, 4ULL);
-    BOOST_CHECK_EQUAL(descendants, 6ULL);
-    pool.GetTransactionAncestry(ty5->GetHash(), ancestors, descendants);
+    BOOST_CHECK_EQUAL(clustersize, 10ULL);
+    pool.GetTransactionAncestry(ty5->GetHash(), ancestors, clustersize);
     BOOST_CHECK_EQUAL(ancestors, 5ULL);
-    BOOST_CHECK_EQUAL(descendants, 6ULL);
-    pool.GetTransactionAncestry(ty6->GetHash(), ancestors, descendants);
+    BOOST_CHECK_EQUAL(clustersize, 10ULL);
+    pool.GetTransactionAncestry(ty6->GetHash(), ancestors, clustersize);
     BOOST_CHECK_EQUAL(ancestors, 9ULL);
-    BOOST_CHECK_EQUAL(descendants, 6ULL);
+    BOOST_CHECK_EQUAL(clustersize, 10ULL);
 }
 
 BOOST_AUTO_TEST_CASE(MempoolAncestryTestsDiamond)
diff --git a/src/txmempool.cpp b/src/txmempool.cpp
index ab6d3ed229f..e268fd61e79 100644
--- a/src/txmempool.cpp
+++ b/src/txmempool.cpp
@@ -1217,16 +1217,16 @@ std::tuple<size_t, size_t, CAmount> CTxMemPool::CalculateDescendantData(const CT
     return {descendant_count, descendant_size, descendant_fees};
 }
 
-void CTxMemPool::GetTransactionAncestry(const Txid& txid, size_t& ancestors, size_t& descendants, size_t* const ancestorsize, CAmount* const ancestorfees) const {
+void CTxMemPool::GetTransactionAncestry(const Txid& txid, size_t& ancestors, size_t& cluster_count, size_t* const ancestorsize, CAmount* const ancestorfees) const {
     LOCK(cs);
     auto it = mapTx.find(txid);
-    ancestors = descendants = 0;
+    ancestors = cluster_count = 0;
     if (it != mapTx.end()) {
         auto [ancestor_count, ancestor_size, ancestor_fees] = CalculateAncestorData(*it);
-        descendants = CalculateDescendantMaximum(it);
         ancestors = ancestor_count;
         if (ancestorsize) *ancestorsize = ancestor_size;
         if (ancestorfees) *ancestorfees = ancestor_fees;
+        cluster_count = m_txgraph->GetCluster(*it, TxGraph::Level::MAIN).size();
     }
 }
 
diff --git a/src/txmempool.h b/src/txmempool.h
index 49ee510a4f0..520410b6849 100644
--- a/src/txmempool.h
+++ b/src/txmempool.h
@@ -516,12 +516,12 @@ public:
     int Expire(std::chrono::seconds time) EXCLUSIVE_LOCKS_REQUIRED(cs);
 
     /**
-     * Calculate the ancestor and descendant count for the given transaction.
+     * Calculate the ancestor and cluster count for the given transaction.
      * The counts include the transaction itself.
      * When ancestors is non-zero (ie, the transaction itself is in the mempool),
      * ancestorsize and ancestorfees will also be set to the appropriate values.
      */
-    void GetTransactionAncestry(const Txid& txid, size_t& ancestors, size_t& descendants, size_t* ancestorsize = nullptr, CAmount* ancestorfees = nullptr) const;
+    void GetTransactionAncestry(const Txid& txid, size_t& ancestors, size_t& cluster_count, size_t* ancestorsize = nullptr, CAmount* ancestorfees = nullptr) const;
 
     /**
      * @returns true if an initial attempt to load the persisted mempool was made, regardless of

From ba09fc9774d5a0eaa58d93a2fa20bef1efc74f1e Mon Sep 17 00:00:00 2001
From: Suhas Daftuar <sdaftuar@chaincode.com>
Date: Wed, 4 Oct 2023 09:19:21 -0400
Subject: [PATCH 36/65] mempool: Remove unused function
 CalculateDescendantMaximum

---
 src/txmempool.cpp | 22 ----------------------
 src/txmempool.h   |  2 --
 2 files changed, 24 deletions(-)

diff --git a/src/txmempool.cpp b/src/txmempool.cpp
index e268fd61e79..7c3be6e1d85 100644
--- a/src/txmempool.cpp
+++ b/src/txmempool.cpp
@@ -1165,28 +1165,6 @@ void CTxMemPool::TrimToSize(size_t sizelimit, std::vector<COutPoint>* pvNoSpends
     }
 }
 
-uint64_t CTxMemPool::CalculateDescendantMaximum(txiter entry) const {
-    // find parent with highest descendant count
-    std::vector<txiter> candidates;
-    setEntries counted;
-    candidates.push_back(entry);
-    uint64_t maximum = 0;
-    while (candidates.size()) {
-        txiter candidate = candidates.back();
-        candidates.pop_back();
-        if (!counted.insert(candidate).second) continue;
-        const CTxMemPoolEntry::Parents& parents = candidate->GetMemPoolParentsConst();
-        if (parents.size() == 0) {
-            maximum = std::max(maximum, candidate->GetCountWithDescendants());
-        } else {
-            for (const CTxMemPoolEntry& i : parents) {
-                candidates.push_back(mapTx.iterator_to(i));
-            }
-        }
-    }
-    return maximum;
-}
-
 std::tuple<size_t, size_t, CAmount> CTxMemPool::CalculateAncestorData(const CTxMemPoolEntry& entry) const
 {
     auto ancestors = m_txgraph->GetAncestors(entry, TxGraph::Level::MAIN);
diff --git a/src/txmempool.h b/src/txmempool.h
index 520410b6849..054d9e12891 100644
--- a/src/txmempool.h
+++ b/src/txmempool.h
@@ -284,8 +284,6 @@ public:
 
     using Limits = kernel::MemPoolLimits;
 
-    uint64_t CalculateDescendantMaximum(txiter entry) const EXCLUSIVE_LOCKS_REQUIRED(cs);
-
     std::tuple<size_t, size_t, CAmount> CalculateAncestorData(const CTxMemPoolEntry& entry) const EXCLUSIVE_LOCKS_REQUIRED(cs);
     std::tuple<size_t, size_t, CAmount> CalculateDescendantData(const CTxMemPoolEntry& entry) const EXCLUSIVE_LOCKS_REQUIRED(cs);
 

From b9a2039f51226dce2c4e38ce5f26eefee171744b Mon Sep 17 00:00:00 2001
From: Suhas Daftuar <sdaftuar@gmail.com>
Date: Sun, 14 Apr 2024 13:49:03 -0400
Subject: [PATCH 37/65] Eliminate use of cached ancestor data in
 miniminer_tests and truc_policy

---
 src/policy/truc_policy.cpp      | 12 +++----
 src/policy/truc_policy.h        |  5 +--
 src/test/miniminer_tests.cpp    | 14 ++++++--
 src/test/txvalidation_tests.cpp | 64 ++++++++++++++++-----------------
 src/test/util/txmempool.cpp     | 16 +++++----
 src/txmempool.h                 |  3 ++
 src/validation.cpp              |  4 +--
 7 files changed, 66 insertions(+), 52 deletions(-)

diff --git a/src/policy/truc_policy.cpp b/src/policy/truc_policy.cpp
index 69e8d5ed1d2..96fbebb7220 100644
--- a/src/policy/truc_policy.cpp
+++ b/src/policy/truc_policy.cpp
@@ -55,7 +55,7 @@ struct ParentInfo {
     {}
 };
 
-std::optional<std::string> PackageTRUCChecks(const CTransactionRef& ptx, int64_t vsize,
+std::optional<std::string> PackageTRUCChecks(const CTxMemPool& pool, const CTransactionRef& ptx, int64_t vsize,
                                            const Package& package,
                                            const CTxMemPool::setEntries& mempool_ancestors)
 {
@@ -94,7 +94,7 @@ std::optional<std::string> PackageTRUCChecks(const CTransactionRef& ptx, int64_t
                     return ParentInfo{mempool_parent->GetTx().GetHash(),
                                       mempool_parent->GetTx().GetWitnessHash(),
                                       mempool_parent->GetTx().version,
-                                      /*has_mempool_descendant=*/mempool_parent->GetCountWithDescendants() > 1};
+                                      /*has_mempool_descendant=*/pool.GetDescendantCount(mempool_parent) > 1};
                 } else {
                     auto& parent_index = in_package_parents.front();
                     auto& package_parent = package.at(parent_index);
@@ -161,7 +161,7 @@ std::optional<std::string> PackageTRUCChecks(const CTransactionRef& ptx, int64_t
     return std::nullopt;
 }
 
-std::optional<std::pair<std::string, CTransactionRef>> SingleTRUCChecks(const CTransactionRef& ptx,
+std::optional<std::pair<std::string, CTransactionRef>> SingleTRUCChecks(const CTxMemPool& pool, const CTransactionRef& ptx,
                                           const CTxMemPool::setEntries& mempool_ancestors,
                                           const std::set<Txid>& direct_conflicts,
                                           int64_t vsize)
@@ -222,14 +222,14 @@ std::optional<std::pair<std::string, CTransactionRef>> SingleTRUCChecks(const CT
         const bool child_will_be_replaced = !children.empty() &&
             std::any_of(children.cbegin(), children.cend(),
                 [&direct_conflicts](const CTxMemPoolEntry& child){return direct_conflicts.count(child.GetTx().GetHash()) > 0;});
-        if (parent_entry->GetCountWithDescendants() + 1 > TRUC_DESCENDANT_LIMIT && !child_will_be_replaced) {
+        if (pool.GetDescendantCount(parent_entry) + 1 > TRUC_DESCENDANT_LIMIT && !child_will_be_replaced) {
             // Allow sibling eviction for TRUC transaction: if another child already exists, even if
             // we don't conflict inputs with it, consider evicting it under RBF rules. We rely on TRUC rules
             // only permitting 1 descendant, as otherwise we would need to have logic for deciding
             // which descendant to evict. Skip if this isn't true, e.g. if the transaction has
             // multiple children or the sibling also has descendants due to a reorg.
-            const bool consider_sibling_eviction{parent_entry->GetCountWithDescendants() == 2 &&
-                children.begin()->get().GetCountWithAncestors() == 2};
+            const bool consider_sibling_eviction{pool.GetDescendantCount(parent_entry) == 2 &&
+                pool.GetAncestorCount(children.begin()->get()) == 2};
 
             // Return the sibling if its eviction can be considered. Provide the "descendant count
             // limit" string either way, as the caller may decide not to do sibling eviction.
diff --git a/src/policy/truc_policy.h b/src/policy/truc_policy.h
index acd8ae56b1c..abe5295876d 100644
--- a/src/policy/truc_policy.h
+++ b/src/policy/truc_policy.h
@@ -49,6 +49,7 @@ static_assert(TRUC_MAX_VSIZE + TRUC_CHILD_MAX_VSIZE <= DEFAULT_DESCENDANT_SIZE_L
  * 6. A TRUC tx must be within TRUC_MAX_VSIZE.
  *
  *
+ * @param[in]   pool                    A reference to the mempool.
  * @param[in]   mempool_ancestors       The in-mempool ancestors of ptx.
  * @param[in]   direct_conflicts        In-mempool transactions this tx conflicts with. These conflicts
  *                                      are used to more accurately calculate the resulting descendant
@@ -63,7 +64,7 @@ static_assert(TRUC_MAX_VSIZE + TRUC_CHILD_MAX_VSIZE <= DEFAULT_DESCENDANT_SIZE_L
  * - debug string + nullptr if this transaction violates some TRUC rule and sibling eviction is not
  *   applicable.
  */
-std::optional<std::pair<std::string, CTransactionRef>> SingleTRUCChecks(const CTransactionRef& ptx,
+std::optional<std::pair<std::string, CTransactionRef>> SingleTRUCChecks(const CTxMemPool& pool, const CTransactionRef& ptx,
                                           const CTxMemPool::setEntries& mempool_ancestors,
                                           const std::set<Txid>& direct_conflicts,
                                           int64_t vsize);
@@ -89,7 +90,7 @@ std::optional<std::pair<std::string, CTransactionRef>> SingleTRUCChecks(const CT
  *
  * @returns debug string if an error occurs, std::nullopt otherwise.
  * */
-std::optional<std::string> PackageTRUCChecks(const CTransactionRef& ptx, int64_t vsize,
+std::optional<std::string> PackageTRUCChecks(const CTxMemPool& pool, const CTransactionRef& ptx, int64_t vsize,
                                            const Package& package,
                                            const CTxMemPool::setEntries& mempool_ancestors);
 
diff --git a/src/test/miniminer_tests.cpp b/src/test/miniminer_tests.cpp
index 4d4cf940e37..28f467a416e 100644
--- a/src/test/miniminer_tests.cpp
+++ b/src/test/miniminer_tests.cpp
@@ -448,14 +448,22 @@ BOOST_FIXTURE_TEST_CASE(miniminer_overlap, TestChain100Setup)
     BOOST_CHECK(tx2_feerate > tx3_feerate);
     const auto tx3_anc_feerate = CFeeRate(low_fee + med_fee + high_fee + high_fee, tx_vsizes[0] + tx_vsizes[1] + tx_vsizes[2] + tx_vsizes[3]);
     const auto& tx3_entry{*Assert(pool.GetEntry(tx3->GetHash()))};
-    BOOST_CHECK(tx3_anc_feerate == CFeeRate(tx3_entry.GetModFeesWithAncestors(), tx3_entry.GetSizeWithAncestors()));
+
+    // Check that ancestor feerate is calculated correctly.
+    auto [dummy_count, ancestor_vsize, mod_fees] = pool.CalculateAncestorData(tx3_entry);
+    BOOST_CHECK(tx3_anc_feerate == CFeeRate(mod_fees, ancestor_vsize));
+
     const auto tx4_feerate = CFeeRate(high_fee, tx_vsizes[4]);
     const auto tx6_anc_feerate = CFeeRate(high_fee + low_fee + med_fee, tx_vsizes[4] + tx_vsizes[5] + tx_vsizes[6]);
     const auto& tx6_entry{*Assert(pool.GetEntry(tx6->GetHash()))};
-    BOOST_CHECK(tx6_anc_feerate == CFeeRate(tx6_entry.GetModFeesWithAncestors(), tx6_entry.GetSizeWithAncestors()));
+
+    std::tie(std::ignore, ancestor_vsize, mod_fees) = pool.CalculateAncestorData(tx6_entry);
+    BOOST_CHECK(tx6_anc_feerate == CFeeRate(mod_fees, ancestor_vsize));
     const auto tx7_anc_feerate = CFeeRate(high_fee + low_fee + high_fee, tx_vsizes[4] + tx_vsizes[5] + tx_vsizes[7]);
     const auto& tx7_entry{*Assert(pool.GetEntry(tx7->GetHash()))};
-    BOOST_CHECK(tx7_anc_feerate == CFeeRate(tx7_entry.GetModFeesWithAncestors(), tx7_entry.GetSizeWithAncestors()));
+
+    std::tie(std::ignore, ancestor_vsize, mod_fees) = pool.CalculateAncestorData(tx7_entry);
+    BOOST_CHECK(tx7_anc_feerate == CFeeRate(mod_fees, ancestor_vsize));
     BOOST_CHECK(tx4_feerate > tx6_anc_feerate);
     BOOST_CHECK(tx4_feerate > tx7_anc_feerate);
 
diff --git a/src/test/txvalidation_tests.cpp b/src/test/txvalidation_tests.cpp
index d7f78443a88..89cf2f85626 100644
--- a/src/test/txvalidation_tests.cpp
+++ b/src/test/txvalidation_tests.cpp
@@ -298,14 +298,14 @@ BOOST_FIXTURE_TEST_CASE(version3_tests, RegTestingSetup)
         const auto expected_error_str{strprintf("non-version=3 tx %s (wtxid=%s) cannot spend from version=3 tx %s (wtxid=%s)",
             tx_v2_from_v3->GetHash().ToString(), tx_v2_from_v3->GetWitnessHash().ToString(),
             mempool_tx_v3->GetHash().ToString(), mempool_tx_v3->GetWitnessHash().ToString())};
-        auto result_v2_from_v3{SingleTRUCChecks(tx_v2_from_v3, *ancestors_v2_from_v3, empty_conflicts_set, GetVirtualTransactionSize(*tx_v2_from_v3))};
+        auto result_v2_from_v3{SingleTRUCChecks(pool, tx_v2_from_v3, *ancestors_v2_from_v3, empty_conflicts_set, GetVirtualTransactionSize(*tx_v2_from_v3))};
         BOOST_CHECK_EQUAL(result_v2_from_v3->first, expected_error_str);
         BOOST_CHECK_EQUAL(result_v2_from_v3->second, nullptr);
 
         Package package_v3_v2{mempool_tx_v3, tx_v2_from_v3};
-        BOOST_CHECK_EQUAL(*PackageTRUCChecks(tx_v2_from_v3, GetVirtualTransactionSize(*tx_v2_from_v3), package_v3_v2, empty_ancestors), expected_error_str);
+        BOOST_CHECK_EQUAL(*PackageTRUCChecks(pool, tx_v2_from_v3, GetVirtualTransactionSize(*tx_v2_from_v3), package_v3_v2, empty_ancestors), expected_error_str);
         CTxMemPool::setEntries entries_mempool_v3{pool.GetIter(mempool_tx_v3->GetHash()).value()};
-        BOOST_CHECK_EQUAL(*PackageTRUCChecks(tx_v2_from_v3, GetVirtualTransactionSize(*tx_v2_from_v3), {tx_v2_from_v3}, entries_mempool_v3), expected_error_str);
+        BOOST_CHECK_EQUAL(*PackageTRUCChecks(pool, tx_v2_from_v3, GetVirtualTransactionSize(*tx_v2_from_v3), {tx_v2_from_v3}, entries_mempool_v3), expected_error_str);
 
         // mempool_tx_v3  mempool_tx_v2
         //            ^    ^
@@ -315,12 +315,12 @@ BOOST_FIXTURE_TEST_CASE(version3_tests, RegTestingSetup)
         const auto expected_error_str_2{strprintf("non-version=3 tx %s (wtxid=%s) cannot spend from version=3 tx %s (wtxid=%s)",
             tx_v2_from_v2_and_v3->GetHash().ToString(), tx_v2_from_v2_and_v3->GetWitnessHash().ToString(),
             mempool_tx_v3->GetHash().ToString(), mempool_tx_v3->GetWitnessHash().ToString())};
-        auto result_v2_from_both{SingleTRUCChecks(tx_v2_from_v2_and_v3, *ancestors_v2_from_both, empty_conflicts_set, GetVirtualTransactionSize(*tx_v2_from_v2_and_v3))};
+        auto result_v2_from_both{SingleTRUCChecks(pool, tx_v2_from_v2_and_v3, *ancestors_v2_from_both, empty_conflicts_set, GetVirtualTransactionSize(*tx_v2_from_v2_and_v3))};
         BOOST_CHECK_EQUAL(result_v2_from_both->first, expected_error_str_2);
         BOOST_CHECK_EQUAL(result_v2_from_both->second, nullptr);
 
         Package package_v3_v2_v2{mempool_tx_v3, mempool_tx_v2, tx_v2_from_v2_and_v3};
-        BOOST_CHECK_EQUAL(*PackageTRUCChecks(tx_v2_from_v2_and_v3, GetVirtualTransactionSize(*tx_v2_from_v2_and_v3), package_v3_v2_v2, empty_ancestors), expected_error_str_2);
+        BOOST_CHECK_EQUAL(*PackageTRUCChecks(pool, tx_v2_from_v2_and_v3, GetVirtualTransactionSize(*tx_v2_from_v2_and_v3), package_v3_v2_v2, empty_ancestors), expected_error_str_2);
     }
 
     // TRUC cannot spend from an unconfirmed non-TRUC transaction.
@@ -333,14 +333,14 @@ BOOST_FIXTURE_TEST_CASE(version3_tests, RegTestingSetup)
         const auto expected_error_str{strprintf("version=3 tx %s (wtxid=%s) cannot spend from non-version=3 tx %s (wtxid=%s)",
             tx_v3_from_v2->GetHash().ToString(), tx_v3_from_v2->GetWitnessHash().ToString(),
             mempool_tx_v2->GetHash().ToString(), mempool_tx_v2->GetWitnessHash().ToString())};
-        auto result_v3_from_v2{SingleTRUCChecks(tx_v3_from_v2, *ancestors_v3_from_v2,  empty_conflicts_set, GetVirtualTransactionSize(*tx_v3_from_v2))};
+        auto result_v3_from_v2{SingleTRUCChecks(pool, tx_v3_from_v2, *ancestors_v3_from_v2,  empty_conflicts_set, GetVirtualTransactionSize(*tx_v3_from_v2))};
         BOOST_CHECK_EQUAL(result_v3_from_v2->first, expected_error_str);
         BOOST_CHECK_EQUAL(result_v3_from_v2->second, nullptr);
 
         Package package_v2_v3{mempool_tx_v2, tx_v3_from_v2};
-        BOOST_CHECK_EQUAL(*PackageTRUCChecks(tx_v3_from_v2, GetVirtualTransactionSize(*tx_v3_from_v2), package_v2_v3, empty_ancestors), expected_error_str);
+        BOOST_CHECK_EQUAL(*PackageTRUCChecks(pool, tx_v3_from_v2, GetVirtualTransactionSize(*tx_v3_from_v2), package_v2_v3, empty_ancestors), expected_error_str);
         CTxMemPool::setEntries entries_mempool_v2{pool.GetIter(mempool_tx_v2->GetHash()).value()};
-        BOOST_CHECK_EQUAL(*PackageTRUCChecks(tx_v3_from_v2, GetVirtualTransactionSize(*tx_v3_from_v2), {tx_v3_from_v2}, entries_mempool_v2), expected_error_str);
+        BOOST_CHECK_EQUAL(*PackageTRUCChecks(pool, tx_v3_from_v2, GetVirtualTransactionSize(*tx_v3_from_v2), {tx_v3_from_v2}, entries_mempool_v2), expected_error_str);
 
         // mempool_tx_v3  mempool_tx_v2
         //            ^    ^
@@ -350,7 +350,7 @@ BOOST_FIXTURE_TEST_CASE(version3_tests, RegTestingSetup)
         const auto expected_error_str_2{strprintf("version=3 tx %s (wtxid=%s) cannot spend from non-version=3 tx %s (wtxid=%s)",
             tx_v3_from_v2_and_v3->GetHash().ToString(), tx_v3_from_v2_and_v3->GetWitnessHash().ToString(),
             mempool_tx_v2->GetHash().ToString(), mempool_tx_v2->GetWitnessHash().ToString())};
-        auto result_v3_from_both{SingleTRUCChecks(tx_v3_from_v2_and_v3, *ancestors_v3_from_both, empty_conflicts_set, GetVirtualTransactionSize(*tx_v3_from_v2_and_v3))};
+        auto result_v3_from_both{SingleTRUCChecks(pool, tx_v3_from_v2_and_v3, *ancestors_v3_from_both, empty_conflicts_set, GetVirtualTransactionSize(*tx_v3_from_v2_and_v3))};
         BOOST_CHECK_EQUAL(result_v3_from_both->first, expected_error_str_2);
         BOOST_CHECK_EQUAL(result_v3_from_both->second, nullptr);
 
@@ -358,7 +358,7 @@ BOOST_FIXTURE_TEST_CASE(version3_tests, RegTestingSetup)
         const auto expected_error_str_3{strprintf("tx %s (wtxid=%s) would have too many ancestors",
             tx_v3_from_v2_and_v3->GetHash().ToString(), tx_v3_from_v2_and_v3->GetWitnessHash().ToString())};
         Package package_v3_v2_v3{mempool_tx_v3, mempool_tx_v2, tx_v3_from_v2_and_v3};
-        BOOST_CHECK_EQUAL(*PackageTRUCChecks(tx_v3_from_v2_and_v3, GetVirtualTransactionSize(*tx_v3_from_v2_and_v3), package_v3_v2_v3, empty_ancestors), expected_error_str_3);
+        BOOST_CHECK_EQUAL(*PackageTRUCChecks(pool, tx_v3_from_v2_and_v3, GetVirtualTransactionSize(*tx_v3_from_v2_and_v3), package_v3_v2_v3, empty_ancestors), expected_error_str_3);
     }
     // V3 from V3 is ok, and non-V3 from non-V3 is ok.
     {
@@ -367,22 +367,22 @@ BOOST_FIXTURE_TEST_CASE(version3_tests, RegTestingSetup)
         // tx_v3_from_v3
         auto tx_v3_from_v3 = make_tx({COutPoint{mempool_tx_v3->GetHash(), 0}}, /*version=*/3);
         auto ancestors_v3{pool.CalculateMemPoolAncestors(entry.FromTx(tx_v3_from_v3), m_limits)};
-        BOOST_CHECK(SingleTRUCChecks(tx_v3_from_v3, *ancestors_v3, empty_conflicts_set, GetVirtualTransactionSize(*tx_v3_from_v3))
+        BOOST_CHECK(SingleTRUCChecks(pool, tx_v3_from_v3, *ancestors_v3, empty_conflicts_set, GetVirtualTransactionSize(*tx_v3_from_v3))
                     == std::nullopt);
 
         Package package_v3_v3{mempool_tx_v3, tx_v3_from_v3};
-        BOOST_CHECK(PackageTRUCChecks(tx_v3_from_v3, GetVirtualTransactionSize(*tx_v3_from_v3), package_v3_v3, empty_ancestors) == std::nullopt);
+        BOOST_CHECK(PackageTRUCChecks(pool, tx_v3_from_v3, GetVirtualTransactionSize(*tx_v3_from_v3), package_v3_v3, empty_ancestors) == std::nullopt);
 
         // mempool_tx_v2
         //      ^
         // tx_v2_from_v2
         auto tx_v2_from_v2 = make_tx({COutPoint{mempool_tx_v2->GetHash(), 0}}, /*version=*/2);
         auto ancestors_v2{pool.CalculateMemPoolAncestors(entry.FromTx(tx_v2_from_v2), m_limits)};
-        BOOST_CHECK(SingleTRUCChecks(tx_v2_from_v2, *ancestors_v2, empty_conflicts_set, GetVirtualTransactionSize(*tx_v2_from_v2))
+        BOOST_CHECK(SingleTRUCChecks(pool, tx_v2_from_v2, *ancestors_v2, empty_conflicts_set, GetVirtualTransactionSize(*tx_v2_from_v2))
                     == std::nullopt);
 
         Package package_v2_v2{mempool_tx_v2, tx_v2_from_v2};
-        BOOST_CHECK(PackageTRUCChecks(tx_v2_from_v2, GetVirtualTransactionSize(*tx_v2_from_v2), package_v2_v2, empty_ancestors) == std::nullopt);
+        BOOST_CHECK(PackageTRUCChecks(pool, tx_v2_from_v2, GetVirtualTransactionSize(*tx_v2_from_v2), package_v2_v2, empty_ancestors) == std::nullopt);
     }
 
     // Tx spending TRUC cannot have too many mempool ancestors
@@ -404,11 +404,11 @@ BOOST_FIXTURE_TEST_CASE(version3_tests, RegTestingSetup)
         BOOST_CHECK_EQUAL(ancestors->size(), 3);
         const auto expected_error_str{strprintf("tx %s (wtxid=%s) would have too many ancestors",
             tx_v3_multi_parent->GetHash().ToString(), tx_v3_multi_parent->GetWitnessHash().ToString())};
-        auto result{SingleTRUCChecks(tx_v3_multi_parent, *ancestors, empty_conflicts_set, GetVirtualTransactionSize(*tx_v3_multi_parent))};
+        auto result{SingleTRUCChecks(pool, tx_v3_multi_parent, *ancestors, empty_conflicts_set, GetVirtualTransactionSize(*tx_v3_multi_parent))};
         BOOST_CHECK_EQUAL(result->first, expected_error_str);
         BOOST_CHECK_EQUAL(result->second, nullptr);
 
-        BOOST_CHECK_EQUAL(*PackageTRUCChecks(tx_v3_multi_parent, GetVirtualTransactionSize(*tx_v3_multi_parent), package_multi_parents, empty_ancestors),
+        BOOST_CHECK_EQUAL(*PackageTRUCChecks(pool, tx_v3_multi_parent, GetVirtualTransactionSize(*tx_v3_multi_parent), package_multi_parents, empty_ancestors),
                           expected_error_str);
     }
 
@@ -429,13 +429,13 @@ BOOST_FIXTURE_TEST_CASE(version3_tests, RegTestingSetup)
         auto ancestors{pool.CalculateMemPoolAncestors(entry.FromTx(tx_v3_multi_gen), m_limits)};
         const auto expected_error_str{strprintf("tx %s (wtxid=%s) would have too many ancestors",
             tx_v3_multi_gen->GetHash().ToString(), tx_v3_multi_gen->GetWitnessHash().ToString())};
-        auto result{SingleTRUCChecks(tx_v3_multi_gen, *ancestors, empty_conflicts_set, GetVirtualTransactionSize(*tx_v3_multi_gen))};
+        auto result{SingleTRUCChecks(pool, tx_v3_multi_gen, *ancestors, empty_conflicts_set, GetVirtualTransactionSize(*tx_v3_multi_gen))};
         BOOST_CHECK_EQUAL(result->first, expected_error_str);
         BOOST_CHECK_EQUAL(result->second, nullptr);
 
         // Middle tx is what triggers a failure for the grandchild:
-        BOOST_CHECK_EQUAL(*PackageTRUCChecks(middle_tx, GetVirtualTransactionSize(*middle_tx), package_multi_gen, empty_ancestors), expected_error_str);
-        BOOST_CHECK(PackageTRUCChecks(tx_v3_multi_gen, GetVirtualTransactionSize(*tx_v3_multi_gen), package_multi_gen, empty_ancestors) == std::nullopt);
+        BOOST_CHECK_EQUAL(*PackageTRUCChecks(pool, middle_tx, GetVirtualTransactionSize(*middle_tx), package_multi_gen, empty_ancestors), expected_error_str);
+        BOOST_CHECK(PackageTRUCChecks(pool, tx_v3_multi_gen, GetVirtualTransactionSize(*tx_v3_multi_gen), package_multi_gen, empty_ancestors) == std::nullopt);
     }
 
     // Tx spending TRUC cannot be too large in virtual size.
@@ -447,12 +447,12 @@ BOOST_FIXTURE_TEST_CASE(version3_tests, RegTestingSetup)
         auto ancestors{pool.CalculateMemPoolAncestors(entry.FromTx(tx_v3_child_big), m_limits)};
         const auto expected_error_str{strprintf("version=3 child tx %s (wtxid=%s) is too big: %u > %u virtual bytes",
             tx_v3_child_big->GetHash().ToString(), tx_v3_child_big->GetWitnessHash().ToString(), vsize, TRUC_CHILD_MAX_VSIZE)};
-        auto result{SingleTRUCChecks(tx_v3_child_big, *ancestors, empty_conflicts_set, GetVirtualTransactionSize(*tx_v3_child_big))};
+        auto result{SingleTRUCChecks(pool, tx_v3_child_big, *ancestors, empty_conflicts_set, GetVirtualTransactionSize(*tx_v3_child_big))};
         BOOST_CHECK_EQUAL(result->first, expected_error_str);
         BOOST_CHECK_EQUAL(result->second, nullptr);
 
         Package package_child_big{mempool_tx_v3, tx_v3_child_big};
-        BOOST_CHECK_EQUAL(*PackageTRUCChecks(tx_v3_child_big, GetVirtualTransactionSize(*tx_v3_child_big), package_child_big, empty_ancestors),
+        BOOST_CHECK_EQUAL(*PackageTRUCChecks(pool, tx_v3_child_big, GetVirtualTransactionSize(*tx_v3_child_big), package_child_big, empty_ancestors),
                           expected_error_str);
     }
 
@@ -485,18 +485,18 @@ BOOST_FIXTURE_TEST_CASE(version3_tests, RegTestingSetup)
         BOOST_CHECK_EQUAL(total_sigops, tx_many_sigops->vin.size() * MAX_PUBKEYS_PER_MULTISIG);
         const int64_t bip141_vsize{GetVirtualTransactionSize(*tx_many_sigops)};
         // Weight limit is not reached...
-        BOOST_CHECK(SingleTRUCChecks(tx_many_sigops, *ancestors, empty_conflicts_set, bip141_vsize) == std::nullopt);
+        BOOST_CHECK(SingleTRUCChecks(pool, tx_many_sigops, *ancestors, empty_conflicts_set, bip141_vsize) == std::nullopt);
         // ...but sigop limit is.
         const auto expected_error_str{strprintf("version=3 child tx %s (wtxid=%s) is too big: %u > %u virtual bytes",
             tx_many_sigops->GetHash().ToString(), tx_many_sigops->GetWitnessHash().ToString(),
             total_sigops * DEFAULT_BYTES_PER_SIGOP / WITNESS_SCALE_FACTOR, TRUC_CHILD_MAX_VSIZE)};
-        auto result{SingleTRUCChecks(tx_many_sigops, *ancestors, empty_conflicts_set,
+        auto result{SingleTRUCChecks(pool, tx_many_sigops, *ancestors, empty_conflicts_set,
                                         GetVirtualTransactionSize(*tx_many_sigops, /*nSigOpCost=*/total_sigops, /*bytes_per_sigop=*/ DEFAULT_BYTES_PER_SIGOP))};
         BOOST_CHECK_EQUAL(result->first, expected_error_str);
         BOOST_CHECK_EQUAL(result->second, nullptr);
 
         Package package_child_sigops{mempool_tx_v3, tx_many_sigops};
-        BOOST_CHECK_EQUAL(*PackageTRUCChecks(tx_many_sigops, total_sigops * DEFAULT_BYTES_PER_SIGOP / WITNESS_SCALE_FACTOR, package_child_sigops, empty_ancestors),
+        BOOST_CHECK_EQUAL(*PackageTRUCChecks(pool, tx_many_sigops, total_sigops * DEFAULT_BYTES_PER_SIGOP / WITNESS_SCALE_FACTOR, package_child_sigops, empty_ancestors),
                           expected_error_str);
     }
 
@@ -505,11 +505,11 @@ BOOST_FIXTURE_TEST_CASE(version3_tests, RegTestingSetup)
     {
         BOOST_CHECK(GetTransactionWeight(*tx_mempool_v3_child) <= TRUC_CHILD_MAX_VSIZE * WITNESS_SCALE_FACTOR);
         auto ancestors{pool.CalculateMemPoolAncestors(entry.FromTx(tx_mempool_v3_child), m_limits)};
-        BOOST_CHECK(SingleTRUCChecks(tx_mempool_v3_child, *ancestors, empty_conflicts_set, GetVirtualTransactionSize(*tx_mempool_v3_child)) == std::nullopt);
+        BOOST_CHECK(SingleTRUCChecks(pool, tx_mempool_v3_child, *ancestors, empty_conflicts_set, GetVirtualTransactionSize(*tx_mempool_v3_child)) == std::nullopt);
         AddToMempool(pool, entry.FromTx(tx_mempool_v3_child));
 
         Package package_v3_1p1c{mempool_tx_v3, tx_mempool_v3_child};
-        BOOST_CHECK(PackageTRUCChecks(tx_mempool_v3_child, GetVirtualTransactionSize(*tx_mempool_v3_child), package_v3_1p1c, empty_ancestors) == std::nullopt);
+        BOOST_CHECK(PackageTRUCChecks(pool, tx_mempool_v3_child, GetVirtualTransactionSize(*tx_mempool_v3_child), package_v3_1p1c, empty_ancestors) == std::nullopt);
     }
 
     // A TRUC transaction cannot have more than 1 descendant. Sibling is returned when exactly 1 exists.
@@ -520,27 +520,27 @@ BOOST_FIXTURE_TEST_CASE(version3_tests, RegTestingSetup)
         auto ancestors_1sibling{pool.CalculateMemPoolAncestors(entry.FromTx(tx_v3_child2), m_limits)};
         const auto expected_error_str{strprintf("tx %s (wtxid=%s) would exceed descendant count limit",
             mempool_tx_v3->GetHash().ToString(), mempool_tx_v3->GetWitnessHash().ToString())};
-        auto result_with_sibling_eviction{SingleTRUCChecks(tx_v3_child2, *ancestors_1sibling, empty_conflicts_set, GetVirtualTransactionSize(*tx_v3_child2))};
+        auto result_with_sibling_eviction{SingleTRUCChecks(pool, tx_v3_child2, *ancestors_1sibling, empty_conflicts_set, GetVirtualTransactionSize(*tx_v3_child2))};
         BOOST_CHECK_EQUAL(result_with_sibling_eviction->first, expected_error_str);
         // The other mempool child is returned to allow for sibling eviction.
         BOOST_CHECK_EQUAL(result_with_sibling_eviction->second, tx_mempool_v3_child);
 
         // If directly replacing the child, make sure there is no double-counting.
-        BOOST_CHECK(SingleTRUCChecks(tx_v3_child2, *ancestors_1sibling, {tx_mempool_v3_child->GetHash()}, GetVirtualTransactionSize(*tx_v3_child2))
+        BOOST_CHECK(SingleTRUCChecks(pool, tx_v3_child2, *ancestors_1sibling, {tx_mempool_v3_child->GetHash()}, GetVirtualTransactionSize(*tx_v3_child2))
                     == std::nullopt);
 
         Package package_v3_1p2c{mempool_tx_v3, tx_mempool_v3_child, tx_v3_child2};
-        BOOST_CHECK_EQUAL(*PackageTRUCChecks(tx_v3_child2, GetVirtualTransactionSize(*tx_v3_child2), package_v3_1p2c, empty_ancestors),
+        BOOST_CHECK_EQUAL(*PackageTRUCChecks(pool, tx_v3_child2, GetVirtualTransactionSize(*tx_v3_child2), package_v3_1p2c, empty_ancestors),
                           expected_error_str);
 
         // Configuration where parent already has 2 other children in mempool (no sibling eviction allowed). This may happen as the result of a reorg.
         AddToMempool(pool, entry.FromTx(tx_v3_child2));
         auto tx_v3_child3 = make_tx({COutPoint{mempool_tx_v3->GetHash(), 24}}, /*version=*/3);
         auto entry_mempool_parent = pool.GetIter(mempool_tx_v3->GetHash()).value();
-        BOOST_CHECK_EQUAL(entry_mempool_parent->GetCountWithDescendants(), 3);
+        BOOST_CHECK_EQUAL(pool.GetDescendantCount(entry_mempool_parent), 3);
         auto ancestors_2siblings{pool.CalculateMemPoolAncestors(entry.FromTx(tx_v3_child3), m_limits)};
 
-        auto result_2children{SingleTRUCChecks(tx_v3_child3, *ancestors_2siblings, empty_conflicts_set, GetVirtualTransactionSize(*tx_v3_child3))};
+        auto result_2children{SingleTRUCChecks(pool, tx_v3_child3, *ancestors_2siblings, empty_conflicts_set, GetVirtualTransactionSize(*tx_v3_child3))};
         BOOST_CHECK_EQUAL(result_2children->first, expected_error_str);
         // The other mempool child is not returned because sibling eviction is not allowed.
         BOOST_CHECK_EQUAL(result_2children->second, nullptr);
@@ -560,7 +560,7 @@ BOOST_FIXTURE_TEST_CASE(version3_tests, RegTestingSetup)
         auto ancestors_3gen{pool.CalculateMemPoolAncestors(entry.FromTx(tx_to_submit), m_limits)};
         const auto expected_error_str{strprintf("tx %s (wtxid=%s) would exceed descendant count limit",
             tx_mempool_grandparent->GetHash().ToString(), tx_mempool_grandparent->GetWitnessHash().ToString())};
-        auto result_3gen{SingleTRUCChecks(tx_to_submit, *ancestors_3gen, empty_conflicts_set, GetVirtualTransactionSize(*tx_to_submit))};
+        auto result_3gen{SingleTRUCChecks(pool, tx_to_submit, *ancestors_3gen, empty_conflicts_set, GetVirtualTransactionSize(*tx_to_submit))};
         BOOST_CHECK_EQUAL(result_3gen->first, expected_error_str);
         // The other mempool child is not returned because sibling eviction is not allowed.
         BOOST_CHECK_EQUAL(result_3gen->second, nullptr);
diff --git a/src/test/util/txmempool.cpp b/src/test/util/txmempool.cpp
index 0cb15b69420..ffa21a41889 100644
--- a/src/test/util/txmempool.cpp
+++ b/src/test/util/txmempool.cpp
@@ -183,24 +183,26 @@ void CheckMempoolTRUCInvariants(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()));
+        auto [desc_count, desc_size, desc_fees] = tx_pool.CalculateDescendantData(entry);
+        auto [anc_count, anc_size, anc_fees] = tx_pool.CalculateAncestorData(entry);
+
         if (tx_info.tx->version == TRUC_VERSION) {
             // Check that special maximum virtual size is respected
             Assert(entry.GetTxSize() <= TRUC_MAX_VSIZE);
 
             // Check that special TRUC ancestor/descendant limits and rules are always respected
-            Assert(entry.GetCountWithDescendants() <= TRUC_DESCENDANT_LIMIT);
-            Assert(entry.GetCountWithAncestors() <= TRUC_ANCESTOR_LIMIT);
-            Assert(entry.GetSizeWithDescendants() <= TRUC_MAX_VSIZE + TRUC_CHILD_MAX_VSIZE);
-            Assert(entry.GetSizeWithAncestors() <= TRUC_MAX_VSIZE + TRUC_CHILD_MAX_VSIZE);
-
+            Assert(desc_count <= TRUC_DESCENDANT_LIMIT);
+            Assert(anc_count <= TRUC_ANCESTOR_LIMIT);
+            Assert(desc_size <= TRUC_MAX_VSIZE + TRUC_CHILD_MAX_VSIZE);
+            Assert(anc_size <= TRUC_MAX_VSIZE + TRUC_CHILD_MAX_VSIZE);
             // If this transaction has at least 1 ancestor, it's a "child" and has restricted weight.
-            if (entry.GetCountWithAncestors() > 1) {
+            if (anc_count > 1) {
                 Assert(entry.GetTxSize() <= TRUC_CHILD_MAX_VSIZE);
                 // All TRUC transactions must only have TRUC unconfirmed parents.
                 const auto& parents = entry.GetMemPoolParentsConst();
                 Assert(parents.begin()->get().GetSharedTx()->version == TRUC_VERSION);
             }
-        } else if (entry.GetCountWithAncestors() > 1) {
+        } else if (anc_count > 1) {
             // All non-TRUC transactions must only have non-TRUC unconfirmed parents.
             for (const auto& parent : entry.GetMemPoolParentsConst()) {
                 Assert(parent.get().GetSharedTx()->version != TRUC_VERSION);
diff --git a/src/txmempool.h b/src/txmempool.h
index 054d9e12891..9a4389c366f 100644
--- a/src/txmempool.h
+++ b/src/txmempool.h
@@ -286,6 +286,9 @@ public:
 
     std::tuple<size_t, size_t, CAmount> CalculateAncestorData(const CTxMemPoolEntry& entry) const EXCLUSIVE_LOCKS_REQUIRED(cs);
     std::tuple<size_t, size_t, CAmount> CalculateDescendantData(const CTxMemPoolEntry& entry) const EXCLUSIVE_LOCKS_REQUIRED(cs);
+    int64_t GetDescendantCount(txiter it) const { LOCK(cs); return m_txgraph->GetDescendants(*it, TxGraph::Level::MAIN).size(); }
+    int64_t GetDescendantCount(const CTxMemPoolEntry &e) const { LOCK(cs); return m_txgraph->GetDescendants(e, TxGraph::Level::MAIN).size(); }
+    int64_t GetAncestorCount(const CTxMemPoolEntry &e) const { LOCK(cs); return m_txgraph->GetAncestors(e, TxGraph::Level::MAIN).size(); }
 
 private:
     typedef std::map<txiter, setEntries, CompareIteratorByHash> cacheMap;
diff --git a/src/validation.cpp b/src/validation.cpp
index ac8205528a5..348e610238e 100644
--- a/src/validation.cpp
+++ b/src/validation.cpp
@@ -972,7 +972,7 @@ bool MemPoolAccept::PreChecks(ATMPArgs& args, Workspace& ws)
     // check using the full ancestor set here because it's more convenient to use what we have
     // already calculated.
     if (!args.m_bypass_limits) {
-        if (const auto err{SingleTRUCChecks(ws.m_ptx, ws.m_ancestors, ws.m_conflicts, ws.m_vsize)}) {
+        if (const auto err{SingleTRUCChecks(m_pool, ws.m_ptx, ws.m_ancestors, ws.m_conflicts, ws.m_vsize)}) {
             // Single transaction contexts only.
             if (args.m_allow_sibling_eviction && err->second != nullptr) {
                 // We should only be considering where replacement is considered valid as well.
@@ -1498,7 +1498,7 @@ PackageMempoolAcceptResult MemPoolAccept::AcceptMultipleTransactionsInternal(con
     // At this point we have all in-mempool ancestors, and we know every transaction's vsize.
     // Run the TRUC checks on the package.
     for (Workspace& ws : workspaces) {
-        if (auto err{PackageTRUCChecks(ws.m_ptx, ws.m_vsize, txns, ws.m_ancestors)}) {
+        if (auto err{PackageTRUCChecks(m_pool, ws.m_ptx, ws.m_vsize, txns, ws.m_ancestors)}) {
             package_state.Invalid(PackageValidationResult::PCKG_POLICY, "TRUC-violation", err.value());
             return PackageMempoolAcceptResult(package_state, {});
         }

From ff3b398d124b9efa49b612dbbb715bbe5d53e727 Mon Sep 17 00:00:00 2001
From: Suhas Daftuar <sdaftuar@chaincode.com>
Date: Wed, 4 Oct 2023 09:28:05 -0400
Subject: [PATCH 38/65] mempool: eliminate accessors to mempool entry
 ancestor/descendant cached state

---
 src/kernel/mempool_entry.h |  9 ---------
 src/txmempool.cpp          | 25 +------------------------
 2 files changed, 1 insertion(+), 33 deletions(-)

diff --git a/src/kernel/mempool_entry.h b/src/kernel/mempool_entry.h
index 28c2290cb5d..2e61f1023c4 100644
--- a/src/kernel/mempool_entry.h
+++ b/src/kernel/mempool_entry.h
@@ -166,17 +166,8 @@ public:
         lockPoints = lp;
     }
 
-    uint64_t GetCountWithDescendants() const { return m_count_with_descendants; }
-    int64_t GetSizeWithDescendants() const { return nSizeWithDescendants; }
-    CAmount GetModFeesWithDescendants() const { return nModFeesWithDescendants; }
-
     bool GetSpendsCoinbase() const { return spendsCoinbase; }
 
-    uint64_t GetCountWithAncestors() const { return m_count_with_ancestors; }
-    int64_t GetSizeWithAncestors() const { return nSizeWithAncestors; }
-    CAmount GetModFeesWithAncestors() const { return nModFeesWithAncestors; }
-    int64_t GetSigOpCostWithAncestors() const { return nSigOpCostWithAncestors; }
-
     const Parents& GetMemPoolParentsConst() const { return m_parents; }
     const Children& GetMemPoolChildrenConst() const { return m_children; }
     Parents& GetMemPoolParents() const { return m_parents; }
diff --git a/src/txmempool.cpp b/src/txmempool.cpp
index 7c3be6e1d85..28a6418b944 100644
--- a/src/txmempool.cpp
+++ b/src/txmempool.cpp
@@ -720,40 +720,17 @@ void CTxMemPool::check(const CCoinsViewCache& active_coins_tip, int64_t spendhei
         };
         assert(setParentCheck.size() == it->GetMemPoolParentsConst().size());
         assert(std::equal(setParentCheck.begin(), setParentCheck.end(), it->GetMemPoolParentsConst().begin(), comp));
-        // Verify ancestor state is correct.
-        auto ancestors{AssumeCalculateMemPoolAncestors(__func__, *it, Limits::NoLimits())};
-        uint64_t nCountCheck = ancestors.size() + 1;
-        int32_t nSizeCheck = it->GetTxSize();
-        CAmount nFeesCheck = it->GetModifiedFee();
-        int64_t nSigOpCheck = it->GetSigOpCost();
-
-        for (txiter ancestorIt : ancestors) {
-            nSizeCheck += ancestorIt->GetTxSize();
-            nFeesCheck += ancestorIt->GetModifiedFee();
-            nSigOpCheck += ancestorIt->GetSigOpCost();
-        }
-
-        assert(it->GetCountWithAncestors() == nCountCheck);
-        assert(it->GetSizeWithAncestors() == nSizeCheck);
-        assert(it->GetSigOpCostWithAncestors() == nSigOpCheck);
-        assert(it->GetModFeesWithAncestors() == nFeesCheck);
 
         // Check children against mapNextTx
         CTxMemPoolEntry::Children setChildrenCheck;
         auto iter = mapNextTx.lower_bound(COutPoint(it->GetTx().GetHash(), 0));
-        int32_t child_sizes{0};
         for (; iter != mapNextTx.end() && iter->first->hash == it->GetTx().GetHash(); ++iter) {
             txiter childit = iter->second;
             assert(childit != mapTx.end()); // mapNextTx points to in-mempool transactions
-            if (setChildrenCheck.insert(*childit).second) {
-                child_sizes += childit->GetTxSize();
-            }
+            setChildrenCheck.insert(*childit);
         }
         assert(setChildrenCheck.size() == it->GetMemPoolChildrenConst().size());
         assert(std::equal(setChildrenCheck.begin(), setChildrenCheck.end(), it->GetMemPoolChildrenConst().begin(), comp));
-        // Also check to make sure size is greater than sum with immediate children.
-        // just a sanity check, not definitive that this calc is correct...
-        assert(it->GetSizeWithDescendants() >= child_sizes + it->GetTxSize());
 
         TxValidationState dummy_state; // Not used. CheckTxInputs() should always pass
         CAmount txfee = 0;

From fc4e3e6bc12284d3b328c1ad19502294accfe5ad Mon Sep 17 00:00:00 2001
From: Suhas Daftuar <sdaftuar@chaincode.com>
Date: Wed, 4 Oct 2023 09:48:04 -0400
Subject: [PATCH 39/65] Remove unused members from CTxMemPoolEntry

---
 src/kernel/mempool_entry.h | 24 +-----------------------
 src/txmempool.cpp          | 12 ------------
 2 files changed, 1 insertion(+), 35 deletions(-)

diff --git a/src/kernel/mempool_entry.h b/src/kernel/mempool_entry.h
index 2e61f1023c4..8be0a77e00d 100644
--- a/src/kernel/mempool_entry.h
+++ b/src/kernel/mempool_entry.h
@@ -88,21 +88,6 @@ private:
     CAmount m_modified_fee;         //!< Used for determining the priority of the transaction for mining in a block
     mutable LockPoints lockPoints;  //!< Track the height and time at which tx was final
 
-    // Information about descendants of this transaction that are in the
-    // mempool; if we remove this transaction we must remove all of these
-    // descendants as well.
-    int64_t m_count_with_descendants{1}; //!< number of descendant transactions
-    // Using int64_t instead of int32_t to avoid signed integer overflow issues.
-    int64_t nSizeWithDescendants;      //!< ... and size
-    CAmount nModFeesWithDescendants;   //!< ... and total fees (all including us)
-
-    // Analogous statistics for ancestor transactions
-    int64_t m_count_with_ancestors{1};
-    // Using int64_t instead of int32_t to avoid signed integer overflow issues.
-    int64_t nSizeWithAncestors;
-    CAmount nModFeesWithAncestors;
-    int64_t nSigOpCostWithAncestors;
-
 public:
     virtual ~CTxMemPoolEntry() = default;
     CTxMemPoolEntry(TxGraph::Ref&& ref, const CTransactionRef& tx, CAmount fee,
@@ -120,12 +105,7 @@ public:
           spendsCoinbase{spends_coinbase},
           sigOpCost{sigops_cost},
           m_modified_fee{nFee},
-          lockPoints{lp},
-          nSizeWithDescendants{GetTxSize()},
-          nModFeesWithDescendants{nFee},
-          nSizeWithAncestors{GetTxSize()},
-          nModFeesWithAncestors{nFee},
-          nSigOpCostWithAncestors{sigOpCost} {}
+          lockPoints{lp} {}
 
     CTxMemPoolEntry& operator=(const CTxMemPoolEntry&) = delete;
     CTxMemPoolEntry(CTxMemPoolEntry&&) = default;
@@ -155,8 +135,6 @@ public:
     // Updates the modified fees with descendants/ancestors.
     void UpdateModifiedFee(CAmount fee_diff)
     {
-        nModFeesWithDescendants = SaturatingAdd(nModFeesWithDescendants, fee_diff);
-        nModFeesWithAncestors = SaturatingAdd(nModFeesWithAncestors, fee_diff);
         m_modified_fee = SaturatingAdd(m_modified_fee, fee_diff);
     }
 
diff --git a/src/txmempool.cpp b/src/txmempool.cpp
index 28a6418b944..960296e2d8c 100644
--- a/src/txmempool.cpp
+++ b/src/txmempool.cpp
@@ -361,22 +361,10 @@ void CTxMemPool::UpdateForRemoveFromMempool(const setEntries &entriesToRemove, b
 
 void CTxMemPoolEntry::UpdateDescendantState(int32_t modifySize, CAmount modifyFee, int64_t modifyCount)
 {
-    nSizeWithDescendants += modifySize;
-    assert(nSizeWithDescendants > 0);
-    nModFeesWithDescendants = SaturatingAdd(nModFeesWithDescendants, modifyFee);
-    m_count_with_descendants += modifyCount;
-    assert(m_count_with_descendants > 0);
 }
 
 void CTxMemPoolEntry::UpdateAncestorState(int32_t modifySize, CAmount modifyFee, int64_t modifyCount, int64_t modifySigOps)
 {
-    nSizeWithAncestors += modifySize;
-    assert(nSizeWithAncestors > 0);
-    nModFeesWithAncestors = SaturatingAdd(nModFeesWithAncestors, modifyFee);
-    m_count_with_ancestors += modifyCount;
-    assert(m_count_with_ancestors > 0);
-    nSigOpCostWithAncestors += modifySigOps;
-    assert(int(nSigOpCostWithAncestors) >= 0);
 }
 
 //! Clamp option values and populate the error if options are not valid.

From 08be765ac26a3ae721cb3574d4348602a9982e44 Mon Sep 17 00:00:00 2001
From: Suhas Daftuar <sdaftuar@chaincode.com>
Date: Wed, 4 Oct 2023 10:47:14 -0400
Subject: [PATCH 40/65] Remove mempool logic designed to maintain
 ancestor/descendant state

---
 src/kernel/mempool_entry.h |   4 -
 src/txmempool.cpp          | 157 ++-----------------------------------
 src/txmempool.h            |  30 +------
 3 files changed, 6 insertions(+), 185 deletions(-)

diff --git a/src/kernel/mempool_entry.h b/src/kernel/mempool_entry.h
index 8be0a77e00d..e12047debda 100644
--- a/src/kernel/mempool_entry.h
+++ b/src/kernel/mempool_entry.h
@@ -128,10 +128,6 @@ public:
     size_t DynamicMemoryUsage() const { return nUsageSize; }
     const LockPoints& GetLockPoints() const { return lockPoints; }
 
-    // Adjusts the descendant state.
-    void UpdateDescendantState(int32_t modifySize, CAmount modifyFee, int64_t modifyCount);
-    // Adjusts the ancestor state
-    void UpdateAncestorState(int32_t modifySize, CAmount modifyFee, int64_t modifyCount, int64_t modifySigOps);
     // Updates the modified fees with descendants/ancestors.
     void UpdateModifiedFee(CAmount fee_diff)
     {
diff --git a/src/txmempool.cpp b/src/txmempool.cpp
index 960296e2d8c..233e34210c7 100644
--- a/src/txmempool.cpp
+++ b/src/txmempool.cpp
@@ -54,70 +54,16 @@ bool TestLockPointValidity(CChain& active_chain, const LockPoints& lp)
     return true;
 }
 
-void CTxMemPool::UpdateForDescendants(txiter updateIt, cacheMap& cachedDescendants,
-                                      const std::set<Txid>& setExclude)
-{
-    CTxMemPoolEntry::Children stageEntries, descendants;
-    stageEntries = updateIt->GetMemPoolChildrenConst();
-
-    while (!stageEntries.empty()) {
-        const CTxMemPoolEntry& descendant = *stageEntries.begin();
-        descendants.insert(descendant);
-        stageEntries.erase(descendant);
-        const CTxMemPoolEntry::Children& children = descendant.GetMemPoolChildrenConst();
-        for (const CTxMemPoolEntry& childEntry : children) {
-            cacheMap::iterator cacheIt = cachedDescendants.find(mapTx.iterator_to(childEntry));
-            if (cacheIt != cachedDescendants.end()) {
-                // We've already calculated this one, just add the entries for this set
-                // but don't traverse again.
-                for (txiter cacheEntry : cacheIt->second) {
-                    descendants.insert(*cacheEntry);
-                }
-            } else if (!descendants.count(childEntry)) {
-                // Schedule for later processing
-                stageEntries.insert(childEntry);
-            }
-        }
-    }
-    // descendants now contains all in-mempool descendants of updateIt.
-    // Update and add to cached descendant map
-    int32_t modifySize = 0;
-    CAmount modifyFee = 0;
-    int64_t modifyCount = 0;
-    for (const CTxMemPoolEntry& descendant : descendants) {
-        if (!setExclude.count(descendant.GetTx().GetHash())) {
-            modifySize += descendant.GetTxSize();
-            modifyFee += descendant.GetModifiedFee();
-            modifyCount++;
-            cachedDescendants[updateIt].insert(mapTx.iterator_to(descendant));
-            // Update ancestor state for each descendant
-            mapTx.modify(mapTx.iterator_to(descendant), [=](CTxMemPoolEntry& e) {
-              e.UpdateAncestorState(updateIt->GetTxSize(), updateIt->GetModifiedFee(), 1, updateIt->GetSigOpCost());
-            });
-        }
-    }
-    mapTx.modify(updateIt, [=](CTxMemPoolEntry& e) { e.UpdateDescendantState(modifySize, modifyFee, modifyCount); });
-}
-
 void CTxMemPool::UpdateTransactionsFromBlock(const std::vector<Txid>& vHashesToUpdate)
 {
     AssertLockHeld(cs);
-    // For each entry in vHashesToUpdate, store the set of in-mempool, but not
-    // in-vHashesToUpdate transactions, so that we don't have to recalculate
-    // descendants when we come across a previously seen entry.
-    cacheMap mapMemPoolDescendantsToUpdate;
 
     // Use a set for lookups into vHashesToUpdate (these entries are already
     // accounted for in the state of their ancestors)
     std::set<Txid> setAlreadyIncluded(vHashesToUpdate.begin(), vHashesToUpdate.end());
 
-    std::set<Txid> descendants_to_remove;
-
     // Iterate in reverse, so that whenever we are looking at a transaction
     // we are sure that all in-mempool descendants have already been processed.
-    // This maximizes the benefit of the descendant cache and guarantees that
-    // CTxMemPoolEntry::m_children will be updated, an assumption made in
-    // UpdateForDescendants.
     for (const Txid& hash : vHashesToUpdate | std::views::reverse) {
         // calculate children from mapNextTx
         txiter it = mapTx.find(hash);
@@ -143,22 +89,13 @@ void CTxMemPool::UpdateTransactionsFromBlock(const std::vector<Txid>& vHashesToU
                 // block and transactions that were in the mempool to txgraph.
                 m_txgraph->AddDependency(/*parent=*/*it, /*child=*/*childIter);
             }
-        } // release epoch guard for UpdateForDescendants
-        UpdateForDescendants(it, mapMemPoolDescendantsToUpdate, setAlreadyIncluded);
+        }
     }
 
     auto txs_to_remove = m_txgraph->Trim(); // Enforce cluster size limits.
     for (auto txptr : txs_to_remove) {
         const CTxMemPoolEntry& entry = *(static_cast<const CTxMemPoolEntry*>(txptr));
-        descendants_to_remove.insert(entry.GetTx().GetHash());
-    }
-
-    for (const auto& txid : descendants_to_remove) {
-        // This txid may have been removed already in a prior call to removeRecursive.
-        // Therefore we ensure it is not yet removed already.
-        if (const std::optional<txiter> txiter = GetIter(txid)) {
-            removeRecursive((*txiter)->GetTx(), MemPoolRemovalReason::SIZELIMIT);
-        }
+        removeUnchecked(mapTx.iterator_to(entry), MemPoolRemovalReason::SIZELIMIT);
     }
 }
 
@@ -265,33 +202,13 @@ CTxMemPool::setEntries CTxMemPool::AssumeCalculateMemPoolAncestors(
     return std::move(result).value_or(CTxMemPool::setEntries{});
 }
 
-void CTxMemPool::UpdateAncestorsOf(bool add, txiter it, setEntries &setAncestors)
+void CTxMemPool::UpdateAncestorsOf(bool add, txiter it)
 {
     const CTxMemPoolEntry::Parents& parents = it->GetMemPoolParentsConst();
     // add or remove this tx as a child of each parent
     for (const CTxMemPoolEntry& parent : parents) {
         UpdateChild(mapTx.iterator_to(parent), it, add);
     }
-    const int32_t updateCount = (add ? 1 : -1);
-    const int32_t updateSize{updateCount * it->GetTxSize()};
-    const CAmount updateFee = updateCount * it->GetModifiedFee();
-    for (txiter ancestorIt : setAncestors) {
-        mapTx.modify(ancestorIt, [=](CTxMemPoolEntry& e) { e.UpdateDescendantState(updateSize, updateFee, updateCount); });
-    }
-}
-
-void CTxMemPool::UpdateEntryForAncestors(txiter it, const setEntries &setAncestors)
-{
-    int64_t updateCount = setAncestors.size();
-    int64_t updateSize = 0;
-    CAmount updateFee = 0;
-    int64_t updateSigOpsCost = 0;
-    for (txiter ancestorIt : setAncestors) {
-        updateSize += ancestorIt->GetTxSize();
-        updateFee += ancestorIt->GetModifiedFee();
-        updateSigOpsCost += ancestorIt->GetSigOpCost();
-    }
-    mapTx.modify(it, [=](CTxMemPoolEntry& e){ e.UpdateAncestorState(updateSize, updateFee, updateCount, updateSigOpsCost); });
 }
 
 void CTxMemPool::UpdateChildrenForRemoval(txiter it)
@@ -304,52 +221,10 @@ void CTxMemPool::UpdateChildrenForRemoval(txiter it)
 
 void CTxMemPool::UpdateForRemoveFromMempool(const setEntries &entriesToRemove, bool updateDescendants)
 {
-    // For each entry, walk back all ancestors and decrement size associated with this
-    // transaction
-    if (updateDescendants) {
-        // updateDescendants should be true whenever we're not recursively
-        // removing a tx and all its descendants, eg when a transaction is
-        // confirmed in a block.
-        // Here we only update statistics and not data in CTxMemPool::Parents
-        // and CTxMemPoolEntry::Children (which we need to preserve until we're
-        // finished with all operations that need to traverse the mempool).
-        for (txiter removeIt : entriesToRemove) {
-            setEntries setDescendants;
-            CalculateDescendants(removeIt, setDescendants);
-            setDescendants.erase(removeIt); // don't update state for self
-            int32_t modifySize = -removeIt->GetTxSize();
-            CAmount modifyFee = -removeIt->GetModifiedFee();
-            int modifySigOps = -removeIt->GetSigOpCost();
-            for (txiter dit : setDescendants) {
-                mapTx.modify(dit, [=](CTxMemPoolEntry& e){ e.UpdateAncestorState(modifySize, modifyFee, -1, modifySigOps); });
-            }
-        }
-    }
     for (txiter removeIt : entriesToRemove) {
-        const CTxMemPoolEntry &entry = *removeIt;
-        // Since this is a tx that is already in the mempool, we can call CMPA
-        // with fSearchForParents = false.  If the mempool is in a consistent
-        // state, then using true or false should both be correct, though false
-        // should be a bit faster.
-        // However, if we happen to be in the middle of processing a reorg, then
-        // the mempool can be in an inconsistent state.  In this case, the set
-        // of ancestors reachable via GetMemPoolParents()/GetMemPoolChildren()
-        // will be the same as the set of ancestors whose packages include this
-        // transaction, because when we add a new transaction to the mempool in
-        // addNewTransaction(), we assume it has no children, and in the case of a
-        // reorg where that assumption is false, the in-mempool children aren't
-        // linked to the in-block tx's until UpdateTransactionsFromBlock() is
-        // called.
-        // So if we're being called during a reorg, ie before
-        // UpdateTransactionsFromBlock() has been called, then
-        // GetMemPoolParents()/GetMemPoolChildren() will differ from the set of
-        // mempool parents we'd calculate by searching, and it's important that
-        // we use the cached notion of ancestor transactions as the set of
-        // things to update for removal.
-        auto ancestors{AssumeCalculateMemPoolAncestors(__func__, entry, Limits::NoLimits(), /*fSearchForParents=*/false)};
         // Note that UpdateAncestorsOf severs the child links that point to
         // removeIt in the entries for the parents of removeIt.
-        UpdateAncestorsOf(false, removeIt, ancestors);
+        UpdateAncestorsOf(false, removeIt);
     }
     // After updating all the ancestor sizes, we can now sever the link between each
     // transaction being removed and any mempool children (ie, update CTxMemPoolEntry::m_parents
@@ -359,15 +234,6 @@ void CTxMemPool::UpdateForRemoveFromMempool(const setEntries &entriesToRemove, b
     }
 }
 
-void CTxMemPoolEntry::UpdateDescendantState(int32_t modifySize, CAmount modifyFee, int64_t modifyCount)
-{
-}
-
-void CTxMemPoolEntry::UpdateAncestorState(int32_t modifySize, CAmount modifyFee, int64_t modifyCount, int64_t modifySigOps)
-{
-}
-
-//! Clamp option values and populate the error if options are not valid.
 static CTxMemPool::Options&& Flatten(CTxMemPool::Options&& opts, bilingual_str& error)
 {
     opts.check_ratio = std::clamp<int>(opts.check_ratio, 0, 1'000'000);
@@ -470,8 +336,7 @@ void CTxMemPool::addNewTransaction(CTxMemPool::txiter newit, CTxMemPool::setEntr
     for (const auto& pit : GetIterSet(setParentTransactions)) {
         UpdateParent(newit, pit, true);
     }
-    UpdateAncestorsOf(true, newit, setAncestors);
-    UpdateEntryForAncestors(newit, setAncestors);
+    UpdateAncestorsOf(true, newit);
 
     nTransactionsUpdated++;
     totalTxSize += entry.GetTxSize();
@@ -823,18 +688,6 @@ void CTxMemPool::PrioritiseTransaction(const Txid& hash, const CAmount& nFeeDelt
             // transaction fee to be current modified fee + feedelta.
             mapTx.modify(it, [&nFeeDelta](CTxMemPoolEntry& e) { e.UpdateModifiedFee(nFeeDelta); });
             m_txgraph->SetTransactionFee(*it, it->GetModifiedFee());
-            // Now update all ancestors' modified fees with descendants
-            auto ancestors{AssumeCalculateMemPoolAncestors(__func__, *it, Limits::NoLimits(), /*fSearchForParents=*/false)};
-            for (txiter ancestorIt : ancestors) {
-                mapTx.modify(ancestorIt, [=](CTxMemPoolEntry& e){ e.UpdateDescendantState(0, nFeeDelta, 0);});
-            }
-            // Now update all descendants' modified fees with ancestors
-            setEntries setDescendants;
-            CalculateDescendants(it, setDescendants);
-            setDescendants.erase(it);
-            for (txiter descendantIt : setDescendants) {
-                mapTx.modify(descendantIt, [=](CTxMemPoolEntry& e){ e.UpdateAncestorState(0, nFeeDelta, 0, 0); });
-            }
             ++nTransactionsUpdated;
         }
         if (delta == 0) {
diff --git a/src/txmempool.h b/src/txmempool.h
index 9a4389c366f..b5da8c4cd37 100644
--- a/src/txmempool.h
+++ b/src/txmempool.h
@@ -350,7 +350,6 @@ public:
      */
     void check(const CCoinsViewCache& active_coins_tip, int64_t spendheight) const EXCLUSIVE_LOCKS_REQUIRED(::cs_main);
 
-
     void removeRecursive(const CTransaction& tx, MemPoolRemovalReason reason) EXCLUSIVE_LOCKS_REQUIRED(cs);
     /** After reorg, filter the entries that would no longer be valid in the next block, and update
      * the entries' cached LockPoints if needed.  The mempool does not have any knowledge of
@@ -639,35 +638,8 @@ private:
      */
     void RemoveStaged(setEntries& stage, bool updateDescendants, MemPoolRemovalReason reason) EXCLUSIVE_LOCKS_REQUIRED(cs);
 
-    /** UpdateForDescendants is used by UpdateTransactionsFromBlock to update
-     *  the descendants for a single transaction that has been added to the
-     *  mempool but may have child transactions in the mempool, eg during a
-     *  chain reorg.
-     *
-     * @pre CTxMemPoolEntry::m_children is correct for the given tx and all
-     *      descendants.
-     * @pre cachedDescendants is an accurate cache where each entry has all
-     *      descendants of the corresponding key, including those that should
-     *      be removed for violation of ancestor limits.
-     * @post if updateIt has any non-excluded descendants, cachedDescendants has
-     *       a new cache line for updateIt.
-     *
-     * @param[in] updateIt the entry to update for its descendants
-     * @param[in,out] cachedDescendants a cache where each line corresponds to all
-     *     descendants. It will be updated with the descendants of the transaction
-     *     being updated, so that future invocations don't need to walk the same
-     *     transaction again, if encountered in another transaction chain.
-     * @param[in] setExclude the set of descendant transactions in the mempool
-     *     that must not be accounted for (because any descendants in setExclude
-     *     were added to the mempool after the transaction being updated and hence
-     *     their state is already reflected in the parent state).
-     */
-    void UpdateForDescendants(txiter updateIt, cacheMap& cachedDescendants,
-                              const std::set<Txid>& setExclude) EXCLUSIVE_LOCKS_REQUIRED(cs);
     /** Update ancestors of hash to add/remove it as a descendant transaction. */
-    void UpdateAncestorsOf(bool add, txiter hash, setEntries &setAncestors) EXCLUSIVE_LOCKS_REQUIRED(cs);
-    /** Set ancestor state for an entry */
-    void UpdateEntryForAncestors(txiter it, const setEntries &setAncestors) EXCLUSIVE_LOCKS_REQUIRED(cs);
+    void UpdateAncestorsOf(bool add, txiter hash) EXCLUSIVE_LOCKS_REQUIRED(cs);
     /** For each transaction being removed, update ancestors and any direct children.
       * If updateDescendants is true, then also update in-mempool descendants'
       * ancestor state. */

From 0402e6c7808017bf5c04edb4b68128ede7d1c1e7 Mon Sep 17 00:00:00 2001
From: Suhas Daftuar <sdaftuar@chaincode.com>
Date: Sat, 14 Oct 2023 21:15:06 -0400
Subject: [PATCH 41/65] Remove unused limits from CalculateMemPoolAncestors

---
 src/policy/rbf.cpp              |  2 +-
 src/rpc/mempool.cpp             |  2 +-
 src/test/txvalidation_tests.cpp | 31 ++++++++++++++-----------------
 src/txmempool.cpp               | 26 ++++++--------------------
 src/txmempool.h                 | 22 ++++++----------------
 src/validation.cpp              |  2 +-
 6 files changed, 29 insertions(+), 56 deletions(-)

diff --git a/src/policy/rbf.cpp b/src/policy/rbf.cpp
index 6852cd52a33..19823464768 100644
--- a/src/policy/rbf.cpp
+++ b/src/policy/rbf.cpp
@@ -39,7 +39,7 @@ RBFTransactionState IsRBFOptIn(const CTransaction& tx, const CTxMemPool& pool)
     // If all the inputs have nSequence >= maxint-1, it still might be
     // signaled for RBF if any unconfirmed parents have signaled.
     const auto& entry{*Assert(pool.GetEntry(tx.GetHash()))};
-    auto ancestors{pool.AssumeCalculateMemPoolAncestors(__func__, entry, CTxMemPool::Limits::NoLimits(),
+    auto ancestors{pool.AssumeCalculateMemPoolAncestors(__func__, entry,
                                                         /*fSearchForParents=*/false)};
 
     for (CTxMemPool::txiter it : ancestors) {
diff --git a/src/rpc/mempool.cpp b/src/rpc/mempool.cpp
index b5373697e7a..d558a8cb58e 100644
--- a/src/rpc/mempool.cpp
+++ b/src/rpc/mempool.cpp
@@ -474,7 +474,7 @@ static RPCHelpMan getmempoolancestors()
         throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, "Transaction not in mempool");
     }
 
-    auto ancestors{mempool.AssumeCalculateMemPoolAncestors(self.m_name, *entry, CTxMemPool::Limits::NoLimits(), /*fSearchForParents=*/false)};
+    auto ancestors{mempool.AssumeCalculateMemPoolAncestors(self.m_name, *entry, /*fSearchForParents=*/false)};
 
     if (!fVerbose) {
         UniValue o(UniValue::VARR);
diff --git a/src/test/txvalidation_tests.cpp b/src/test/txvalidation_tests.cpp
index 89cf2f85626..27f5d959841 100644
--- a/src/test/txvalidation_tests.cpp
+++ b/src/test/txvalidation_tests.cpp
@@ -285,8 +285,6 @@ BOOST_FIXTURE_TEST_CASE(version3_tests, RegTestingSetup)
     AddToMempool(pool, entry.FromTx(mempool_tx_v3));
     auto mempool_tx_v2 = make_tx(random_outpoints(1), /*version=*/2);
     AddToMempool(pool, entry.FromTx(mempool_tx_v2));
-    // Default values.
-    CTxMemPool::Limits m_limits{};
 
     // Cannot spend from an unconfirmed TRUC transaction unless this tx is also TRUC.
     {
@@ -294,7 +292,7 @@ BOOST_FIXTURE_TEST_CASE(version3_tests, RegTestingSetup)
         //      ^
         // tx_v2_from_v3
         auto tx_v2_from_v3 = make_tx({COutPoint{mempool_tx_v3->GetHash(), 0}}, /*version=*/2);
-        auto ancestors_v2_from_v3{pool.CalculateMemPoolAncestors(entry.FromTx(tx_v2_from_v3), m_limits)};
+        auto ancestors_v2_from_v3{pool.CalculateMemPoolAncestors(entry.FromTx(tx_v2_from_v3))};
         const auto expected_error_str{strprintf("non-version=3 tx %s (wtxid=%s) cannot spend from version=3 tx %s (wtxid=%s)",
             tx_v2_from_v3->GetHash().ToString(), tx_v2_from_v3->GetWitnessHash().ToString(),
             mempool_tx_v3->GetHash().ToString(), mempool_tx_v3->GetWitnessHash().ToString())};
@@ -311,7 +309,7 @@ BOOST_FIXTURE_TEST_CASE(version3_tests, RegTestingSetup)
         //            ^    ^
         //    tx_v2_from_v2_and_v3
         auto tx_v2_from_v2_and_v3 = make_tx({COutPoint{mempool_tx_v3->GetHash(), 0}, COutPoint{mempool_tx_v2->GetHash(), 0}}, /*version=*/2);
-        auto ancestors_v2_from_both{pool.CalculateMemPoolAncestors(entry.FromTx(tx_v2_from_v2_and_v3), m_limits)};
+        auto ancestors_v2_from_both{pool.CalculateMemPoolAncestors(entry.FromTx(tx_v2_from_v2_and_v3))};
         const auto expected_error_str_2{strprintf("non-version=3 tx %s (wtxid=%s) cannot spend from version=3 tx %s (wtxid=%s)",
             tx_v2_from_v2_and_v3->GetHash().ToString(), tx_v2_from_v2_and_v3->GetWitnessHash().ToString(),
             mempool_tx_v3->GetHash().ToString(), mempool_tx_v3->GetWitnessHash().ToString())};
@@ -329,7 +327,7 @@ BOOST_FIXTURE_TEST_CASE(version3_tests, RegTestingSetup)
         //      ^
         // tx_v3_from_v2
         auto tx_v3_from_v2 = make_tx({COutPoint{mempool_tx_v2->GetHash(), 0}}, /*version=*/3);
-        auto ancestors_v3_from_v2{pool.CalculateMemPoolAncestors(entry.FromTx(tx_v3_from_v2), m_limits)};
+        auto ancestors_v3_from_v2{pool.CalculateMemPoolAncestors(entry.FromTx(tx_v3_from_v2))};
         const auto expected_error_str{strprintf("version=3 tx %s (wtxid=%s) cannot spend from non-version=3 tx %s (wtxid=%s)",
             tx_v3_from_v2->GetHash().ToString(), tx_v3_from_v2->GetWitnessHash().ToString(),
             mempool_tx_v2->GetHash().ToString(), mempool_tx_v2->GetWitnessHash().ToString())};
@@ -346,7 +344,7 @@ BOOST_FIXTURE_TEST_CASE(version3_tests, RegTestingSetup)
         //            ^    ^
         //    tx_v3_from_v2_and_v3
         auto tx_v3_from_v2_and_v3 = make_tx({COutPoint{mempool_tx_v3->GetHash(), 0}, COutPoint{mempool_tx_v2->GetHash(), 0}}, /*version=*/3);
-        auto ancestors_v3_from_both{pool.CalculateMemPoolAncestors(entry.FromTx(tx_v3_from_v2_and_v3), m_limits)};
+        auto ancestors_v3_from_both{pool.CalculateMemPoolAncestors(entry.FromTx(tx_v3_from_v2_and_v3))};
         const auto expected_error_str_2{strprintf("version=3 tx %s (wtxid=%s) cannot spend from non-version=3 tx %s (wtxid=%s)",
             tx_v3_from_v2_and_v3->GetHash().ToString(), tx_v3_from_v2_and_v3->GetWitnessHash().ToString(),
             mempool_tx_v2->GetHash().ToString(), mempool_tx_v2->GetWitnessHash().ToString())};
@@ -366,7 +364,7 @@ BOOST_FIXTURE_TEST_CASE(version3_tests, RegTestingSetup)
         //      ^
         // tx_v3_from_v3
         auto tx_v3_from_v3 = make_tx({COutPoint{mempool_tx_v3->GetHash(), 0}}, /*version=*/3);
-        auto ancestors_v3{pool.CalculateMemPoolAncestors(entry.FromTx(tx_v3_from_v3), m_limits)};
+        auto ancestors_v3{pool.CalculateMemPoolAncestors(entry.FromTx(tx_v3_from_v3))};
         BOOST_CHECK(SingleTRUCChecks(pool, tx_v3_from_v3, *ancestors_v3, empty_conflicts_set, GetVirtualTransactionSize(*tx_v3_from_v3))
                     == std::nullopt);
 
@@ -377,7 +375,7 @@ BOOST_FIXTURE_TEST_CASE(version3_tests, RegTestingSetup)
         //      ^
         // tx_v2_from_v2
         auto tx_v2_from_v2 = make_tx({COutPoint{mempool_tx_v2->GetHash(), 0}}, /*version=*/2);
-        auto ancestors_v2{pool.CalculateMemPoolAncestors(entry.FromTx(tx_v2_from_v2), m_limits)};
+        auto ancestors_v2{pool.CalculateMemPoolAncestors(entry.FromTx(tx_v2_from_v2))};
         BOOST_CHECK(SingleTRUCChecks(pool, tx_v2_from_v2, *ancestors_v2, empty_conflicts_set, GetVirtualTransactionSize(*tx_v2_from_v2))
                     == std::nullopt);
 
@@ -400,7 +398,7 @@ BOOST_FIXTURE_TEST_CASE(version3_tests, RegTestingSetup)
         }
         auto tx_v3_multi_parent = make_tx(mempool_outpoints, /*version=*/3);
         package_multi_parents.emplace_back(tx_v3_multi_parent);
-        auto ancestors{pool.CalculateMemPoolAncestors(entry.FromTx(tx_v3_multi_parent), m_limits)};
+        auto ancestors{pool.CalculateMemPoolAncestors(entry.FromTx(tx_v3_multi_parent))};
         BOOST_CHECK_EQUAL(ancestors->size(), 3);
         const auto expected_error_str{strprintf("tx %s (wtxid=%s) would have too many ancestors",
             tx_v3_multi_parent->GetHash().ToString(), tx_v3_multi_parent->GetWitnessHash().ToString())};
@@ -426,7 +424,7 @@ BOOST_FIXTURE_TEST_CASE(version3_tests, RegTestingSetup)
         }
         auto tx_v3_multi_gen = make_tx({last_outpoint}, /*version=*/3);
         package_multi_gen.emplace_back(tx_v3_multi_gen);
-        auto ancestors{pool.CalculateMemPoolAncestors(entry.FromTx(tx_v3_multi_gen), m_limits)};
+        auto ancestors{pool.CalculateMemPoolAncestors(entry.FromTx(tx_v3_multi_gen))};
         const auto expected_error_str{strprintf("tx %s (wtxid=%s) would have too many ancestors",
             tx_v3_multi_gen->GetHash().ToString(), tx_v3_multi_gen->GetWitnessHash().ToString())};
         auto result{SingleTRUCChecks(pool, tx_v3_multi_gen, *ancestors, empty_conflicts_set, GetVirtualTransactionSize(*tx_v3_multi_gen))};
@@ -444,7 +442,7 @@ BOOST_FIXTURE_TEST_CASE(version3_tests, RegTestingSetup)
     {
         auto tx_v3_child_big = make_tx(many_inputs, /*version=*/3);
         const auto vsize{GetVirtualTransactionSize(*tx_v3_child_big)};
-        auto ancestors{pool.CalculateMemPoolAncestors(entry.FromTx(tx_v3_child_big), m_limits)};
+        auto ancestors{pool.CalculateMemPoolAncestors(entry.FromTx(tx_v3_child_big))};
         const auto expected_error_str{strprintf("version=3 child tx %s (wtxid=%s) is too big: %u > %u virtual bytes",
             tx_v3_child_big->GetHash().ToString(), tx_v3_child_big->GetWitnessHash().ToString(), vsize, TRUC_CHILD_MAX_VSIZE)};
         auto result{SingleTRUCChecks(pool, tx_v3_child_big, *ancestors, empty_conflicts_set, GetVirtualTransactionSize(*tx_v3_child_big))};
@@ -479,7 +477,7 @@ BOOST_FIXTURE_TEST_CASE(version3_tests, RegTestingSetup)
         mtx_many_sigops.vout.back().nValue = 10000;
         auto tx_many_sigops{MakeTransactionRef(mtx_many_sigops)};
 
-        auto ancestors{pool.CalculateMemPoolAncestors(entry.FromTx(tx_many_sigops), m_limits)};
+        auto ancestors{pool.CalculateMemPoolAncestors(entry.FromTx(tx_many_sigops))};
         // legacy uses fAccurate = false, and the maximum number of multisig keys is used
         const int64_t total_sigops{static_cast<int64_t>(tx_many_sigops->vin.size()) * static_cast<int64_t>(script_multisig.GetSigOpCount(/*fAccurate=*/false))};
         BOOST_CHECK_EQUAL(total_sigops, tx_many_sigops->vin.size() * MAX_PUBKEYS_PER_MULTISIG);
@@ -504,7 +502,7 @@ BOOST_FIXTURE_TEST_CASE(version3_tests, RegTestingSetup)
     auto tx_mempool_v3_child = make_tx({COutPoint{mempool_tx_v3->GetHash(), 0}}, /*version=*/3);
     {
         BOOST_CHECK(GetTransactionWeight(*tx_mempool_v3_child) <= TRUC_CHILD_MAX_VSIZE * WITNESS_SCALE_FACTOR);
-        auto ancestors{pool.CalculateMemPoolAncestors(entry.FromTx(tx_mempool_v3_child), m_limits)};
+        auto ancestors{pool.CalculateMemPoolAncestors(entry.FromTx(tx_mempool_v3_child))};
         BOOST_CHECK(SingleTRUCChecks(pool, tx_mempool_v3_child, *ancestors, empty_conflicts_set, GetVirtualTransactionSize(*tx_mempool_v3_child)) == std::nullopt);
         AddToMempool(pool, entry.FromTx(tx_mempool_v3_child));
 
@@ -515,9 +513,8 @@ BOOST_FIXTURE_TEST_CASE(version3_tests, RegTestingSetup)
     // A TRUC transaction cannot have more than 1 descendant. Sibling is returned when exactly 1 exists.
     {
         auto tx_v3_child2 = make_tx({COutPoint{mempool_tx_v3->GetHash(), 1}}, /*version=*/3);
-
         // Configuration where parent already has 1 other child in mempool
-        auto ancestors_1sibling{pool.CalculateMemPoolAncestors(entry.FromTx(tx_v3_child2), m_limits)};
+        auto ancestors_1sibling{pool.CalculateMemPoolAncestors(entry.FromTx(tx_v3_child2))};
         const auto expected_error_str{strprintf("tx %s (wtxid=%s) would exceed descendant count limit",
             mempool_tx_v3->GetHash().ToString(), mempool_tx_v3->GetWitnessHash().ToString())};
         auto result_with_sibling_eviction{SingleTRUCChecks(pool, tx_v3_child2, *ancestors_1sibling, empty_conflicts_set, GetVirtualTransactionSize(*tx_v3_child2))};
@@ -538,7 +535,7 @@ BOOST_FIXTURE_TEST_CASE(version3_tests, RegTestingSetup)
         auto tx_v3_child3 = make_tx({COutPoint{mempool_tx_v3->GetHash(), 24}}, /*version=*/3);
         auto entry_mempool_parent = pool.GetIter(mempool_tx_v3->GetHash()).value();
         BOOST_CHECK_EQUAL(pool.GetDescendantCount(entry_mempool_parent), 3);
-        auto ancestors_2siblings{pool.CalculateMemPoolAncestors(entry.FromTx(tx_v3_child3), m_limits)};
+        auto ancestors_2siblings{pool.CalculateMemPoolAncestors(entry.FromTx(tx_v3_child3))};
 
         auto result_2children{SingleTRUCChecks(pool, tx_v3_child3, *ancestors_2siblings, empty_conflicts_set, GetVirtualTransactionSize(*tx_v3_child3))};
         BOOST_CHECK_EQUAL(result_2children->first, expected_error_str);
@@ -557,7 +554,7 @@ BOOST_FIXTURE_TEST_CASE(version3_tests, RegTestingSetup)
         AddToMempool(pool, entry.FromTx(tx_mempool_sibling));
         AddToMempool(pool, entry.FromTx(tx_mempool_nibling));
 
-        auto ancestors_3gen{pool.CalculateMemPoolAncestors(entry.FromTx(tx_to_submit), m_limits)};
+        auto ancestors_3gen{pool.CalculateMemPoolAncestors(entry.FromTx(tx_to_submit))};
         const auto expected_error_str{strprintf("tx %s (wtxid=%s) would exceed descendant count limit",
             tx_mempool_grandparent->GetHash().ToString(), tx_mempool_grandparent->GetWitnessHash().ToString())};
         auto result_3gen{SingleTRUCChecks(pool, tx_to_submit, *ancestors_3gen, empty_conflicts_set, GetVirtualTransactionSize(*tx_to_submit))};
diff --git a/src/txmempool.cpp b/src/txmempool.cpp
index 233e34210c7..d16a5efc4d6 100644
--- a/src/txmempool.cpp
+++ b/src/txmempool.cpp
@@ -99,11 +99,7 @@ void CTxMemPool::UpdateTransactionsFromBlock(const std::vector<Txid>& vHashesToU
     }
 }
 
-util::Result<CTxMemPool::setEntries> CTxMemPool::CalculateAncestorsAndCheckLimits(
-    int64_t entry_size,
-    size_t entry_count,
-    CTxMemPoolEntry::Parents& staged_ancestors,
-    const Limits& limits) const
+util::Result<CTxMemPool::setEntries> CTxMemPool::CalculateAncestors(CTxMemPoolEntry::Parents& staged_ancestors) const
 {
     setEntries ancestors;
 
@@ -141,11 +137,7 @@ util::Result<void> CTxMemPool::CheckPackageLimits(const Package& package,
         }
     }
 
-    // When multiple transactions are passed in, the ancestors and descendants of all transactions
-    // considered together must be within limits even if they are not interdependent. This may be
-    // stricter than the limits for each individual transaction.
-    const auto ancestors{CalculateAncestorsAndCheckLimits(total_vsize, package.size(),
-                                                          staged_ancestors, m_opts.limits)};
+    const auto ancestors{CalculateAncestors(staged_ancestors)};
     // It's possible to overestimate the ancestor/descendant totals.
     if (!ancestors.has_value()) return util::Error{Untranslated("possibly " + util::ErrorString(ancestors).original)};
     return {};
@@ -161,7 +153,6 @@ bool CTxMemPool::HasDescendants(const Txid& txid) const
 
 util::Result<CTxMemPool::setEntries> CTxMemPool::CalculateMemPoolAncestors(
     const CTxMemPoolEntry &entry,
-    const Limits& limits,
     bool fSearchForParents /* = true */) const
 {
     CTxMemPoolEntry::Parents staged_ancestors;
@@ -184,17 +175,15 @@ util::Result<CTxMemPool::setEntries> CTxMemPool::CalculateMemPoolAncestors(
         staged_ancestors = it->GetMemPoolParentsConst();
     }
 
-    return CalculateAncestorsAndCheckLimits(entry.GetTxSize(), /*entry_count=*/1, staged_ancestors,
-                                            limits);
+    return CalculateAncestors(staged_ancestors);
 }
 
 CTxMemPool::setEntries CTxMemPool::AssumeCalculateMemPoolAncestors(
     std::string_view calling_fn_name,
     const CTxMemPoolEntry &entry,
-    const Limits& limits,
     bool fSearchForParents /* = true */) const
 {
-    auto result{CalculateMemPoolAncestors(entry, limits, fSearchForParents)};
+    auto result{CalculateMemPoolAncestors(entry, fSearchForParents)};
     if (!Assume(result)) {
         LogPrintLevel(BCLog::MEMPOOL, BCLog::Level::Error, "%s: CalculateMemPoolAncestors failed unexpectedly, continuing with empty ancestor set (%s)\n",
                       calling_fn_name, util::ErrorString(result).original);
@@ -283,10 +272,7 @@ void CTxMemPool::Apply(ChangeSet* changeset)
             // We can only use a cached ancestor calculation for the first
             // transaction in a package, because in-package parents won't be
             // present in the cached ancestor sets of in-package children.
-            // We pass in Limits::NoLimits() to ensure that this function won't fail
-            // (we're going to be applying this set of transactions whether or
-            // not the mempool policy limits are being respected).
-            ancestors = *Assume(changeset->CalculateMemPoolAncestors(tx_entry, Limits::NoLimits()));
+            ancestors = *Assume(changeset->CalculateMemPoolAncestors(tx_entry));
         }
         // First splice this entry into mapTx.
         auto node_handle = changeset->m_to_add.extract(tx_entry);
@@ -306,7 +292,7 @@ void CTxMemPool::Apply(ChangeSet* changeset)
 
 void CTxMemPool::addNewTransaction(CTxMemPool::txiter it)
 {
-    auto ancestors{AssumeCalculateMemPoolAncestors(__func__, *it, Limits::NoLimits())};
+    auto ancestors{AssumeCalculateMemPoolAncestors(__func__, *it)};
     return addNewTransaction(it, ancestors);
 }
 
diff --git a/src/txmempool.h b/src/txmempool.h
index b5da8c4cd37..40f5ffeba8f 100644
--- a/src/txmempool.h
+++ b/src/txmempool.h
@@ -306,21 +306,14 @@ private:
 
 
     /**
-     * Helper function to calculate all in-mempool ancestors of staged_ancestors and apply ancestor
-     * and descendant limits (including staged_ancestors themselves, entry_size and entry_count).
+     * Helper function to calculate all in-mempool ancestors of staged_ancestors
      *
-     * @param[in]   entry_size          Virtual size to include in the limits.
-     * @param[in]   entry_count         How many entries to include in the limits.
      * @param[in]   staged_ancestors    Should contain entries in the mempool.
-     * @param[in]   limits              Maximum number and size of ancestors and descendants
      *
      * @return all in-mempool ancestors, or an error if any ancestor or descendant limits were hit
      */
-    util::Result<setEntries> CalculateAncestorsAndCheckLimits(int64_t entry_size,
-                                                              size_t entry_count,
-                                                              CTxMemPoolEntry::Parents &staged_ancestors,
-                                                              const Limits& limits
-                                                              ) const EXCLUSIVE_LOCKS_REQUIRED(cs);
+    util::Result<setEntries> CalculateAncestors(CTxMemPoolEntry::Parents &staged_ancestors)
+            const EXCLUSIVE_LOCKS_REQUIRED(cs);
 
     static TxMempoolInfo GetInfo(CTxMemPool::indexed_transaction_set::const_iterator it)
     {
@@ -437,15 +430,13 @@ public:
      * (these are all calculated including the tx itself)
      *
      * @param[in]   entry               CTxMemPoolEntry of which all in-mempool ancestors are calculated
-     * @param[in]   limits              Maximum number and size of ancestors and descendants
      * @param[in]   fSearchForParents   Whether to search a tx's vin for in-mempool parents, or look
      *                                  up parents from mapLinks. Must be true for entries not in
      *                                  the mempool
      *
-     * @return all in-mempool ancestors, or an error if any ancestor or descendant limits were hit
+     * @return all in-mempool ancestors
      */
     util::Result<setEntries> CalculateMemPoolAncestors(const CTxMemPoolEntry& entry,
-                                   const Limits& limits,
                                    bool fSearchForParents = true) const EXCLUSIVE_LOCKS_REQUIRED(cs);
 
     /**
@@ -465,7 +456,6 @@ public:
     setEntries AssumeCalculateMemPoolAncestors(
         std::string_view calling_fn_name,
         const CTxMemPoolEntry &entry,
-        const Limits& limits,
         bool fSearchForParents = true) const EXCLUSIVE_LOCKS_REQUIRED(cs);
 
     bool HasDescendants(const Txid& txid) const;
@@ -729,7 +719,7 @@ public:
         /** Check if any cluster limits are exceeded. Returns true if pass, false if fail. */
         bool CheckMemPoolPolicyLimits();
 
-        util::Result<CTxMemPool::setEntries> CalculateMemPoolAncestors(TxHandle tx, const Limits& limits)
+        util::Result<CTxMemPool::setEntries> CalculateMemPoolAncestors(TxHandle tx)
         {
             // Look up transaction in our cache first
             auto it = m_ancestors.find(tx);
@@ -738,7 +728,7 @@ public:
             // If not found, try to have the mempool calculate it, and cache
             // for later.
             LOCK(m_pool->cs);
-            auto ret{m_pool->CalculateMemPoolAncestors(*tx, limits)};
+            auto ret{m_pool->CalculateMemPoolAncestors(*tx)};
             if (ret) m_ancestors.try_emplace(tx, *ret);
             return ret;
         }
diff --git a/src/validation.cpp b/src/validation.cpp
index 348e610238e..49f8af3ec94 100644
--- a/src/validation.cpp
+++ b/src/validation.cpp
@@ -962,7 +962,7 @@ bool MemPoolAccept::PreChecks(ATMPArgs& args, Workspace& ws)
     ws.m_iters_conflicting = m_pool.GetIterSet(ws.m_conflicts);
 
     // Calculate in-mempool ancestors, up to a limit.
-    if (auto ancestors{m_subpackage.m_changeset->CalculateMemPoolAncestors(ws.m_tx_handle, m_pool.m_opts.limits)}) {
+    if (auto ancestors{m_subpackage.m_changeset->CalculateMemPoolAncestors(ws.m_tx_handle)}) {
         ws.m_ancestors = std::move(*ancestors);
     } else {
         return state.Invalid(TxValidationResult::TX_MEMPOOL_POLICY, "too-long-mempool-chain", util::ErrorString(ancestors).original);

From b9cec7f0a1e089cd77bb2fa1c2b54e93442e594c Mon Sep 17 00:00:00 2001
From: Suhas Daftuar <sdaftuar@chaincode.com>
Date: Sun, 15 Oct 2023 06:12:22 -0400
Subject: [PATCH 42/65] Make removeConflicts private

---
 src/txmempool.h | 5 ++++-
 1 file changed, 4 insertions(+), 1 deletion(-)

diff --git a/src/txmempool.h b/src/txmempool.h
index 40f5ffeba8f..cdf9bcc9f19 100644
--- a/src/txmempool.h
+++ b/src/txmempool.h
@@ -320,6 +320,10 @@ private:
         return TxMempoolInfo{it->GetSharedTx(), it->GetTime(), it->GetFee(), it->GetTxSize(), it->GetModifiedFee() - it->GetFee()};
     }
 
+    // Helper to remove all transactions that conflict with a given
+    // transaction (used for transactions appearing in a block).
+    void removeConflicts(const CTransaction& tx) EXCLUSIVE_LOCKS_REQUIRED(cs);
+
 public:
     indirectmap<COutPoint, txiter> mapNextTx GUARDED_BY(cs);
     std::map<Txid, CAmount> mapDeltas GUARDED_BY(cs);
@@ -352,7 +356,6 @@ public:
      *                                        and updates an entry's LockPoints.
      * */
     void removeForReorg(CChain& chain, std::function<bool(txiter)> filter_final_and_mature) EXCLUSIVE_LOCKS_REQUIRED(cs, cs_main);
-    void removeConflicts(const CTransaction& tx) EXCLUSIVE_LOCKS_REQUIRED(cs);
     void removeForBlock(const std::vector<CTransactionRef>& vtx, unsigned int nBlockHeight) EXCLUSIVE_LOCKS_REQUIRED(cs);
 
     bool CompareMiningScoreWithTopology(const Wtxid& hasha, const Wtxid& hashb) const;

From 241a3e666b59abb695c9d0a13d7458a763c2c5a0 Mon Sep 17 00:00:00 2001
From: Suhas Daftuar <sdaftuar@chaincode.com>
Date: Sat, 14 Oct 2023 21:31:51 -0400
Subject: [PATCH 43/65] Simplify ancestor calculation functions

Now that ancestor calculation never fails (due to ancestor/descendant limits
being eliminated), we can eliminate the error handling from
CalculateMemPoolAncestors.
---
 src/policy/rbf.cpp              |  3 +-
 src/rpc/mempool.cpp             |  2 +-
 src/test/txvalidation_tests.cpp | 34 ++++++++++----------
 src/txmempool.cpp               | 55 +++------------------------------
 src/txmempool.h                 | 34 +++++---------------
 src/validation.cpp              |  7 +----
 6 files changed, 31 insertions(+), 104 deletions(-)

diff --git a/src/policy/rbf.cpp b/src/policy/rbf.cpp
index 19823464768..fdf6f53cf40 100644
--- a/src/policy/rbf.cpp
+++ b/src/policy/rbf.cpp
@@ -39,8 +39,7 @@ RBFTransactionState IsRBFOptIn(const CTransaction& tx, const CTxMemPool& pool)
     // If all the inputs have nSequence >= maxint-1, it still might be
     // signaled for RBF if any unconfirmed parents have signaled.
     const auto& entry{*Assert(pool.GetEntry(tx.GetHash()))};
-    auto ancestors{pool.AssumeCalculateMemPoolAncestors(__func__, entry,
-                                                        /*fSearchForParents=*/false)};
+    auto ancestors{pool.CalculateMemPoolAncestors(entry, /*fSearchForParents=*/false)};
 
     for (CTxMemPool::txiter it : ancestors) {
         if (SignalsOptInRBF(it->GetTx())) {
diff --git a/src/rpc/mempool.cpp b/src/rpc/mempool.cpp
index d558a8cb58e..01870ef3577 100644
--- a/src/rpc/mempool.cpp
+++ b/src/rpc/mempool.cpp
@@ -474,7 +474,7 @@ static RPCHelpMan getmempoolancestors()
         throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, "Transaction not in mempool");
     }
 
-    auto ancestors{mempool.AssumeCalculateMemPoolAncestors(self.m_name, *entry, /*fSearchForParents=*/false)};
+    auto ancestors{mempool.CalculateMemPoolAncestors(*entry, /*fSearchForParents=*/false)};
 
     if (!fVerbose) {
         UniValue o(UniValue::VARR);
diff --git a/src/test/txvalidation_tests.cpp b/src/test/txvalidation_tests.cpp
index 27f5d959841..c0c9cc9c586 100644
--- a/src/test/txvalidation_tests.cpp
+++ b/src/test/txvalidation_tests.cpp
@@ -296,7 +296,7 @@ BOOST_FIXTURE_TEST_CASE(version3_tests, RegTestingSetup)
         const auto expected_error_str{strprintf("non-version=3 tx %s (wtxid=%s) cannot spend from version=3 tx %s (wtxid=%s)",
             tx_v2_from_v3->GetHash().ToString(), tx_v2_from_v3->GetWitnessHash().ToString(),
             mempool_tx_v3->GetHash().ToString(), mempool_tx_v3->GetWitnessHash().ToString())};
-        auto result_v2_from_v3{SingleTRUCChecks(pool, tx_v2_from_v3, *ancestors_v2_from_v3, empty_conflicts_set, GetVirtualTransactionSize(*tx_v2_from_v3))};
+        auto result_v2_from_v3{SingleTRUCChecks(pool, tx_v2_from_v3, ancestors_v2_from_v3, empty_conflicts_set, GetVirtualTransactionSize(*tx_v2_from_v3))};
         BOOST_CHECK_EQUAL(result_v2_from_v3->first, expected_error_str);
         BOOST_CHECK_EQUAL(result_v2_from_v3->second, nullptr);
 
@@ -313,7 +313,7 @@ BOOST_FIXTURE_TEST_CASE(version3_tests, RegTestingSetup)
         const auto expected_error_str_2{strprintf("non-version=3 tx %s (wtxid=%s) cannot spend from version=3 tx %s (wtxid=%s)",
             tx_v2_from_v2_and_v3->GetHash().ToString(), tx_v2_from_v2_and_v3->GetWitnessHash().ToString(),
             mempool_tx_v3->GetHash().ToString(), mempool_tx_v3->GetWitnessHash().ToString())};
-        auto result_v2_from_both{SingleTRUCChecks(pool, tx_v2_from_v2_and_v3, *ancestors_v2_from_both, empty_conflicts_set, GetVirtualTransactionSize(*tx_v2_from_v2_and_v3))};
+        auto result_v2_from_both{SingleTRUCChecks(pool, tx_v2_from_v2_and_v3, ancestors_v2_from_both, empty_conflicts_set, GetVirtualTransactionSize(*tx_v2_from_v2_and_v3))};
         BOOST_CHECK_EQUAL(result_v2_from_both->first, expected_error_str_2);
         BOOST_CHECK_EQUAL(result_v2_from_both->second, nullptr);
 
@@ -331,7 +331,7 @@ BOOST_FIXTURE_TEST_CASE(version3_tests, RegTestingSetup)
         const auto expected_error_str{strprintf("version=3 tx %s (wtxid=%s) cannot spend from non-version=3 tx %s (wtxid=%s)",
             tx_v3_from_v2->GetHash().ToString(), tx_v3_from_v2->GetWitnessHash().ToString(),
             mempool_tx_v2->GetHash().ToString(), mempool_tx_v2->GetWitnessHash().ToString())};
-        auto result_v3_from_v2{SingleTRUCChecks(pool, tx_v3_from_v2, *ancestors_v3_from_v2,  empty_conflicts_set, GetVirtualTransactionSize(*tx_v3_from_v2))};
+        auto result_v3_from_v2{SingleTRUCChecks(pool, tx_v3_from_v2, ancestors_v3_from_v2,  empty_conflicts_set, GetVirtualTransactionSize(*tx_v3_from_v2))};
         BOOST_CHECK_EQUAL(result_v3_from_v2->first, expected_error_str);
         BOOST_CHECK_EQUAL(result_v3_from_v2->second, nullptr);
 
@@ -348,7 +348,7 @@ BOOST_FIXTURE_TEST_CASE(version3_tests, RegTestingSetup)
         const auto expected_error_str_2{strprintf("version=3 tx %s (wtxid=%s) cannot spend from non-version=3 tx %s (wtxid=%s)",
             tx_v3_from_v2_and_v3->GetHash().ToString(), tx_v3_from_v2_and_v3->GetWitnessHash().ToString(),
             mempool_tx_v2->GetHash().ToString(), mempool_tx_v2->GetWitnessHash().ToString())};
-        auto result_v3_from_both{SingleTRUCChecks(pool, tx_v3_from_v2_and_v3, *ancestors_v3_from_both, empty_conflicts_set, GetVirtualTransactionSize(*tx_v3_from_v2_and_v3))};
+        auto result_v3_from_both{SingleTRUCChecks(pool, tx_v3_from_v2_and_v3, ancestors_v3_from_both, empty_conflicts_set, GetVirtualTransactionSize(*tx_v3_from_v2_and_v3))};
         BOOST_CHECK_EQUAL(result_v3_from_both->first, expected_error_str_2);
         BOOST_CHECK_EQUAL(result_v3_from_both->second, nullptr);
 
@@ -365,7 +365,7 @@ BOOST_FIXTURE_TEST_CASE(version3_tests, RegTestingSetup)
         // tx_v3_from_v3
         auto tx_v3_from_v3 = make_tx({COutPoint{mempool_tx_v3->GetHash(), 0}}, /*version=*/3);
         auto ancestors_v3{pool.CalculateMemPoolAncestors(entry.FromTx(tx_v3_from_v3))};
-        BOOST_CHECK(SingleTRUCChecks(pool, tx_v3_from_v3, *ancestors_v3, empty_conflicts_set, GetVirtualTransactionSize(*tx_v3_from_v3))
+        BOOST_CHECK(SingleTRUCChecks(pool, tx_v3_from_v3, ancestors_v3, empty_conflicts_set, GetVirtualTransactionSize(*tx_v3_from_v3))
                     == std::nullopt);
 
         Package package_v3_v3{mempool_tx_v3, tx_v3_from_v3};
@@ -376,7 +376,7 @@ BOOST_FIXTURE_TEST_CASE(version3_tests, RegTestingSetup)
         // tx_v2_from_v2
         auto tx_v2_from_v2 = make_tx({COutPoint{mempool_tx_v2->GetHash(), 0}}, /*version=*/2);
         auto ancestors_v2{pool.CalculateMemPoolAncestors(entry.FromTx(tx_v2_from_v2))};
-        BOOST_CHECK(SingleTRUCChecks(pool, tx_v2_from_v2, *ancestors_v2, empty_conflicts_set, GetVirtualTransactionSize(*tx_v2_from_v2))
+        BOOST_CHECK(SingleTRUCChecks(pool, tx_v2_from_v2, ancestors_v2, empty_conflicts_set, GetVirtualTransactionSize(*tx_v2_from_v2))
                     == std::nullopt);
 
         Package package_v2_v2{mempool_tx_v2, tx_v2_from_v2};
@@ -399,10 +399,10 @@ BOOST_FIXTURE_TEST_CASE(version3_tests, RegTestingSetup)
         auto tx_v3_multi_parent = make_tx(mempool_outpoints, /*version=*/3);
         package_multi_parents.emplace_back(tx_v3_multi_parent);
         auto ancestors{pool.CalculateMemPoolAncestors(entry.FromTx(tx_v3_multi_parent))};
-        BOOST_CHECK_EQUAL(ancestors->size(), 3);
+        BOOST_CHECK_EQUAL(ancestors.size(), 3);
         const auto expected_error_str{strprintf("tx %s (wtxid=%s) would have too many ancestors",
             tx_v3_multi_parent->GetHash().ToString(), tx_v3_multi_parent->GetWitnessHash().ToString())};
-        auto result{SingleTRUCChecks(pool, tx_v3_multi_parent, *ancestors, empty_conflicts_set, GetVirtualTransactionSize(*tx_v3_multi_parent))};
+        auto result{SingleTRUCChecks(pool, tx_v3_multi_parent, ancestors, empty_conflicts_set, GetVirtualTransactionSize(*tx_v3_multi_parent))};
         BOOST_CHECK_EQUAL(result->first, expected_error_str);
         BOOST_CHECK_EQUAL(result->second, nullptr);
 
@@ -427,7 +427,7 @@ BOOST_FIXTURE_TEST_CASE(version3_tests, RegTestingSetup)
         auto ancestors{pool.CalculateMemPoolAncestors(entry.FromTx(tx_v3_multi_gen))};
         const auto expected_error_str{strprintf("tx %s (wtxid=%s) would have too many ancestors",
             tx_v3_multi_gen->GetHash().ToString(), tx_v3_multi_gen->GetWitnessHash().ToString())};
-        auto result{SingleTRUCChecks(pool, tx_v3_multi_gen, *ancestors, empty_conflicts_set, GetVirtualTransactionSize(*tx_v3_multi_gen))};
+        auto result{SingleTRUCChecks(pool, tx_v3_multi_gen, ancestors, empty_conflicts_set, GetVirtualTransactionSize(*tx_v3_multi_gen))};
         BOOST_CHECK_EQUAL(result->first, expected_error_str);
         BOOST_CHECK_EQUAL(result->second, nullptr);
 
@@ -445,7 +445,7 @@ BOOST_FIXTURE_TEST_CASE(version3_tests, RegTestingSetup)
         auto ancestors{pool.CalculateMemPoolAncestors(entry.FromTx(tx_v3_child_big))};
         const auto expected_error_str{strprintf("version=3 child tx %s (wtxid=%s) is too big: %u > %u virtual bytes",
             tx_v3_child_big->GetHash().ToString(), tx_v3_child_big->GetWitnessHash().ToString(), vsize, TRUC_CHILD_MAX_VSIZE)};
-        auto result{SingleTRUCChecks(pool, tx_v3_child_big, *ancestors, empty_conflicts_set, GetVirtualTransactionSize(*tx_v3_child_big))};
+        auto result{SingleTRUCChecks(pool, tx_v3_child_big, ancestors, empty_conflicts_set, GetVirtualTransactionSize(*tx_v3_child_big))};
         BOOST_CHECK_EQUAL(result->first, expected_error_str);
         BOOST_CHECK_EQUAL(result->second, nullptr);
 
@@ -483,12 +483,12 @@ BOOST_FIXTURE_TEST_CASE(version3_tests, RegTestingSetup)
         BOOST_CHECK_EQUAL(total_sigops, tx_many_sigops->vin.size() * MAX_PUBKEYS_PER_MULTISIG);
         const int64_t bip141_vsize{GetVirtualTransactionSize(*tx_many_sigops)};
         // Weight limit is not reached...
-        BOOST_CHECK(SingleTRUCChecks(pool, tx_many_sigops, *ancestors, empty_conflicts_set, bip141_vsize) == std::nullopt);
+        BOOST_CHECK(SingleTRUCChecks(pool, tx_many_sigops, ancestors, empty_conflicts_set, bip141_vsize) == std::nullopt);
         // ...but sigop limit is.
         const auto expected_error_str{strprintf("version=3 child tx %s (wtxid=%s) is too big: %u > %u virtual bytes",
             tx_many_sigops->GetHash().ToString(), tx_many_sigops->GetWitnessHash().ToString(),
             total_sigops * DEFAULT_BYTES_PER_SIGOP / WITNESS_SCALE_FACTOR, TRUC_CHILD_MAX_VSIZE)};
-        auto result{SingleTRUCChecks(pool, tx_many_sigops, *ancestors, empty_conflicts_set,
+        auto result{SingleTRUCChecks(pool, tx_many_sigops, ancestors, empty_conflicts_set,
                                         GetVirtualTransactionSize(*tx_many_sigops, /*nSigOpCost=*/total_sigops, /*bytes_per_sigop=*/ DEFAULT_BYTES_PER_SIGOP))};
         BOOST_CHECK_EQUAL(result->first, expected_error_str);
         BOOST_CHECK_EQUAL(result->second, nullptr);
@@ -503,7 +503,7 @@ BOOST_FIXTURE_TEST_CASE(version3_tests, RegTestingSetup)
     {
         BOOST_CHECK(GetTransactionWeight(*tx_mempool_v3_child) <= TRUC_CHILD_MAX_VSIZE * WITNESS_SCALE_FACTOR);
         auto ancestors{pool.CalculateMemPoolAncestors(entry.FromTx(tx_mempool_v3_child))};
-        BOOST_CHECK(SingleTRUCChecks(pool, tx_mempool_v3_child, *ancestors, empty_conflicts_set, GetVirtualTransactionSize(*tx_mempool_v3_child)) == std::nullopt);
+        BOOST_CHECK(SingleTRUCChecks(pool, tx_mempool_v3_child, ancestors, empty_conflicts_set, GetVirtualTransactionSize(*tx_mempool_v3_child)) == std::nullopt);
         AddToMempool(pool, entry.FromTx(tx_mempool_v3_child));
 
         Package package_v3_1p1c{mempool_tx_v3, tx_mempool_v3_child};
@@ -517,13 +517,13 @@ BOOST_FIXTURE_TEST_CASE(version3_tests, RegTestingSetup)
         auto ancestors_1sibling{pool.CalculateMemPoolAncestors(entry.FromTx(tx_v3_child2))};
         const auto expected_error_str{strprintf("tx %s (wtxid=%s) would exceed descendant count limit",
             mempool_tx_v3->GetHash().ToString(), mempool_tx_v3->GetWitnessHash().ToString())};
-        auto result_with_sibling_eviction{SingleTRUCChecks(pool, tx_v3_child2, *ancestors_1sibling, empty_conflicts_set, GetVirtualTransactionSize(*tx_v3_child2))};
+        auto result_with_sibling_eviction{SingleTRUCChecks(pool, tx_v3_child2, ancestors_1sibling, empty_conflicts_set, GetVirtualTransactionSize(*tx_v3_child2))};
         BOOST_CHECK_EQUAL(result_with_sibling_eviction->first, expected_error_str);
         // The other mempool child is returned to allow for sibling eviction.
         BOOST_CHECK_EQUAL(result_with_sibling_eviction->second, tx_mempool_v3_child);
 
         // If directly replacing the child, make sure there is no double-counting.
-        BOOST_CHECK(SingleTRUCChecks(pool, tx_v3_child2, *ancestors_1sibling, {tx_mempool_v3_child->GetHash()}, GetVirtualTransactionSize(*tx_v3_child2))
+        BOOST_CHECK(SingleTRUCChecks(pool, tx_v3_child2, ancestors_1sibling, {tx_mempool_v3_child->GetHash()}, GetVirtualTransactionSize(*tx_v3_child2))
                     == std::nullopt);
 
         Package package_v3_1p2c{mempool_tx_v3, tx_mempool_v3_child, tx_v3_child2};
@@ -537,7 +537,7 @@ BOOST_FIXTURE_TEST_CASE(version3_tests, RegTestingSetup)
         BOOST_CHECK_EQUAL(pool.GetDescendantCount(entry_mempool_parent), 3);
         auto ancestors_2siblings{pool.CalculateMemPoolAncestors(entry.FromTx(tx_v3_child3))};
 
-        auto result_2children{SingleTRUCChecks(pool, tx_v3_child3, *ancestors_2siblings, empty_conflicts_set, GetVirtualTransactionSize(*tx_v3_child3))};
+        auto result_2children{SingleTRUCChecks(pool, tx_v3_child3, ancestors_2siblings, empty_conflicts_set, GetVirtualTransactionSize(*tx_v3_child3))};
         BOOST_CHECK_EQUAL(result_2children->first, expected_error_str);
         // The other mempool child is not returned because sibling eviction is not allowed.
         BOOST_CHECK_EQUAL(result_2children->second, nullptr);
@@ -557,7 +557,7 @@ BOOST_FIXTURE_TEST_CASE(version3_tests, RegTestingSetup)
         auto ancestors_3gen{pool.CalculateMemPoolAncestors(entry.FromTx(tx_to_submit))};
         const auto expected_error_str{strprintf("tx %s (wtxid=%s) would exceed descendant count limit",
             tx_mempool_grandparent->GetHash().ToString(), tx_mempool_grandparent->GetWitnessHash().ToString())};
-        auto result_3gen{SingleTRUCChecks(pool, tx_to_submit, *ancestors_3gen, empty_conflicts_set, GetVirtualTransactionSize(*tx_to_submit))};
+        auto result_3gen{SingleTRUCChecks(pool, tx_to_submit, ancestors_3gen, empty_conflicts_set, GetVirtualTransactionSize(*tx_to_submit))};
         BOOST_CHECK_EQUAL(result_3gen->first, expected_error_str);
         // The other mempool child is not returned because sibling eviction is not allowed.
         BOOST_CHECK_EQUAL(result_3gen->second, nullptr);
diff --git a/src/txmempool.cpp b/src/txmempool.cpp
index d16a5efc4d6..f83b4544f40 100644
--- a/src/txmempool.cpp
+++ b/src/txmempool.cpp
@@ -99,7 +99,7 @@ void CTxMemPool::UpdateTransactionsFromBlock(const std::vector<Txid>& vHashesToU
     }
 }
 
-util::Result<CTxMemPool::setEntries> CTxMemPool::CalculateAncestors(CTxMemPoolEntry::Parents& staged_ancestors) const
+CTxMemPool::setEntries CTxMemPool::CalculateAncestors(CTxMemPoolEntry::Parents& staged_ancestors) const
 {
     setEntries ancestors;
 
@@ -127,19 +127,6 @@ util::Result<CTxMemPool::setEntries> CTxMemPool::CalculateAncestors(CTxMemPoolEn
 util::Result<void> CTxMemPool::CheckPackageLimits(const Package& package,
                                                   const int64_t total_vsize) const
 {
-    CTxMemPoolEntry::Parents staged_ancestors;
-    for (const auto& tx : package) {
-        for (const auto& input : tx->vin) {
-            std::optional<txiter> piter = GetIter(input.prevout.hash);
-            if (piter) {
-                staged_ancestors.insert(**piter);
-            }
-        }
-    }
-
-    const auto ancestors{CalculateAncestors(staged_ancestors)};
-    // It's possible to overestimate the ancestor/descendant totals.
-    if (!ancestors.has_value()) return util::Error{Untranslated("possibly " + util::ErrorString(ancestors).original)};
     return {};
 }
 
@@ -151,7 +138,7 @@ bool CTxMemPool::HasDescendants(const Txid& txid) const
     return m_txgraph->GetDescendants(*entry, TxGraph::Level::MAIN).size() > 1;
 }
 
-util::Result<CTxMemPool::setEntries> CTxMemPool::CalculateMemPoolAncestors(
+CTxMemPool::setEntries CTxMemPool::CalculateMemPoolAncestors(
     const CTxMemPoolEntry &entry,
     bool fSearchForParents /* = true */) const
 {
@@ -178,19 +165,6 @@ util::Result<CTxMemPool::setEntries> CTxMemPool::CalculateMemPoolAncestors(
     return CalculateAncestors(staged_ancestors);
 }
 
-CTxMemPool::setEntries CTxMemPool::AssumeCalculateMemPoolAncestors(
-    std::string_view calling_fn_name,
-    const CTxMemPoolEntry &entry,
-    bool fSearchForParents /* = true */) const
-{
-    auto result{CalculateMemPoolAncestors(entry, fSearchForParents)};
-    if (!Assume(result)) {
-        LogPrintLevel(BCLog::MEMPOOL, BCLog::Level::Error, "%s: CalculateMemPoolAncestors failed unexpectedly, continuing with empty ancestor set (%s)\n",
-                      calling_fn_name, util::ErrorString(result).original);
-    }
-    return std::move(result).value_or(CTxMemPool::setEntries{});
-}
-
 void CTxMemPool::UpdateAncestorsOf(bool add, txiter it)
 {
     const CTxMemPoolEntry::Parents& parents = it->GetMemPoolParentsConst();
@@ -264,16 +238,6 @@ void CTxMemPool::Apply(ChangeSet* changeset)
 
     for (size_t i=0; i<changeset->m_entry_vec.size(); ++i) {
         auto tx_entry = changeset->m_entry_vec[i];
-        std::optional<CTxMemPool::setEntries> ancestors;
-        if (i == 0) {
-            // Note: ChangeSet::CalculateMemPoolAncestors() will return a
-            // cached value if mempool ancestors for this transaction were
-            // previously calculated.
-            // We can only use a cached ancestor calculation for the first
-            // transaction in a package, because in-package parents won't be
-            // present in the cached ancestor sets of in-package children.
-            ancestors = *Assume(changeset->CalculateMemPoolAncestors(tx_entry));
-        }
         // First splice this entry into mapTx.
         auto node_handle = changeset->m_to_add.extract(tx_entry);
         auto result = mapTx.insert(std::move(node_handle));
@@ -281,22 +245,11 @@ void CTxMemPool::Apply(ChangeSet* changeset)
         Assume(result.inserted);
         txiter it = result.position;
 
-        // Now update the entry for ancestors/descendants.
-        if (ancestors.has_value()) {
-            addNewTransaction(it, *ancestors);
-        } else {
-            addNewTransaction(it);
-        }
+        addNewTransaction(it);
     }
 }
 
-void CTxMemPool::addNewTransaction(CTxMemPool::txiter it)
-{
-    auto ancestors{AssumeCalculateMemPoolAncestors(__func__, *it)};
-    return addNewTransaction(it, ancestors);
-}
-
-void CTxMemPool::addNewTransaction(CTxMemPool::txiter newit, CTxMemPool::setEntries& setAncestors)
+void CTxMemPool::addNewTransaction(CTxMemPool::txiter newit)
 {
     const CTxMemPoolEntry& entry = *newit;
 
diff --git a/src/txmempool.h b/src/txmempool.h
index cdf9bcc9f19..d2b7f232b94 100644
--- a/src/txmempool.h
+++ b/src/txmempool.h
@@ -310,9 +310,9 @@ private:
      *
      * @param[in]   staged_ancestors    Should contain entries in the mempool.
      *
-     * @return all in-mempool ancestors, or an error if any ancestor or descendant limits were hit
+     * @return all in-mempool ancestors
      */
-    util::Result<setEntries> CalculateAncestors(CTxMemPoolEntry::Parents &staged_ancestors)
+    setEntries CalculateAncestors(CTxMemPoolEntry::Parents &staged_ancestors)
             const EXCLUSIVE_LOCKS_REQUIRED(cs);
 
     static TxMempoolInfo GetInfo(CTxMemPool::indexed_transaction_set::const_iterator it)
@@ -429,7 +429,7 @@ public:
     }
 
     /**
-     * Try to calculate all in-mempool ancestors of entry.
+     * Calculate all in-mempool ancestors of entry.
      * (these are all calculated including the tx itself)
      *
      * @param[in]   entry               CTxMemPoolEntry of which all in-mempool ancestors are calculated
@@ -439,28 +439,9 @@ public:
      *
      * @return all in-mempool ancestors
      */
-    util::Result<setEntries> CalculateMemPoolAncestors(const CTxMemPoolEntry& entry,
+    setEntries CalculateMemPoolAncestors(const CTxMemPoolEntry& entry,
                                    bool fSearchForParents = true) const EXCLUSIVE_LOCKS_REQUIRED(cs);
 
-    /**
-     * Same as CalculateMemPoolAncestors, but always returns a (non-optional) setEntries.
-     * Should only be used when it is assumed CalculateMemPoolAncestors would not fail. If
-     * CalculateMemPoolAncestors does unexpectedly fail, an empty setEntries is returned and the
-     * error is logged to BCLog::MEMPOOL with level BCLog::Level::Error. In debug builds, failure
-     * of CalculateMemPoolAncestors will lead to shutdown due to assertion failure.
-     *
-     * @param[in]   calling_fn_name     Name of calling function so we can properly log the call site
-     *
-     * @return a setEntries corresponding to the result of CalculateMemPoolAncestors or an empty
-     *         setEntries if it failed
-     *
-     * @see CTXMemPool::CalculateMemPoolAncestors()
-     */
-    setEntries AssumeCalculateMemPoolAncestors(
-        std::string_view calling_fn_name,
-        const CTxMemPoolEntry &entry,
-        bool fSearchForParents = true) const EXCLUSIVE_LOCKS_REQUIRED(cs);
-
     bool HasDescendants(const Txid& txid) const;
 
     /** Collect the entire cluster of connected transactions for each transaction in txids.
@@ -722,7 +703,7 @@ public:
         /** Check if any cluster limits are exceeded. Returns true if pass, false if fail. */
         bool CheckMemPoolPolicyLimits();
 
-        util::Result<CTxMemPool::setEntries> CalculateMemPoolAncestors(TxHandle tx)
+        CTxMemPool::setEntries CalculateMemPoolAncestors(TxHandle tx)
         {
             // Look up transaction in our cache first
             auto it = m_ancestors.find(tx);
@@ -731,8 +712,8 @@ public:
             // If not found, try to have the mempool calculate it, and cache
             // for later.
             LOCK(m_pool->cs);
-            auto ret{m_pool->CalculateMemPoolAncestors(*tx)};
-            if (ret) m_ancestors.try_emplace(tx, *ret);
+            auto ret = m_pool->CalculateMemPoolAncestors(*tx);
+            m_ancestors.try_emplace(tx, ret);
             return ret;
         }
 
@@ -796,7 +777,6 @@ private:
     // tracking (due to lack of CValidationInterface::TransactionAddedToMempool
     // callbacks).
     void addNewTransaction(CTxMemPool::txiter it) EXCLUSIVE_LOCKS_REQUIRED(cs);
-    void addNewTransaction(CTxMemPool::txiter it, CTxMemPool::setEntries& setAncestors) EXCLUSIVE_LOCKS_REQUIRED(cs);
 public:
     void StartBlockBuilding() const EXCLUSIVE_LOCKS_REQUIRED(cs) { assert(!m_builder); m_builder = m_txgraph->GetBlockBuilder(); }
     FeePerWeight GetBlockBuilderChunk(std::vector<CTxMemPoolEntry::CTxMemPoolEntryRef>& entries) const EXCLUSIVE_LOCKS_REQUIRED(cs)
diff --git a/src/validation.cpp b/src/validation.cpp
index 49f8af3ec94..6a02acd5861 100644
--- a/src/validation.cpp
+++ b/src/validation.cpp
@@ -961,12 +961,7 @@ bool MemPoolAccept::PreChecks(ATMPArgs& args, Workspace& ws)
 
     ws.m_iters_conflicting = m_pool.GetIterSet(ws.m_conflicts);
 
-    // Calculate in-mempool ancestors, up to a limit.
-    if (auto ancestors{m_subpackage.m_changeset->CalculateMemPoolAncestors(ws.m_tx_handle)}) {
-        ws.m_ancestors = std::move(*ancestors);
-    } else {
-        return state.Invalid(TxValidationResult::TX_MEMPOOL_POLICY, "too-long-mempool-chain", util::ErrorString(ancestors).original);
-    }
+    ws.m_ancestors = m_subpackage.m_changeset->CalculateMemPoolAncestors(ws.m_tx_handle);
 
     // Even though just checking direct mempool parents for inheritance would be sufficient, we
     // check using the full ancestor set here because it's more convenient to use what we have

From c8b6f70d6492a153b59697d6303fc0515f316f89 Mon Sep 17 00:00:00 2001
From: Suhas Daftuar <sdaftuar@gmail.com>
Date: Sun, 14 Apr 2024 18:21:34 -0400
Subject: [PATCH 44/65] Use txgraph to calculate ancestors

---
 src/policy/rbf.cpp  |  2 +-
 src/rpc/mempool.cpp |  2 +-
 src/txmempool.cpp   | 76 ++++++++++++++++++---------------------------
 src/txmempool.h     | 20 ++----------
 4 files changed, 35 insertions(+), 65 deletions(-)

diff --git a/src/policy/rbf.cpp b/src/policy/rbf.cpp
index fdf6f53cf40..c78fed8ef3e 100644
--- a/src/policy/rbf.cpp
+++ b/src/policy/rbf.cpp
@@ -39,7 +39,7 @@ RBFTransactionState IsRBFOptIn(const CTransaction& tx, const CTxMemPool& pool)
     // If all the inputs have nSequence >= maxint-1, it still might be
     // signaled for RBF if any unconfirmed parents have signaled.
     const auto& entry{*Assert(pool.GetEntry(tx.GetHash()))};
-    auto ancestors{pool.CalculateMemPoolAncestors(entry, /*fSearchForParents=*/false)};
+    auto ancestors{pool.CalculateMemPoolAncestors(entry)};
 
     for (CTxMemPool::txiter it : ancestors) {
         if (SignalsOptInRBF(it->GetTx())) {
diff --git a/src/rpc/mempool.cpp b/src/rpc/mempool.cpp
index 01870ef3577..7a016335926 100644
--- a/src/rpc/mempool.cpp
+++ b/src/rpc/mempool.cpp
@@ -474,7 +474,7 @@ static RPCHelpMan getmempoolancestors()
         throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, "Transaction not in mempool");
     }
 
-    auto ancestors{mempool.CalculateMemPoolAncestors(*entry, /*fSearchForParents=*/false)};
+    auto ancestors{mempool.CalculateMemPoolAncestors(*entry)};
 
     if (!fVerbose) {
         UniValue o(UniValue::VARR);
diff --git a/src/txmempool.cpp b/src/txmempool.cpp
index f83b4544f40..2b8bec25498 100644
--- a/src/txmempool.cpp
+++ b/src/txmempool.cpp
@@ -99,31 +99,6 @@ void CTxMemPool::UpdateTransactionsFromBlock(const std::vector<Txid>& vHashesToU
     }
 }
 
-CTxMemPool::setEntries CTxMemPool::CalculateAncestors(CTxMemPoolEntry::Parents& staged_ancestors) const
-{
-    setEntries ancestors;
-
-    while (!staged_ancestors.empty()) {
-        const CTxMemPoolEntry& stage = staged_ancestors.begin()->get();
-        txiter stageit = mapTx.iterator_to(stage);
-
-        ancestors.insert(stageit);
-        staged_ancestors.erase(stage);
-
-        const CTxMemPoolEntry::Parents& parents = stageit->GetMemPoolParentsConst();
-        for (const CTxMemPoolEntry& parent : parents) {
-            txiter parent_it = mapTx.iterator_to(parent);
-
-            // If this is a new ancestor, add it.
-            if (ancestors.count(parent_it) == 0) {
-                staged_ancestors.insert(parent);
-            }
-        }
-    }
-
-    return ancestors;
-}
-
 util::Result<void> CTxMemPool::CheckPackageLimits(const Package& package,
                                                   const int64_t total_vsize) const
 {
@@ -138,31 +113,42 @@ bool CTxMemPool::HasDescendants(const Txid& txid) const
     return m_txgraph->GetDescendants(*entry, TxGraph::Level::MAIN).size() > 1;
 }
 
-CTxMemPool::setEntries CTxMemPool::CalculateMemPoolAncestors(
-    const CTxMemPoolEntry &entry,
-    bool fSearchForParents /* = true */) const
+CTxMemPool::setEntries CTxMemPool::CalculateMemPoolAncestors(const CTxMemPoolEntry &entry) const
 {
-    CTxMemPoolEntry::Parents staged_ancestors;
-    const CTransaction &tx = entry.GetTx();
-
-    if (fSearchForParents) {
-        // Get parents of this transaction that are in the mempool
-        // GetMemPoolParents() is only valid for entries in the mempool, so we
-        // iterate mapTx to find parents.
-        for (unsigned int i = 0; i < tx.vin.size(); i++) {
-            std::optional<txiter> piter = GetIter(tx.vin[i].prevout.hash);
-            if (piter) {
-                staged_ancestors.insert(**piter);
+    auto ancestors = m_txgraph->GetAncestors(entry, TxGraph::Level::MAIN);
+    setEntries ret;
+    if (ancestors.size() > 0) {
+        for (auto ancestor : ancestors) {
+            if (ancestor != &entry) {
+                ret.insert(mapTx.iterator_to(static_cast<const CTxMemPoolEntry&>(*ancestor)));
             }
         }
-    } else {
-        // If we're not searching for parents, we require this to already be an
-        // entry in the mempool and use the entry's cached parents.
-        txiter it = mapTx.iterator_to(entry);
-        staged_ancestors = it->GetMemPoolParentsConst();
+        return ret;
     }
 
-    return CalculateAncestors(staged_ancestors);
+    // If we didn't get anything back, the transaction is not in the graph.
+    // Find each parent and call GetAncestors on each.
+    setEntries staged_parents;
+    const CTransaction &tx = entry.GetTx();
+
+    // Get parents of this transaction that are in the mempool
+    // GetMemPoolParents() is only valid for entries in the mempool, so we
+    // iterate mapTx to find parents.
+    for (unsigned int i = 0; i < tx.vin.size(); i++) {
+        std::optional<txiter> piter = GetIter(tx.vin[i].prevout.hash);
+        if (piter) {
+            staged_parents.insert(*piter);
+        }
+    }
+
+    for (const auto& parent : staged_parents) {
+        auto parent_ancestors = m_txgraph->GetAncestors(*parent, TxGraph::Level::MAIN);
+        for (auto ancestor : parent_ancestors) {
+            ret.insert(mapTx.iterator_to(static_cast<const CTxMemPoolEntry&>(*ancestor)));
+        }
+    }
+
+    return ret;
 }
 
 void CTxMemPool::UpdateAncestorsOf(bool add, txiter it)
diff --git a/src/txmempool.h b/src/txmempool.h
index d2b7f232b94..3c4882154cd 100644
--- a/src/txmempool.h
+++ b/src/txmempool.h
@@ -304,17 +304,6 @@ private:
      */
     std::set<Txid> m_unbroadcast_txids GUARDED_BY(cs);
 
-
-    /**
-     * Helper function to calculate all in-mempool ancestors of staged_ancestors
-     *
-     * @param[in]   staged_ancestors    Should contain entries in the mempool.
-     *
-     * @return all in-mempool ancestors
-     */
-    setEntries CalculateAncestors(CTxMemPoolEntry::Parents &staged_ancestors)
-            const EXCLUSIVE_LOCKS_REQUIRED(cs);
-
     static TxMempoolInfo GetInfo(CTxMemPool::indexed_transaction_set::const_iterator it)
     {
         return TxMempoolInfo{it->GetSharedTx(), it->GetTime(), it->GetFee(), it->GetTxSize(), it->GetModifiedFee() - it->GetFee()};
@@ -429,18 +418,13 @@ public:
     }
 
     /**
-     * Calculate all in-mempool ancestors of entry.
-     * (these are all calculated including the tx itself)
+     * Calculate all in-mempool ancestors of entry (not including the tx itself)
      *
      * @param[in]   entry               CTxMemPoolEntry of which all in-mempool ancestors are calculated
-     * @param[in]   fSearchForParents   Whether to search a tx's vin for in-mempool parents, or look
-     *                                  up parents from mapLinks. Must be true for entries not in
-     *                                  the mempool
      *
      * @return all in-mempool ancestors
      */
-    setEntries CalculateMemPoolAncestors(const CTxMemPoolEntry& entry,
-                                   bool fSearchForParents = true) const EXCLUSIVE_LOCKS_REQUIRED(cs);
+    setEntries CalculateMemPoolAncestors(const CTxMemPoolEntry& entry) const EXCLUSIVE_LOCKS_REQUIRED(cs);
 
     bool HasDescendants(const Txid& txid) const;
 

From a4458d6c406215dccb31fd35e0968a65a3269670 Mon Sep 17 00:00:00 2001
From: Suhas Daftuar <sdaftuar@gmail.com>
Date: Sun, 14 Apr 2024 19:28:25 -0400
Subject: [PATCH 45/65] Use txgraph to calculate descendants

---
 src/txmempool.cpp | 28 +++-------------------------
 1 file changed, 3 insertions(+), 25 deletions(-)

diff --git a/src/txmempool.cpp b/src/txmempool.cpp
index 2b8bec25498..8ba41e9403e 100644
--- a/src/txmempool.cpp
+++ b/src/txmempool.cpp
@@ -323,33 +323,11 @@ void CTxMemPool::removeUnchecked(txiter it, MemPoolRemovalReason reason)
     nTransactionsUpdated++;
 }
 
-// Calculates descendants of entry that are not already in setDescendants, and adds to
-// setDescendants. Assumes entryit is already a tx in the mempool and CTxMemPoolEntry::m_children
-// is correct for tx and all descendants.
-// Also assumes that if an entry is in setDescendants already, then all
-// in-mempool descendants of it are already in setDescendants as well, so that we
-// can save time by not iterating over those entries.
+// Calculates descendants of given entry and adds to setDescendants.
 void CTxMemPool::CalculateDescendants(txiter entryit, setEntries& setDescendants) const
 {
-    setEntries stage;
-    if (setDescendants.count(entryit) == 0) {
-        stage.insert(entryit);
-    }
-    // Traverse down the children of entry, only adding children that are not
-    // accounted for in setDescendants already (because those children have either
-    // already been walked, or will be walked in this iteration).
-    while (!stage.empty()) {
-        txiter it = *stage.begin();
-        setDescendants.insert(it);
-        stage.erase(it);
-
-        const CTxMemPoolEntry::Children& children = it->GetMemPoolChildrenConst();
-        for (const CTxMemPoolEntry& child : children) {
-            txiter childiter = mapTx.iterator_to(child);
-            if (!setDescendants.count(childiter)) {
-                stage.insert(childiter);
-            }
-        }
+    for (auto tx : m_txgraph->GetDescendants(*entryit, TxGraph::Level::MAIN)) {
+        setDescendants.insert(mapTx.iterator_to(static_cast<const CTxMemPoolEntry&>(*tx)));
     }
 }
 

From 5560913e51af036b5e6907e08cd07488617b12f7 Mon Sep 17 00:00:00 2001
From: Suhas Daftuar <sdaftuar@chaincode.com>
Date: Thu, 23 Jan 2025 15:49:00 -0500
Subject: [PATCH 46/65] Rework truc_policy to use descendants, not children

---
 src/policy/truc_policy.cpp | 15 +++++++++------
 1 file changed, 9 insertions(+), 6 deletions(-)

diff --git a/src/policy/truc_policy.cpp b/src/policy/truc_policy.cpp
index 96fbebb7220..853ccd58355 100644
--- a/src/policy/truc_policy.cpp
+++ b/src/policy/truc_policy.cpp
@@ -166,6 +166,7 @@ std::optional<std::pair<std::string, CTransactionRef>> SingleTRUCChecks(const CT
                                           const std::set<Txid>& direct_conflicts,
                                           int64_t vsize)
 {
+    LOCK(pool.cs);
     // Check TRUC and non-TRUC inheritance.
     for (const auto& entry : mempool_ancestors) {
         if (ptx->version != TRUC_VERSION && entry->GetTx().version == TRUC_VERSION) {
@@ -215,13 +216,15 @@ std::optional<std::pair<std::string, CTransactionRef>> SingleTRUCChecks(const CT
         // If there are any ancestors, this is the only child allowed. The parent cannot have any
         // other descendants. We handle the possibility of multiple children as that case is
         // possible through a reorg.
-        const auto& children = parent_entry->GetMemPoolChildrenConst();
+        CTxMemPool::setEntries descendants;
+        pool.CalculateDescendants(parent_entry, descendants);
+        descendants.erase(parent_entry);
         // Don't double-count a transaction that is going to be replaced. This logic assumes that
         // any descendant of the TRUC transaction is a direct child, which makes sense because a
         // TRUC transaction can only have 1 descendant.
-        const bool child_will_be_replaced = !children.empty() &&
-            std::any_of(children.cbegin(), children.cend(),
-                [&direct_conflicts](const CTxMemPoolEntry& child){return direct_conflicts.count(child.GetTx().GetHash()) > 0;});
+        const bool child_will_be_replaced = !descendants.empty() &&
+            std::any_of(descendants.cbegin(), descendants.cend(),
+                [&direct_conflicts](const CTxMemPool::txiter& child){return direct_conflicts.count(child->GetTx().GetHash()) > 0;});
         if (pool.GetDescendantCount(parent_entry) + 1 > TRUC_DESCENDANT_LIMIT && !child_will_be_replaced) {
             // Allow sibling eviction for TRUC transaction: if another child already exists, even if
             // we don't conflict inputs with it, consider evicting it under RBF rules. We rely on TRUC rules
@@ -229,14 +232,14 @@ std::optional<std::pair<std::string, CTransactionRef>> SingleTRUCChecks(const CT
             // which descendant to evict. Skip if this isn't true, e.g. if the transaction has
             // multiple children or the sibling also has descendants due to a reorg.
             const bool consider_sibling_eviction{pool.GetDescendantCount(parent_entry) == 2 &&
-                pool.GetAncestorCount(children.begin()->get()) == 2};
+                pool.GetAncestorCount(**descendants.begin()) == 2};
 
             // Return the sibling if its eviction can be considered. Provide the "descendant count
             // limit" string either way, as the caller may decide not to do sibling eviction.
             return std::make_pair(strprintf("tx %u (wtxid=%s) would exceed descendant count limit",
                                             parent_entry->GetSharedTx()->GetHash().ToString(),
                                             parent_entry->GetSharedTx()->GetWitnessHash().ToString()),
-                                  consider_sibling_eviction ?  children.begin()->get().GetSharedTx() : nullptr);
+                                  consider_sibling_eviction ? (*descendants.begin())->GetSharedTx() : nullptr);
         }
     }
     return std::nullopt;

From 19b8479868e5c854d9268e3647b9488f9b23af0f Mon Sep 17 00:00:00 2001
From: Suhas Daftuar <sdaftuar@gmail.com>
Date: Tue, 16 Apr 2024 11:02:26 -0400
Subject: [PATCH 47/65] Make getting parents/children a function of the
 mempool, not a mempool entry

---
 src/rpc/mempool.cpp            |  2 +-
 src/test/fuzz/package_eval.cpp |  2 +-
 src/test/util/txmempool.cpp    |  6 +++---
 src/txmempool.cpp              | 32 ++++++++++++++++++++++++++++++++
 src/txmempool.h                |  2 ++
 5 files changed, 39 insertions(+), 5 deletions(-)

diff --git a/src/rpc/mempool.cpp b/src/rpc/mempool.cpp
index 7a016335926..f07f06f88f4 100644
--- a/src/rpc/mempool.cpp
+++ b/src/rpc/mempool.cpp
@@ -327,7 +327,7 @@ static void entryToJSON(const CTxMemPool& pool, UniValue& info, const CTxMemPool
     info.pushKV("depends", std::move(depends));
 
     UniValue spent(UniValue::VARR);
-    for (const CTxMemPoolEntry& child : e.GetMemPoolChildrenConst()) {
+    for (const CTxMemPoolEntry& child : pool.GetChildren(e)) {
         spent.push_back(child.GetTx().GetHash().ToString());
     }
 
diff --git a/src/test/fuzz/package_eval.cpp b/src/test/fuzz/package_eval.cpp
index 50f4c416d79..3f1eeeb3dd7 100644
--- a/src/test/fuzz/package_eval.cpp
+++ b/src/test/fuzz/package_eval.cpp
@@ -174,7 +174,7 @@ std::optional<COutPoint> GetChildEvictingPrevout(const CTxMemPool& tx_pool)
         const auto& entry = *Assert(tx_pool.GetEntry(tx_info.tx->GetHash()));
         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();
+            const auto& children = tx_pool.GetChildren(entry);
             if (!children.empty()) {
                 Assert(children.size() == 1);
                 // Find an input that doesn't spend from parent's txid
diff --git a/src/test/util/txmempool.cpp b/src/test/util/txmempool.cpp
index ffa21a41889..e85c496d01b 100644
--- a/src/test/util/txmempool.cpp
+++ b/src/test/util/txmempool.cpp
@@ -157,7 +157,7 @@ void CheckMempoolEphemeralInvariants(const CTxMemPool& tx_pool)
         Assert(entry.GetFee() == 0 && entry.GetModifiedFee() == 0);
 
         // Transaction has single dust; make sure it's swept or will not be mined
-        const auto& children = entry.GetMemPoolChildrenConst();
+        const auto& children = tx_pool.GetChildren(entry);
 
         // Multiple children should never happen as non-dust-spending child
         // can get mined as package
@@ -199,12 +199,12 @@ void CheckMempoolTRUCInvariants(const CTxMemPool& tx_pool)
             if (anc_count > 1) {
                 Assert(entry.GetTxSize() <= TRUC_CHILD_MAX_VSIZE);
                 // All TRUC transactions must only have TRUC unconfirmed parents.
-                const auto& parents = entry.GetMemPoolParentsConst();
+                const auto& parents = tx_pool.GetParents(entry);
                 Assert(parents.begin()->get().GetSharedTx()->version == TRUC_VERSION);
             }
         } else if (anc_count > 1) {
             // All non-TRUC transactions must only have non-TRUC unconfirmed parents.
-            for (const auto& parent : entry.GetMemPoolParentsConst()) {
+            for (const auto& parent : tx_pool.GetParents(entry)) {
                 Assert(parent.get().GetSharedTx()->version != TRUC_VERSION);
             }
         }
diff --git a/src/txmempool.cpp b/src/txmempool.cpp
index 8ba41e9403e..fb835b1f3ad 100644
--- a/src/txmempool.cpp
+++ b/src/txmempool.cpp
@@ -54,6 +54,38 @@ bool TestLockPointValidity(CChain& active_chain, const LockPoints& lp)
     return true;
 }
 
+std::vector<CTxMemPoolEntry::CTxMemPoolEntryRef> CTxMemPool::GetChildren(const CTxMemPoolEntry& entry) const
+{
+    LOCK(cs);
+    std::vector<CTxMemPoolEntry::CTxMemPoolEntryRef> ret;
+    setEntries children;
+    auto iter = mapNextTx.lower_bound(COutPoint(entry.GetTx().GetHash(), 0));
+    for (; iter != mapNextTx.end() && iter->first->hash == entry.GetTx().GetHash(); ++iter) {
+        children.insert(iter->second);
+    }
+    for (const auto& child : children) {
+        ret.emplace_back(*child);
+    }
+    return ret;
+}
+
+std::vector<CTxMemPoolEntry::CTxMemPoolEntryRef> CTxMemPool::GetParents(const CTxMemPoolEntry& entry) const
+{
+    LOCK(cs);
+    std::vector<CTxMemPoolEntry::CTxMemPoolEntryRef> ret;
+    std::set<Txid> inputs;
+    for (const auto& txin : entry.GetTx().vin) {
+        inputs.insert(txin.prevout.hash);
+    }
+    for (const auto& hash : inputs) {
+        std::optional<txiter> piter = GetIter(hash);
+        if (piter) {
+            ret.emplace_back(**piter);
+        }
+    }
+    return ret;
+}
+
 void CTxMemPool::UpdateTransactionsFromBlock(const std::vector<Txid>& vHashesToUpdate)
 {
     AssertLockHeld(cs);
diff --git a/src/txmempool.h b/src/txmempool.h
index 3c4882154cd..addf3e137bd 100644
--- a/src/txmempool.h
+++ b/src/txmempool.h
@@ -289,6 +289,8 @@ public:
     int64_t GetDescendantCount(txiter it) const { LOCK(cs); return m_txgraph->GetDescendants(*it, TxGraph::Level::MAIN).size(); }
     int64_t GetDescendantCount(const CTxMemPoolEntry &e) const { LOCK(cs); return m_txgraph->GetDescendants(e, TxGraph::Level::MAIN).size(); }
     int64_t GetAncestorCount(const CTxMemPoolEntry &e) const { LOCK(cs); return m_txgraph->GetAncestors(e, TxGraph::Level::MAIN).size(); }
+    std::vector<CTxMemPoolEntry::CTxMemPoolEntryRef> GetChildren(const CTxMemPoolEntry &entry) const;
+    std::vector<CTxMemPoolEntry::CTxMemPoolEntryRef> GetParents(const CTxMemPoolEntry &entry) const;
 
 private:
     typedef std::map<txiter, setEntries, CompareIteratorByHash> cacheMap;

From 3a646ec4626441c8c2946598f94199a65d9646d6 Mon Sep 17 00:00:00 2001
From: Suhas Daftuar <sdaftuar@chaincode.com>
Date: Sun, 21 Sep 2025 12:52:05 -0400
Subject: [PATCH 48/65] Rework RBF and TRUC validation

Calculating mempool ancestors for a new transaction should not be done until
after cluster size limits have been enforced, to limit CPU DoS potential.

Achieve this by reworking TRUC and RBF validation logic:

- TRUC policy enforcement is now done using only mempool parents of
  new transactions, not all mempool ancestors (note that it's fine to calculate
  ancestors of in-mempool transactions, if the number of such calls is
  reasonably bounded).
- RBF replacement checks are performed earlier (which allows for checking
  cluster size limits earlier, because cluster size checks cannot happen until
  after all conflicts are staged for removal).
- Verifying that a new transaction doesn't conflict with an ancestor now
  happens later, in AcceptSingleTransaction() rather than in PreChecks(). This
  means that the test is not performed at all in AcceptMultipleTransactions(),
  but in package acceptance we already disallow RBF in situations where a
  package transaction has in-mempool parents.

Also to ensure that all RBF validation logic is applied in both the single
transaction and multiple transaction cases, remove the optimization that skips
the PackageMempoolChecks() in the case of a single transaction being validated
in AcceptMultipleTransactions().
---
 src/policy/truc_policy.cpp      | 57 ++++++++++++-------
 src/policy/truc_policy.h        |  6 +-
 src/test/txvalidation_tests.cpp | 97 ++++++++++++++++-----------------
 src/txmempool.cpp               |  9 ++-
 src/txmempool.h                 |  3 +-
 src/validation.cpp              | 76 ++++++++++++++------------
 6 files changed, 137 insertions(+), 111 deletions(-)

diff --git a/src/policy/truc_policy.cpp b/src/policy/truc_policy.cpp
index 853ccd58355..c5ba866a5da 100644
--- a/src/policy/truc_policy.cpp
+++ b/src/policy/truc_policy.cpp
@@ -57,7 +57,7 @@ struct ParentInfo {
 
 std::optional<std::string> PackageTRUCChecks(const CTxMemPool& pool, const CTransactionRef& ptx, int64_t vsize,
                                            const Package& package,
-                                           const CTxMemPool::setEntries& mempool_ancestors)
+                                           const std::vector<CTxMemPoolEntry::CTxMemPoolEntryRef>& mempool_parents)
 {
     // This function is specialized for these limits, and must be reimplemented if they ever change.
     static_assert(TRUC_ANCESTOR_LIMIT == 2);
@@ -65,7 +65,7 @@ std::optional<std::string> PackageTRUCChecks(const CTxMemPool& pool, const CTran
 
     const auto in_package_parents{FindInPackageParents(package, ptx)};
 
-    // Now we have all ancestors, so we can start checking TRUC rules.
+    // Now we have all parents, so we can start checking TRUC rules.
     if (ptx->version == TRUC_VERSION) {
         // SingleTRUCChecks should have checked this already.
         if (!Assume(vsize <= TRUC_MAX_VSIZE)) {
@@ -73,12 +73,19 @@ std::optional<std::string> PackageTRUCChecks(const CTxMemPool& pool, const CTran
                              ptx->GetHash().ToString(), ptx->GetWitnessHash().ToString(), vsize, TRUC_MAX_VSIZE);
         }
 
-        if (mempool_ancestors.size() + in_package_parents.size() + 1 > TRUC_ANCESTOR_LIMIT) {
+        if (mempool_parents.size() + in_package_parents.size() + 1 > TRUC_ANCESTOR_LIMIT) {
             return strprintf("tx %s (wtxid=%s) would have too many ancestors",
                              ptx->GetHash().ToString(), ptx->GetWitnessHash().ToString());
         }
 
-        const bool has_parent{mempool_ancestors.size() + in_package_parents.size() > 0};
+        if (mempool_parents.size()) {
+            if (pool.GetAncestorCount(mempool_parents[0]) + in_package_parents.size() + 1 > TRUC_ANCESTOR_LIMIT) {
+                return strprintf("tx %s (wtxid=%s) would have too many ancestors",
+                                 ptx->GetHash().ToString(), ptx->GetWitnessHash().ToString());
+            }
+        }
+
+        const bool has_parent{mempool_parents.size() + in_package_parents.size() > 0};
         if (has_parent) {
             // A TRUC child cannot be too large.
             if (vsize > TRUC_CHILD_MAX_VSIZE) {
@@ -89,12 +96,12 @@ std::optional<std::string> PackageTRUCChecks(const CTxMemPool& pool, const CTran
 
             // Exactly 1 parent exists, either in mempool or package. Find it.
             const auto parent_info = [&] {
-                if (mempool_ancestors.size() > 0) {
-                    auto& mempool_parent = *mempool_ancestors.begin();
+                if (mempool_parents.size() > 0) {
+                    const auto& mempool_parent = &mempool_parents[0].get();
                     return ParentInfo{mempool_parent->GetTx().GetHash(),
                                       mempool_parent->GetTx().GetWitnessHash(),
                                       mempool_parent->GetTx().version,
-                                      /*has_mempool_descendant=*/pool.GetDescendantCount(mempool_parent) > 1};
+                                      /*has_mempool_descendant=*/pool.GetDescendantCount(*mempool_parent) > 1};
                 } else {
                     auto& parent_index = in_package_parents.front();
                     auto& package_parent = package.at(parent_index);
@@ -141,11 +148,11 @@ std::optional<std::string> PackageTRUCChecks(const CTxMemPool& pool, const CTran
         }
     } else {
         // Non-TRUC transactions cannot have TRUC parents.
-        for (auto it : mempool_ancestors) {
-            if (it->GetTx().version == TRUC_VERSION) {
+        for (auto it : mempool_parents) {
+            if (it.get().GetTx().version == TRUC_VERSION) {
                 return strprintf("non-version=3 tx %s (wtxid=%s) cannot spend from version=3 tx %s (wtxid=%s)",
                                  ptx->GetHash().ToString(), ptx->GetWitnessHash().ToString(),
-                                 it->GetSharedTx()->GetHash().ToString(), it->GetSharedTx()->GetWitnessHash().ToString());
+                                 it.get().GetSharedTx()->GetHash().ToString(), it.get().GetSharedTx()->GetWitnessHash().ToString());
             }
         }
         for (const auto& index: in_package_parents) {
@@ -162,13 +169,14 @@ std::optional<std::string> PackageTRUCChecks(const CTxMemPool& pool, const CTran
 }
 
 std::optional<std::pair<std::string, CTransactionRef>> SingleTRUCChecks(const CTxMemPool& pool, const CTransactionRef& ptx,
-                                          const CTxMemPool::setEntries& mempool_ancestors,
+                                          const std::vector<CTxMemPoolEntry::CTxMemPoolEntryRef>& mempool_parents,
                                           const std::set<Txid>& direct_conflicts,
                                           int64_t vsize)
 {
     LOCK(pool.cs);
     // Check TRUC and non-TRUC inheritance.
-    for (const auto& entry : mempool_ancestors) {
+    for (const auto& entry_ref : mempool_parents) {
+        const auto& entry = &entry_ref.get();
         if (ptx->version != TRUC_VERSION && entry->GetTx().version == TRUC_VERSION) {
             return std::make_pair(strprintf("non-version=3 tx %s (wtxid=%s) cannot spend from version=3 tx %s (wtxid=%s)",
                              ptx->GetHash().ToString(), ptx->GetWitnessHash().ToString(),
@@ -196,14 +204,21 @@ std::optional<std::pair<std::string, CTransactionRef>> SingleTRUCChecks(const CT
     }
 
     // Check that TRUC_ANCESTOR_LIMIT would not be violated.
-    if (mempool_ancestors.size() + 1 > TRUC_ANCESTOR_LIMIT) {
+    if (mempool_parents.size() + 1 > TRUC_ANCESTOR_LIMIT) {
         return std::make_pair(strprintf("tx %s (wtxid=%s) would have too many ancestors",
                          ptx->GetHash().ToString(), ptx->GetWitnessHash().ToString()),
             nullptr);
     }
 
     // Remaining checks only pertain to transactions with unconfirmed ancestors.
-    if (mempool_ancestors.size() > 0) {
+    if (mempool_parents.size() > 0) {
+        // Ensure that the in-mempool parent doesn't have any additional
+        // ancestors, as that would also be a violation.
+        if (pool.GetAncestorCount(mempool_parents[0]) + 1 > TRUC_ANCESTOR_LIMIT) {
+            return std::make_pair(strprintf("tx %s (wtxid=%s) would have too many ancestors",
+                             ptx->GetHash().ToString(), ptx->GetWitnessHash().ToString()),
+                nullptr);
+        }
         // If this transaction spends TRUC parents, it cannot be too large.
         if (vsize > TRUC_CHILD_MAX_VSIZE) {
             return std::make_pair(strprintf("version=3 child tx %s (wtxid=%s) is too big: %u > %u virtual bytes",
@@ -211,14 +226,14 @@ std::optional<std::pair<std::string, CTransactionRef>> SingleTRUCChecks(const CT
                 nullptr);
         }
 
-        // Check the descendant counts of in-mempool ancestors.
-        const auto& parent_entry = *mempool_ancestors.begin();
-        // If there are any ancestors, this is the only child allowed. The parent cannot have any
+        // Check the descendant counts of in-mempool parents.
+        const auto& parent_entry = mempool_parents[0].get();
+        // If there are any parents, this is the only child allowed. The parent cannot have any
         // other descendants. We handle the possibility of multiple children as that case is
         // possible through a reorg.
         CTxMemPool::setEntries descendants;
-        pool.CalculateDescendants(parent_entry, descendants);
-        descendants.erase(parent_entry);
+        auto parent_it = pool.CalculateDescendants(parent_entry, descendants);
+        descendants.erase(parent_it);
         // Don't double-count a transaction that is going to be replaced. This logic assumes that
         // any descendant of the TRUC transaction is a direct child, which makes sense because a
         // TRUC transaction can only have 1 descendant.
@@ -237,8 +252,8 @@ std::optional<std::pair<std::string, CTransactionRef>> SingleTRUCChecks(const CT
             // Return the sibling if its eviction can be considered. Provide the "descendant count
             // limit" string either way, as the caller may decide not to do sibling eviction.
             return std::make_pair(strprintf("tx %u (wtxid=%s) would exceed descendant count limit",
-                                            parent_entry->GetSharedTx()->GetHash().ToString(),
-                                            parent_entry->GetSharedTx()->GetWitnessHash().ToString()),
+                                            parent_entry.GetSharedTx()->GetHash().ToString(),
+                                            parent_entry.GetSharedTx()->GetWitnessHash().ToString()),
                                   consider_sibling_eviction ? (*descendants.begin())->GetSharedTx() : nullptr);
         }
     }
diff --git a/src/policy/truc_policy.h b/src/policy/truc_policy.h
index abe5295876d..0ffd07511db 100644
--- a/src/policy/truc_policy.h
+++ b/src/policy/truc_policy.h
@@ -50,7 +50,7 @@ static_assert(TRUC_MAX_VSIZE + TRUC_CHILD_MAX_VSIZE <= DEFAULT_DESCENDANT_SIZE_L
  *
  *
  * @param[in]   pool                    A reference to the mempool.
- * @param[in]   mempool_ancestors       The in-mempool ancestors of ptx.
+ * @param[in]   mempool_parents         The in-mempool ancestors of ptx.
  * @param[in]   direct_conflicts        In-mempool transactions this tx conflicts with. These conflicts
  *                                      are used to more accurately calculate the resulting descendant
  *                                      count of in-mempool ancestors.
@@ -65,7 +65,7 @@ static_assert(TRUC_MAX_VSIZE + TRUC_CHILD_MAX_VSIZE <= DEFAULT_DESCENDANT_SIZE_L
  *   applicable.
  */
 std::optional<std::pair<std::string, CTransactionRef>> SingleTRUCChecks(const CTxMemPool& pool, const CTransactionRef& ptx,
-                                          const CTxMemPool::setEntries& mempool_ancestors,
+                                          const std::vector<CTxMemPoolEntry::CTxMemPoolEntryRef>& mempool_parents,
                                           const std::set<Txid>& direct_conflicts,
                                           int64_t vsize);
 
@@ -92,6 +92,6 @@ std::optional<std::pair<std::string, CTransactionRef>> SingleTRUCChecks(const CT
  * */
 std::optional<std::string> PackageTRUCChecks(const CTxMemPool& pool, const CTransactionRef& ptx, int64_t vsize,
                                            const Package& package,
-                                           const CTxMemPool::setEntries& mempool_ancestors);
+                                           const std::vector<CTxMemPoolEntry::CTxMemPoolEntryRef>& mempool_parents);
 
 #endif // BITCOIN_POLICY_TRUC_POLICY_H
diff --git a/src/test/txvalidation_tests.cpp b/src/test/txvalidation_tests.cpp
index c0c9cc9c586..3271838e788 100644
--- a/src/test/txvalidation_tests.cpp
+++ b/src/test/txvalidation_tests.cpp
@@ -115,7 +115,6 @@ BOOST_FIXTURE_TEST_CASE(ephemeral_tests, RegTestingSetup)
     CTxMemPool& pool = *Assert(m_node.mempool);
     LOCK2(cs_main, pool.cs);
     TestMemPoolEntryHelper entry;
-    CTxMemPool::setEntries empty_ancestors;
 
     TxValidationState child_state;
     Wtxid child_wtxid;
@@ -279,7 +278,7 @@ BOOST_FIXTURE_TEST_CASE(version3_tests, RegTestingSetup)
     LOCK2(cs_main, pool.cs);
     TestMemPoolEntryHelper entry;
     std::set<Txid> empty_conflicts_set;
-    CTxMemPool::setEntries empty_ancestors;
+    std::vector<CTxMemPoolEntry::CTxMemPoolEntryRef> empty_parents;
 
     auto mempool_tx_v3 = make_tx(random_outpoints(1), /*version=*/3);
     AddToMempool(pool, entry.FromTx(mempool_tx_v3));
@@ -292,33 +291,32 @@ BOOST_FIXTURE_TEST_CASE(version3_tests, RegTestingSetup)
         //      ^
         // tx_v2_from_v3
         auto tx_v2_from_v3 = make_tx({COutPoint{mempool_tx_v3->GetHash(), 0}}, /*version=*/2);
-        auto ancestors_v2_from_v3{pool.CalculateMemPoolAncestors(entry.FromTx(tx_v2_from_v3))};
+        auto parents_v2_from_v3 = pool.GetParents(entry.FromTx(tx_v2_from_v3));
         const auto expected_error_str{strprintf("non-version=3 tx %s (wtxid=%s) cannot spend from version=3 tx %s (wtxid=%s)",
             tx_v2_from_v3->GetHash().ToString(), tx_v2_from_v3->GetWitnessHash().ToString(),
             mempool_tx_v3->GetHash().ToString(), mempool_tx_v3->GetWitnessHash().ToString())};
-        auto result_v2_from_v3{SingleTRUCChecks(pool, tx_v2_from_v3, ancestors_v2_from_v3, empty_conflicts_set, GetVirtualTransactionSize(*tx_v2_from_v3))};
+        auto result_v2_from_v3{SingleTRUCChecks(pool, tx_v2_from_v3, parents_v2_from_v3, empty_conflicts_set, GetVirtualTransactionSize(*tx_v2_from_v3))};
         BOOST_CHECK_EQUAL(result_v2_from_v3->first, expected_error_str);
         BOOST_CHECK_EQUAL(result_v2_from_v3->second, nullptr);
 
         Package package_v3_v2{mempool_tx_v3, tx_v2_from_v3};
-        BOOST_CHECK_EQUAL(*PackageTRUCChecks(pool, tx_v2_from_v3, GetVirtualTransactionSize(*tx_v2_from_v3), package_v3_v2, empty_ancestors), expected_error_str);
-        CTxMemPool::setEntries entries_mempool_v3{pool.GetIter(mempool_tx_v3->GetHash()).value()};
-        BOOST_CHECK_EQUAL(*PackageTRUCChecks(pool, tx_v2_from_v3, GetVirtualTransactionSize(*tx_v2_from_v3), {tx_v2_from_v3}, entries_mempool_v3), expected_error_str);
+        BOOST_CHECK_EQUAL(*PackageTRUCChecks(pool, tx_v2_from_v3, GetVirtualTransactionSize(*tx_v2_from_v3), package_v3_v2, empty_parents), expected_error_str);
+        BOOST_CHECK_EQUAL(*PackageTRUCChecks(pool, tx_v2_from_v3, GetVirtualTransactionSize(*tx_v2_from_v3), {tx_v2_from_v3}, parents_v2_from_v3), expected_error_str);
 
         // mempool_tx_v3  mempool_tx_v2
         //            ^    ^
         //    tx_v2_from_v2_and_v3
         auto tx_v2_from_v2_and_v3 = make_tx({COutPoint{mempool_tx_v3->GetHash(), 0}, COutPoint{mempool_tx_v2->GetHash(), 0}}, /*version=*/2);
-        auto ancestors_v2_from_both{pool.CalculateMemPoolAncestors(entry.FromTx(tx_v2_from_v2_and_v3))};
+        auto parents_2_from_both{pool.GetParents(entry.FromTx(tx_v2_from_v2_and_v3))};
         const auto expected_error_str_2{strprintf("non-version=3 tx %s (wtxid=%s) cannot spend from version=3 tx %s (wtxid=%s)",
             tx_v2_from_v2_and_v3->GetHash().ToString(), tx_v2_from_v2_and_v3->GetWitnessHash().ToString(),
             mempool_tx_v3->GetHash().ToString(), mempool_tx_v3->GetWitnessHash().ToString())};
-        auto result_v2_from_both{SingleTRUCChecks(pool, tx_v2_from_v2_and_v3, ancestors_v2_from_both, empty_conflicts_set, GetVirtualTransactionSize(*tx_v2_from_v2_and_v3))};
+        auto result_v2_from_both{SingleTRUCChecks(pool, tx_v2_from_v2_and_v3, parents_2_from_both, empty_conflicts_set, GetVirtualTransactionSize(*tx_v2_from_v2_and_v3))};
         BOOST_CHECK_EQUAL(result_v2_from_both->first, expected_error_str_2);
         BOOST_CHECK_EQUAL(result_v2_from_both->second, nullptr);
 
         Package package_v3_v2_v2{mempool_tx_v3, mempool_tx_v2, tx_v2_from_v2_and_v3};
-        BOOST_CHECK_EQUAL(*PackageTRUCChecks(pool, tx_v2_from_v2_and_v3, GetVirtualTransactionSize(*tx_v2_from_v2_and_v3), package_v3_v2_v2, empty_ancestors), expected_error_str_2);
+        BOOST_CHECK_EQUAL(*PackageTRUCChecks(pool, tx_v2_from_v2_and_v3, GetVirtualTransactionSize(*tx_v2_from_v2_and_v3), package_v3_v2_v2, empty_parents), expected_error_str_2);
     }
 
     // TRUC cannot spend from an unconfirmed non-TRUC transaction.
@@ -327,28 +325,27 @@ BOOST_FIXTURE_TEST_CASE(version3_tests, RegTestingSetup)
         //      ^
         // tx_v3_from_v2
         auto tx_v3_from_v2 = make_tx({COutPoint{mempool_tx_v2->GetHash(), 0}}, /*version=*/3);
-        auto ancestors_v3_from_v2{pool.CalculateMemPoolAncestors(entry.FromTx(tx_v3_from_v2))};
+        auto parents_v3_from_v2{pool.GetParents(entry.FromTx(tx_v3_from_v2))};
         const auto expected_error_str{strprintf("version=3 tx %s (wtxid=%s) cannot spend from non-version=3 tx %s (wtxid=%s)",
             tx_v3_from_v2->GetHash().ToString(), tx_v3_from_v2->GetWitnessHash().ToString(),
             mempool_tx_v2->GetHash().ToString(), mempool_tx_v2->GetWitnessHash().ToString())};
-        auto result_v3_from_v2{SingleTRUCChecks(pool, tx_v3_from_v2, ancestors_v3_from_v2,  empty_conflicts_set, GetVirtualTransactionSize(*tx_v3_from_v2))};
+        auto result_v3_from_v2{SingleTRUCChecks(pool, tx_v3_from_v2, parents_v3_from_v2,  empty_conflicts_set, GetVirtualTransactionSize(*tx_v3_from_v2))};
         BOOST_CHECK_EQUAL(result_v3_from_v2->first, expected_error_str);
         BOOST_CHECK_EQUAL(result_v3_from_v2->second, nullptr);
 
         Package package_v2_v3{mempool_tx_v2, tx_v3_from_v2};
-        BOOST_CHECK_EQUAL(*PackageTRUCChecks(pool, tx_v3_from_v2, GetVirtualTransactionSize(*tx_v3_from_v2), package_v2_v3, empty_ancestors), expected_error_str);
-        CTxMemPool::setEntries entries_mempool_v2{pool.GetIter(mempool_tx_v2->GetHash()).value()};
-        BOOST_CHECK_EQUAL(*PackageTRUCChecks(pool, tx_v3_from_v2, GetVirtualTransactionSize(*tx_v3_from_v2), {tx_v3_from_v2}, entries_mempool_v2), expected_error_str);
+        BOOST_CHECK_EQUAL(*PackageTRUCChecks(pool, tx_v3_from_v2, GetVirtualTransactionSize(*tx_v3_from_v2), package_v2_v3, empty_parents), expected_error_str);
+        BOOST_CHECK_EQUAL(*PackageTRUCChecks(pool, tx_v3_from_v2, GetVirtualTransactionSize(*tx_v3_from_v2), {tx_v3_from_v2}, parents_v3_from_v2), expected_error_str);
 
         // mempool_tx_v3  mempool_tx_v2
         //            ^    ^
         //    tx_v3_from_v2_and_v3
         auto tx_v3_from_v2_and_v3 = make_tx({COutPoint{mempool_tx_v3->GetHash(), 0}, COutPoint{mempool_tx_v2->GetHash(), 0}}, /*version=*/3);
-        auto ancestors_v3_from_both{pool.CalculateMemPoolAncestors(entry.FromTx(tx_v3_from_v2_and_v3))};
+        auto parents_v3_from_both{pool.GetParents(entry.FromTx(tx_v3_from_v2_and_v3))};
         const auto expected_error_str_2{strprintf("version=3 tx %s (wtxid=%s) cannot spend from non-version=3 tx %s (wtxid=%s)",
             tx_v3_from_v2_and_v3->GetHash().ToString(), tx_v3_from_v2_and_v3->GetWitnessHash().ToString(),
             mempool_tx_v2->GetHash().ToString(), mempool_tx_v2->GetWitnessHash().ToString())};
-        auto result_v3_from_both{SingleTRUCChecks(pool, tx_v3_from_v2_and_v3, ancestors_v3_from_both, empty_conflicts_set, GetVirtualTransactionSize(*tx_v3_from_v2_and_v3))};
+        auto result_v3_from_both{SingleTRUCChecks(pool, tx_v3_from_v2_and_v3, parents_v3_from_both, empty_conflicts_set, GetVirtualTransactionSize(*tx_v3_from_v2_and_v3))};
         BOOST_CHECK_EQUAL(result_v3_from_both->first, expected_error_str_2);
         BOOST_CHECK_EQUAL(result_v3_from_both->second, nullptr);
 
@@ -356,7 +353,7 @@ BOOST_FIXTURE_TEST_CASE(version3_tests, RegTestingSetup)
         const auto expected_error_str_3{strprintf("tx %s (wtxid=%s) would have too many ancestors",
             tx_v3_from_v2_and_v3->GetHash().ToString(), tx_v3_from_v2_and_v3->GetWitnessHash().ToString())};
         Package package_v3_v2_v3{mempool_tx_v3, mempool_tx_v2, tx_v3_from_v2_and_v3};
-        BOOST_CHECK_EQUAL(*PackageTRUCChecks(pool, tx_v3_from_v2_and_v3, GetVirtualTransactionSize(*tx_v3_from_v2_and_v3), package_v3_v2_v3, empty_ancestors), expected_error_str_3);
+        BOOST_CHECK_EQUAL(*PackageTRUCChecks(pool, tx_v3_from_v2_and_v3, GetVirtualTransactionSize(*tx_v3_from_v2_and_v3), package_v3_v2_v3, empty_parents), expected_error_str_3);
     }
     // V3 from V3 is ok, and non-V3 from non-V3 is ok.
     {
@@ -364,23 +361,23 @@ BOOST_FIXTURE_TEST_CASE(version3_tests, RegTestingSetup)
         //      ^
         // tx_v3_from_v3
         auto tx_v3_from_v3 = make_tx({COutPoint{mempool_tx_v3->GetHash(), 0}}, /*version=*/3);
-        auto ancestors_v3{pool.CalculateMemPoolAncestors(entry.FromTx(tx_v3_from_v3))};
-        BOOST_CHECK(SingleTRUCChecks(pool, tx_v3_from_v3, ancestors_v3, empty_conflicts_set, GetVirtualTransactionSize(*tx_v3_from_v3))
+        auto parents_v3{pool.GetParents(entry.FromTx(tx_v3_from_v3))};
+        BOOST_CHECK(SingleTRUCChecks(pool, tx_v3_from_v3, parents_v3, empty_conflicts_set, GetVirtualTransactionSize(*tx_v3_from_v3))
                     == std::nullopt);
 
         Package package_v3_v3{mempool_tx_v3, tx_v3_from_v3};
-        BOOST_CHECK(PackageTRUCChecks(pool, tx_v3_from_v3, GetVirtualTransactionSize(*tx_v3_from_v3), package_v3_v3, empty_ancestors) == std::nullopt);
+        BOOST_CHECK(PackageTRUCChecks(pool, tx_v3_from_v3, GetVirtualTransactionSize(*tx_v3_from_v3), package_v3_v3, empty_parents) == std::nullopt);
 
         // mempool_tx_v2
         //      ^
         // tx_v2_from_v2
         auto tx_v2_from_v2 = make_tx({COutPoint{mempool_tx_v2->GetHash(), 0}}, /*version=*/2);
-        auto ancestors_v2{pool.CalculateMemPoolAncestors(entry.FromTx(tx_v2_from_v2))};
-        BOOST_CHECK(SingleTRUCChecks(pool, tx_v2_from_v2, ancestors_v2, empty_conflicts_set, GetVirtualTransactionSize(*tx_v2_from_v2))
+        auto parents_v2{pool.GetParents(entry.FromTx(tx_v2_from_v2))};
+        BOOST_CHECK(SingleTRUCChecks(pool, tx_v2_from_v2, parents_v2, empty_conflicts_set, GetVirtualTransactionSize(*tx_v2_from_v2))
                     == std::nullopt);
 
         Package package_v2_v2{mempool_tx_v2, tx_v2_from_v2};
-        BOOST_CHECK(PackageTRUCChecks(pool, tx_v2_from_v2, GetVirtualTransactionSize(*tx_v2_from_v2), package_v2_v2, empty_ancestors) == std::nullopt);
+        BOOST_CHECK(PackageTRUCChecks(pool, tx_v2_from_v2, GetVirtualTransactionSize(*tx_v2_from_v2), package_v2_v2, empty_parents) == std::nullopt);
     }
 
     // Tx spending TRUC cannot have too many mempool ancestors
@@ -398,15 +395,15 @@ BOOST_FIXTURE_TEST_CASE(version3_tests, RegTestingSetup)
         }
         auto tx_v3_multi_parent = make_tx(mempool_outpoints, /*version=*/3);
         package_multi_parents.emplace_back(tx_v3_multi_parent);
-        auto ancestors{pool.CalculateMemPoolAncestors(entry.FromTx(tx_v3_multi_parent))};
-        BOOST_CHECK_EQUAL(ancestors.size(), 3);
+        auto parents{pool.GetParents(entry.FromTx(tx_v3_multi_parent))};
+        BOOST_CHECK_EQUAL(parents.size(), 3);
         const auto expected_error_str{strprintf("tx %s (wtxid=%s) would have too many ancestors",
             tx_v3_multi_parent->GetHash().ToString(), tx_v3_multi_parent->GetWitnessHash().ToString())};
-        auto result{SingleTRUCChecks(pool, tx_v3_multi_parent, ancestors, empty_conflicts_set, GetVirtualTransactionSize(*tx_v3_multi_parent))};
+        auto result{SingleTRUCChecks(pool, tx_v3_multi_parent, parents, empty_conflicts_set, GetVirtualTransactionSize(*tx_v3_multi_parent))};
         BOOST_CHECK_EQUAL(result->first, expected_error_str);
         BOOST_CHECK_EQUAL(result->second, nullptr);
 
-        BOOST_CHECK_EQUAL(*PackageTRUCChecks(pool, tx_v3_multi_parent, GetVirtualTransactionSize(*tx_v3_multi_parent), package_multi_parents, empty_ancestors),
+        BOOST_CHECK_EQUAL(*PackageTRUCChecks(pool, tx_v3_multi_parent, GetVirtualTransactionSize(*tx_v3_multi_parent), package_multi_parents, empty_parents),
                           expected_error_str);
     }
 
@@ -424,16 +421,16 @@ BOOST_FIXTURE_TEST_CASE(version3_tests, RegTestingSetup)
         }
         auto tx_v3_multi_gen = make_tx({last_outpoint}, /*version=*/3);
         package_multi_gen.emplace_back(tx_v3_multi_gen);
-        auto ancestors{pool.CalculateMemPoolAncestors(entry.FromTx(tx_v3_multi_gen))};
+        auto parents{pool.GetParents(entry.FromTx(tx_v3_multi_gen))};
         const auto expected_error_str{strprintf("tx %s (wtxid=%s) would have too many ancestors",
             tx_v3_multi_gen->GetHash().ToString(), tx_v3_multi_gen->GetWitnessHash().ToString())};
-        auto result{SingleTRUCChecks(pool, tx_v3_multi_gen, ancestors, empty_conflicts_set, GetVirtualTransactionSize(*tx_v3_multi_gen))};
+        auto result{SingleTRUCChecks(pool, tx_v3_multi_gen, parents, empty_conflicts_set, GetVirtualTransactionSize(*tx_v3_multi_gen))};
         BOOST_CHECK_EQUAL(result->first, expected_error_str);
         BOOST_CHECK_EQUAL(result->second, nullptr);
 
         // Middle tx is what triggers a failure for the grandchild:
-        BOOST_CHECK_EQUAL(*PackageTRUCChecks(pool, middle_tx, GetVirtualTransactionSize(*middle_tx), package_multi_gen, empty_ancestors), expected_error_str);
-        BOOST_CHECK(PackageTRUCChecks(pool, tx_v3_multi_gen, GetVirtualTransactionSize(*tx_v3_multi_gen), package_multi_gen, empty_ancestors) == std::nullopt);
+        BOOST_CHECK_EQUAL(*PackageTRUCChecks(pool, middle_tx, GetVirtualTransactionSize(*middle_tx), package_multi_gen, empty_parents), expected_error_str);
+        BOOST_CHECK(PackageTRUCChecks(pool, tx_v3_multi_gen, GetVirtualTransactionSize(*tx_v3_multi_gen), package_multi_gen, empty_parents) == std::nullopt);
     }
 
     // Tx spending TRUC cannot be too large in virtual size.
@@ -442,15 +439,15 @@ BOOST_FIXTURE_TEST_CASE(version3_tests, RegTestingSetup)
     {
         auto tx_v3_child_big = make_tx(many_inputs, /*version=*/3);
         const auto vsize{GetVirtualTransactionSize(*tx_v3_child_big)};
-        auto ancestors{pool.CalculateMemPoolAncestors(entry.FromTx(tx_v3_child_big))};
+        auto parents{pool.GetParents(entry.FromTx(tx_v3_child_big))};
         const auto expected_error_str{strprintf("version=3 child tx %s (wtxid=%s) is too big: %u > %u virtual bytes",
             tx_v3_child_big->GetHash().ToString(), tx_v3_child_big->GetWitnessHash().ToString(), vsize, TRUC_CHILD_MAX_VSIZE)};
-        auto result{SingleTRUCChecks(pool, tx_v3_child_big, ancestors, empty_conflicts_set, GetVirtualTransactionSize(*tx_v3_child_big))};
+        auto result{SingleTRUCChecks(pool, tx_v3_child_big, parents, empty_conflicts_set, GetVirtualTransactionSize(*tx_v3_child_big))};
         BOOST_CHECK_EQUAL(result->first, expected_error_str);
         BOOST_CHECK_EQUAL(result->second, nullptr);
 
         Package package_child_big{mempool_tx_v3, tx_v3_child_big};
-        BOOST_CHECK_EQUAL(*PackageTRUCChecks(pool, tx_v3_child_big, GetVirtualTransactionSize(*tx_v3_child_big), package_child_big, empty_ancestors),
+        BOOST_CHECK_EQUAL(*PackageTRUCChecks(pool, tx_v3_child_big, GetVirtualTransactionSize(*tx_v3_child_big), package_child_big, empty_parents),
                           expected_error_str);
     }
 
@@ -477,24 +474,24 @@ BOOST_FIXTURE_TEST_CASE(version3_tests, RegTestingSetup)
         mtx_many_sigops.vout.back().nValue = 10000;
         auto tx_many_sigops{MakeTransactionRef(mtx_many_sigops)};
 
-        auto ancestors{pool.CalculateMemPoolAncestors(entry.FromTx(tx_many_sigops))};
+        auto parents{pool.GetParents(entry.FromTx(tx_many_sigops))};
         // legacy uses fAccurate = false, and the maximum number of multisig keys is used
         const int64_t total_sigops{static_cast<int64_t>(tx_many_sigops->vin.size()) * static_cast<int64_t>(script_multisig.GetSigOpCount(/*fAccurate=*/false))};
         BOOST_CHECK_EQUAL(total_sigops, tx_many_sigops->vin.size() * MAX_PUBKEYS_PER_MULTISIG);
         const int64_t bip141_vsize{GetVirtualTransactionSize(*tx_many_sigops)};
         // Weight limit is not reached...
-        BOOST_CHECK(SingleTRUCChecks(pool, tx_many_sigops, ancestors, empty_conflicts_set, bip141_vsize) == std::nullopt);
+        BOOST_CHECK(SingleTRUCChecks(pool, tx_many_sigops, parents, empty_conflicts_set, bip141_vsize) == std::nullopt);
         // ...but sigop limit is.
         const auto expected_error_str{strprintf("version=3 child tx %s (wtxid=%s) is too big: %u > %u virtual bytes",
             tx_many_sigops->GetHash().ToString(), tx_many_sigops->GetWitnessHash().ToString(),
             total_sigops * DEFAULT_BYTES_PER_SIGOP / WITNESS_SCALE_FACTOR, TRUC_CHILD_MAX_VSIZE)};
-        auto result{SingleTRUCChecks(pool, tx_many_sigops, ancestors, empty_conflicts_set,
+        auto result{SingleTRUCChecks(pool, tx_many_sigops, parents, empty_conflicts_set,
                                         GetVirtualTransactionSize(*tx_many_sigops, /*nSigOpCost=*/total_sigops, /*bytes_per_sigop=*/ DEFAULT_BYTES_PER_SIGOP))};
         BOOST_CHECK_EQUAL(result->first, expected_error_str);
         BOOST_CHECK_EQUAL(result->second, nullptr);
 
         Package package_child_sigops{mempool_tx_v3, tx_many_sigops};
-        BOOST_CHECK_EQUAL(*PackageTRUCChecks(pool, tx_many_sigops, total_sigops * DEFAULT_BYTES_PER_SIGOP / WITNESS_SCALE_FACTOR, package_child_sigops, empty_ancestors),
+        BOOST_CHECK_EQUAL(*PackageTRUCChecks(pool, tx_many_sigops, total_sigops * DEFAULT_BYTES_PER_SIGOP / WITNESS_SCALE_FACTOR, package_child_sigops, empty_parents),
                           expected_error_str);
     }
 
@@ -502,32 +499,32 @@ BOOST_FIXTURE_TEST_CASE(version3_tests, RegTestingSetup)
     auto tx_mempool_v3_child = make_tx({COutPoint{mempool_tx_v3->GetHash(), 0}}, /*version=*/3);
     {
         BOOST_CHECK(GetTransactionWeight(*tx_mempool_v3_child) <= TRUC_CHILD_MAX_VSIZE * WITNESS_SCALE_FACTOR);
-        auto ancestors{pool.CalculateMemPoolAncestors(entry.FromTx(tx_mempool_v3_child))};
-        BOOST_CHECK(SingleTRUCChecks(pool, tx_mempool_v3_child, ancestors, empty_conflicts_set, GetVirtualTransactionSize(*tx_mempool_v3_child)) == std::nullopt);
+        auto parents{pool.GetParents(entry.FromTx(tx_mempool_v3_child))};
+        BOOST_CHECK(SingleTRUCChecks(pool, tx_mempool_v3_child, parents, empty_conflicts_set, GetVirtualTransactionSize(*tx_mempool_v3_child)) == std::nullopt);
         AddToMempool(pool, entry.FromTx(tx_mempool_v3_child));
 
         Package package_v3_1p1c{mempool_tx_v3, tx_mempool_v3_child};
-        BOOST_CHECK(PackageTRUCChecks(pool, tx_mempool_v3_child, GetVirtualTransactionSize(*tx_mempool_v3_child), package_v3_1p1c, empty_ancestors) == std::nullopt);
+        BOOST_CHECK(PackageTRUCChecks(pool, tx_mempool_v3_child, GetVirtualTransactionSize(*tx_mempool_v3_child), package_v3_1p1c, empty_parents) == std::nullopt);
     }
 
     // A TRUC transaction cannot have more than 1 descendant. Sibling is returned when exactly 1 exists.
     {
         auto tx_v3_child2 = make_tx({COutPoint{mempool_tx_v3->GetHash(), 1}}, /*version=*/3);
         // Configuration where parent already has 1 other child in mempool
-        auto ancestors_1sibling{pool.CalculateMemPoolAncestors(entry.FromTx(tx_v3_child2))};
+        auto parents_1sibling{pool.GetParents(entry.FromTx(tx_v3_child2))};
         const auto expected_error_str{strprintf("tx %s (wtxid=%s) would exceed descendant count limit",
             mempool_tx_v3->GetHash().ToString(), mempool_tx_v3->GetWitnessHash().ToString())};
-        auto result_with_sibling_eviction{SingleTRUCChecks(pool, tx_v3_child2, ancestors_1sibling, empty_conflicts_set, GetVirtualTransactionSize(*tx_v3_child2))};
+        auto result_with_sibling_eviction{SingleTRUCChecks(pool, tx_v3_child2, parents_1sibling, empty_conflicts_set, GetVirtualTransactionSize(*tx_v3_child2))};
         BOOST_CHECK_EQUAL(result_with_sibling_eviction->first, expected_error_str);
         // The other mempool child is returned to allow for sibling eviction.
         BOOST_CHECK_EQUAL(result_with_sibling_eviction->second, tx_mempool_v3_child);
 
         // If directly replacing the child, make sure there is no double-counting.
-        BOOST_CHECK(SingleTRUCChecks(pool, tx_v3_child2, ancestors_1sibling, {tx_mempool_v3_child->GetHash()}, GetVirtualTransactionSize(*tx_v3_child2))
+        BOOST_CHECK(SingleTRUCChecks(pool, tx_v3_child2, parents_1sibling, {tx_mempool_v3_child->GetHash()}, GetVirtualTransactionSize(*tx_v3_child2))
                     == std::nullopt);
 
         Package package_v3_1p2c{mempool_tx_v3, tx_mempool_v3_child, tx_v3_child2};
-        BOOST_CHECK_EQUAL(*PackageTRUCChecks(pool, tx_v3_child2, GetVirtualTransactionSize(*tx_v3_child2), package_v3_1p2c, empty_ancestors),
+        BOOST_CHECK_EQUAL(*PackageTRUCChecks(pool, tx_v3_child2, GetVirtualTransactionSize(*tx_v3_child2), package_v3_1p2c, empty_parents),
                           expected_error_str);
 
         // Configuration where parent already has 2 other children in mempool (no sibling eviction allowed). This may happen as the result of a reorg.
@@ -535,9 +532,9 @@ BOOST_FIXTURE_TEST_CASE(version3_tests, RegTestingSetup)
         auto tx_v3_child3 = make_tx({COutPoint{mempool_tx_v3->GetHash(), 24}}, /*version=*/3);
         auto entry_mempool_parent = pool.GetIter(mempool_tx_v3->GetHash()).value();
         BOOST_CHECK_EQUAL(pool.GetDescendantCount(entry_mempool_parent), 3);
-        auto ancestors_2siblings{pool.CalculateMemPoolAncestors(entry.FromTx(tx_v3_child3))};
+        auto parents_2siblings{pool.GetParents(entry.FromTx(tx_v3_child3))};
 
-        auto result_2children{SingleTRUCChecks(pool, tx_v3_child3, ancestors_2siblings, empty_conflicts_set, GetVirtualTransactionSize(*tx_v3_child3))};
+        auto result_2children{SingleTRUCChecks(pool, tx_v3_child3, parents_2siblings, empty_conflicts_set, GetVirtualTransactionSize(*tx_v3_child3))};
         BOOST_CHECK_EQUAL(result_2children->first, expected_error_str);
         // The other mempool child is not returned because sibling eviction is not allowed.
         BOOST_CHECK_EQUAL(result_2children->second, nullptr);
@@ -554,10 +551,10 @@ BOOST_FIXTURE_TEST_CASE(version3_tests, RegTestingSetup)
         AddToMempool(pool, entry.FromTx(tx_mempool_sibling));
         AddToMempool(pool, entry.FromTx(tx_mempool_nibling));
 
-        auto ancestors_3gen{pool.CalculateMemPoolAncestors(entry.FromTx(tx_to_submit))};
+        auto parents_3gen{pool.GetParents(entry.FromTx(tx_to_submit))};
         const auto expected_error_str{strprintf("tx %s (wtxid=%s) would exceed descendant count limit",
             tx_mempool_grandparent->GetHash().ToString(), tx_mempool_grandparent->GetWitnessHash().ToString())};
-        auto result_3gen{SingleTRUCChecks(pool, tx_to_submit, ancestors_3gen, empty_conflicts_set, GetVirtualTransactionSize(*tx_to_submit))};
+        auto result_3gen{SingleTRUCChecks(pool, tx_to_submit, parents_3gen, empty_conflicts_set, GetVirtualTransactionSize(*tx_to_submit))};
         BOOST_CHECK_EQUAL(result_3gen->first, expected_error_str);
         // The other mempool child is not returned because sibling eviction is not allowed.
         BOOST_CHECK_EQUAL(result_3gen->second, nullptr);
diff --git a/src/txmempool.cpp b/src/txmempool.cpp
index fb835b1f3ad..99b7d3ef516 100644
--- a/src/txmempool.cpp
+++ b/src/txmempool.cpp
@@ -358,9 +358,16 @@ void CTxMemPool::removeUnchecked(txiter it, MemPoolRemovalReason reason)
 // Calculates descendants of given entry and adds to setDescendants.
 void CTxMemPool::CalculateDescendants(txiter entryit, setEntries& setDescendants) const
 {
-    for (auto tx : m_txgraph->GetDescendants(*entryit, TxGraph::Level::MAIN)) {
+    (void)CalculateDescendants(*entryit, setDescendants);
+    return;
+}
+
+CTxMemPool::txiter CTxMemPool::CalculateDescendants(const CTxMemPoolEntry& entry, setEntries& setDescendants) const
+{
+    for (auto tx : m_txgraph->GetDescendants(entry, TxGraph::Level::MAIN)) {
         setDescendants.insert(mapTx.iterator_to(static_cast<const CTxMemPoolEntry&>(*tx)));
     }
+    return mapTx.iterator_to(entry);
 }
 
 void CTxMemPool::removeRecursive(const CTransaction &origTx, MemPoolRemovalReason reason)
diff --git a/src/txmempool.h b/src/txmempool.h
index addf3e137bd..437bdf4ebd3 100644
--- a/src/txmempool.h
+++ b/src/txmempool.h
@@ -451,10 +451,11 @@ public:
     util::Result<void> CheckPackageLimits(const Package& package,
                                           int64_t total_vsize) const EXCLUSIVE_LOCKS_REQUIRED(cs);
 
-    /** Populate setDescendants with all in-mempool descendants of hash.
+    /** Populate setDescendants with all in-mempool descendants of given transaction.
      *  Assumes that setDescendants includes all in-mempool descendants of anything
      *  already in it.  */
     void CalculateDescendants(txiter it, setEntries& setDescendants) const EXCLUSIVE_LOCKS_REQUIRED(cs);
+    CTxMemPool::txiter CalculateDescendants(const CTxMemPoolEntry& entry, setEntries& setDescendants) const EXCLUSIVE_LOCKS_REQUIRED(cs);
 
     /** The minimum fee to get into the mempool, which may itself not be enough
      *  for larger-sized transactions.
diff --git a/src/validation.cpp b/src/validation.cpp
index 6a02acd5861..62b629d4b86 100644
--- a/src/validation.cpp
+++ b/src/validation.cpp
@@ -632,8 +632,8 @@ private:
         /** Iterators to mempool entries that this transaction directly conflicts with or may
          * replace via sibling eviction. */
         CTxMemPool::setEntries m_iters_conflicting;
-        /** All mempool ancestors of this transaction. */
-        CTxMemPool::setEntries m_ancestors;
+        /** All mempool parents of this transaction. */
+        std::vector<CTxMemPoolEntry::CTxMemPoolEntryRef> m_parents;
         /* Handle to the tx in the changeset */
         CTxMemPool::ChangeSet::TxHandle m_tx_handle;
         /** Whether RBF-related data structures (m_conflicts, m_iters_conflicting,
@@ -961,18 +961,15 @@ bool MemPoolAccept::PreChecks(ATMPArgs& args, Workspace& ws)
 
     ws.m_iters_conflicting = m_pool.GetIterSet(ws.m_conflicts);
 
-    ws.m_ancestors = m_subpackage.m_changeset->CalculateMemPoolAncestors(ws.m_tx_handle);
+    ws.m_parents = m_pool.GetParents(*ws.m_tx_handle);
 
-    // Even though just checking direct mempool parents for inheritance would be sufficient, we
-    // check using the full ancestor set here because it's more convenient to use what we have
-    // already calculated.
     if (!args.m_bypass_limits) {
-        if (const auto err{SingleTRUCChecks(m_pool, ws.m_ptx, ws.m_ancestors, ws.m_conflicts, ws.m_vsize)}) {
+        // Perform the TRUC checks, using the in-mempool parents.
+        if (const auto err{SingleTRUCChecks(m_pool, ws.m_ptx, ws.m_parents, ws.m_conflicts, ws.m_vsize)}) {
             // Single transaction contexts only.
             if (args.m_allow_sibling_eviction && err->second != nullptr) {
                 // We should only be considering where replacement is considered valid as well.
                 Assume(args.m_allow_replacement);
-
                 // Potential sibling eviction. Add the sibling to our list of mempool conflicts to be
                 // included in RBF checks.
                 ws.m_conflicts.insert(err->second->GetHash());
@@ -991,16 +988,6 @@ bool MemPoolAccept::PreChecks(ATMPArgs& args, Workspace& ws)
         }
     }
 
-    // A transaction that spends outputs that would be replaced by it is invalid. Now
-    // that we have the set of all ancestors we can detect this
-    // pathological case by making sure ws.m_conflicts and ws.m_ancestors don't
-    // intersect.
-    if (const auto err_string{EntriesAndTxidsDisjoint(ws.m_ancestors, ws.m_conflicts, hash)}) {
-        // We classify this as a consensus error because a transaction depending on something it
-        // conflicts with would be inconsistent.
-        return state.Invalid(TxValidationResult::TX_CONSENSUS, "bad-txns-spends-conflicting-tx", *err_string);
-    }
-
     // We want to detect conflicts in any tx in a package to trigger package RBF logic
     m_subpackage.m_rbf |= !ws.m_conflicts.empty();
     return true;
@@ -1086,12 +1073,16 @@ bool MemPoolAccept::PackageMempoolChecks(const std::vector<CTransactionRef>& txn
         return package_state.Invalid(PackageValidationResult::PCKG_POLICY, "package RBF failed: package must be 1-parent-1-child");
     }
 
-    // If the package has in-mempool ancestors, we won't consider a package RBF
+    // If the package has in-mempool parents, we won't consider a package RBF
     // since it would result in a cluster larger than 2.
     // N.B. To relax this constraint we will need to revisit how CCoinsViewMemPool::PackageAddTransaction
     // is being used inside AcceptMultipleTransactions to track available inputs while processing a package.
+    // Specifically we would need to check that the ancestors of the new
+    // transactions don't intersect with the set of transactions to be removed
+    // due to RBF, which is not checked at all in the package acceptance
+    // context.
     for (const auto& ws : workspaces) {
-        if (!ws.m_ancestors.empty()) {
+        if (!ws.m_parents.empty()) {
             return package_state.Invalid(PackageValidationResult::PCKG_POLICY, "package RBF failed: new transaction cannot have mempool ancestors");
         }
     }
@@ -1115,7 +1106,6 @@ bool MemPoolAccept::PackageMempoolChecks(const std::vector<CTransactionRef>& txn
                                      "package RBF failed: too many potential replacements", *err_string);
     }
 
-
     for (CTxMemPool::txiter it : all_conflicts) {
         m_subpackage.m_changeset->StageRemoval(it);
         m_subpackage.m_conflicting_fees += it->GetModifiedFee();
@@ -1361,15 +1351,6 @@ MempoolAcceptResult MemPoolAccept::AcceptSingleTransactionInternal(const CTransa
         return MempoolAcceptResult::Failure(ws.m_state);
     }
 
-    m_subpackage.m_total_vsize = ws.m_vsize;
-    m_subpackage.m_total_modified_fees = ws.m_modified_fees;
-
-    // Individual modified feerate exceeded caller-defined max; abort
-    if (args.m_client_maxfeerate && CFeeRate(ws.m_modified_fees, ws.m_vsize) > args.m_client_maxfeerate.value()) {
-        ws.m_state.Invalid(TxValidationResult::TX_MEMPOOL_POLICY, "max feerate exceeded", "");
-        return MempoolAcceptResult::Failure(ws.m_state);
-    }
-
     if (m_subpackage.m_rbf && !ReplacementChecks(ws)) {
         if (ws.m_state.GetResult() == TxValidationResult::TX_RECONSIDERABLE) {
             // Failed for incentives-based fee reasons. Provide the effective feerate and which tx was included.
@@ -1384,6 +1365,32 @@ MempoolAcceptResult MemPoolAccept::AcceptSingleTransactionInternal(const CTransa
         return MempoolAcceptResult::Failure(ws.m_state);
     }
 
+    // Now that we've verified the cluster limit is respected, we can perform
+    // calculations involving the full ancestors of the tx.
+    if (ws.m_conflicts.size()) {
+        auto ancestors = m_subpackage.m_changeset->CalculateMemPoolAncestors(ws.m_tx_handle);
+
+        // A transaction that spends outputs that would be replaced by it is invalid. Now
+        // that we have the set of all ancestors we can detect this
+        // pathological case by making sure ws.m_conflicts and this tx's ancestors don't
+        // intersect.
+        if (const auto err_string{EntriesAndTxidsDisjoint(ancestors, ws.m_conflicts, ptx->GetHash())}) {
+            // We classify this as a consensus error because a transaction depending on something it
+            // conflicts with would be inconsistent.
+            ws.m_state.Invalid(TxValidationResult::TX_CONSENSUS, "bad-txns-spends-conflicting-tx", *err_string);
+            return MempoolAcceptResult::Failure(ws.m_state);
+        }
+    }
+
+    m_subpackage.m_total_vsize = ws.m_vsize;
+    m_subpackage.m_total_modified_fees = ws.m_modified_fees;
+
+    // Individual modified feerate exceeded caller-defined max; abort
+    if (args.m_client_maxfeerate && CFeeRate(ws.m_modified_fees, ws.m_vsize) > args.m_client_maxfeerate.value()) {
+        ws.m_state.Invalid(TxValidationResult::TX_MEMPOOL_POLICY, "max feerate exceeded", "");
+        return MempoolAcceptResult::Failure(ws.m_state);
+    }
+
     if (m_pool.m_opts.require_standard) {
         Wtxid dummy_wtxid;
         if (!CheckEphemeralSpends(/*package=*/{ptx}, m_pool.m_opts.dust_relay_feerate, m_pool, ws.m_state, dummy_wtxid)) {
@@ -1490,10 +1497,10 @@ PackageMempoolAcceptResult MemPoolAccept::AcceptMultipleTransactionsInternal(con
         m_viewmempool.PackageAddTransaction(ws.m_ptx);
     }
 
-    // At this point we have all in-mempool ancestors, and we know every transaction's vsize.
+    // At this point we have all in-mempool parents, and we know every transaction's vsize.
     // Run the TRUC checks on the package.
     for (Workspace& ws : workspaces) {
-        if (auto err{PackageTRUCChecks(m_pool, ws.m_ptx, ws.m_vsize, txns, ws.m_ancestors)}) {
+        if (auto err{PackageTRUCChecks(m_pool, ws.m_ptx, ws.m_vsize, txns, ws.m_parents)}) {
             package_state.Invalid(PackageValidationResult::PCKG_POLICY, "TRUC-violation", err.value());
             return PackageMempoolAcceptResult(package_state, {});
         }
@@ -1525,9 +1532,8 @@ PackageMempoolAcceptResult MemPoolAccept::AcceptMultipleTransactionsInternal(con
             MempoolAcceptResult::FeeFailure(placeholder_state, CFeeRate(m_subpackage.m_total_modified_fees, m_subpackage.m_total_vsize), all_package_wtxids)}});
     }
 
-    // Apply package mempool ancestor/descendant limits. Skip if there is only one transaction,
-    // because it's unnecessary.
-    if (txns.size() > 1 && !PackageMempoolChecks(txns, workspaces, m_subpackage.m_total_vsize, package_state)) {
+    // Apply package mempool RBF checks.
+    if (!PackageMempoolChecks(txns, workspaces, m_subpackage.m_total_vsize, package_state)) {
         return PackageMempoolAcceptResult(package_state, std::move(results));
     }
 

From 1902111e0f20fe6b5c12be019d24691d6b0b8d3e Mon Sep 17 00:00:00 2001
From: Suhas Daftuar <sdaftuar@chaincode.com>
Date: Sat, 25 Jan 2025 11:30:50 -0500
Subject: [PATCH 49/65] Eliminate CheckPackageLimits, which no longer does
 anything

---
 src/node/interfaces.cpp |  3 +--
 src/txmempool.cpp       |  6 ------
 src/txmempool.h         | 15 ---------------
 src/validation.cpp      | 10 ++--------
 4 files changed, 3 insertions(+), 31 deletions(-)

diff --git a/src/node/interfaces.cpp b/src/node/interfaces.cpp
index 65997267652..0506f00bb75 100644
--- a/src/node/interfaces.cpp
+++ b/src/node/interfaces.cpp
@@ -719,8 +719,7 @@ public:
         if (!m_node.mempool->CheckPolicyLimits(tx)) {
             return util::Error{Untranslated("too many unconfirmed transactions in cluster")};
         }
-        LOCK(m_node.mempool->cs);
-        return m_node.mempool->CheckPackageLimits({tx}, GetVirtualTransactionSize(*tx));
+        return {};
     }
     CFeeRate estimateSmartFee(int num_blocks, bool conservative, FeeCalculation* calc) override
     {
diff --git a/src/txmempool.cpp b/src/txmempool.cpp
index 99b7d3ef516..921765de732 100644
--- a/src/txmempool.cpp
+++ b/src/txmempool.cpp
@@ -131,12 +131,6 @@ void CTxMemPool::UpdateTransactionsFromBlock(const std::vector<Txid>& vHashesToU
     }
 }
 
-util::Result<void> CTxMemPool::CheckPackageLimits(const Package& package,
-                                                  const int64_t total_vsize) const
-{
-    return {};
-}
-
 bool CTxMemPool::HasDescendants(const Txid& txid) const
 {
     LOCK(cs);
diff --git a/src/txmempool.h b/src/txmempool.h
index 437bdf4ebd3..0c0ec241888 100644
--- a/src/txmempool.h
+++ b/src/txmempool.h
@@ -436,21 +436,6 @@ public:
      * more transactions as a DoS protection. */
     std::vector<txiter> GatherClusters(const std::vector<Txid>& txids) const EXCLUSIVE_LOCKS_REQUIRED(cs);
 
-    /** Calculate all in-mempool ancestors of a set of transactions not already in the mempool and
-     * check ancestor and descendant limits. Heuristics are used to estimate the ancestor and
-     * descendant count of all entries if the package were to be added to the mempool.  The limits
-     * are applied to the union of all package transactions. For example, if the package has 3
-     * transactions and limits.ancestor_count = 25, the union of all 3 sets of ancestors (including the
-     * transactions themselves) must be <= 22.
-     * @param[in]       package                 Transaction package being evaluated for acceptance
-     *                                          to mempool. The transactions need not be direct
-     *                                          ancestors/descendants of each other.
-     * @param[in]       total_vsize             Sum of virtual sizes for all transactions in package.
-     * @returns {} or the error reason if a limit is hit.
-     */
-    util::Result<void> CheckPackageLimits(const Package& package,
-                                          int64_t total_vsize) const EXCLUSIVE_LOCKS_REQUIRED(cs);
-
     /** Populate setDescendants with all in-mempool descendants of given transaction.
      *  Assumes that setDescendants includes all in-mempool descendants of anything
      *  already in it.  */
diff --git a/src/validation.cpp b/src/validation.cpp
index 62b629d4b86..b2ea91e29d1 100644
--- a/src/validation.cpp
+++ b/src/validation.cpp
@@ -1054,17 +1054,11 @@ bool MemPoolAccept::PackageMempoolChecks(const std::vector<CTransactionRef>& txn
     AssertLockHeld(cs_main);
     AssertLockHeld(m_pool.cs);
 
-    // CheckPackageLimits expects the package transactions to not already be in the mempool.
-    assert(std::all_of(txns.cbegin(), txns.cend(), [this](const auto& tx) { return !m_pool.exists(tx->GetHash()); }));
+    assert(std::all_of(txns.cbegin(), txns.cend(), [this](const auto& tx)
+                       { return !m_pool.exists(tx->GetHash());}));
 
     assert(txns.size() == workspaces.size());
 
-    auto result = m_pool.CheckPackageLimits(txns, total_vsize);
-    if (!result) {
-        // This is a package-wide error, separate from an individual transaction error.
-        return package_state.Invalid(PackageValidationResult::PCKG_POLICY, "package-mempool-limits", util::ErrorString(result).original);
-    }
-
     // No conflicts means we're finished. Further checks are all RBF-only.
     if (!m_subpackage.m_rbf) return true;
 

From 1ca4f01090cfa968c789fafde42054da3263a0e2 Mon Sep 17 00:00:00 2001
From: Suhas Daftuar <sdaftuar@chaincode.com>
Date: Sat, 8 Feb 2025 13:38:19 -0500
Subject: [PATCH 50/65] Fix miniminer_tests to work with cluster limits

---
 src/test/miniminer_tests.cpp | 34 ++++++++++++++++++++--------------
 1 file changed, 20 insertions(+), 14 deletions(-)

diff --git a/src/test/miniminer_tests.cpp b/src/test/miniminer_tests.cpp
index 28f467a416e..45c932c1f03 100644
--- a/src/test/miniminer_tests.cpp
+++ b/src/test/miniminer_tests.cpp
@@ -598,17 +598,23 @@ BOOST_FIXTURE_TEST_CASE(calculate_cluster, TestChain100Setup)
     CTxMemPool& pool = *Assert(m_node.mempool);
     LOCK2(cs_main, pool.cs);
 
-    // Add chain of size 500
-    TestMemPoolEntryHelper entry;
+    // Add 500 transactions in 10 clusters
+    std::vector<Txid> last_txs;
     std::vector<Txid> chain_txids;
     auto& lasttx = m_coinbase_txns[0];
-    for (auto i{0}; i < 500; ++i) {
-        const auto tx = make_tx({COutPoint{lasttx->GetHash(), 0}}, /*num_outputs=*/1);
-        AddToMempool(pool, entry.Fee(CENT).FromTx(tx));
-        chain_txids.push_back(tx->GetHash());
-        lasttx = tx;
+    TestMemPoolEntryHelper entry;
+    for (int cluster_count=0; cluster_count < 10; ++cluster_count) {
+        // Add chain of size 50
+        lasttx = m_coinbase_txns[cluster_count];
+        for (auto i{0}; i < 50; ++i) {
+            const auto tx = make_tx({COutPoint{lasttx->GetHash(), 0}}, /*num_outputs=*/1);
+            AddToMempool(pool, entry.Fee(CENT).FromTx(tx));
+            chain_txids.push_back(tx->GetHash());
+            lasttx = tx;
+        }
+        last_txs.emplace_back(lasttx->GetHash());
     }
-    const auto cluster_500tx = pool.GatherClusters({lasttx->GetHash()});
+    const auto cluster_500tx = pool.GatherClusters(last_txs);
     CTxMemPool::setEntries cluster_500tx_set{cluster_500tx.begin(), cluster_500tx.end()};
     BOOST_CHECK_EQUAL(cluster_500tx.size(), cluster_500tx_set.size());
     const auto vec_iters_500 = pool.GetIterVec(chain_txids);
@@ -617,29 +623,29 @@ BOOST_FIXTURE_TEST_CASE(calculate_cluster, TestChain100Setup)
     // GatherClusters stops at 500 transactions.
     const auto tx_501 = make_tx({COutPoint{lasttx->GetHash(), 0}}, /*num_outputs=*/1);
     AddToMempool(pool, entry.Fee(CENT).FromTx(tx_501));
-    const auto cluster_501 = pool.GatherClusters({tx_501->GetHash()});
+    const auto cluster_501 = pool.GatherClusters(last_txs);
     BOOST_CHECK_EQUAL(cluster_501.size(), 0);
 
     /* Zig Zag cluster:
-     * txp0     txp1     txp2    ...  txp48  txp49
+     * txp0     txp1     txp2    ...  txp30  txp31
      *    \    /    \   /   \            \   /
-     *     txc0     txc1    txc2  ...    txc48
+     *     txc0     txc1    txc2  ...    txc30
      * Note that each transaction's ancestor size is 1 or 3, and each descendant size is 1, 2 or 3.
      * However, all of these transactions are in the same cluster. */
     std::vector<Txid> zigzag_txids;
-    for (auto p{0}; p < 50; ++p) {
+    for (auto p{0}; p < 32; ++p) {
         const auto txp = make_tx({COutPoint{Txid::FromUint256(GetRandHash()), 0}}, /*num_outputs=*/2);
         AddToMempool(pool, entry.Fee(CENT).FromTx(txp));
         zigzag_txids.push_back(txp->GetHash());
     }
-    for (auto c{0}; c < 49; ++c) {
+    for (auto c{0}; c < 31; ++c) {
         const auto txc = make_tx({COutPoint{zigzag_txids[c], 1}, COutPoint{zigzag_txids[c+1], 0}}, /*num_outputs=*/1);
         AddToMempool(pool, entry.Fee(CENT).FromTx(txc));
         zigzag_txids.push_back(txc->GetHash());
     }
     const auto vec_iters_zigzag = pool.GetIterVec(zigzag_txids);
     // It doesn't matter which tx we calculate cluster for, everybody is in it.
-    const std::vector<size_t> indices{0, 22, 72, zigzag_txids.size() - 1};
+    const std::vector<size_t> indices{0, 22, 52, zigzag_txids.size() - 1};
     for (const auto index : indices) {
         const auto cluster = pool.GatherClusters({zigzag_txids[index]});
         BOOST_CHECK_EQUAL(cluster.size(), zigzag_txids.size());

From 88672e205ba1570fc92449b557fd32d836618781 Mon Sep 17 00:00:00 2001
From: Suhas Daftuar <sdaftuar@gmail.com>
Date: Tue, 16 Apr 2024 11:10:07 -0400
Subject: [PATCH 51/65] Rewrite GatherClusters to use the txgraph
 implementation

---
 src/txmempool.cpp | 32 ++++++++++++++------------------
 1 file changed, 14 insertions(+), 18 deletions(-)

diff --git a/src/txmempool.cpp b/src/txmempool.cpp
index 921765de732..53d92b8d9ea 100644
--- a/src/txmempool.cpp
+++ b/src/txmempool.cpp
@@ -977,28 +977,24 @@ void CTxMemPool::SetLoadTried(bool load_tried)
 std::vector<CTxMemPool::txiter> CTxMemPool::GatherClusters(const std::vector<Txid>& txids) const
 {
     AssertLockHeld(cs);
-    std::vector<txiter> clustered_txs{GetIterVec(txids)};
-    // Use epoch: visiting an entry means we have added it to the clustered_txs vector. It does not
-    // necessarily mean the entry has been processed.
-    WITH_FRESH_EPOCH(m_epoch);
-    for (const auto& it : clustered_txs) {
-        visited(it);
-    }
-    // i = index of where the list of entries to process starts
-    for (size_t i{0}; i < clustered_txs.size(); ++i) {
-        // DoS protection: if there are 500 or more entries to process, just quit.
-        if (clustered_txs.size() > 500) return {};
-        const txiter& tx_iter = clustered_txs.at(i);
-        for (const auto& entries : {tx_iter->GetMemPoolParentsConst(), tx_iter->GetMemPoolChildrenConst()}) {
-            for (const CTxMemPoolEntry& entry : entries) {
-                const auto entry_it = mapTx.iterator_to(entry);
-                if (!visited(entry_it)) {
-                    clustered_txs.push_back(entry_it);
+
+    std::vector<CTxMemPool::txiter> ret;
+    std::set<const CTxMemPoolEntry*> unique_cluster_representatives;
+    for (auto txid : txids) {
+        auto it = mapTx.find(txid);
+        if (it != mapTx.end()) {
+            auto cluster = m_txgraph->GetCluster(*it, TxGraph::Level::MAIN);
+            if (unique_cluster_representatives.insert(static_cast<const CTxMemPoolEntry*>(&(**cluster.begin()))).second) {
+                for (auto tx : cluster) {
+                    ret.emplace_back(mapTx.iterator_to(static_cast<const CTxMemPoolEntry&>(*tx)));
                 }
             }
         }
     }
-    return clustered_txs;
+    if (ret.size() > 500) {
+        return {};
+    }
+    return ret;
 }
 
 util::Result<std::pair<std::vector<FeeFrac>, std::vector<FeeFrac>>> CTxMemPool::ChangeSet::CalculateChunksForRBF()

From 84de685cf7ee3baf3ca73087e5222411a0504df8 Mon Sep 17 00:00:00 2001
From: Suhas Daftuar <sdaftuar@gmail.com>
Date: Tue, 16 Apr 2024 12:13:42 -0400
Subject: [PATCH 52/65] Stop tracking parents/children outside of txgraph

---
 src/kernel/mempool_entry.h |  10 ----
 src/txmempool.cpp          | 102 +++++--------------------------------
 src/txmempool.h            |  12 -----
 3 files changed, 14 insertions(+), 110 deletions(-)

diff --git a/src/kernel/mempool_entry.h b/src/kernel/mempool_entry.h
index e12047debda..b274e1f7eee 100644
--- a/src/kernel/mempool_entry.h
+++ b/src/kernel/mempool_entry.h
@@ -67,16 +67,11 @@ class CTxMemPoolEntry : public TxGraph::Ref
 {
 public:
     typedef std::reference_wrapper<const CTxMemPoolEntry> CTxMemPoolEntryRef;
-    // two aliases, should the types ever diverge
-    typedef std::set<CTxMemPoolEntryRef, CompareIteratorByHash> Parents;
-    typedef std::set<CTxMemPoolEntryRef, CompareIteratorByHash> Children;
 
 private:
     CTxMemPoolEntry(const CTxMemPoolEntry&) = delete;
 
     const CTransactionRef tx;
-    mutable Parents m_parents;
-    mutable Children m_children;
     const CAmount nFee;             //!< Cached to avoid expensive parent-transaction lookups
     const int32_t nTxWeight;         //!< ... and avoid recomputing tx weight (also used for GetTxSize())
     const size_t nUsageSize;        //!< ... and total memory usage
@@ -142,11 +137,6 @@ public:
 
     bool GetSpendsCoinbase() const { return spendsCoinbase; }
 
-    const Parents& GetMemPoolParentsConst() const { return m_parents; }
-    const Children& GetMemPoolChildrenConst() const { return m_children; }
-    Parents& GetMemPoolParents() const { return m_parents; }
-    Children& GetMemPoolChildren() const { return m_children; }
-
     mutable size_t idx_randomized; //!< Index in mempool's txns_randomized
     mutable Epoch::Marker m_epoch_marker; //!< epoch when last touched, useful for graph algorithms
 };
diff --git a/src/txmempool.cpp b/src/txmempool.cpp
index 53d92b8d9ea..64acf95223b 100644
--- a/src/txmempool.cpp
+++ b/src/txmempool.cpp
@@ -90,10 +90,6 @@ void CTxMemPool::UpdateTransactionsFromBlock(const std::vector<Txid>& vHashesToU
 {
     AssertLockHeld(cs);
 
-    // Use a set for lookups into vHashesToUpdate (these entries are already
-    // accounted for in the state of their ancestors)
-    std::set<Txid> setAlreadyIncluded(vHashesToUpdate.begin(), vHashesToUpdate.end());
-
     // Iterate in reverse, so that whenever we are looking at a transaction
     // we are sure that all in-mempool descendants have already been processed.
     for (const Txid& hash : vHashesToUpdate | std::views::reverse) {
@@ -103,20 +99,10 @@ void CTxMemPool::UpdateTransactionsFromBlock(const std::vector<Txid>& vHashesToU
             continue;
         }
         auto iter = mapNextTx.lower_bound(COutPoint(hash, 0));
-        // First calculate the children, and update CTxMemPoolEntry::m_children to
-        // include them, and update their CTxMemPoolEntry::m_parents to include this tx.
-        // we cache the in-mempool children to avoid duplicate updates
         {
-            WITH_FRESH_EPOCH(m_epoch);
             for (; iter != mapNextTx.end() && iter->first->hash == hash; ++iter) {
                 txiter childIter = iter->second;
                 assert(childIter != mapTx.end());
-                // We can skip updating entries we've encountered before or that
-                // are in the block (which are already accounted for).
-                if (!visited(childIter) && !setAlreadyIncluded.count(iter->second->GetTx().GetHash())) {
-                    UpdateChild(it, childIter, true);
-                    UpdateParent(childIter, it, true);
-                }
                 // Add dependencies that are discovered between transactions in the
                 // block and transactions that were in the mempool to txgraph.
                 m_txgraph->AddDependency(/*parent=*/*it, /*child=*/*childIter);
@@ -158,8 +144,6 @@ CTxMemPool::setEntries CTxMemPool::CalculateMemPoolAncestors(const CTxMemPoolEnt
     const CTransaction &tx = entry.GetTx();
 
     // Get parents of this transaction that are in the mempool
-    // GetMemPoolParents() is only valid for entries in the mempool, so we
-    // iterate mapTx to find parents.
     for (unsigned int i = 0; i < tx.vin.size(); i++) {
         std::optional<txiter> piter = GetIter(tx.vin[i].prevout.hash);
         if (piter) {
@@ -177,38 +161,6 @@ CTxMemPool::setEntries CTxMemPool::CalculateMemPoolAncestors(const CTxMemPoolEnt
     return ret;
 }
 
-void CTxMemPool::UpdateAncestorsOf(bool add, txiter it)
-{
-    const CTxMemPoolEntry::Parents& parents = it->GetMemPoolParentsConst();
-    // add or remove this tx as a child of each parent
-    for (const CTxMemPoolEntry& parent : parents) {
-        UpdateChild(mapTx.iterator_to(parent), it, add);
-    }
-}
-
-void CTxMemPool::UpdateChildrenForRemoval(txiter it)
-{
-    const CTxMemPoolEntry::Children& children = it->GetMemPoolChildrenConst();
-    for (const CTxMemPoolEntry& updateIt : children) {
-        UpdateParent(mapTx.iterator_to(updateIt), it, false);
-    }
-}
-
-void CTxMemPool::UpdateForRemoveFromMempool(const setEntries &entriesToRemove, bool updateDescendants)
-{
-    for (txiter removeIt : entriesToRemove) {
-        // Note that UpdateAncestorsOf severs the child links that point to
-        // removeIt in the entries for the parents of removeIt.
-        UpdateAncestorsOf(false, removeIt);
-    }
-    // After updating all the ancestor sizes, we can now sever the link between each
-    // transaction being removed and any mempool children (ie, update CTxMemPoolEntry::m_parents
-    // for each direct child of a transaction being removed).
-    for (txiter removeIt : entriesToRemove) {
-        UpdateChildrenForRemoval(removeIt);
-    }
-}
-
 static CTxMemPool::Options&& Flatten(CTxMemPool::Options&& opts, bilingual_str& error)
 {
     opts.check_ratio = std::clamp<int>(opts.check_ratio, 0, 1'000'000);
@@ -271,10 +223,8 @@ void CTxMemPool::addNewTransaction(CTxMemPool::txiter newit)
     cachedInnerUsage += entry.DynamicMemoryUsage();
 
     const CTransaction& tx = newit->GetTx();
-    std::set<Txid> setParentTransactions;
     for (unsigned int i = 0; i < tx.vin.size(); i++) {
         mapNextTx.insert(std::make_pair(&tx.vin[i].prevout, newit));
-        setParentTransactions.insert(tx.vin[i].prevout.hash);
     }
     // Don't bother worrying about child transactions of this one.
     // Normal case of a new transaction arriving is that there can't be any
@@ -283,12 +233,6 @@ void CTxMemPool::addNewTransaction(CTxMemPool::txiter newit)
     // In that case, our disconnect block logic will call UpdateTransactionsFromBlock
     // to clean up the mess we're leaving here.
 
-    // Update ancestors with information about this tx
-    for (const auto& pit : GetIterSet(setParentTransactions)) {
-        UpdateParent(newit, pit, true);
-    }
-    UpdateAncestorsOf(true, newit);
-
     nTransactionsUpdated++;
     totalTxSize += entry.GetTxSize();
     m_total_fee += entry.GetFee();
@@ -344,7 +288,6 @@ void CTxMemPool::removeUnchecked(txiter it, MemPoolRemovalReason reason)
     totalTxSize -= it->GetTxSize();
     m_total_fee -= it->GetFee();
     cachedInnerUsage -= it->DynamicMemoryUsage();
-    cachedInnerUsage -= memusage::DynamicUsage(it->GetMemPoolParentsConst()) + memusage::DynamicUsage(it->GetMemPoolChildrenConst());
     mapTx.erase(it);
     nTransactionsUpdated++;
 }
@@ -483,8 +426,8 @@ void CTxMemPool::check(const CCoinsViewCache& active_coins_tip, int64_t spendhei
         check_total_fee += it->GetFee();
         innerUsage += it->DynamicMemoryUsage();
         const CTransaction& tx = it->GetTx();
-        innerUsage += memusage::DynamicUsage(it->GetMemPoolParentsConst()) + memusage::DynamicUsage(it->GetMemPoolChildrenConst());
-        CTxMemPoolEntry::Parents setParentCheck;
+        std::set<CTxMemPoolEntry::CTxMemPoolEntryRef, CompareIteratorByHash> setParentCheck;
+        std::set<CTxMemPoolEntry::CTxMemPoolEntryRef, CompareIteratorByHash> setParentsStored;
         for (const CTxIn &txin : tx.vin) {
             // Check that every mempool transaction's inputs refer to available coins, or other mempool tx's.
             indexed_transaction_set::const_iterator it2 = mapTx.find(txin.prevout.hash);
@@ -507,19 +450,26 @@ void CTxMemPool::check(const CCoinsViewCache& active_coins_tip, int64_t spendhei
         auto comp = [](const CTxMemPoolEntry& a, const CTxMemPoolEntry& b) -> bool {
             return a.GetTx().GetHash() == b.GetTx().GetHash();
         };
-        assert(setParentCheck.size() == it->GetMemPoolParentsConst().size());
-        assert(std::equal(setParentCheck.begin(), setParentCheck.end(), it->GetMemPoolParentsConst().begin(), comp));
+        for (auto &txentry : GetParents(*it)) {
+            setParentsStored.insert(dynamic_cast<const CTxMemPoolEntry&>(txentry.get()));
+        }
+        assert(setParentCheck.size() == setParentsStored.size());
+        assert(std::equal(setParentCheck.begin(), setParentCheck.end(), setParentsStored.begin(), comp));
 
         // Check children against mapNextTx
-        CTxMemPoolEntry::Children setChildrenCheck;
+        std::set<CTxMemPoolEntry::CTxMemPoolEntryRef, CompareIteratorByHash> setChildrenCheck;
+        std::set<CTxMemPoolEntry::CTxMemPoolEntryRef, CompareIteratorByHash> setChildrenStored;
         auto iter = mapNextTx.lower_bound(COutPoint(it->GetTx().GetHash(), 0));
         for (; iter != mapNextTx.end() && iter->first->hash == it->GetTx().GetHash(); ++iter) {
             txiter childit = iter->second;
             assert(childit != mapTx.end()); // mapNextTx points to in-mempool transactions
             setChildrenCheck.insert(*childit);
         }
-        assert(setChildrenCheck.size() == it->GetMemPoolChildrenConst().size());
-        assert(std::equal(setChildrenCheck.begin(), setChildrenCheck.end(), it->GetMemPoolChildrenConst().begin(), comp));
+        for (auto &txentry : GetChildren(*it)) {
+            setChildrenStored.insert(dynamic_cast<const CTxMemPoolEntry&>(txentry.get()));
+        }
+        assert(setChildrenCheck.size() == setChildrenStored.size());
+        assert(std::equal(setChildrenCheck.begin(), setChildrenCheck.end(), setChildrenStored.begin(), comp));
 
         TxValidationState dummy_state; // Not used. CheckTxInputs() should always pass
         CAmount txfee = 0;
@@ -777,7 +727,6 @@ void CTxMemPool::RemoveUnbroadcastTx(const Txid& txid, const bool unchecked) {
 
 void CTxMemPool::RemoveStaged(setEntries &stage, bool updateDescendants, MemPoolRemovalReason reason) {
     AssertLockHeld(cs);
-    UpdateForRemoveFromMempool(stage, updateDescendants);
     for (txiter it : stage) {
         removeUnchecked(it, reason);
     }
@@ -812,28 +761,6 @@ int CTxMemPool::Expire(std::chrono::seconds time)
     return stage.size();
 }
 
-void CTxMemPool::UpdateChild(txiter entry, txiter child, bool add)
-{
-    AssertLockHeld(cs);
-    CTxMemPoolEntry::Children s;
-    if (add && entry->GetMemPoolChildren().insert(*child).second) {
-        cachedInnerUsage += memusage::IncrementalDynamicUsage(s);
-    } else if (!add && entry->GetMemPoolChildren().erase(*child)) {
-        cachedInnerUsage -= memusage::IncrementalDynamicUsage(s);
-    }
-}
-
-void CTxMemPool::UpdateParent(txiter entry, txiter parent, bool add)
-{
-    AssertLockHeld(cs);
-    CTxMemPoolEntry::Parents s;
-    if (add && entry->GetMemPoolParents().insert(*parent).second) {
-        cachedInnerUsage += memusage::IncrementalDynamicUsage(s);
-    } else if (!add && entry->GetMemPoolParents().erase(*parent)) {
-        cachedInnerUsage -= memusage::IncrementalDynamicUsage(s);
-    }
-}
-
 CFeeRate CTxMemPool::GetMinFee(size_t sizelimit) const {
     LOCK(cs);
     if (!blockSinceLastRollingFeeBump || rollingMinimumFeeRate == 0)
@@ -900,7 +827,6 @@ void CTxMemPool::TrimToSize(size_t sizelimit, std::vector<COutPoint>* pvNoSpends
         for (auto ref : worst_chunk) {
             stage.insert(mapTx.iterator_to(static_cast<const CTxMemPoolEntry&>(*ref)));
         }
-        UpdateForRemoveFromMempool(stage, false);
         for (auto e : stage) {
             removeUnchecked(e, MemPoolRemovalReason::SIZELIMIT);
         }
diff --git a/src/txmempool.h b/src/txmempool.h
index 0c0ec241888..1891c8d48a7 100644
--- a/src/txmempool.h
+++ b/src/txmempool.h
@@ -296,9 +296,6 @@ private:
     typedef std::map<txiter, setEntries, CompareIteratorByHash> cacheMap;
 
 
-    void UpdateParent(txiter entry, txiter parent, bool add) EXCLUSIVE_LOCKS_REQUIRED(cs);
-    void UpdateChild(txiter entry, txiter child, bool add) EXCLUSIVE_LOCKS_REQUIRED(cs);
-
     std::vector<indexed_transaction_set::const_iterator> GetSortedScoreWithTopology() const EXCLUSIVE_LOCKS_REQUIRED(cs);
 
     /**
@@ -584,15 +581,6 @@ private:
      */
     void RemoveStaged(setEntries& stage, bool updateDescendants, MemPoolRemovalReason reason) EXCLUSIVE_LOCKS_REQUIRED(cs);
 
-    /** Update ancestors of hash to add/remove it as a descendant transaction. */
-    void UpdateAncestorsOf(bool add, txiter hash) EXCLUSIVE_LOCKS_REQUIRED(cs);
-    /** For each transaction being removed, update ancestors and any direct children.
-      * If updateDescendants is true, then also update in-mempool descendants'
-      * ancestor state. */
-    void UpdateForRemoveFromMempool(const setEntries &entriesToRemove, bool updateDescendants) EXCLUSIVE_LOCKS_REQUIRED(cs);
-    /** Sever link between specified transaction and direct children. */
-    void UpdateChildrenForRemoval(txiter entry) EXCLUSIVE_LOCKS_REQUIRED(cs);
-
     /** Before calling removeUnchecked for a given transaction,
      *  UpdateForRemoveFromMempool must be called on the entire (dependent) set
      *  of transactions being removed at the same time.  We use each

From 7976eb1ae77af2c88e1e61e85d4a61390b34b986 Mon Sep 17 00:00:00 2001
From: Suhas Daftuar <sdaftuar@chaincode.com>
Date: Tue, 4 Feb 2025 15:03:25 -0500
Subject: [PATCH 53/65] Avoid violating mempool policy limits in tests

Changes AddToMempool() helper to only apply changes if the mempool limits are
respected.

Fix package_rbf fuzz target to handle mempool policy violations
---
 src/test/fuzz/rbf.cpp       | 24 +++++++++++++++++++-----
 src/test/util/txmempool.cpp |  2 +-
 src/test/util/txmempool.h   |  2 +-
 3 files changed, 21 insertions(+), 7 deletions(-)

diff --git a/src/test/fuzz/rbf.cpp b/src/test/fuzz/rbf.cpp
index 2ca57341533..02ec3cb0e8a 100644
--- a/src/test/fuzz/rbf.cpp
+++ b/src/test/fuzz/rbf.cpp
@@ -120,8 +120,8 @@ FUZZ_TARGET(package_rbf, .init = initialize_package_rbf)
     replacement_tx->vin[0].prevout = g_outpoints.at(iter++);
     CTransaction replacement_tx_final{*replacement_tx};
     auto replacement_entry = ConsumeTxMemPoolEntry(fuzzed_data_provider, replacement_tx_final);
-    int32_t replacement_vsize = replacement_entry.GetTxSize();
-    int64_t running_vsize_total{replacement_vsize};
+    int32_t replacement_weight = replacement_entry.GetAdjustedWeight();
+    int64_t running_vsize_total{replacement_entry.GetTxSize()};
 
     LOCK2(cs_main, pool.cs);
 
@@ -144,6 +144,14 @@ FUZZ_TARGET(package_rbf, .init = initialize_package_rbf)
         }
         assert(!pool.GetIter(parent_entry.GetTx().GetHash()));
         AddToMempool(pool, parent_entry);
+
+        // It's possible that adding this to the mempool failed due to cluster
+        // size limits; if so bail out.
+        if(!pool.GetIter(parent_entry.GetTx().GetHash())) {
+            mempool_txs.pop_back();
+            continue;
+        }
+
         child.vin[0].prevout = COutPoint{mempool_txs.back().GetHash(), 0};
         mempool_txs.emplace_back(child);
         const auto child_entry = ConsumeTxMemPoolEntry(fuzzed_data_provider, mempool_txs.back());
@@ -155,6 +163,12 @@ FUZZ_TARGET(package_rbf, .init = initialize_package_rbf)
         }
         if (!pool.GetIter(child_entry.GetTx().GetHash())) {
             AddToMempool(pool, child_entry);
+            // Adding this transaction to the mempool may fail due to cluster
+            // size limits; if so bail out.
+            if(!pool.GetIter(child_entry.GetTx().GetHash())) {
+                mempool_txs.pop_back();
+                continue;
+            }
         }
 
         if (fuzzed_data_provider.ConsumeBool()) {
@@ -165,7 +179,7 @@ FUZZ_TARGET(package_rbf, .init = initialize_package_rbf)
     // Pick some transactions at random to be the direct conflicts
     CTxMemPool::setEntries direct_conflicts;
     for (auto& tx : mempool_txs) {
-        if (fuzzed_data_provider.ConsumeBool()) {
+        if (fuzzed_data_provider.ConsumeBool() && pool.GetIter(tx.GetHash())) {
             direct_conflicts.insert(*pool.GetIter(tx.GetHash()));
         }
     }
@@ -206,11 +220,11 @@ FUZZ_TARGET(package_rbf, .init = initialize_package_rbf)
         FeeFrac replaced;
         for (auto txiter : all_conflicts) {
             replaced.fee += txiter->GetModifiedFee();
-            replaced.size += txiter->GetTxSize();
+            replaced.size += txiter->GetAdjustedWeight();
         }
         // The total fee & size of the new diagram minus replaced fee & size should be the total
         // fee & size of the old diagram minus replacement fee & size.
-        assert((first_sum - replaced) == (second_sum - FeeFrac{replacement_fees, replacement_vsize}));
+        assert((first_sum - replaced) == (second_sum - FeeFrac{replacement_fees, replacement_weight}));
     }
 
     // If internals report error, wrapper should too
diff --git a/src/test/util/txmempool.cpp b/src/test/util/txmempool.cpp
index e85c496d01b..980621dee03 100644
--- a/src/test/util/txmempool.cpp
+++ b/src/test/util/txmempool.cpp
@@ -218,5 +218,5 @@ void AddToMempool(CTxMemPool& tx_pool, const CTxMemPoolEntry& entry)
     changeset->StageAddition(entry.GetSharedTx(), entry.GetFee(),
             entry.GetTime().count(), entry.GetHeight(), entry.GetSequence(),
             entry.GetSpendsCoinbase(), entry.GetSigOpCost(), entry.GetLockPoints());
-    changeset->Apply();
+    if (changeset->CheckMemPoolPolicyLimits()) changeset->Apply();
 }
diff --git a/src/test/util/txmempool.h b/src/test/util/txmempool.h
index 36caad2ae1a..2ed498a9ec5 100644
--- a/src/test/util/txmempool.h
+++ b/src/test/util/txmempool.h
@@ -64,7 +64,7 @@ void CheckMempoolEphemeralInvariants(const CTxMemPool& tx_pool);
 void CheckMempoolTRUCInvariants(const CTxMemPool& tx_pool);
 
 /** One-line wrapper for creating a mempool changeset with a single transaction
- *  and applying it. */
+ *  and applying it if the policy limits are respected. */
 void AddToMempool(CTxMemPool& tx_pool, const CTxMemPoolEntry& entry);
 
 #endif // BITCOIN_TEST_UTIL_TXMEMPOOL_H

From f107417490ab5b81d3ec139de777a19db87845b6 Mon Sep 17 00:00:00 2001
From: Suhas Daftuar <sdaftuar@chaincode.com>
Date: Wed, 11 Oct 2023 11:34:16 -0400
Subject: [PATCH 54/65] bench: add more mempool benchmarks

Add benchmarks for:

  - adding a transaction
  - calculating mempool ancestors/descendants
---
 src/bench/mempool_stress.cpp | 66 +++++++++++++++++++++++++++++++++---
 1 file changed, 62 insertions(+), 4 deletions(-)

diff --git a/src/bench/mempool_stress.cpp b/src/bench/mempool_stress.cpp
index 49ff17c1b02..5f0a20ecd6c 100644
--- a/src/bench/mempool_stress.cpp
+++ b/src/bench/mempool_stress.cpp
@@ -21,7 +21,7 @@
 
 class CCoinsViewCache;
 
-static void AddTx(const CTransactionRef& tx, CTxMemPool& pool) EXCLUSIVE_LOCKS_REQUIRED(cs_main, pool.cs)
+static void AddTx(const CTransactionRef& tx, CTxMemPool& pool, FastRandomContext& det_rand) EXCLUSIVE_LOCKS_REQUIRED(cs_main, pool.cs)
 {
     int64_t nTime = 0;
     unsigned int nHeight = 1;
@@ -29,7 +29,7 @@ static void AddTx(const CTransactionRef& tx, CTxMemPool& pool) EXCLUSIVE_LOCKS_R
     bool spendsCoinbase = false;
     unsigned int sigOpCost = 4;
     LockPoints lp;
-    AddToMempool(pool, CTxMemPoolEntry(TxGraph::Ref(), tx, 1000, nTime, nHeight, sequence, spendsCoinbase, sigOpCost, lp));
+    AddToMempool(pool, CTxMemPoolEntry(TxGraph::Ref(), tx, det_rand.randrange(10000)+1000, nTime, nHeight, sequence, spendsCoinbase, sigOpCost, lp));
 }
 
 struct Available {
@@ -93,6 +93,33 @@ static std::vector<CTransactionRef> CreateCoinCluster(FastRandomContext& det_ran
     return ordered_coins;
 }
 
+static void MemPoolAddTransactions(benchmark::Bench& bench)
+{
+    FastRandomContext det_rand{true};
+    int childTxs = 50;
+    if (bench.complexityN() > 1) {
+        childTxs = static_cast<int>(bench.complexityN());
+    }
+    const auto testing_setup = MakeNoLogFileContext<const TestingSetup>(ChainType::MAIN);
+    CTxMemPool& pool = *testing_setup.get()->m_node.mempool;
+
+    std::vector<CTransactionRef> transactions;
+    // Create 1000 clusters of 100 transactions each
+    for (int i=0; i<100; i++) {
+        auto new_txs = CreateCoinCluster(det_rand, childTxs, /*min_ancestors*/ 1);
+        transactions.insert(transactions.end(), new_txs.begin(), new_txs.end());
+    }
+
+    LOCK2(cs_main, pool.cs);
+
+    bench.run([&]() NO_THREAD_SAFETY_ANALYSIS {
+        for (auto& tx : transactions) {
+            AddTx(tx, pool, det_rand);
+        }
+        pool.TrimToSize(0, nullptr);
+    });
+}
+
 static void ComplexMemPool(benchmark::Bench& bench)
 {
     FastRandomContext det_rand{true};
@@ -121,7 +148,7 @@ static void ComplexMemPool(benchmark::Bench& bench)
                 ++tx_count;
                 hashes_remove_for_block.emplace_back(tx->GetHash());
             }
-            AddTx(tx, pool);
+            AddTx(tx, pool, det_rand);
         }
     }
 
@@ -131,12 +158,41 @@ static void ComplexMemPool(benchmark::Bench& bench)
     bench.run([&]() NO_THREAD_SAFETY_ANALYSIS {
         pool.removeForBlock(tx_remove_for_block, /*nBlockHeight*/100);
         for (auto& tx: tx_remove_for_block) {
-            AddTx(tx, pool);
+            AddTx(tx, pool, det_rand);
         }
         pool.UpdateTransactionsFromBlock(hashes_remove_for_block);
     });
 }
 
+static void MemPoolAncestorsDescendants(benchmark::Bench& bench)
+{
+    FastRandomContext det_rand{true};
+    int childTxs = 50;
+    if (bench.complexityN() > 1) {
+        childTxs = static_cast<int>(bench.complexityN());
+    }
+    const auto testing_setup = MakeNoLogFileContext<const TestingSetup>(ChainType::MAIN);
+    CTxMemPool& pool = *testing_setup.get()->m_node.mempool;
+
+    LOCK2(cs_main, pool.cs);
+
+    std::vector<CTransactionRef> transactions = CreateCoinCluster(det_rand, childTxs, /*min_ancestors=*/1);
+    for (auto& tx : transactions) {
+        AddTx(tx, pool, det_rand);
+    }
+
+    CTxMemPool::txiter first_tx = *pool.GetIter(transactions[0]->GetHash());
+    CTxMemPool::txiter last_tx = *pool.GetIter(transactions.back()->GetHash());
+
+    bench.run([&]() NO_THREAD_SAFETY_ANALYSIS {
+        CTxMemPool::setEntries dummy;
+        ankerl::nanobench::doNotOptimizeAway(dummy);
+        pool.CalculateDescendants({first_tx}, dummy);
+        ankerl::nanobench::doNotOptimizeAway(pool.CalculateMemPoolAncestors(*last_tx));
+    });
+}
+
+
 static void MempoolCheck(benchmark::Bench& bench)
 {
     FastRandomContext det_rand{true};
@@ -152,5 +208,7 @@ static void MempoolCheck(benchmark::Bench& bench)
     });
 }
 
+BENCHMARK(MemPoolAncestorsDescendants, benchmark::PriorityLevel::HIGH);
+BENCHMARK(MemPoolAddTransactions, benchmark::PriorityLevel::HIGH);
 BENCHMARK(ComplexMemPool, benchmark::PriorityLevel::HIGH);
 BENCHMARK(MempoolCheck, benchmark::PriorityLevel::HIGH);

From 72e74e0d42284c712529bf3c619b1b740c070f1b Mon Sep 17 00:00:00 2001
From: Suhas Daftuar <sdaftuar@gmail.com>
Date: Thu, 12 Oct 2023 10:48:55 -0400
Subject: [PATCH 55/65] fuzz: try to add more code coverage for mempool fuzzing

Including test coverage for mempool eviction and expiry
---
 src/test/fuzz/tx_pool.cpp | 52 +++++++++++++++++++++++++++++++--------
 src/txmempool.cpp         |  1 +
 2 files changed, 43 insertions(+), 10 deletions(-)

diff --git a/src/test/fuzz/tx_pool.cpp b/src/test/fuzz/tx_pool.cpp
index c728485d041..4dcfd30ad0d 100644
--- a/src/test/fuzz/tx_pool.cpp
+++ b/src/test/fuzz/tx_pool.cpp
@@ -80,14 +80,10 @@ struct TransactionsDelta final : public CValidationInterface {
 
 void SetMempoolConstraints(ArgsManager& args, FuzzedDataProvider& fuzzed_data_provider)
 {
-    args.ForceSetArg("-limitancestorcount",
-                     ToString(fuzzed_data_provider.ConsumeIntegralInRange<unsigned>(0, 50)));
-    args.ForceSetArg("-limitancestorsize",
-                     ToString(fuzzed_data_provider.ConsumeIntegralInRange<unsigned>(0, 202)));
-    args.ForceSetArg("-limitdescendantcount",
-                     ToString(fuzzed_data_provider.ConsumeIntegralInRange<unsigned>(0, 50)));
-    args.ForceSetArg("-limitdescendantsize",
-                     ToString(fuzzed_data_provider.ConsumeIntegralInRange<unsigned>(0, 202)));
+    args.ForceSetArg("-limitclustercount",
+                     ToString(fuzzed_data_provider.ConsumeIntegralInRange<unsigned>(1, 64)));
+    args.ForceSetArg("-limitclustersize",
+                     ToString(fuzzed_data_provider.ConsumeIntegralInRange<unsigned>(1, 250)));
     args.ForceSetArg("-maxmempool",
                      ToString(fuzzed_data_provider.ConsumeIntegralInRange<unsigned>(0, 200)));
     args.ForceSetArg("-mempoolexpiry",
@@ -104,14 +100,41 @@ void Finish(FuzzedDataProvider& fuzzed_data_provider, MockedTxPool& tx_pool, Cha
         auto assembler = BlockAssembler{chainstate, &tx_pool, options};
         auto block_template = assembler.CreateNewBlock();
         Assert(block_template->block.vtx.size() >= 1);
+
+        // Try updating the mempool for this block, as though it were mined.
+        LOCK2(::cs_main, tx_pool.cs);
+        tx_pool.removeForBlock(block_template->block.vtx, chainstate.m_chain.Height() + 1);
+
+        // Now try to add those transactions back, as though a reorg happened.
+        std::vector<Txid> hashes_to_update;
+        for (const auto& tx : block_template->block.vtx) {
+            const auto res = AcceptToMemoryPool(chainstate, tx, GetTime(), true, /*test_accept=*/false);
+            if (res.m_result_type == MempoolAcceptResult::ResultType::VALID) {
+                hashes_to_update.push_back(tx->GetHash());
+            } else {
+                tx_pool.removeRecursive(*tx, MemPoolRemovalReason::REORG);
+            }
+        }
+        tx_pool.UpdateTransactionsFromBlock(hashes_to_update);
     }
     const auto info_all = tx_pool.infoAll();
     if (!info_all.empty()) {
         const auto& tx_to_remove = *PickValue(fuzzed_data_provider, info_all).tx;
         WITH_LOCK(tx_pool.cs, tx_pool.removeRecursive(tx_to_remove, MemPoolRemovalReason::BLOCK /* dummy */));
         assert(tx_pool.size() < info_all.size());
-        WITH_LOCK(::cs_main, tx_pool.check(chainstate.CoinsTip(), chainstate.m_chain.Height() + 1));
     }
+
+    if (fuzzed_data_provider.ConsumeBool()) {
+        // Try eviction
+        LOCK2(::cs_main, tx_pool.cs);
+        tx_pool.TrimToSize(fuzzed_data_provider.ConsumeIntegralInRange<size_t>(0U, tx_pool.DynamicMemoryUsage() * 2));
+    }
+    if (fuzzed_data_provider.ConsumeBool()) {
+        // Try expiry
+        LOCK2(::cs_main, tx_pool.cs);
+        tx_pool.Expire(GetMockTime() - std::chrono::seconds(fuzzed_data_provider.ConsumeIntegral<uint32_t>()));
+    }
+    WITH_LOCK(::cs_main, tx_pool.check(chainstate.CoinsTip(), chainstate.m_chain.Height() + 1));
     g_setup->m_node.validation_signals->SyncWithValidationInterfaceQueue();
 }
 
@@ -264,11 +287,20 @@ FUZZ_TARGET(tx_pool_standard, .init = initialize_tx_pool)
 
                 tx_mut.vin.push_back(in);
             }
+
+            // Check sigops in mempool + block template creation
+            bool add_sigops{fuzzed_data_provider.ConsumeBool()};
+
             const auto amount_fee = fuzzed_data_provider.ConsumeIntegralInRange<CAmount>(-1000, amount_in);
             const auto amount_out = (amount_in - amount_fee) / num_out;
             for (int i = 0; i < num_out; ++i) {
-                tx_mut.vout.emplace_back(amount_out, P2WSH_OP_TRUE);
+                if (i == 0 && add_sigops) {
+                    tx_mut.vout.emplace_back(amount_out, CScript() << std::vector<unsigned char>(33, 0x02) << OP_CHECKSIG);
+                } else {
+                    tx_mut.vout.emplace_back(amount_out, P2WSH_OP_TRUE);
+                }
             }
+
             auto tx = MakeTransactionRef(tx_mut);
             // Restore previously removed outpoints
             for (const auto& in : tx->vin) {
diff --git a/src/txmempool.cpp b/src/txmempool.cpp
index 64acf95223b..d7303cc6749 100644
--- a/src/txmempool.cpp
+++ b/src/txmempool.cpp
@@ -418,6 +418,7 @@ void CTxMemPool::check(const CCoinsViewCache& active_coins_tip, int64_t spendhei
     uint64_t innerUsage = 0;
 
     assert(!m_txgraph->IsOversized(TxGraph::Level::MAIN));
+    m_txgraph->SanityCheck();
 
     CCoinsViewCache mempoolDuplicate(const_cast<CCoinsViewCache*>(&active_coins_tip));
 

From 21693f031a534193cc7f066a5c6e23db3937bf39 Mon Sep 17 00:00:00 2001
From: Suhas Daftuar <sdaftuar@chaincode.com>
Date: Wed, 19 Apr 2023 17:12:04 -0400
Subject: [PATCH 56/65] Expose cluster information via rpc

Co-authored-by: glozow <gloriajzhao@gmail.com>
---
 src/rpc/mempool.cpp                           | 121 ++++++++++++++++++
 src/test/fuzz/rpc.cpp                         |   2 +
 src/txmempool.cpp                             |  22 ++++
 src/txmempool.h                               |  17 +++
 test/functional/mempool_persist.py            |   3 +-
 .../mining_prioritisetransaction.py           |   7 +
 6 files changed, 171 insertions(+), 1 deletion(-)

diff --git a/src/rpc/mempool.cpp b/src/rpc/mempool.cpp
index f07f06f88f4..2f8a48702d7 100644
--- a/src/rpc/mempool.cpp
+++ b/src/rpc/mempool.cpp
@@ -258,6 +258,23 @@ static RPCHelpMan testmempoolaccept()
     };
 }
 
+static std::vector<RPCResult> ClusterDescription()
+{
+    return {
+        RPCResult{RPCResult::Type::NUM, "weight", "total sigops-adjusted weight (as defined in BIP 141 and modified by '-bytespersigop'"},
+        RPCResult{RPCResult::Type::NUM, "txcount", "number of transactions"},
+        RPCResult{RPCResult::Type::ARR, "txs", "transactions in this cluster in mining order",
+            {RPCResult{RPCResult::Type::OBJ, "txentry", "",
+                {
+                    RPCResult{RPCResult::Type::STR_HEX, "txid", "the transaction id"},
+                    RPCResult{RPCResult::Type::NUM, "chunkfee", "fee of the chunk containing this tx"},
+                    RPCResult{RPCResult::Type::NUM, "chunkweight", "sigops-adjusted weight of the chunk containing this transaction"}
+                }
+            }}
+        }
+    };
+}
+
 static std::vector<RPCResult> MempoolEntryDescription()
 {
     return {
@@ -269,6 +286,7 @@ static std::vector<RPCResult> MempoolEntryDescription()
         RPCResult{RPCResult::Type::NUM, "descendantsize", "virtual transaction size of in-mempool descendants (including this one)"},
         RPCResult{RPCResult::Type::NUM, "ancestorcount", "number of in-mempool ancestor transactions (including this one)"},
         RPCResult{RPCResult::Type::NUM, "ancestorsize", "virtual transaction size of in-mempool ancestors (including this one)"},
+        RPCResult{RPCResult::Type::NUM, "chunkweight", "sigops-adjusted weight (as defined in BIP 141 and modified by '-bytespersigop') of this transaction's chunk"},
         RPCResult{RPCResult::Type::STR_HEX, "wtxid", "hash of serialized transaction, including witness data"},
         RPCResult{RPCResult::Type::OBJ, "fees", "",
             {
@@ -276,6 +294,7 @@ static std::vector<RPCResult> MempoolEntryDescription()
                 RPCResult{RPCResult::Type::STR_AMOUNT, "modified", "transaction fee with fee deltas used for mining priority, denominated in " + CURRENCY_UNIT},
                 RPCResult{RPCResult::Type::STR_AMOUNT, "ancestor", "transaction fees of in-mempool ancestors (including this one) with fee deltas used for mining priority, denominated in " + CURRENCY_UNIT},
                 RPCResult{RPCResult::Type::STR_AMOUNT, "descendant", "transaction fees of in-mempool descendants (including this one) with fee deltas used for mining priority, denominated in " + CURRENCY_UNIT},
+                RPCResult{RPCResult::Type::STR_AMOUNT, "chunk", "transaction fees of chunk, denominated in " + CURRENCY_UNIT},
             }},
         RPCResult{RPCResult::Type::ARR, "depends", "unconfirmed transactions used as inputs for this transaction",
             {RPCResult{RPCResult::Type::STR_HEX, "transactionid", "parent transaction id"}}},
@@ -286,6 +305,27 @@ static std::vector<RPCResult> MempoolEntryDescription()
     };
 }
 
+static void clusterToJSON(const CTxMemPool& pool, UniValue& info, std::vector<const CTxMemPoolEntry *> cluster) EXCLUSIVE_LOCKS_REQUIRED(pool.cs)
+{
+    AssertLockHeld(pool.cs);
+    int total_weight{0};
+    for (const auto& tx : cluster) {
+        total_weight += tx->GetAdjustedWeight();
+    }
+    info.pushKV("weight", total_weight);
+    info.pushKV("txcount", (int)cluster.size());
+    UniValue txs(UniValue::VARR);
+    for (const auto& tx : cluster) {
+        UniValue txentry(UniValue::VOBJ);
+        auto feerate = pool.GetMainChunkFeerate(*tx);
+        txentry.pushKV("txid", tx->GetTx().GetHash().ToString());
+        txentry.pushKV("chunkfee", ValueFromAmount((int)feerate.fee));
+        txentry.pushKV("chunkweight", feerate.size);
+        txs.push_back(txentry);
+    }
+    info.pushKV("txs", txs);
+}
+
 static void entryToJSON(const CTxMemPool& pool, UniValue& info, const CTxMemPoolEntry& e) EXCLUSIVE_LOCKS_REQUIRED(pool.cs)
 {
     AssertLockHeld(pool.cs);
@@ -302,12 +342,15 @@ static void entryToJSON(const CTxMemPool& pool, UniValue& info, const CTxMemPool
     info.pushKV("ancestorcount", ancestor_count);
     info.pushKV("ancestorsize", ancestor_size);
     info.pushKV("wtxid", e.GetTx().GetWitnessHash().ToString());
+    auto feerate = pool.GetMainChunkFeerate(e);
+    info.pushKV("chunkweight", feerate.size);
 
     UniValue fees(UniValue::VOBJ);
     fees.pushKV("base", ValueFromAmount(e.GetFee()));
     fees.pushKV("modified", ValueFromAmount(e.GetModifiedFee()));
     fees.pushKV("ancestor", ValueFromAmount(ancestor_fees));
     fees.pushKV("descendant", ValueFromAmount(descendant_fees));
+    fees.pushKV("chunk", ValueFromAmount((int)feerate.fee));
     info.pushKV("fees", std::move(fees));
 
     const CTransaction& tx = e.GetTx();
@@ -384,6 +427,49 @@ UniValue MempoolToJSON(const CTxMemPool& pool, bool verbose, bool include_mempoo
     }
 }
 
+static RPCHelpMan getmempoolfeeratediagram()
+{
+    return RPCHelpMan{"getmempoolfeeratediagram",
+        "Returns the feerate diagram for the whole mempool.",
+        {},
+        {
+            RPCResult{"mempool chunks",
+                RPCResult::Type::ARR, "", "",
+                {
+                    {
+                        RPCResult::Type::OBJ, "", "",
+                        {
+                            {RPCResult::Type::NUM, "weight", "cumulative sigops-adjusted weight"},
+                            {RPCResult::Type::NUM, "fee", "cumulative fee"}
+                        }
+                    }
+                }
+            }
+        },
+        RPCExamples{
+            HelpExampleCli("getmempoolfeeratediagram", "")
+            + HelpExampleRpc("getmempoolfeeratediagram", "")
+        },
+        [&](const RPCHelpMan& self, const JSONRPCRequest& request) -> UniValue
+        {
+            const CTxMemPool& mempool = EnsureAnyMemPool(request.context);
+            LOCK(mempool.cs);
+
+            UniValue result(UniValue::VARR);
+
+            auto diagram = mempool.GetFeerateDiagram();
+
+            for (auto f : diagram) {
+                UniValue o(UniValue::VOBJ);
+                o.pushKV("weight", f.size);
+                o.pushKV("fee", ValueFromAmount(f.fee));
+                result.push_back(o);
+            }
+            return result;
+        }
+    };
+}
+
 static RPCHelpMan getrawmempool()
 {
     return RPCHelpMan{
@@ -561,6 +647,35 @@ static RPCHelpMan getmempooldescendants()
     };
 }
 
+static RPCHelpMan getmempoolcluster()
+{
+    return RPCHelpMan{"getmempoolcluster",
+        "Returns mempool data for given cluster\n",
+        {
+            {"txid", RPCArg::Type::STR_HEX, RPCArg::Optional::NO, "The txid of a transaction in the cluster"},
+        },
+        RPCResult{
+            RPCResult::Type::OBJ, "", "", ClusterDescription()},
+        RPCExamples{
+            HelpExampleCli("getmempoolcluster", "txid")
+            + HelpExampleRpc("getmempoolcluster", "txid")
+        },
+        [&](const RPCHelpMan& self, const JSONRPCRequest& request) -> UniValue
+{
+    uint256 hash = ParseHashV(request.params[0], "parameter 1");
+
+    const CTxMemPool& mempool = EnsureAnyMemPool(request.context);
+    LOCK(mempool.cs);
+
+    auto cluster = mempool.GetCluster(Txid::FromUint256(hash));
+
+    UniValue info(UniValue::VOBJ);
+    clusterToJSON(mempool, info, cluster);
+    return info;
+},
+    };
+}
+
 static RPCHelpMan getmempoolentry()
 {
     return RPCHelpMan{
@@ -694,6 +809,8 @@ UniValue MempoolInfoToJSON(const CTxMemPool& pool)
     ret.pushKV("fullrbf", true);
     ret.pushKV("permitbaremultisig", pool.m_opts.permit_bare_multisig);
     ret.pushKV("maxdatacarriersize", pool.m_opts.max_datacarrier_bytes.value_or(0));
+    ret.pushKV("limitclustercount", pool.m_opts.limits.cluster_count);
+    ret.pushKV("limitclustersize", pool.m_opts.limits.cluster_size_vbytes);
     return ret;
 }
 
@@ -718,6 +835,8 @@ static RPCHelpMan getmempoolinfo()
                 {RPCResult::Type::BOOL, "fullrbf", "True if the mempool accepts RBF without replaceability signaling inspection (DEPRECATED)"},
                 {RPCResult::Type::BOOL, "permitbaremultisig", "True if the mempool accepts transactions with bare multisig outputs"},
                 {RPCResult::Type::NUM, "maxdatacarriersize", "Maximum number of bytes that can be used by OP_RETURN outputs in the mempool"},
+                {RPCResult::Type::NUM, "limitclustercount", "Maximum number of transactions that can be in a cluster (configured by -limitclustercount)"},
+                {RPCResult::Type::NUM, "limitclustersize", "Maximum size of a cluster in virtual bytes (configured by -limitclustersize)"},
             }},
         RPCExamples{
             HelpExampleCli("getmempoolinfo", "")
@@ -1145,8 +1264,10 @@ void RegisterMempoolRPCCommands(CRPCTable& t)
         {"blockchain", &getmempoolancestors},
         {"blockchain", &getmempooldescendants},
         {"blockchain", &getmempoolentry},
+        {"blockchain", &getmempoolcluster},
         {"blockchain", &gettxspendingprevout},
         {"blockchain", &getmempoolinfo},
+        {"hidden", &getmempoolfeeratediagram},
         {"blockchain", &getrawmempool},
         {"blockchain", &importmempool},
         {"blockchain", &savemempool},
diff --git a/src/test/fuzz/rpc.cpp b/src/test/fuzz/rpc.cpp
index 580a6338a84..9fd1021fdb8 100644
--- a/src/test/fuzz/rpc.cpp
+++ b/src/test/fuzz/rpc.cpp
@@ -136,6 +136,8 @@ const std::vector<std::string> RPC_COMMANDS_SAFE_FOR_FUZZING{
     "getmempoolancestors",
     "getmempooldescendants",
     "getmempoolentry",
+    "getmempoolfeeratediagram",
+    "getmempoolcluster",
     "getmempoolinfo",
     "getmininginfo",
     "getnettotals",
diff --git a/src/txmempool.cpp b/src/txmempool.cpp
index d7303cc6749..597d4864094 100644
--- a/src/txmempool.cpp
+++ b/src/txmempool.cpp
@@ -1010,3 +1010,25 @@ bool CTxMemPool::ChangeSet::CheckMemPoolPolicyLimits()
 
     return !m_pool->m_txgraph->IsOversized(TxGraph::Level::TOP);
 }
+
+std::vector<FeePerWeight> CTxMemPool::GetFeerateDiagram() const
+{
+    FeePerWeight zero{};
+    std::vector<FeePerWeight> ret;
+
+    ret.emplace_back(zero);
+
+    StartBlockBuilding();
+
+    std::vector<CTxMemPoolEntry::CTxMemPoolEntryRef> dummy;
+
+    FeePerWeight last_selection = GetBlockBuilderChunk(dummy);
+    while (last_selection != FeePerWeight{}) {
+        last_selection += ret.back();
+        ret.emplace_back(last_selection);
+        IncludeBuilderChunk();
+        last_selection = GetBlockBuilderChunk(dummy);
+    }
+    StopBlockBuilding();
+    return ret;
+}
diff --git a/src/txmempool.h b/src/txmempool.h
index 1891c8d48a7..e2020b65260 100644
--- a/src/txmempool.h
+++ b/src/txmempool.h
@@ -406,6 +406,23 @@ public:
      */
     void UpdateTransactionsFromBlock(const std::vector<Txid>& vHashesToUpdate) EXCLUSIVE_LOCKS_REQUIRED(cs, cs_main) LOCKS_EXCLUDED(m_epoch);
 
+    std::vector<FeePerWeight> GetFeerateDiagram() const EXCLUSIVE_LOCKS_REQUIRED(cs);
+    FeePerWeight GetMainChunkFeerate(const CTxMemPoolEntry& tx) const EXCLUSIVE_LOCKS_REQUIRED(cs) {
+        return m_txgraph->GetMainChunkFeerate(tx);
+    }
+    std::vector<const CTxMemPoolEntry*> GetCluster(Txid txid) const EXCLUSIVE_LOCKS_REQUIRED(cs) {
+        auto tx = GetIter(txid);
+        if (!tx) return {};
+        auto cluster = m_txgraph->GetCluster(**tx, TxGraph::Level::MAIN);
+        std::vector<const CTxMemPoolEntry*> ret;
+        ret.reserve(cluster.size());
+        for (const auto& tx : cluster) {
+            ret.emplace_back(static_cast<const CTxMemPoolEntry*>(tx));
+        }
+        return ret;
+    }
+
+
     size_t GetUniqueClusterCount(const setEntries& iters_conflicting) const EXCLUSIVE_LOCKS_REQUIRED(cs) {
         std::vector<const TxGraph::Ref *> entries;
         entries.reserve(iters_conflicting.size());
diff --git a/test/functional/mempool_persist.py b/test/functional/mempool_persist.py
index a9560dd6e3b..ceb69cf1ccb 100755
--- a/test/functional/mempool_persist.py
+++ b/test/functional/mempool_persist.py
@@ -128,7 +128,8 @@ class MempoolPersistTest(BitcoinTestFramework):
         assert_equal(fees['base'] + Decimal('0.00001000'), fees['modified'])
 
         self.log.debug('Verify all fields are loaded correctly')
-        assert_equal(last_entry, self.nodes[0].getmempoolentry(txid=last_txid))
+        new_entry = self.nodes[0].getmempoolentry(txid=last_txid)
+        assert_equal({**last_entry, "clusterid": None}, {**new_entry, "clusterid": None})
         self.nodes[0].sendrawtransaction(tx_prioritised_not_submitted['hex'])
         entry_prioritised_before_restart = self.nodes[0].getmempoolentry(txid=tx_prioritised_not_submitted['txid'])
         assert_equal(entry_prioritised_before_restart['fees']['base'] + Decimal('0.00009999'), entry_prioritised_before_restart['fees']['modified'])
diff --git a/test/functional/mining_prioritisetransaction.py b/test/functional/mining_prioritisetransaction.py
index a8646d49181..c3b56e8d3a4 100755
--- a/test/functional/mining_prioritisetransaction.py
+++ b/test/functional/mining_prioritisetransaction.py
@@ -101,14 +101,21 @@ class PrioritiseTransactionTest(BitcoinTestFramework):
         self.nodes[0].prioritisetransaction(txid=txid_c, fee_delta=int(fee_delta_c_1 * COIN))
         self.nodes[0].prioritisetransaction(txid=txid_c, fee_delta=int(fee_delta_c_2 * COIN))
         raw_before[txid_a]["fees"]["descendant"] += fee_delta_b + fee_delta_c_1 + fee_delta_c_2
+        # We expect tx_a to have a chunk fee that includes tx_b and tx_c.
+        raw_before[txid_a]["fees"]["chunk"] += fee_delta_b + fee_delta_c_1 + fee_delta_c_2
         raw_before[txid_b]["fees"]["modified"] += fee_delta_b
         raw_before[txid_b]["fees"]["ancestor"] += fee_delta_b
         raw_before[txid_b]["fees"]["descendant"] += fee_delta_b
+        # We also expect tx_b and tx_c to have their chunk fees modified too,
+        # since they chunk together.
+        raw_before[txid_b]["fees"]["chunk"] += fee_delta_b + fee_delta_c_1 + fee_delta_c_2
         raw_before[txid_c]["fees"]["modified"] += fee_delta_c_1 + fee_delta_c_2
         raw_before[txid_c]["fees"]["ancestor"] += fee_delta_c_1 + fee_delta_c_2
         raw_before[txid_c]["fees"]["descendant"] += fee_delta_c_1 + fee_delta_c_2
+        raw_before[txid_c]["fees"]["chunk"] += fee_delta_b + fee_delta_c_1 + fee_delta_c_2
         raw_before[txid_d]["fees"]["ancestor"] += fee_delta_b + fee_delta_c_1 + fee_delta_c_2
         raw_after = self.nodes[0].getrawmempool(verbose=True)
+        # Don't bother comparing cluster ids, which are not meant to be stable.
         assert_equal(raw_before[txid_a], raw_after[txid_a])
         assert_equal(raw_before, raw_after)
         assert_equal(self.nodes[0].getprioritisedtransactions(), {txid_b: {"fee_delta" : fee_delta_b*COIN, "in_mempool" : True, "modified_fee": int(fee_delta_b*COIN + COIN * tx_o_b["fee"])}, txid_c: {"fee_delta" : (fee_delta_c_1 + fee_delta_c_2)*COIN, "in_mempool" : True, "modified_fee": int((fee_delta_c_1 + fee_delta_c_2 ) * COIN + COIN * tx_o_c["fee"])}})

From 72f60c877e001bb8cbcd3a7fb7addfdaba149693 Mon Sep 17 00:00:00 2001
From: Suhas Daftuar <sdaftuar@chaincode.com>
Date: Wed, 24 Apr 2024 19:52:18 -0400
Subject: [PATCH 57/65] doc: Update mempool_replacements.md to reflect feerate
 diagram checks

---
 doc/policy/mempool-replacements.md | 28 +++++++++-------------------
 1 file changed, 9 insertions(+), 19 deletions(-)

diff --git a/doc/policy/mempool-replacements.md b/doc/policy/mempool-replacements.md
index 73682e2ffb3..422af9ae69e 100644
--- a/doc/policy/mempool-replacements.md
+++ b/doc/policy/mempool-replacements.md
@@ -12,12 +12,7 @@ other consensus and policy rules, each of the following conditions are met:
 
 1. (Removed)
 
-2. The replacement transaction only include an unconfirmed input if that input was included in
-   one of the directly conflicting transactions. An unconfirmed input spends an output from a
-   currently-unconfirmed transaction.
-
-   *Rationale*: When RBF was originally implemented, the mempool did not keep track of
-   ancestor feerates yet. This rule was suggested as a temporary restriction.
+2. (Removed)
 
 3. The replacement transaction pays an absolute fee of at least the sum paid by the original
    transactions.
@@ -38,23 +33,16 @@ other consensus and policy rules, each of the following conditions are met:
    *Rationale*: Try to prevent DoS attacks where an attacker causes the network to repeatedly relay
    transactions each paying a tiny additional amount in fees, e.g. just 1 satoshi.
 
-5. The number of original transactions does not exceed 100. More precisely, the sum of all
-   directly conflicting transactions' descendant counts (number of transactions inclusive of itself
-   and its descendants) must not exceed 100; it is possible that this overestimates the true number
-   of original transactions.
+5. The number of distinct clusters corresponding to conflicting transactions does not exceed 100.
 
-   *Rationale*: Try to prevent DoS attacks where an attacker is able to easily occupy and flush out
-   significant portions of the node's mempool using replacements with multiple directly conflicting
-   transactions, each with large descendant sets.
+   *Rationale*: Limit CPU usage required to update the mempool for so many transactions being
+   removed at once.
 
-6. The replacement transaction's feerate is greater than the feerates of all directly conflicting
-   transactions.
+6. The feerate diagram of the mempool must be strictly improved by the replacement transaction.
 
-   *Rationale*: This rule was originally intended to ensure that the replacement transaction is
-   preferable for block-inclusion, compared to what would be removed from the mempool. This rule
-   predates ancestor feerate-based transaction selection.
+   *Rationale*: This ensures that block fees in all future blocks will go up
+   after the replacement (ignoring tail effects at the end of a block).
 
-This set of rules is similar but distinct from BIP125.
 
 ## History
 
@@ -79,3 +67,5 @@ This set of rules is similar but distinct from BIP125.
 * Signaling for replace-by-fee is no longer required as of [PR 30592](https://github.com/bitcoin/bitcoin/pull/30592).
 
 * The incremental relay feerate default is 0.1sat/vB ([PR #33106](https://github.com/bitcoin/bitcoin/pull/33106)).
+
+* Feerate diagram policy enabled in conjunction with switch to cluster mempool as of **v31.0**.

From 6c5c44f774058bf2a0dfaaadc78347dcb5815f52 Mon Sep 17 00:00:00 2001
From: Suhas Daftuar <sdaftuar@chaincode.com>
Date: Sat, 27 Apr 2024 09:31:59 -0400
Subject: [PATCH 58/65] test: add functional test for new cluster mempool RPCs

Co-authored-by: glozow <gloriajzhao@gmail.com>
---
 test/functional/feature_rbf.py                |   6 +-
 test/functional/mempool_cluster.py            | 327 ++++++++++++++++++
 test/functional/mempool_updatefromblock.py    |   5 +-
 .../functional/test_framework/mempool_util.py |   2 +
 test/functional/test_runner.py                |   1 +
 5 files changed, 336 insertions(+), 5 deletions(-)
 create mode 100755 test/functional/mempool_cluster.py

diff --git a/test/functional/feature_rbf.py b/test/functional/feature_rbf.py
index 0590af129dd..4b2c89f3d9b 100755
--- a/test/functional/feature_rbf.py
+++ b/test/functional/feature_rbf.py
@@ -20,9 +20,9 @@ from test_framework.util import (
 )
 from test_framework.wallet import MiniWallet
 from test_framework.address import ADDRESS_BCRT1_UNSPENDABLE
+from test_framework.mempool_util import DEFAULT_CLUSTER_LIMIT
 
 MAX_REPLACEMENT_LIMIT = 100
-MAX_CLUSTER_LIMIT = 64
 
 class ReplaceByFeeTest(BitcoinTestFramework):
     def set_test_params(self):
@@ -136,7 +136,7 @@ class ReplaceByFeeTest(BitcoinTestFramework):
         prevout = tx0_outpoint
         remaining_value = initial_nValue
         chain_txids = []
-        for _ in range(MAX_CLUSTER_LIMIT):
+        for _ in range(DEFAULT_CLUSTER_LIMIT):
             if remaining_value <= 1 * COIN:
                 break
             remaining_value -= int(0.1 * COIN)
@@ -211,7 +211,7 @@ class ReplaceByFeeTest(BitcoinTestFramework):
                     yield x
 
         fee = int(0.00001 * COIN)
-        n = MAX_CLUSTER_LIMIT
+        n = DEFAULT_CLUSTER_LIMIT
         tree_txs = list(branch(tx0_outpoint, initial_nValue, n, fee=fee))
         assert_equal(len(tree_txs), n)
 
diff --git a/test/functional/mempool_cluster.py b/test/functional/mempool_cluster.py
new file mode 100755
index 00000000000..4b4812e6195
--- /dev/null
+++ b/test/functional/mempool_cluster.py
@@ -0,0 +1,327 @@
+#!/usr/bin/env python3
+# Copyright (c) 2024 The Bitcoin Core developers
+# Distributed under the MIT software license, see the accompanying
+# file COPYING or http://www.opensource.org/licenses/mit-license.php.
+"""Test cluster mempool accessors and limits"""
+
+from decimal import Decimal
+
+from test_framework.mempool_util import (
+    DEFAULT_CLUSTER_LIMIT,
+    DEFAULT_CLUSTER_SIZE_LIMIT_KVB,
+)
+from test_framework.messages import (
+    COIN,
+)
+from test_framework.test_framework import BitcoinTestFramework
+from test_framework.wallet import (
+    MiniWallet,
+)
+from test_framework.util import (
+    assert_equal,
+    assert_greater_than,
+    assert_greater_than_or_equal,
+    assert_raises_rpc_error,
+)
+
+def weight_to_vsize(weight):
+    # Divide by 4, round up
+    return (weight + 3) // 4
+
+def cleanup(func):
+    def wrapper(self, *args, **kwargs):
+        try:
+            func(self, *args, **kwargs)
+        finally:
+            # Mine blocks to clear the mempool and replenish the wallet's confirmed UTXOs.
+            while (len(self.nodes[0].getrawmempool()) > 0):
+                self.generate(self.nodes[0], 1)
+            self.wallet.rescan_utxos(include_mempool=True)
+    return wrapper
+
+class MempoolClusterTest(BitcoinTestFramework):
+    def set_test_params(self):
+        self.num_nodes = 1
+
+    def add_chain_cluster(self, node, cluster_count, target_vsize=None):
+        """Create a cluster of transactions, with the count specified.
+        The topology is a chain: the i'th transaction depends on the (i-1)'th transaction.
+        Optionally provide a target_vsize for each transaction.
+        """
+        parent_tx = self.wallet.send_self_transfer(from_node=node, confirmed_only=True, target_vsize=target_vsize)
+        utxo_to_spend = parent_tx["new_utxo"]
+        all_txids = [parent_tx["txid"]]
+        all_results = [parent_tx]
+
+        while len(all_results) < cluster_count:
+            next_tx = self.wallet.send_self_transfer(from_node=node, utxo_to_spend=utxo_to_spend, target_vsize=target_vsize)
+            assert next_tx["txid"] in node.getrawmempool()
+
+            # Confirm that each transaction is in the same cluster as the first.
+            assert_equal(node.getmempoolcluster(next_tx['txid']), node.getmempoolcluster(parent_tx['txid']))
+
+            # Confirm that the ancestors are what we expect
+            mempool_ancestors = node.getmempoolancestors(next_tx['txid'])
+            assert_equal(sorted(mempool_ancestors), sorted(all_txids))
+
+            # Confirm that each successive transaction is added as a descendant.
+            assert all([ next_tx["txid"] in node.getmempooldescendants(x) for x in all_txids ])
+
+            # Update for next iteration
+            all_results.append(next_tx)
+            all_txids.append(next_tx["txid"])
+            utxo_to_spend = next_tx["new_utxo"]
+
+        assert node.getmempoolcluster(parent_tx['txid'])['txcount'] == cluster_count
+        return all_results
+
+    def check_feerate_diagram(self, node):
+        """Sanity check the feerate diagram."""
+        feeratediagram = node.getmempoolfeeratediagram()
+        last_val = {"weight": 0, "fee": 0}
+        for x in feeratediagram:
+            # The weight is always positive, except for the first iteration
+            assert x['weight'] > 0 or x['fee'] == 0
+            # Monotonically decreasing fee per weight
+            assert_greater_than_or_equal(last_val['fee'] * x['weight'], x['fee'] * last_val['weight'])
+            last_val = x
+
+    def test_limit_enforcement(self, cluster_submitted, target_vsize_per_tx=None):
+        """
+        the cluster may change as a result of these transactions, so cluster_submitted is mutated accordingly
+        """
+        # Cluster has already been submitted and has at least 3 transactions, otherwise this test won't work.
+        assert_greater_than_or_equal(len(cluster_submitted), 3)
+        node = self.nodes[0]
+        last_result = cluster_submitted[-1]
+
+        # Test that adding one more transaction to the cluster will fail.
+        bad_tx = self.wallet.create_self_transfer(utxo_to_spend=last_result["new_utxo"], target_vsize=target_vsize_per_tx)
+        assert_raises_rpc_error(-26, "too-large-cluster", node.sendrawtransaction, bad_tx["hex"])
+
+        # It should also limit cluster sizes during replacement
+        utxo_to_double_spend = self.wallet.get_utxo(confirmed_only=True)
+        fee = Decimal("0.000001")
+        tx_to_replace = self.wallet.create_self_transfer(utxo_to_spend=utxo_to_double_spend, fee=fee)
+        node.sendrawtransaction(tx_to_replace["hex"])
+
+        # Multiply fee by 5, which should easily cover the cost to replace (but
+        # is still too large a cluster). Otherwise, use the target vsize at
+        # 10sat/vB
+        fee_to_use = target_vsize_per_tx * 10 if target_vsize_per_tx is not None else int(fee * COIN * 5)
+        bad_tx_also_replacement = self.wallet.create_self_transfer_multi(
+            utxos_to_spend=[last_result["new_utxo"], utxo_to_double_spend],
+            target_vsize=target_vsize_per_tx,
+            fee_per_output=fee_to_use,
+        )
+        assert_raises_rpc_error(-26, "too-large-cluster", node.sendrawtransaction, bad_tx_also_replacement["hex"])
+
+        # Replace the last transaction. We are extending the cluster by one, but also removing one: 64 + 1 - 1 = 64
+        # In the case of vsize, it should similarly cancel out.
+        second_to_last_utxo = cluster_submitted[-2]["new_utxo"]
+        fee_to_beat = cluster_submitted[-1]["fee"]
+        vsize_to_use = cluster_submitted[-1]["tx"].get_vsize() if target_vsize_per_tx is not None else None
+        good_tx_replacement = self.wallet.create_self_transfer(utxo_to_spend=second_to_last_utxo, fee=fee_to_beat * 5, target_vsize=vsize_to_use)
+        node.sendrawtransaction(good_tx_replacement["hex"], maxfeerate=0)
+
+        cluster_submitted[-1] = good_tx_replacement
+
+    def test_limit_enforcement_package(self, cluster_submitted):
+        node = self.nodes[0]
+        # Create a package from the second to last transaction. This shouldn't work because the effect is 64 + 2 - 1 = 65
+        last_utxo = cluster_submitted[-2]["new_utxo"]
+        fee_to_beat = cluster_submitted[-1]["fee"]
+        # We do not use package RBF here because it has additional restrictions on mempool ancestors.
+        parent_tx_bad = self.wallet.create_self_transfer(utxo_to_spend=last_utxo, fee=fee_to_beat * 5)
+        child_tx_bad = self.wallet.create_self_transfer(utxo_to_spend=parent_tx_bad["new_utxo"])
+        # The parent should be submitted, but the child rejected.
+        result_parent_only = node.submitpackage([parent_tx_bad["hex"], child_tx_bad["hex"]])
+
+        assert parent_tx_bad["txid"] in node.getrawmempool()
+        assert child_tx_bad["txid"] not in node.getrawmempool()
+        assert_equal(result_parent_only["package_msg"], "transaction failed")
+        assert_equal(result_parent_only["tx-results"][child_tx_bad["wtxid"]]["error"], "too-large-cluster")
+
+        # Now, create a package from the second to last transaction. This should work because the effect is 64 + 2 - 2 = 64
+        third_to_last_utxo = cluster_submitted[-3]["new_utxo"]
+        parent_tx_good = self.wallet.create_self_transfer(utxo_to_spend=third_to_last_utxo)
+        child_tx_good = self.wallet.create_self_transfer(utxo_to_spend=parent_tx_good["new_utxo"], fee=fee_to_beat * 5)
+        result_both_good = node.submitpackage([parent_tx_good["hex"], child_tx_good["hex"]], maxfeerate=0)
+        assert_equal(result_both_good["package_msg"], "success")
+        assert parent_tx_good["txid"] in node.getrawmempool()
+        assert child_tx_good["txid"] in node.getrawmempool()
+
+    @cleanup
+    def test_cluster_count_limit(self, max_cluster_count):
+        node = self.nodes[0]
+        cluster_submitted = self.add_chain_cluster(node, max_cluster_count)
+        self.check_feerate_diagram(node)
+        for result in cluster_submitted:
+            assert_equal(node.getmempoolcluster(result["txid"])['txcount'], max_cluster_count)
+
+        self.log.info("Test that cluster count limit is enforced")
+        self.test_limit_enforcement(cluster_submitted)
+        self.log.info("Test that the resulting cluster count is correctly calculated in a package")
+        self.test_limit_enforcement_package(cluster_submitted)
+
+    @cleanup
+    def test_cluster_size_limit(self, max_cluster_size_vbytes):
+        node = self.nodes[0]
+        # This number should be smaller than the cluster count limit.
+        num_txns = 10
+        # Leave some buffer so it is possible to add a reasonably-sized transaction.
+        target_vsize_per_tx = int((max_cluster_size_vbytes - 500) / num_txns)
+        cluster_submitted = self.add_chain_cluster(node, num_txns, target_vsize_per_tx)
+
+        vsize_remaining = max_cluster_size_vbytes - weight_to_vsize(node.getmempoolcluster(cluster_submitted[0]["txid"])['weight'])
+        self.log.info("Test that cluster size limit is enforced")
+        self.test_limit_enforcement(cluster_submitted, target_vsize_per_tx=vsize_remaining + 4)
+
+        # Try another cluster and add a small transaction: it should succeed
+        last_result = cluster_submitted[-1]
+        small_tx = self.wallet.create_self_transfer(utxo_to_spend=last_result["new_utxo"], target_vsize=vsize_remaining)
+        node.sendrawtransaction(small_tx["hex"])
+
+    @cleanup
+    def test_cluster_merging(self, max_cluster_count):
+        node = self.nodes[0]
+
+        self.log.info(f"Test merging 2 clusters with transaction counts totaling {max_cluster_count}")
+        for num_txns_cluster1 in [1, 5, 10]:
+            # Create a chain of transactions
+            cluster1 = self.add_chain_cluster(node, num_txns_cluster1)
+            for result in cluster1:
+                node.sendrawtransaction(result["hex"])
+            utxo_from_cluster1 = cluster1[-1]["new_utxo"]
+
+            # Make the next cluster, which contains the remaining transactions
+            assert_greater_than(max_cluster_count, num_txns_cluster1)
+            num_txns_cluster2 = max_cluster_count - num_txns_cluster1
+            cluster2 = self.add_chain_cluster(node, num_txns_cluster2)
+            for result in cluster2:
+                node.sendrawtransaction(result["hex"])
+            utxo_from_cluster2 = cluster2[-1]["new_utxo"]
+
+            # Now create a transaction that spends from both clusters, which would merge them.
+            tx_merger = self.wallet.create_self_transfer_multi(utxos_to_spend=[utxo_from_cluster1, utxo_from_cluster2])
+            assert_raises_rpc_error(-26, "too-large-cluster", node.sendrawtransaction, tx_merger["hex"])
+
+            # Spending from the clusters independently should work
+            tx_spending_cluster1 = self.wallet.send_self_transfer(from_node=node, utxo_to_spend=utxo_from_cluster1)
+            tx_spending_cluster2 = self.wallet.send_self_transfer(from_node=node, utxo_to_spend=utxo_from_cluster2)
+            assert tx_spending_cluster1["txid"] in node.getrawmempool()
+            assert tx_spending_cluster2["txid"] in node.getrawmempool()
+
+        self.log.info(f"Test merging {max_cluster_count} clusters with 1 transaction spending from all of them")
+        utxos_to_merge = []
+        for _ in range(max_cluster_count):
+            # Use a confirmed utxo to ensure distinct clusters
+            confirmed_utxo = self.wallet.get_utxo(confirmed_only=True)
+            singleton = self.wallet.send_self_transfer(from_node=node, utxo_to_spend=confirmed_utxo)
+            assert singleton["txid"] in node.getrawmempool()
+            utxos_to_merge.append(singleton["new_utxo"])
+
+        assert_equal(len(utxos_to_merge), max_cluster_count)
+        tx_merger = self.wallet.create_self_transfer_multi(utxos_to_spend=utxos_to_merge)
+        assert_raises_rpc_error(-26, "too-large-cluster", node.sendrawtransaction, tx_merger["hex"])
+
+        # Spending from 1 fewer cluster should work
+        tx_merger_all_but_one = self.wallet.create_self_transfer_multi(utxos_to_spend=utxos_to_merge[:-1])
+        node.sendrawtransaction(tx_merger_all_but_one["hex"])
+        assert tx_merger_all_but_one["txid"] in node.getrawmempool()
+
+    @cleanup
+    def test_cluster_merging_size(self, max_cluster_size_vbytes):
+        node = self.nodes[0]
+
+        self.log.info(f"Test merging clusters with sizes totaling {max_cluster_size_vbytes} vB")
+        num_txns = 10
+        # Leave some buffer so it is possible to add a reasonably-sized transaction.
+        utxos_to_merge = []
+        vsize_remaining = max_cluster_size_vbytes
+        for _ in range(num_txns):
+            confirmed_utxo = self.wallet.get_utxo(confirmed_only=True)
+            singleton = self.wallet.send_self_transfer(from_node=node, utxo_to_spend=confirmed_utxo)
+            assert singleton["txid"] in node.getrawmempool()
+            utxos_to_merge.append(singleton["new_utxo"])
+            vsize_remaining -= singleton["tx"].get_vsize()
+
+        assert_greater_than_or_equal(vsize_remaining, 500)
+
+        # Create a transaction spending from all clusters that exceeds the cluster size limit.
+        tx_merger_too_big = self.wallet.create_self_transfer_multi(utxos_to_spend=utxos_to_merge, target_vsize=vsize_remaining + 4, fee_per_output=10000)
+        assert_raises_rpc_error(-26, "too-large-cluster", node.sendrawtransaction, tx_merger_too_big["hex"])
+
+        # A transaction that is slightly smaller should work.
+        tx_merger_small = self.wallet.create_self_transfer_multi(utxos_to_spend=utxos_to_merge[:-1], target_vsize=vsize_remaining - 4, fee_per_output=10000)
+        node.sendrawtransaction(tx_merger_small["hex"])
+        assert tx_merger_small["txid"] in node.getrawmempool()
+
+    @cleanup
+    def test_cluster_limit_rbf(self, max_cluster_count):
+        node = self.nodes[0]
+
+        # Use min feerate for the to-be-replaced transactions. There are many, so replacement cost can be expensive.
+        min_feerate = node.getmempoolinfo()["mempoolminfee"]
+
+        self.log.info("Test that cluster size calculation takes RBF into account")
+        utxos_created_by_parents = []
+        fees_rbf_sats = 0
+        for _ in range(max_cluster_count - 1):
+            parent_tx = self.wallet.send_self_transfer(from_node=node, confirmed_only=True)
+            utxo_to_replace = parent_tx["new_utxo"]
+            child_tx = self.wallet.send_self_transfer(from_node=node, utxo_to_spend=utxo_to_replace, fee_rate=min_feerate)
+
+            fees_rbf_sats += int(child_tx["fee"] * COIN)
+            utxos_created_by_parents.append(utxo_to_replace)
+
+        # This transaction would create a cluster of size max_cluster_count
+        # Importantly, the node should account for the fact that half of the transactions will be replaced.
+        tx_merger_replacer = self.wallet.create_self_transfer_multi(utxos_to_spend=utxos_created_by_parents, fee_per_output=fees_rbf_sats * 2)
+        node.sendrawtransaction(tx_merger_replacer["hex"])
+        assert tx_merger_replacer["txid"] in node.getrawmempool()
+        assert_equal(node.getmempoolcluster(tx_merger_replacer["txid"])['txcount'], max_cluster_count)
+
+        self.log.info("Test that cluster size calculation takes package RBF into account")
+        utxos_to_replace = []
+        fee_rbf_decimal = 0
+        for _ in range(max_cluster_count):
+            confirmed_utxo = self.wallet.get_utxo(confirmed_only=True)
+            tx_to_replace = self.wallet.send_self_transfer(from_node=node, utxo_to_spend=confirmed_utxo, fee_rate=min_feerate)
+            fee_rbf_decimal += tx_to_replace["fee"]
+            utxos_to_replace.append(confirmed_utxo)
+
+        tx_replacer = self.wallet.create_self_transfer_multi(utxos_to_spend=utxos_to_replace)
+        tx_replacer_sponsor = self.wallet.create_self_transfer(utxo_to_spend=tx_replacer["new_utxos"][0], fee=fee_rbf_decimal * 2)
+        node.submitpackage([tx_replacer["hex"], tx_replacer_sponsor["hex"]], maxfeerate=0)
+        assert tx_replacer["txid"] in node.getrawmempool()
+        assert tx_replacer_sponsor["txid"] in node.getrawmempool()
+        assert_equal(node.getmempoolcluster(tx_replacer["txid"])['txcount'], 2)
+
+
+    def run_test(self):
+        node = self.nodes[0]
+        self.wallet = MiniWallet(node)
+        self.generate(self.wallet, 400)
+
+        self.test_cluster_limit_rbf(DEFAULT_CLUSTER_LIMIT)
+
+        for cluster_size_limit_kvb in [10, 20, 33, 100, DEFAULT_CLUSTER_SIZE_LIMIT_KVB]:
+            self.log.info(f"-> Resetting node with -limitclustersize={cluster_size_limit_kvb}")
+            self.restart_node(0, extra_args=[f"-limitclustersize={cluster_size_limit_kvb}"])
+
+            cluster_size_limit = cluster_size_limit_kvb * 1000
+            self.test_cluster_size_limit(cluster_size_limit)
+            self.test_cluster_merging_size(cluster_size_limit)
+
+        for cluster_count_limit in [4, 10, 16, 32, DEFAULT_CLUSTER_LIMIT]:
+            self.log.info(f"-> Resetting node with -limitclustercount={cluster_count_limit}")
+            self.restart_node(0, extra_args=[f"-limitclustercount={cluster_count_limit}"])
+
+            self.test_cluster_count_limit(cluster_count_limit)
+            if cluster_count_limit > 10:
+                self.test_cluster_merging(cluster_count_limit)
+
+
+if __name__ == '__main__':
+    MempoolClusterTest(__file__).main()
diff --git a/test/functional/mempool_updatefromblock.py b/test/functional/mempool_updatefromblock.py
index bf0b8778b64..060c72e2c93 100755
--- a/test/functional/mempool_updatefromblock.py
+++ b/test/functional/mempool_updatefromblock.py
@@ -18,6 +18,7 @@ from test_framework.blocktools import (
 from test_framework.test_framework import BitcoinTestFramework
 from test_framework.util import assert_equal, assert_raises_rpc_error
 from test_framework.wallet import MiniWallet
+from test_framework.mempool_util import DEFAULT_CLUSTER_LIMIT
 
 MAX_DISCONNECTED_TX_POOL_BYTES = 20_000_000
 
@@ -197,7 +198,7 @@ class MempoolUpdateFromBlockTest(BitcoinTestFramework):
         fork_blocks = self.create_empty_fork(fork_length=10)
 
         # Two higher than descendant count
-        chain = wallet.create_self_transfer_chain(chain_length=64 + 2)
+        chain = wallet.create_self_transfer_chain(chain_length=DEFAULT_CLUSTER_LIMIT + 2)
         for tx in chain[:-2]:
             self.nodes[0].sendrawtransaction(tx["hex"])
 
@@ -219,7 +220,7 @@ class MempoolUpdateFromBlockTest(BitcoinTestFramework):
 
     def run_test(self):
         # Mine in batches of 25 to test multi-block reorg under chain limits
-        self.transaction_graph_test(size=64, n_tx_to_mine=[25, 50, 75])
+        self.transaction_graph_test(size=DEFAULT_CLUSTER_LIMIT, n_tx_to_mine=[25, 50, 75])
 
         self.test_max_disconnect_pool_bytes()
 
diff --git a/test/functional/test_framework/mempool_util.py b/test/functional/test_framework/mempool_util.py
index 3c4609c0b44..89e2558307e 100644
--- a/test/functional/test_framework/mempool_util.py
+++ b/test/functional/test_framework/mempool_util.py
@@ -33,6 +33,8 @@ from .wallet import (
 DEFAULT_MIN_RELAY_TX_FEE = 100
 # Default for -incrementalrelayfee in sat/kvB
 DEFAULT_INCREMENTAL_RELAY_FEE = 100
+DEFAULT_CLUSTER_LIMIT = 64
+DEFAULT_CLUSTER_SIZE_LIMIT_KVB = 101
 
 TRUC_MAX_VSIZE = 10000
 TRUC_CHILD_MAX_VSIZE = 1000
diff --git a/test/functional/test_runner.py b/test/functional/test_runner.py
index 97b23921653..32c81ef7278 100755
--- a/test/functional/test_runner.py
+++ b/test/functional/test_runner.py
@@ -340,6 +340,7 @@ BASE_SCRIPTS = [
     'p2p_sendtxrcncl.py',
     'rpc_scantxoutset.py',
     'feature_unsupported_utxo_db.py',
+    'mempool_cluster.py',
     'feature_logging.py',
     'interface_ipc.py',
     'feature_anchors.py',

From 9567eaa66da88a79c54f7a77922d817862122af2 Mon Sep 17 00:00:00 2001
From: Suhas Daftuar <sdaftuar@chaincode.com>
Date: Tue, 29 Jul 2025 16:16:18 -0400
Subject: [PATCH 59/65] Invoke TxGraph::DoWork() at appropriate times

---
 src/txmempool.cpp | 3 +++
 src/txmempool.h   | 4 ++++
 2 files changed, 7 insertions(+)

diff --git a/src/txmempool.cpp b/src/txmempool.cpp
index 597d4864094..5197fb012df 100644
--- a/src/txmempool.cpp
+++ b/src/txmempool.cpp
@@ -211,6 +211,7 @@ void CTxMemPool::Apply(ChangeSet* changeset)
 
         addNewTransaction(it);
     }
+    m_txgraph->DoWork(POST_CHANGE_WORK);
 }
 
 void CTxMemPool::addNewTransaction(CTxMemPool::txiter newit)
@@ -357,6 +358,7 @@ void CTxMemPool::removeForReorg(CChain& chain, std::function<bool(txiter)> check
     for (indexed_transaction_set::const_iterator it = mapTx.begin(); it != mapTx.end(); it++) {
         assert(TestLockPointValidity(chain, it->GetLockPoints()));
     }
+    m_txgraph->DoWork(POST_CHANGE_WORK);
 }
 
 void CTxMemPool::removeConflicts(const CTransaction &tx)
@@ -401,6 +403,7 @@ void CTxMemPool::removeForBlock(const std::vector<CTransactionRef>& vtx, unsigne
     }
     lastRollingFeeUpdate = GetTime();
     blockSinceLastRollingFeeBump = true;
+    m_txgraph->DoWork(POST_CHANGE_WORK);
 }
 
 void CTxMemPool::check(const CCoinsViewCache& active_coins_tip, int64_t spendheight) const
diff --git a/src/txmempool.h b/src/txmempool.h
index e2020b65260..a3487c04ea4 100644
--- a/src/txmempool.h
+++ b/src/txmempool.h
@@ -55,6 +55,10 @@ static const uint32_t MEMPOOL_HEIGHT = 0x7FFFFFFF;
  * iterations. */
 static constexpr uint64_t ACCEPTABLE_ITERS = 1'700;
 
+/** How much work we ask TxGraph to do after a mempool change occurs (either
+ * due to a changeset being applied, a new block being found, or a reorg). */
+static constexpr uint64_t POST_CHANGE_WORK = 5 * ACCEPTABLE_ITERS;
+
 /**
  * Test whether the LockPoints height and time are still valid on the current chain
  */

From a86ac117681727b6e72ab50ed751d0d3b0cdff34 Mon Sep 17 00:00:00 2001
From: Suhas Daftuar <sdaftuar@chaincode.com>
Date: Tue, 2 Sep 2025 19:01:10 -0400
Subject: [PATCH 60/65] Update comments for CTxMemPool class

---
 src/txmempool.h | 90 ++++++++++++++++++++-----------------------------
 1 file changed, 37 insertions(+), 53 deletions(-)

diff --git a/src/txmempool.h b/src/txmempool.h
index a3487c04ea4..1fc94c6db70 100644
--- a/src/txmempool.h
+++ b/src/txmempool.h
@@ -141,64 +141,48 @@ struct TxMempoolInfo
  * requirements as defined in doc/policy/mempool-replacements.md.
  * - a non-standard transaction.
  *
- * CTxMemPool::mapTx, and CTxMemPoolEntry bookkeeping:
+ * TxGraph (CTxMemPool::m_txgraph) provides an abstraction layer for separating
+ * the transaction graph parts of the mempool from the rest of the
+ * Bitcoin-specific logic. Specifically, TxGraph handles (for each transaction)
+ * managing the in-mempool parents and children, and has knowledge of the fee
+ * and size of every transaction. It uses this to partition the mempool into
+ * connected clusters, and it implements (among other things):
+ *  - limits on the size of a cluster (in both number of transactions
+ *    and total weight)
+ *  - sorting the mempool optimally for block inclusion, taking into account
+ *    dependencies
+ *  - selecting transactions for removal due to cluster size limit violations
+ *    after a reorg.
+ * See txgraph.h and txgraph.cpp for more details.
  *
- * mapTx is a boost::multi_index that sorts the mempool on 5 criteria:
+ * CTxMemPool itself handles the Bitcoin-specific parts of mempool
+ * transactions; it stores the full transaction inside CTxMemPoolEntry, along
+ * with other consensus-specific fields (such as whether a transaction spends a
+ * coinbase, or the LockPoints for transaction finality). And it provides
+ * interfaces to the rest of the codebase, such as:
+ *  - to validation for replace-by-fee calculations and cluster size limits
+ *    when evaluating unconfirmed transactions
+ *  - to validation for evicting transactions due to expiry or the mempool size
+ *    limit being hit
+ *  - to validation for updating the mempool to be consistent with the best
+ *    chain after a new block is connected or after a reorg.
+ *  - to net_processing for ordering transactions that are to-be-announced to
+ *    other peers
+ *  - to RPC code for inspecting the mempool
+ *
+ * (Many of these interfaces are just wrappers around corresponding TxGraph
+ * functions.)
+ *
+ * Within CTxMemPool, the mempool entries are stored in a boost::multi_index
+ * mapTx, which sorts the mempool on 3 criteria:
  * - transaction hash (txid)
  * - witness-transaction hash (wtxid)
- * - descendant feerate [we use max(feerate of tx, feerate of tx with all descendants)]
  * - time in mempool
- * - ancestor feerate [we use min(feerate of tx, feerate of tx with all unconfirmed ancestors)]
  *
- * Note: the term "descendant" refers to in-mempool transactions that depend on
- * this one, while "ancestor" refers to in-mempool transactions that a given
- * transaction depends on.
- *
- * In order for the feerate sort to remain correct, we must update transactions
- * in the mempool when new descendants arrive.  To facilitate this, we track
- * the set of in-mempool direct parents and direct children in mapLinks.  Within
- * each CTxMemPoolEntry, we track the size and fees of all descendants.
- *
- * Usually when a new transaction is added to the mempool, it has no in-mempool
- * children (because any such children would be an orphan).  So in
- * addNewTransaction(), we:
- * - update a new entry's m_parents to include all in-mempool parents
- * - update each of those parent entries to include the new tx as a child
- * - update all ancestors of the transaction to include the new tx's size/fee
- *
- * When a transaction is removed from the mempool, we must:
- * - update all in-mempool parents to not track the tx in their m_children
- * - update all ancestors to not include the tx's size/fees in descendant state
- * - update all in-mempool children to not include it as a parent
- *
- * These happen in UpdateForRemoveFromMempool().  (Note that when removing a
- * transaction along with its descendants, we must calculate that set of
- * transactions to be removed before doing the removal, or else the mempool can
- * be in an inconsistent state where it's impossible to walk the ancestors of
- * a transaction.)
- *
- * In the event of a reorg, the assumption that a newly added tx has no
- * in-mempool children is false.  In particular, the mempool is in an
- * inconsistent state while new transactions are being added, because there may
- * be descendant transactions of a tx coming from a disconnected block that are
- * unreachable from just looking at transactions in the mempool (the linking
- * transactions may also be in the disconnected block, waiting to be added).
- * Because of this, there's not much benefit in trying to search for in-mempool
- * children in addNewTransaction().  Instead, in the special case of transactions
- * being added from a disconnected block, we require the caller to clean up the
- * state, to account for in-mempool, out-of-block descendants for all the
- * in-block transactions by calling UpdateTransactionsFromBlock().  Note that
- * until this is called, the mempool state is not consistent, and in particular
- * mapLinks may not be correct (and therefore functions like
- * CalculateMemPoolAncestors() and CalculateDescendants() that rely
- * on them to walk the mempool are not generally safe to use).
- *
- * Computational limits:
- *
- * Updating all in-mempool ancestors of a newly added transaction can be slow,
- * if no bound exists on how many in-mempool ancestors there may be.
- * CalculateMemPoolAncestors() takes configurable limits that are designed to
- * prevent these calculations from being too CPU intensive.
+ * We also maintain a map from COutPoint to the (in-mempool) transaction that
+ * spends it (mapNextTx). This allows us to recover from a reorg and find
+ * transactions in the mempool that conflict with transactions that are
+ * confirmed in a block.
  *
  */
 class CTxMemPool

From 79f73ad713a8d62a6172fbad228cbca848f9ff57 Mon Sep 17 00:00:00 2001
From: Suhas Daftuar <sdaftuar@chaincode.com>
Date: Wed, 17 Sep 2025 13:26:45 -0400
Subject: [PATCH 61/65] Add check that GetSortedScoreWithTopology() agrees with
 CompareMiningScoreWithTopology()

We use CompareMiningScoreWithTopology() for sorting transaction announcements
during tx relay, and we use GetSortedScoreWithTopology() in
CTxMemPool::check().
---
 src/txmempool.cpp | 9 +++++++++
 1 file changed, 9 insertions(+)

diff --git a/src/txmempool.cpp b/src/txmempool.cpp
index 5197fb012df..592f6194523 100644
--- a/src/txmempool.cpp
+++ b/src/txmempool.cpp
@@ -425,11 +425,20 @@ void CTxMemPool::check(const CCoinsViewCache& active_coins_tip, int64_t spendhei
 
     CCoinsViewCache mempoolDuplicate(const_cast<CCoinsViewCache*>(&active_coins_tip));
 
+    std::optional<Wtxid> last_wtxid = std::nullopt;
+
     for (const auto& it : GetSortedScoreWithTopology()) {
         checkTotal += it->GetTxSize();
         check_total_fee += it->GetFee();
         innerUsage += it->DynamicMemoryUsage();
         const CTransaction& tx = it->GetTx();
+
+        // CompareMiningScoreWithTopology should agree with GetSortedScoreWithTopology()
+        if (last_wtxid) {
+            assert(CompareMiningScoreWithTopology(*last_wtxid, tx.GetWitnessHash()));
+        }
+        last_wtxid = tx.GetWitnessHash();
+
         std::set<CTxMemPoolEntry::CTxMemPoolEntryRef, CompareIteratorByHash> setParentCheck;
         std::set<CTxMemPoolEntry::CTxMemPoolEntryRef, CompareIteratorByHash> setParentsStored;
         for (const CTxIn &txin : tx.vin) {

From 4ef4ddb504e53cb148e8dd713695db37df0e1e4f Mon Sep 17 00:00:00 2001
From: Suhas Daftuar <sdaftuar@chaincode.com>
Date: Sun, 19 Oct 2025 10:31:52 -0400
Subject: [PATCH 62/65] doc: update policy/packages.md for new package
 acceptance logic

---
 doc/policy/packages.md | 16 +---------------
 1 file changed, 1 insertion(+), 15 deletions(-)

diff --git a/doc/policy/packages.md b/doc/policy/packages.md
index 7522a984435..4795f715e80 100644
--- a/doc/policy/packages.md
+++ b/doc/policy/packages.md
@@ -38,9 +38,7 @@ The following rules are enforced for all packages:
 
    - Packages are 1-parent-1-child, with no in-mempool ancestors of the package.
 
-   - All conflicting clusters (connected components of mempool transactions) must be clusters of up to size 2.
-
-   - No more than MAX_REPLACEMENT_CANDIDATES transactions can be replaced, analogous to
+   - The number of distinct clusters containing conflicting transactions can be no more than 100, analogous to
      regular [replacement rule](./mempool-replacements.md) 5).
 
    - Replacements must pay more total fees at the incremental relay fee (analogous to
@@ -56,18 +54,6 @@ The following rules are enforced for all packages:
      result in more robust fee bumping. More general package RBF may be
      enabled in the future.
 
-* When packages are evaluated against ancestor/descendant limits, the union of all transactions'
-  descendants and ancestors is considered. (#21800)
-
-   - *Rationale*: This is essentially a "worst case" heuristic intended for packages that are
-     heavily connected, i.e. some transaction in the package is the ancestor or descendant of all
-     the other transactions.
-
-* [CPFP Carve Out](./mempool-limits.md#CPFP-Carve-Out) is disabled in packaged contexts. (#21800)
-
-   - *Rationale*: This carve out cannot be accurately applied when there are multiple transactions'
-     ancestors and descendants being considered at the same time.
-
 The following rules are only enforced for packages to be submitted to the mempool (not
 enforced for test accepts):
 

From de2e9a24c40e1915827506250ed0bbda4009ce83 Mon Sep 17 00:00:00 2001
From: Suhas Daftuar <sdaftuar@chaincode.com>
Date: Thu, 30 Oct 2025 07:58:33 -0400
Subject: [PATCH 63/65] test: extend package rbf functional test to larger
 clusters

Co-Authored-By: Gregory Sanders <gsanders87@gmail.com>
---
 test/functional/mempool_package_rbf.py | 14 +++++++-------
 1 file changed, 7 insertions(+), 7 deletions(-)

diff --git a/test/functional/mempool_package_rbf.py b/test/functional/mempool_package_rbf.py
index 759e3cb07d3..c54534f6f82 100755
--- a/test/functional/mempool_package_rbf.py
+++ b/test/functional/mempool_package_rbf.py
@@ -93,7 +93,7 @@ class PackageRBFTest(BitcoinTestFramework):
         self.test_child_conflicts_parent_mempool_ancestor()
 
     def test_package_rbf_basic(self):
-        self.log.info("Test that a child can pay to replace its parents' conflicts of cluster size 2")
+        self.log.info("Test that a child can pay to replace its parents' conflicts")
         node = self.nodes[0]
         # Reuse the same coins so that the transactions conflict with one another.
         parent_coin = self.coins.pop()
@@ -195,12 +195,12 @@ class PackageRBFTest(BitcoinTestFramework):
         parent_coins = self.coins[:num_coins]
         del self.coins[:num_coins]
 
-        # Original transactions: 101 transactions with 1 descendants each -> 202 total transactions, 101 clusters
-        size_two_clusters = []
+        # Original transactions: 101 transactions with 2 descendants each -> 303 total transactions, 101 clusters
+        size_three_clusters = []
         for coin in parent_coins:
-            size_two_clusters.append(self.wallet.send_self_transfer_chain(from_node=node, chain_length=2, utxo_to_spend=coin))
-        expected_txns = [txn["tx"] for parent_child_txns in size_two_clusters for txn in parent_child_txns]
-        assert_equal(len(expected_txns), num_coins * 2)
+            size_three_clusters.append(self.wallet.send_self_transfer_chain(from_node=node, chain_length=3, utxo_to_spend=coin))
+        expected_txns = [txn["tx"] for parent_child_txns in size_three_clusters for txn in parent_child_txns]
+        assert_equal(len(expected_txns), num_coins * 3)
         self.assert_mempool_contents(expected=expected_txns)
 
         # parent feeerate needs to be high enough for minrelay
@@ -240,7 +240,7 @@ class PackageRBFTest(BitcoinTestFramework):
         package_child = self.wallet.create_self_transfer(fee_rate=child_feerate, utxo_to_spend=package_parent["new_utxos"][0])
         pkg_results = node.submitpackage([package_parent["hex"], package_child["hex"]], maxfeerate=0)
         assert_equal(pkg_results["package_msg"], "success")
-        self.assert_mempool_contents(expected=[singleton_tx["tx"], size_two_clusters[-1][0]["tx"], size_two_clusters[-1][1]["tx"], package_parent["tx"], package_child["tx"]] )
+        self.assert_mempool_contents(expected=[singleton_tx["tx"], size_three_clusters[-1][0]["tx"], size_three_clusters[-1][1]["tx"], size_three_clusters[-1][2]["tx"], package_parent["tx"], package_child["tx"]] )
 
         self.generate(node, 1)
 

From 315e43e5d86c06b1e51b907f1942cab150205d24 Mon Sep 17 00:00:00 2001
From: Suhas Daftuar <sdaftuar@chaincode.com>
Date: Thu, 30 Oct 2025 13:48:46 -0400
Subject: [PATCH 64/65] Sanity check `GetFeerateDiagram()` in
 CTxMemPool::check()

---
 src/txmempool.cpp | 8 +++++++-
 1 file changed, 7 insertions(+), 1 deletion(-)

diff --git a/src/txmempool.cpp b/src/txmempool.cpp
index 592f6194523..5a46a029cdc 100644
--- a/src/txmempool.cpp
+++ b/src/txmempool.cpp
@@ -425,9 +425,15 @@ void CTxMemPool::check(const CCoinsViewCache& active_coins_tip, int64_t spendhei
 
     CCoinsViewCache mempoolDuplicate(const_cast<CCoinsViewCache*>(&active_coins_tip));
 
+    const auto score_with_topo{GetSortedScoreWithTopology()};
+
+    // Number of chunks is bounded by number of transactions.
+    const auto diagram{GetFeerateDiagram()};
+    Assume(diagram.size() <= score_with_topo.size() + 1);
+
     std::optional<Wtxid> last_wtxid = std::nullopt;
 
-    for (const auto& it : GetSortedScoreWithTopology()) {
+    for (const auto& it : score_with_topo) {
         checkTotal += it->GetTxSize();
         check_total_fee += it->GetFee();
         innerUsage += it->DynamicMemoryUsage();

From 17cf9ff7efdbab07644fc2f9017fcac1b0757c38 Mon Sep 17 00:00:00 2001
From: Suhas Daftuar <sdaftuar@chaincode.com>
Date: Tue, 11 Nov 2025 15:51:38 -0500
Subject: [PATCH 65/65] Use cluster size limit for -maxmempool bound, and allow
 -maxmempool=0 in general

Previously we would sanity check the -maxmempool configuration based on a
multiple of the descendant size limit, but with cluster mempool the maximum
evicted size is now the cluster size limit, so use that instead.

Also allow -maxmempool=0 in general (and not just if
-limitdescendantsize/-limitclustersize is set to 0).
---
 src/txmempool.cpp                  | 6 +++---
 test/functional/feature_dbcrash.py | 1 -
 2 files changed, 3 insertions(+), 4 deletions(-)

diff --git a/src/txmempool.cpp b/src/txmempool.cpp
index 5a46a029cdc..df90683a406 100644
--- a/src/txmempool.cpp
+++ b/src/txmempool.cpp
@@ -164,9 +164,9 @@ CTxMemPool::setEntries CTxMemPool::CalculateMemPoolAncestors(const CTxMemPoolEnt
 static CTxMemPool::Options&& Flatten(CTxMemPool::Options&& opts, bilingual_str& error)
 {
     opts.check_ratio = std::clamp<int>(opts.check_ratio, 0, 1'000'000);
-    int64_t descendant_limit_bytes = opts.limits.descendant_size_vbytes * 40;
-    if (opts.max_size_bytes < 0 || opts.max_size_bytes < descendant_limit_bytes) {
-        error = strprintf(_("-maxmempool must be at least %d MB"), std::ceil(descendant_limit_bytes / 1'000'000.0));
+    int64_t cluster_limit_bytes = opts.limits.cluster_size_vbytes * 40;
+    if (opts.max_size_bytes < 0 || (opts.max_size_bytes > 0 && opts.max_size_bytes < cluster_limit_bytes)) {
+        error = strprintf(_("-maxmempool must be at least %d MB"), std::ceil(cluster_limit_bytes / 1'000'000.0));
     }
     return std::move(opts);
 }
diff --git a/test/functional/feature_dbcrash.py b/test/functional/feature_dbcrash.py
index c3008970956..0c2059d165f 100755
--- a/test/functional/feature_dbcrash.py
+++ b/test/functional/feature_dbcrash.py
@@ -53,7 +53,6 @@ class ChainstateWriteCrashTest(BitcoinTestFramework):
 
         # Set -maxmempool=0 to turn off mempool memory sharing with dbcache
         self.base_args = [
-            "-limitdescendantsize=0",
             "-maxmempool=0",
             "-dbbatchsize=200000",
         ]