txmempool.cpp raw
1 // Copyright (c) 2009-2010 Satoshi Nakamoto
2 // Copyright (c) 2009-present The Bitcoin Core developers
3 // Distributed under the MIT software license, see the accompanying
4 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
5
6 #include <txmempool.h>
7
8 #include <chain.h>
9 #include <coins.h>
10 #include <common/system.h>
11 #include <consensus/consensus.h>
12 #include <consensus/tx_verify.h>
13 #include <consensus/validation.h>
14 #include <policy/policy.h>
15 #include <policy/settings.h>
16 #include <random.h>
17 #include <tinyformat.h>
18 #include <util/check.h>
19 #include <util/feefrac.h>
20 #include <util/log.h>
21 #include <util/moneystr.h>
22 #include <util/overflow.h>
23 #include <util/result.h>
24 #include <util/time.h>
25 #include <util/trace.h>
26 #include <util/translation.h>
27 #include <validationinterface.h>
28
29 #include <algorithm>
30 #include <cmath>
31 #include <numeric>
32 #include <optional>
33 #include <ranges>
34 #include <string_view>
35 #include <utility>
36
37 TRACEPOINT_SEMAPHORE(mempool, added);
38 TRACEPOINT_SEMAPHORE(mempool, removed);
39
40 bool TestLockPointValidity(CChain& active_chain, const LockPoints& lp)
41 {
42 AssertLockHeld(cs_main);
43 // If there are relative lock times then the maxInputBlock will be set
44 // If there are no relative lock times, the LockPoints don't depend on the chain
45 if (lp.maxInputBlock) {
46 // Check whether active_chain is an extension of the block at which the LockPoints
47 // calculation was valid. If not LockPoints are no longer valid
48 if (!active_chain.Contains(*lp.maxInputBlock)) {
49 return false;
50 }
51 }
52
53 // LockPoints still valid
54 return true;
55 }
56
57 std::vector<CTxMemPoolEntry::CTxMemPoolEntryRef> CTxMemPool::GetChildren(const CTxMemPoolEntry& entry) const
58 {
59 std::vector<CTxMemPoolEntry::CTxMemPoolEntryRef> ret;
60 const auto& hash = entry.GetTx().GetHash();
61 {
62 LOCK(cs);
63 auto iter = mapNextTx.lower_bound(COutPoint(hash, 0));
64 for (; iter != mapNextTx.end() && iter->first->hash == hash; ++iter) {
65 ret.emplace_back(*(iter->second));
66 }
67 }
68 std::ranges::sort(ret, CompareIteratorByHash{});
69 auto removed = std::ranges::unique(ret, [](auto& a, auto& b) noexcept { return &a.get() == &b.get(); });
70 ret.erase(removed.begin(), removed.end());
71 return ret;
72 }
73
74 std::vector<CTxMemPoolEntry::CTxMemPoolEntryRef> CTxMemPool::GetParents(const CTxMemPoolEntry& entry) const
75 {
76 LOCK(cs);
77 std::vector<CTxMemPoolEntry::CTxMemPoolEntryRef> ret;
78 std::set<Txid> inputs;
79 for (const auto& txin : entry.GetTx().vin) {
80 inputs.insert(txin.prevout.hash);
81 }
82 for (const auto& hash : inputs) {
83 std::optional<txiter> piter = GetIter(hash);
84 if (piter) {
85 ret.emplace_back(**piter);
86 }
87 }
88 return ret;
89 }
90
91 void CTxMemPool::UpdateTransactionsFromBlock(const std::vector<Txid>& vHashesToUpdate)
92 {
93 AssertLockHeld(cs);
94
95 // Iterate in reverse, so that whenever we are looking at a transaction
96 // we are sure that all in-mempool descendants have already been processed.
97 for (const Txid& hash : vHashesToUpdate | std::views::reverse) {
98 // calculate children from mapNextTx
99 txiter it = mapTx.find(hash);
100 if (it == mapTx.end()) {
101 continue;
102 }
103 auto iter = mapNextTx.lower_bound(COutPoint(hash, 0));
104 {
105 for (; iter != mapNextTx.end() && iter->first->hash == hash; ++iter) {
106 txiter childIter = iter->second;
107 assert(childIter != mapTx.end());
108 // Add dependencies that are discovered between transactions in the
109 // block and transactions that were in the mempool to txgraph.
110 m_txgraph->AddDependency(/*parent=*/*it, /*child=*/*childIter);
111 }
112 }
113 }
114
115 auto txs_to_remove = m_txgraph->Trim(); // Enforce cluster size limits.
116 for (auto txptr : txs_to_remove) {
117 const CTxMemPoolEntry& entry = *(static_cast<const CTxMemPoolEntry*>(txptr));
118 removeUnchecked(mapTx.iterator_to(entry), MemPoolRemovalReason::SIZELIMIT);
119 }
120 }
121
122 bool CTxMemPool::HasDescendants(const Txid& txid) const
123 {
124 LOCK(cs);
125 auto entry = GetEntry(txid);
126 if (!entry) return false;
127 return m_txgraph->GetDescendants(*entry, TxGraph::Level::MAIN).size() > 1;
128 }
129
130 CTxMemPool::setEntries CTxMemPool::CalculateMemPoolAncestors(const CTxMemPoolEntry &entry) const
131 {
132 auto ancestors = m_txgraph->GetAncestors(entry, TxGraph::Level::MAIN);
133 setEntries ret;
134 if (ancestors.size() > 0) {
135 for (auto ancestor : ancestors) {
136 if (ancestor != &entry) {
137 ret.insert(mapTx.iterator_to(static_cast<const CTxMemPoolEntry&>(*ancestor)));
138 }
139 }
140 return ret;
141 }
142
143 // If we didn't get anything back, the transaction is not in the graph.
144 // Find each parent and call GetAncestors on each.
145 setEntries staged_parents;
146 const CTransaction &tx = entry.GetTx();
147
148 // Get parents of this transaction that are in the mempool
149 for (unsigned int i = 0; i < tx.vin.size(); i++) {
150 std::optional<txiter> piter = GetIter(tx.vin[i].prevout.hash);
151 if (piter) {
152 staged_parents.insert(*piter);
153 }
154 }
155
156 for (const auto& parent : staged_parents) {
157 auto parent_ancestors = m_txgraph->GetAncestors(*parent, TxGraph::Level::MAIN);
158 for (auto ancestor : parent_ancestors) {
159 ret.insert(mapTx.iterator_to(static_cast<const CTxMemPoolEntry&>(*ancestor)));
160 }
161 }
162
163 return ret;
164 }
165
166 static CTxMemPool::Options&& Flatten(CTxMemPool::Options&& opts, bilingual_str& error)
167 {
168 opts.check_ratio = std::clamp<int>(opts.check_ratio, 0, 1'000'000);
169 int64_t cluster_limit_bytes = opts.limits.cluster_size_vbytes * 40;
170 if (opts.max_size_bytes < 0 || (opts.max_size_bytes > 0 && opts.max_size_bytes < cluster_limit_bytes)) {
171 error = strprintf(_("-maxmempool must be at least %d MB"), std::ceil(cluster_limit_bytes / 1'000'000.0));
172 }
173 return std::move(opts);
174 }
175
176 CTxMemPool::CTxMemPool(Options opts, bilingual_str& error)
177 : m_opts{Flatten(std::move(opts), error)}
178 {
179 m_txgraph = MakeTxGraph(
180 /*max_cluster_count=*/m_opts.limits.cluster_count,
181 /*max_cluster_size=*/m_opts.limits.cluster_size_vbytes * WITNESS_SCALE_FACTOR,
182 /*acceptable_cost=*/ACCEPTABLE_COST,
183 /*fallback_order=*/[&](const TxGraph::Ref& a, const TxGraph::Ref& b) noexcept {
184 const Txid& txid_a = static_cast<const CTxMemPoolEntry&>(a).GetTx().GetHash();
185 const Txid& txid_b = static_cast<const CTxMemPoolEntry&>(b).GetTx().GetHash();
186 return txid_a <=> txid_b;
187 });
188 }
189
190 bool CTxMemPool::isSpent(const COutPoint& outpoint) const
191 {
192 LOCK(cs);
193 return mapNextTx.count(outpoint);
194 }
195
196 unsigned int CTxMemPool::GetTransactionsUpdated() const
197 {
198 return nTransactionsUpdated;
199 }
200
201 void CTxMemPool::AddTransactionsUpdated(unsigned int n)
202 {
203 nTransactionsUpdated += n;
204 }
205
206 void CTxMemPool::Apply(ChangeSet* changeset)
207 {
208 AssertLockHeld(cs);
209 m_txgraph->CommitStaging();
210
211 RemoveStaged(changeset->m_to_remove, MemPoolRemovalReason::REPLACED);
212
213 for (size_t i=0; i<changeset->m_entry_vec.size(); ++i) {
214 auto tx_entry = changeset->m_entry_vec[i];
215 // First splice this entry into mapTx.
216 auto node_handle = changeset->m_to_add.extract(tx_entry);
217 auto result = mapTx.insert(std::move(node_handle));
218
219 Assume(result.inserted);
220 txiter it = result.position;
221
222 addNewTransaction(it);
223 }
224 if (!m_txgraph->DoWork(/*max_cost=*/POST_CHANGE_COST)) {
225 LogDebug(BCLog::MEMPOOL, "Mempool in non-optimal ordering after addition(s).");
226 }
227 }
228
229 void CTxMemPool::addNewTransaction(CTxMemPool::txiter newit)
230 {
231 const CTxMemPoolEntry& entry = *newit;
232
233 // Update cachedInnerUsage to include contained transaction's usage.
234 // (When we update the entry for in-mempool parents, memory usage will be
235 // further updated.)
236 cachedInnerUsage += entry.DynamicMemoryUsage();
237
238 const CTransaction& tx = newit->GetTx();
239 for (unsigned int i = 0; i < tx.vin.size(); i++) {
240 mapNextTx.insert(std::make_pair(&tx.vin[i].prevout, newit));
241 }
242 // Don't bother worrying about child transactions of this one.
243 // Normal case of a new transaction arriving is that there can't be any
244 // children, because such children would be orphans.
245 // An exception to that is if a transaction enters that used to be in a block.
246 // In that case, our disconnect block logic will call UpdateTransactionsFromBlock
247 // to clean up the mess we're leaving here.
248
249 nTransactionsUpdated++;
250 totalTxSize += entry.GetTxSize();
251 m_total_fee += entry.GetFee();
252
253 txns_randomized.emplace_back(tx.GetWitnessHash(), newit);
254 newit->idx_randomized = txns_randomized.size() - 1;
255
256 TRACEPOINT(mempool, added,
257 entry.GetTx().GetHash().data(),
258 entry.GetTxSize(),
259 entry.GetFee()
260 );
261 }
262
263 void CTxMemPool::removeUnchecked(txiter it, MemPoolRemovalReason reason)
264 {
265 // We increment mempool sequence value no matter removal reason
266 // even if not directly reported below.
267 uint64_t mempool_sequence = GetAndIncrementSequence();
268
269 if (reason != MemPoolRemovalReason::BLOCK && m_opts.signals) {
270 // Notify clients that a transaction has been removed from the mempool
271 // for any reason except being included in a block. Clients interested
272 // in transactions included in blocks can subscribe to the BlockConnected
273 // notification.
274 m_opts.signals->TransactionRemovedFromMempool(it->GetSharedTx(), reason, mempool_sequence);
275 }
276 TRACEPOINT(mempool, removed,
277 it->GetTx().GetHash().data(),
278 RemovalReasonToString(reason).c_str(),
279 it->GetTxSize(),
280 it->GetFee(),
281 std::chrono::duration_cast<std::chrono::duration<std::uint64_t>>(it->GetTime()).count()
282 );
283
284 for (const CTxIn& txin : it->GetTx().vin)
285 mapNextTx.erase(txin.prevout);
286
287 RemoveUnbroadcastTx(it->GetTx().GetHash(), true /* add logging because unchecked */);
288
289 if (txns_randomized.size() > 1) {
290 // Remove entry from txns_randomized by replacing it with the back and deleting the back.
291 txns_randomized[it->idx_randomized] = std::move(txns_randomized.back());
292 txns_randomized[it->idx_randomized].second->idx_randomized = it->idx_randomized;
293 txns_randomized.pop_back();
294 if (txns_randomized.size() * 2 < txns_randomized.capacity()) {
295 txns_randomized.shrink_to_fit();
296 }
297 } else {
298 txns_randomized.clear();
299 }
300
301 totalTxSize -= it->GetTxSize();
302 m_total_fee -= it->GetFee();
303 cachedInnerUsage -= it->DynamicMemoryUsage();
304 mapTx.erase(it);
305 nTransactionsUpdated++;
306 }
307
308 // Calculates descendants of given entry and adds to setDescendants.
309 void CTxMemPool::CalculateDescendants(txiter entryit, setEntries& setDescendants) const
310 {
311 (void)CalculateDescendants(*entryit, setDescendants);
312 return;
313 }
314
315 CTxMemPool::txiter CTxMemPool::CalculateDescendants(const CTxMemPoolEntry& entry, setEntries& setDescendants) const
316 {
317 for (auto tx : m_txgraph->GetDescendants(entry, TxGraph::Level::MAIN)) {
318 setDescendants.insert(mapTx.iterator_to(static_cast<const CTxMemPoolEntry&>(*tx)));
319 }
320 return mapTx.iterator_to(entry);
321 }
322
323 void CTxMemPool::removeRecursive(CTxMemPool::txiter to_remove, MemPoolRemovalReason reason)
324 {
325 AssertLockHeld(cs);
326 Assume(!m_have_changeset);
327 auto descendants = m_txgraph->GetDescendants(*to_remove, TxGraph::Level::MAIN);
328 for (auto tx: descendants) {
329 removeUnchecked(mapTx.iterator_to(static_cast<const CTxMemPoolEntry&>(*tx)), reason);
330 }
331 }
332
333 void CTxMemPool::removeRecursive(const CTransaction &origTx, MemPoolRemovalReason reason)
334 {
335 // Remove transaction from memory pool
336 AssertLockHeld(cs);
337 Assume(!m_have_changeset);
338 txiter origit = mapTx.find(origTx.GetHash());
339 if (origit != mapTx.end()) {
340 removeRecursive(origit, reason);
341 } else {
342 // When recursively removing but origTx isn't in the mempool
343 // be sure to remove any descendants that are in the pool. This can
344 // happen during chain re-orgs if origTx isn't re-accepted into
345 // the mempool for any reason.
346 auto iter = mapNextTx.lower_bound(COutPoint(origTx.GetHash(), 0));
347 std::vector<const TxGraph::Ref*> to_remove;
348 while (iter != mapNextTx.end() && iter->first->hash == origTx.GetHash()) {
349 to_remove.emplace_back(&*(iter->second));
350 ++iter;
351 }
352 auto all_removes = m_txgraph->GetDescendantsUnion(to_remove, TxGraph::Level::MAIN);
353 for (auto ref : all_removes) {
354 auto tx = mapTx.iterator_to(static_cast<const CTxMemPoolEntry&>(*ref));
355 removeUnchecked(tx, reason);
356 }
357 }
358 }
359
360 void CTxMemPool::removeForReorg(CChain& chain, std::function<bool(txiter)> check_final_and_mature)
361 {
362 // Remove transactions spending a coinbase which are now immature and no-longer-final transactions
363 AssertLockHeld(cs);
364 AssertLockHeld(::cs_main);
365 Assume(!m_have_changeset);
366
367 std::vector<const TxGraph::Ref*> to_remove;
368 for (txiter it = mapTx.begin(); it != mapTx.end(); it++) {
369 if (check_final_and_mature(it)) {
370 to_remove.emplace_back(&*it);
371 }
372 }
373
374 auto all_to_remove = m_txgraph->GetDescendantsUnion(to_remove, TxGraph::Level::MAIN);
375
376 for (auto ref : all_to_remove) {
377 auto it = mapTx.iterator_to(static_cast<const CTxMemPoolEntry&>(*ref));
378 removeUnchecked(it, MemPoolRemovalReason::REORG);
379 }
380 for (indexed_transaction_set::const_iterator it = mapTx.begin(); it != mapTx.end(); it++) {
381 assert(TestLockPointValidity(chain, it->GetLockPoints()));
382 }
383 if (!m_txgraph->DoWork(/*max_cost=*/POST_CHANGE_COST)) {
384 LogDebug(BCLog::MEMPOOL, "Mempool in non-optimal ordering after reorg.");
385 }
386 }
387
388 void CTxMemPool::removeConflicts(const CTransaction &tx)
389 {
390 // Remove transactions which depend on inputs of tx, recursively
391 AssertLockHeld(cs);
392 for (const CTxIn &txin : tx.vin) {
393 auto it = mapNextTx.find(txin.prevout);
394 if (it != mapNextTx.end()) {
395 const CTransaction &txConflict = it->second->GetTx();
396 if (Assume(txConflict.GetHash() != tx.GetHash()))
397 {
398 ClearPrioritisation(txConflict.GetHash());
399 removeRecursive(it->second, MemPoolRemovalReason::CONFLICT);
400 }
401 }
402 }
403 }
404
405 void CTxMemPool::removeForBlock(const std::vector<CTransactionRef>& vtx, unsigned int nBlockHeight)
406 {
407 // Remove confirmed txs and conflicts when a new block is connected, updating the fee logic
408 AssertLockHeld(cs);
409 Assume(!m_have_changeset);
410 std::vector<RemovedMempoolTransactionInfo> txs_removed_for_block;
411 if (mapTx.size() || mapNextTx.size() || mapDeltas.size()) {
412 txs_removed_for_block.reserve(vtx.size());
413 for (const auto& tx : vtx) {
414 txiter it = mapTx.find(tx->GetHash());
415 if (it != mapTx.end()) {
416 txs_removed_for_block.emplace_back(*it);
417 removeUnchecked(it, MemPoolRemovalReason::BLOCK);
418 }
419 removeConflicts(*tx);
420 ClearPrioritisation(tx->GetHash());
421 }
422 }
423 if (m_opts.signals) {
424 m_opts.signals->MempoolTransactionsRemovedForBlock(txs_removed_for_block, nBlockHeight);
425 }
426 lastRollingFeeUpdate = GetTime();
427 blockSinceLastRollingFeeBump = true;
428 if (!m_txgraph->DoWork(/*max_cost=*/POST_CHANGE_COST)) {
429 LogDebug(BCLog::MEMPOOL, "Mempool in non-optimal ordering after block.");
430 }
431 }
432
433 void CTxMemPool::check(const CCoinsViewCache& active_coins_tip, int64_t spendheight) const
434 {
435 if (m_opts.check_ratio == 0) return;
436
437 if (FastRandomContext().randrange(m_opts.check_ratio) >= 1) return;
438
439 AssertLockHeld(::cs_main);
440 LOCK(cs);
441 LogDebug(BCLog::MEMPOOL, "Checking mempool with %u transactions and %u inputs\n", (unsigned int)mapTx.size(), (unsigned int)mapNextTx.size());
442
443 uint64_t checkTotal = 0;
444 CAmount check_total_fee{0};
445 CAmount check_total_modified_fee{0};
446 int64_t check_total_adjusted_weight{0};
447 uint64_t innerUsage = 0;
448
449 assert(!m_txgraph->IsOversized(TxGraph::Level::MAIN));
450 m_txgraph->SanityCheck();
451
452 CCoinsViewCache mempoolDuplicate(const_cast<CCoinsViewCache*>(&active_coins_tip));
453
454 const auto score_with_topo{GetSortedScoreWithTopology()};
455
456 // Number of chunks is bounded by number of transactions.
457 const auto diagram{GetFeerateDiagram()};
458 assert(diagram.size() <= score_with_topo.size() + 1);
459 assert(diagram.size() >= 1);
460
461 std::optional<Wtxid> last_wtxid = std::nullopt;
462 auto diagram_iter = diagram.cbegin();
463
464 for (const auto& it : score_with_topo) {
465 // GetSortedScoreWithTopology() contains the same chunks as the feerate
466 // diagram. We do not know where the chunk boundaries are, but we can
467 // check that there are points at which they match the cumulative fee
468 // and weight.
469 // The feerate diagram should never get behind the current transaction
470 // size totals.
471 assert(diagram_iter->size >= check_total_adjusted_weight);
472 if (diagram_iter->fee == check_total_modified_fee &&
473 diagram_iter->size == check_total_adjusted_weight) {
474 ++diagram_iter;
475 }
476 checkTotal += it->GetTxSize();
477 check_total_adjusted_weight += it->GetAdjustedWeight();
478 check_total_fee += it->GetFee();
479 check_total_modified_fee += it->GetModifiedFee();
480 innerUsage += it->DynamicMemoryUsage();
481 const CTransaction& tx = it->GetTx();
482
483 // CompareMiningScoreWithTopology should agree with GetSortedScoreWithTopology()
484 if (last_wtxid) {
485 assert(CompareMiningScoreWithTopology(*last_wtxid, tx.GetWitnessHash()));
486 }
487 last_wtxid = tx.GetWitnessHash();
488
489 std::set<CTxMemPoolEntry::CTxMemPoolEntryRef, CompareIteratorByHash> setParentCheck;
490 std::set<CTxMemPoolEntry::CTxMemPoolEntryRef, CompareIteratorByHash> setParentsStored;
491 for (const CTxIn &txin : tx.vin) {
492 // Check that every mempool transaction's inputs refer to available coins, or other mempool tx's.
493 indexed_transaction_set::const_iterator it2 = mapTx.find(txin.prevout.hash);
494 if (it2 != mapTx.end()) {
495 const CTransaction& tx2 = it2->GetTx();
496 assert(tx2.vout.size() > txin.prevout.n && !tx2.vout[txin.prevout.n].IsNull());
497 setParentCheck.insert(*it2);
498 }
499 // We are iterating through the mempool entries sorted
500 // topologically and by mining score. All parents must have been
501 // checked before their children and their coins added to the
502 // mempoolDuplicate coins cache.
503 assert(mempoolDuplicate.HaveCoin(txin.prevout));
504 // Check whether its inputs are marked in mapNextTx.
505 auto it3 = mapNextTx.find(txin.prevout);
506 assert(it3 != mapNextTx.end());
507 assert(it3->first == &txin.prevout);
508 assert(&it3->second->GetTx() == &tx);
509 }
510 auto comp = [](const CTxMemPoolEntry& a, const CTxMemPoolEntry& b) -> bool {
511 return a.GetTx().GetHash() == b.GetTx().GetHash();
512 };
513 for (auto &txentry : GetParents(*it)) {
514 setParentsStored.insert(dynamic_cast<const CTxMemPoolEntry&>(txentry.get()));
515 }
516 assert(setParentCheck.size() == setParentsStored.size());
517 assert(std::equal(setParentCheck.begin(), setParentCheck.end(), setParentsStored.begin(), comp));
518
519 // Check children against mapNextTx
520 std::set<CTxMemPoolEntry::CTxMemPoolEntryRef, CompareIteratorByHash> setChildrenCheck;
521 std::set<CTxMemPoolEntry::CTxMemPoolEntryRef, CompareIteratorByHash> setChildrenStored;
522 auto iter = mapNextTx.lower_bound(COutPoint(it->GetTx().GetHash(), 0));
523 for (; iter != mapNextTx.end() && iter->first->hash == it->GetTx().GetHash(); ++iter) {
524 txiter childit = iter->second;
525 assert(childit != mapTx.end()); // mapNextTx points to in-mempool transactions
526 setChildrenCheck.insert(*childit);
527 }
528 for (auto &txentry : GetChildren(*it)) {
529 setChildrenStored.insert(dynamic_cast<const CTxMemPoolEntry&>(txentry.get()));
530 }
531 assert(setChildrenCheck.size() == setChildrenStored.size());
532 assert(std::equal(setChildrenCheck.begin(), setChildrenCheck.end(), setChildrenStored.begin(), comp));
533
534 TxValidationState dummy_state; // Not used. CheckTxInputs() should always pass
535 CAmount txfee = 0;
536 assert(!tx.IsCoinBase());
537 assert(Consensus::CheckTxInputs(tx, dummy_state, mempoolDuplicate, spendheight, txfee));
538 for (const auto& input: tx.vin) mempoolDuplicate.SpendCoin(input.prevout);
539 AddCoins(mempoolDuplicate, tx, std::numeric_limits<int>::max());
540 }
541 for (auto it = mapNextTx.cbegin(); it != mapNextTx.cend(); it++) {
542 indexed_transaction_set::const_iterator it2 = it->second;
543 assert(it2 != mapTx.end());
544 }
545
546 ++diagram_iter;
547 assert(diagram_iter == diagram.cend());
548
549 assert(totalTxSize == checkTotal);
550 assert(m_total_fee == check_total_fee);
551 assert(diagram.back().fee == check_total_modified_fee);
552 assert(diagram.back().size == check_total_adjusted_weight);
553 assert(innerUsage == cachedInnerUsage);
554 }
555
556 bool CTxMemPool::CompareMiningScoreWithTopology(const Wtxid& hasha, const Wtxid& hashb) const
557 {
558 /* Return `true` if hasha should be considered sooner than hashb, namely when:
559 * a is not in the mempool but b is, or
560 * both are in the mempool but a is sorted before b in the total mempool ordering
561 * (which takes dependencies and (chunk) feerates into account).
562 */
563 LOCK(cs);
564 auto j{GetIter(hashb)};
565 if (!j.has_value()) return false;
566 auto i{GetIter(hasha)};
567 if (!i.has_value()) return true;
568
569 return m_txgraph->CompareMainOrder(*i.value(), *j.value()) < 0;
570 }
571
572 std::vector<CTxMemPool::indexed_transaction_set::const_iterator> CTxMemPool::GetSortedScoreWithTopology() const
573 {
574 std::vector<indexed_transaction_set::const_iterator> iters;
575 AssertLockHeld(cs);
576
577 iters.reserve(mapTx.size());
578
579 for (indexed_transaction_set::iterator mi = mapTx.begin(); mi != mapTx.end(); ++mi) {
580 iters.push_back(mi);
581 }
582 std::sort(iters.begin(), iters.end(), [this](const auto& a, const auto& b) EXCLUSIVE_LOCKS_REQUIRED(cs) noexcept {
583 return m_txgraph->CompareMainOrder(*a, *b) < 0;
584 });
585 return iters;
586 }
587
588 std::vector<CTxMemPoolEntryRef> CTxMemPool::entryAll() const
589 {
590 AssertLockHeld(cs);
591
592 std::vector<CTxMemPoolEntryRef> ret;
593 ret.reserve(mapTx.size());
594 for (const auto& it : GetSortedScoreWithTopology()) {
595 ret.emplace_back(*it);
596 }
597 return ret;
598 }
599
600 std::vector<TxMempoolInfo> CTxMemPool::infoAll() const
601 {
602 LOCK(cs);
603 auto iters = GetSortedScoreWithTopology();
604
605 std::vector<TxMempoolInfo> ret;
606 ret.reserve(mapTx.size());
607 for (auto it : iters) {
608 ret.push_back(GetInfo(it));
609 }
610
611 return ret;
612 }
613
614 const CTxMemPoolEntry* CTxMemPool::GetEntry(const Txid& txid) const
615 {
616 AssertLockHeld(cs);
617 const auto i = mapTx.find(txid);
618 return i == mapTx.end() ? nullptr : &(*i);
619 }
620
621 CTransactionRef CTxMemPool::get(const Txid& hash) const
622 {
623 LOCK(cs);
624 indexed_transaction_set::const_iterator i = mapTx.find(hash);
625 if (i == mapTx.end())
626 return nullptr;
627 return i->GetSharedTx();
628 }
629
630 CTransactionRef CTxMemPool::get(const Wtxid& hash) const
631 {
632 LOCK(cs);
633 const auto& wtxid_map{mapTx.get<index_by_wtxid>()};
634 const auto it{wtxid_map.find(hash)};
635 if (it == wtxid_map.end()) return nullptr;
636 return it->GetSharedTx();
637 }
638
639 void CTxMemPool::PrioritiseTransaction(const Txid& hash, const CAmount& nFeeDelta)
640 {
641 {
642 LOCK(cs);
643 CAmount &delta = mapDeltas[hash];
644 delta = SaturatingAdd(delta, nFeeDelta);
645 txiter it = mapTx.find(hash);
646 if (it != mapTx.end()) {
647 // PrioritiseTransaction calls stack on previous ones. Set the new
648 // transaction fee to be current modified fee + feedelta.
649 it->UpdateModifiedFee(nFeeDelta);
650 m_txgraph->SetTransactionFee(*it, it->GetModifiedFee());
651 ++nTransactionsUpdated;
652 }
653 if (delta == 0) {
654 mapDeltas.erase(hash);
655 LogInfo("PrioritiseTransaction: %s (%sin mempool) delta cleared\n", hash.ToString(), it == mapTx.end() ? "not " : "");
656 } else {
657 LogInfo("PrioritiseTransaction: %s (%sin mempool) fee += %s, new delta=%s\n",
658 hash.ToString(),
659 it == mapTx.end() ? "not " : "",
660 FormatMoney(nFeeDelta),
661 FormatMoney(delta));
662 }
663 }
664 }
665
666 void CTxMemPool::ApplyDelta(const Txid& hash, CAmount &nFeeDelta) const
667 {
668 AssertLockHeld(cs);
669 std::map<Txid, CAmount>::const_iterator pos = mapDeltas.find(hash);
670 if (pos == mapDeltas.end())
671 return;
672 const CAmount &delta = pos->second;
673 nFeeDelta += delta;
674 }
675
676 void CTxMemPool::ClearPrioritisation(const Txid& hash)
677 {
678 AssertLockHeld(cs);
679 mapDeltas.erase(hash);
680 }
681
682 std::vector<CTxMemPool::delta_info> CTxMemPool::GetPrioritisedTransactions() const
683 {
684 AssertLockNotHeld(cs);
685 LOCK(cs);
686 std::vector<delta_info> result;
687 result.reserve(mapDeltas.size());
688 for (const auto& [txid, delta] : mapDeltas) {
689 const auto iter{mapTx.find(txid)};
690 const bool in_mempool{iter != mapTx.end()};
691 std::optional<CAmount> modified_fee;
692 if (in_mempool) modified_fee = iter->GetModifiedFee();
693 result.emplace_back(delta_info{in_mempool, delta, modified_fee, txid});
694 }
695 return result;
696 }
697
698 const CTransaction* CTxMemPool::GetConflictTx(const COutPoint& prevout) const
699 {
700 const auto it = mapNextTx.find(prevout);
701 return it == mapNextTx.end() ? nullptr : &(it->second->GetTx());
702 }
703
704 std::optional<CTxMemPool::txiter> CTxMemPool::GetIter(const Txid& txid) const
705 {
706 AssertLockHeld(cs);
707 auto it = mapTx.find(txid);
708 return it != mapTx.end() ? std::make_optional(it) : std::nullopt;
709 }
710
711 std::optional<CTxMemPool::txiter> CTxMemPool::GetIter(const Wtxid& wtxid) const
712 {
713 AssertLockHeld(cs);
714 auto it{mapTx.project<0>(mapTx.get<index_by_wtxid>().find(wtxid))};
715 return it != mapTx.end() ? std::make_optional(it) : std::nullopt;
716 }
717
718 CTxMemPool::setEntries CTxMemPool::GetIterSet(const std::set<Txid>& hashes) const
719 {
720 CTxMemPool::setEntries ret;
721 for (const auto& h : hashes) {
722 const auto mi = GetIter(h);
723 if (mi) ret.insert(*mi);
724 }
725 return ret;
726 }
727
728 std::vector<CTxMemPool::txiter> CTxMemPool::GetIterVec(const std::vector<Txid>& txids) const
729 {
730 AssertLockHeld(cs);
731 std::vector<txiter> ret;
732 ret.reserve(txids.size());
733 for (const auto& txid : txids) {
734 const auto it{GetIter(txid)};
735 if (!it) return {};
736 ret.push_back(*it);
737 }
738 return ret;
739 }
740
741 bool CTxMemPool::HasNoInputsOf(const CTransaction &tx) const
742 {
743 for (unsigned int i = 0; i < tx.vin.size(); i++)
744 if (exists(tx.vin[i].prevout.hash))
745 return false;
746 return true;
747 }
748
749 CCoinsViewMemPool::CCoinsViewMemPool(CCoinsView* baseIn, const CTxMemPool& mempoolIn) : CCoinsViewBacked(baseIn), mempool(mempoolIn) { }
750
751 std::optional<Coin> CCoinsViewMemPool::GetCoin(const COutPoint& outpoint) const
752 {
753 // Check to see if the inputs are made available by another tx in the package.
754 // These Coins would not be available in the underlying CoinsView.
755 if (auto it = m_temp_added.find(outpoint); it != m_temp_added.end()) {
756 return it->second;
757 }
758
759 // If an entry in the mempool exists, always return that one, as it's guaranteed to never
760 // conflict with the underlying cache, and it cannot have pruned entries (as it contains full)
761 // transactions. First checking the underlying cache risks returning a pruned entry instead.
762 CTransactionRef ptx = mempool.get(outpoint.hash);
763 if (ptx) {
764 if (outpoint.n < ptx->vout.size()) {
765 Coin coin(ptx->vout[outpoint.n], MEMPOOL_HEIGHT, false);
766 m_non_base_coins.emplace(outpoint);
767 return coin;
768 }
769 return std::nullopt;
770 }
771 return base->GetCoin(outpoint);
772 }
773
774 void CCoinsViewMemPool::PackageAddTransaction(const CTransactionRef& tx)
775 {
776 for (unsigned int n = 0; n < tx->vout.size(); ++n) {
777 m_temp_added.emplace(COutPoint(tx->GetHash(), n), Coin(tx->vout[n], MEMPOOL_HEIGHT, false));
778 m_non_base_coins.emplace(tx->GetHash(), n);
779 }
780 }
781 void CCoinsViewMemPool::Reset()
782 {
783 m_temp_added.clear();
784 m_non_base_coins.clear();
785 }
786
787 size_t CTxMemPool::DynamicMemoryUsage() const {
788 LOCK(cs);
789 // 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.
790 return memusage::MallocUsage(sizeof(CTxMemPoolEntry) + 9 * sizeof(void*)) * mapTx.size() + memusage::DynamicUsage(mapNextTx) + memusage::DynamicUsage(mapDeltas) + memusage::DynamicUsage(txns_randomized) + m_txgraph->GetMainMemoryUsage() + cachedInnerUsage;
791 }
792
793 void CTxMemPool::RemoveUnbroadcastTx(const Txid& txid, const bool unchecked) {
794 LOCK(cs);
795
796 if (m_unbroadcast_txids.erase(txid))
797 {
798 LogDebug(BCLog::MEMPOOL, "Removed %s from set of unbroadcast txns%s", txid.GetHex(), (unchecked ? " before confirmation that txn was sent out" : ""));
799 }
800 }
801
802 void CTxMemPool::RemoveStaged(setEntries &stage, MemPoolRemovalReason reason) {
803 AssertLockHeld(cs);
804 for (txiter it : stage) {
805 removeUnchecked(it, reason);
806 }
807 }
808
809 bool CTxMemPool::CheckPolicyLimits(const CTransactionRef& tx)
810 {
811 LOCK(cs);
812 // Use ChangeSet interface to check whether the cluster count
813 // limits would be violated. Note that the changeset will be destroyed
814 // when it goes out of scope.
815 auto changeset = GetChangeSet();
816 (void) changeset->StageAddition(tx, /*fee=*/0, /*time=*/0, /*entry_height=*/0, /*entry_sequence=*/0, /*spends_coinbase=*/false, /*sigops_cost=*/0, LockPoints{});
817 return changeset->CheckMemPoolPolicyLimits();
818 }
819
820 int CTxMemPool::Expire(std::chrono::seconds time)
821 {
822 AssertLockHeld(cs);
823 Assume(!m_have_changeset);
824 indexed_transaction_set::index<entry_time>::type::iterator it = mapTx.get<entry_time>().begin();
825 setEntries toremove;
826 while (it != mapTx.get<entry_time>().end() && it->GetTime() < time) {
827 toremove.insert(mapTx.project<0>(it));
828 it++;
829 }
830 setEntries stage;
831 for (txiter removeit : toremove) {
832 CalculateDescendants(removeit, stage);
833 }
834 RemoveStaged(stage, MemPoolRemovalReason::EXPIRY);
835 return stage.size();
836 }
837
838 CFeeRate CTxMemPool::GetMinFee(size_t sizelimit) const {
839 LOCK(cs);
840 if (!blockSinceLastRollingFeeBump || rollingMinimumFeeRate == 0)
841 return CFeeRate(llround(rollingMinimumFeeRate));
842
843 int64_t time = GetTime();
844 if (time > lastRollingFeeUpdate + 10) {
845 double halflife = ROLLING_FEE_HALFLIFE;
846 if (DynamicMemoryUsage() < sizelimit / 4)
847 halflife /= 4;
848 else if (DynamicMemoryUsage() < sizelimit / 2)
849 halflife /= 2;
850
851 rollingMinimumFeeRate = rollingMinimumFeeRate / pow(2.0, (time - lastRollingFeeUpdate) / halflife);
852 lastRollingFeeUpdate = time;
853
854 if (rollingMinimumFeeRate < (double)m_opts.incremental_relay_feerate.GetFeePerK() / 2) {
855 rollingMinimumFeeRate = 0;
856 return CFeeRate(0);
857 }
858 }
859 return std::max(CFeeRate(llround(rollingMinimumFeeRate)), m_opts.incremental_relay_feerate);
860 }
861
862 void CTxMemPool::trackPackageRemoved(const CFeeRate& rate) {
863 AssertLockHeld(cs);
864 if (rate.GetFeePerK() > rollingMinimumFeeRate) {
865 rollingMinimumFeeRate = rate.GetFeePerK();
866 blockSinceLastRollingFeeBump = false;
867 }
868 }
869
870 void CTxMemPool::TrimToSize(size_t sizelimit, std::vector<COutPoint>* pvNoSpendsRemaining) {
871 AssertLockHeld(cs);
872 Assume(!m_have_changeset);
873
874 unsigned nTxnRemoved = 0;
875 CFeeRate maxFeeRateRemoved(0);
876
877 while (!mapTx.empty() && DynamicMemoryUsage() > sizelimit) {
878 const auto &[worst_chunk, feeperweight] = m_txgraph->GetWorstMainChunk();
879 FeePerVSize feerate = ToFeePerVSize(feeperweight);
880 CFeeRate removed{feerate.fee, feerate.size};
881
882 // We set the new mempool min fee to the feerate of the removed set, plus the
883 // "minimum reasonable fee rate" (ie some value under which we consider txn
884 // to have 0 fee). This way, we don't allow txn to enter mempool with feerate
885 // equal to txn which were removed with no block in between.
886 removed += m_opts.incremental_relay_feerate;
887 trackPackageRemoved(removed);
888 maxFeeRateRemoved = std::max(maxFeeRateRemoved, removed);
889
890 nTxnRemoved += worst_chunk.size();
891
892 std::vector<CTransaction> txn;
893 if (pvNoSpendsRemaining) {
894 txn.reserve(worst_chunk.size());
895 for (auto ref : worst_chunk) {
896 txn.emplace_back(static_cast<const CTxMemPoolEntry&>(*ref).GetTx());
897 }
898 }
899
900 setEntries stage;
901 for (auto ref : worst_chunk) {
902 stage.insert(mapTx.iterator_to(static_cast<const CTxMemPoolEntry&>(*ref)));
903 }
904 for (auto e : stage) {
905 removeUnchecked(e, MemPoolRemovalReason::SIZELIMIT);
906 }
907 if (pvNoSpendsRemaining) {
908 for (const CTransaction& tx : txn) {
909 for (const CTxIn& txin : tx.vin) {
910 if (exists(txin.prevout.hash)) continue;
911 pvNoSpendsRemaining->push_back(txin.prevout);
912 }
913 }
914 }
915 }
916
917 if (maxFeeRateRemoved > CFeeRate(0)) {
918 LogDebug(BCLog::MEMPOOL, "Removed %u txn, rolling minimum fee bumped to %s\n", nTxnRemoved, maxFeeRateRemoved.ToString());
919 }
920 }
921
922 std::tuple<size_t, size_t, CAmount> CTxMemPool::CalculateAncestorData(const CTxMemPoolEntry& entry) const
923 {
924 auto ancestors = m_txgraph->GetAncestors(entry, TxGraph::Level::MAIN);
925
926 size_t ancestor_count = ancestors.size();
927 size_t ancestor_size = 0;
928 CAmount ancestor_fees = 0;
929 for (auto tx: ancestors) {
930 const CTxMemPoolEntry& anc = static_cast<const CTxMemPoolEntry&>(*tx);
931 ancestor_size += anc.GetTxSize();
932 ancestor_fees += anc.GetModifiedFee();
933 }
934 return {ancestor_count, ancestor_size, ancestor_fees};
935 }
936
937 std::tuple<size_t, size_t, CAmount> CTxMemPool::CalculateDescendantData(const CTxMemPoolEntry& entry) const
938 {
939 auto descendants = m_txgraph->GetDescendants(entry, TxGraph::Level::MAIN);
940 size_t descendant_count = descendants.size();
941 size_t descendant_size = 0;
942 CAmount descendant_fees = 0;
943
944 for (auto tx: descendants) {
945 const CTxMemPoolEntry &desc = static_cast<const CTxMemPoolEntry&>(*tx);
946 descendant_size += desc.GetTxSize();
947 descendant_fees += desc.GetModifiedFee();
948 }
949 return {descendant_count, descendant_size, descendant_fees};
950 }
951
952 void CTxMemPool::GetTransactionAncestry(const Txid& txid, size_t& ancestors, size_t& cluster_count, size_t* const ancestorsize, CAmount* const ancestorfees) const {
953 LOCK(cs);
954 auto it = mapTx.find(txid);
955 ancestors = cluster_count = 0;
956 if (it != mapTx.end()) {
957 auto [ancestor_count, ancestor_size, ancestor_fees] = CalculateAncestorData(*it);
958 ancestors = ancestor_count;
959 if (ancestorsize) *ancestorsize = ancestor_size;
960 if (ancestorfees) *ancestorfees = ancestor_fees;
961 cluster_count = m_txgraph->GetCluster(*it, TxGraph::Level::MAIN).size();
962 }
963 }
964
965 bool CTxMemPool::GetLoadTried() const
966 {
967 LOCK(cs);
968 return m_load_tried;
969 }
970
971 void CTxMemPool::SetLoadTried(bool load_tried)
972 {
973 LOCK(cs);
974 m_load_tried = load_tried;
975 }
976
977 std::vector<CTxMemPool::txiter> CTxMemPool::GatherClusters(const std::vector<Txid>& txids) const
978 {
979 AssertLockHeld(cs);
980
981 std::vector<CTxMemPool::txiter> ret;
982 std::set<const CTxMemPoolEntry*> unique_cluster_representatives;
983 for (auto txid : txids) {
984 auto it = mapTx.find(txid);
985 if (it != mapTx.end()) {
986 // Note that TxGraph::GetCluster will return results in graph
987 // order, which is deterministic (as long as we are not modifying
988 // the graph).
989 auto cluster = m_txgraph->GetCluster(*it, TxGraph::Level::MAIN);
990 if (unique_cluster_representatives.insert(static_cast<const CTxMemPoolEntry*>(&(**cluster.begin()))).second) {
991 for (auto tx : cluster) {
992 ret.emplace_back(mapTx.iterator_to(static_cast<const CTxMemPoolEntry&>(*tx)));
993 }
994 }
995 }
996 }
997 if (ret.size() > 500) {
998 return {};
999 }
1000 return ret;
1001 }
1002
1003 util::Result<std::pair<std::vector<FeeFrac>, std::vector<FeeFrac>>> CTxMemPool::ChangeSet::CalculateChunksForRBF()
1004 {
1005 LOCK(m_pool->cs);
1006
1007 if (!CheckMemPoolPolicyLimits()) {
1008 return util::Error{Untranslated("cluster size limit exceeded")};
1009 }
1010
1011 return m_pool->m_txgraph->GetMainStagingDiagrams();
1012 }
1013
1014 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)
1015 {
1016 LOCK(m_pool->cs);
1017 Assume(m_to_add.find(tx->GetHash()) == m_to_add.end());
1018 Assume(!m_dependencies_processed);
1019
1020 // We need to process dependencies after adding a new transaction.
1021 m_dependencies_processed = false;
1022
1023 CAmount delta{0};
1024 m_pool->ApplyDelta(tx->GetHash(), delta);
1025
1026 FeePerWeight feerate(fee, GetSigOpsAdjustedWeight(GetTransactionWeight(*tx), sigops_cost, ::nBytesPerSigOp));
1027 auto newit = m_to_add.emplace(tx, fee, time, entry_height, entry_sequence, spends_coinbase, sigops_cost, lp).first;
1028 m_pool->m_txgraph->AddTransaction(const_cast<CTxMemPoolEntry&>(*newit), feerate);
1029 if (delta) {
1030 newit->UpdateModifiedFee(delta);
1031 m_pool->m_txgraph->SetTransactionFee(*newit, newit->GetModifiedFee());
1032 }
1033
1034 m_entry_vec.push_back(newit);
1035
1036 return newit;
1037 }
1038
1039 void CTxMemPool::ChangeSet::StageRemoval(CTxMemPool::txiter it)
1040 {
1041 LOCK(m_pool->cs);
1042 m_pool->m_txgraph->RemoveTransaction(*it);
1043 m_to_remove.insert(it);
1044 }
1045
1046 void CTxMemPool::ChangeSet::Apply()
1047 {
1048 LOCK(m_pool->cs);
1049 if (!m_dependencies_processed) {
1050 ProcessDependencies();
1051 }
1052 m_pool->Apply(this);
1053 m_to_add.clear();
1054 m_to_remove.clear();
1055 m_entry_vec.clear();
1056 m_ancestors.clear();
1057 }
1058
1059 void CTxMemPool::ChangeSet::ProcessDependencies()
1060 {
1061 LOCK(m_pool->cs);
1062 Assume(!m_dependencies_processed); // should only call this once.
1063 for (const auto& entryptr : m_entry_vec) {
1064 for (const auto &txin : entryptr->GetSharedTx()->vin) {
1065 std::optional<txiter> piter = m_pool->GetIter(txin.prevout.hash);
1066 if (!piter) {
1067 auto it = m_to_add.find(txin.prevout.hash);
1068 if (it != m_to_add.end()) {
1069 piter = std::make_optional(it);
1070 }
1071 }
1072 if (piter) {
1073 m_pool->m_txgraph->AddDependency(/*parent=*/**piter, /*child=*/*entryptr);
1074 }
1075 }
1076 }
1077 m_dependencies_processed = true;
1078 return;
1079 }
1080
1081 bool CTxMemPool::ChangeSet::CheckMemPoolPolicyLimits()
1082 {
1083 LOCK(m_pool->cs);
1084 if (!m_dependencies_processed) {
1085 ProcessDependencies();
1086 }
1087
1088 return !m_pool->m_txgraph->IsOversized(TxGraph::Level::TOP);
1089 }
1090
1091 std::vector<FeePerWeight> CTxMemPool::GetFeerateDiagram() const
1092 {
1093 FeePerWeight zero{};
1094 std::vector<FeePerWeight> ret;
1095
1096 ret.emplace_back(zero);
1097
1098 StartBlockBuilding();
1099
1100 std::vector<CTxMemPoolEntry::CTxMemPoolEntryRef> dummy;
1101
1102 FeePerWeight last_selection = GetBlockBuilderChunk(dummy);
1103 while (last_selection != FeePerWeight{}) {
1104 last_selection += ret.back();
1105 ret.emplace_back(last_selection);
1106 IncludeBuilderChunk();
1107 last_selection = GetBlockBuilderChunk(dummy);
1108 }
1109 StopBlockBuilding();
1110 return ret;
1111 }
1112