Bitcoin Core  27.99.0
P2P Digital Currency
txmempool.h
Go to the documentation of this file.
1 // Copyright (c) 2009-2010 Satoshi Nakamoto
2 // Copyright (c) 2009-2022 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 #ifndef BITCOIN_TXMEMPOOL_H
7 #define BITCOIN_TXMEMPOOL_H
8 
9 #include <coins.h>
10 #include <consensus/amount.h>
11 #include <indirectmap.h>
12 #include <kernel/cs_main.h>
13 #include <kernel/mempool_entry.h> // IWYU pragma: export
14 #include <kernel/mempool_limits.h> // IWYU pragma: export
15 #include <kernel/mempool_options.h> // IWYU pragma: export
16 #include <kernel/mempool_removal_reason.h> // IWYU pragma: export
17 #include <policy/feerate.h>
18 #include <policy/packages.h>
19 #include <primitives/transaction.h>
20 #include <sync.h>
21 #include <util/epochguard.h>
22 #include <util/hasher.h>
23 #include <util/result.h>
24 #include <util/feefrac.h>
25 
26 #include <boost/multi_index/hashed_index.hpp>
27 #include <boost/multi_index/identity.hpp>
28 #include <boost/multi_index/indexed_by.hpp>
29 #include <boost/multi_index/ordered_index.hpp>
30 #include <boost/multi_index/sequenced_index.hpp>
31 #include <boost/multi_index/tag.hpp>
32 #include <boost/multi_index_container.hpp>
33 
34 #include <atomic>
35 #include <map>
36 #include <optional>
37 #include <set>
38 #include <string>
39 #include <string_view>
40 #include <utility>
41 #include <vector>
42 
43 class CChain;
44 class ValidationSignals;
45 
47 static const uint32_t MEMPOOL_HEIGHT = 0x7FFFFFFF;
48 
53 
54 // extracts a transaction hash from CTxMemPoolEntry or CTransactionRef
56 {
59  {
60  return entry.GetTx().GetHash();
61  }
62 
64  {
65  return tx->GetHash();
66  }
67 };
68 
69 // extracts a transaction witness-hash from CTxMemPoolEntry or CTransactionRef
71 {
74  {
75  return entry.GetTx().GetWitnessHash();
76  }
77 
79  {
80  return tx->GetWitnessHash();
81  }
82 };
83 
84 
90 {
91 public:
92  bool operator()(const CTxMemPoolEntry& a, const CTxMemPoolEntry& b) const
93  {
94  double a_mod_fee, a_size, b_mod_fee, b_size;
95 
96  GetModFeeAndSize(a, a_mod_fee, a_size);
97  GetModFeeAndSize(b, b_mod_fee, b_size);
98 
99  // Avoid division by rewriting (a/b > c/d) as (a*d > c*b).
100  double f1 = a_mod_fee * b_size;
101  double f2 = a_size * b_mod_fee;
102 
103  if (f1 == f2) {
104  return a.GetTime() >= b.GetTime();
105  }
106  return f1 < f2;
107  }
108 
109  // Return the fee/size we're using for sorting this entry.
110  void GetModFeeAndSize(const CTxMemPoolEntry &a, double &mod_fee, double &size) const
111  {
112  // Compare feerate with descendants to feerate of the transaction, and
113  // return the fee/size for the max.
114  double f1 = (double)a.GetModifiedFee() * a.GetSizeWithDescendants();
115  double f2 = (double)a.GetModFeesWithDescendants() * a.GetTxSize();
116 
117  if (f2 > f1) {
118  mod_fee = a.GetModFeesWithDescendants();
119  size = a.GetSizeWithDescendants();
120  } else {
121  mod_fee = a.GetModifiedFee();
122  size = a.GetTxSize();
123  }
124  }
125 };
126 
135 {
136 public:
137  bool operator()(const CTxMemPoolEntry& a, const CTxMemPoolEntry& b) const
138  {
139  double f1 = (double)a.GetFee() * b.GetTxSize();
140  double f2 = (double)b.GetFee() * a.GetTxSize();
141  if (f1 == f2) {
142  return b.GetTx().GetHash() < a.GetTx().GetHash();
143  }
144  return f1 > f2;
145  }
146 };
147 
149 {
150 public:
151  bool operator()(const CTxMemPoolEntry& a, const CTxMemPoolEntry& b) const
152  {
153  return a.GetTime() < b.GetTime();
154  }
155 };
156 
162 {
163 public:
164  template<typename T>
165  bool operator()(const T& a, const T& b) const
166  {
167  double a_mod_fee, a_size, b_mod_fee, b_size;
168 
169  GetModFeeAndSize(a, a_mod_fee, a_size);
170  GetModFeeAndSize(b, b_mod_fee, b_size);
171 
172  // Avoid division by rewriting (a/b > c/d) as (a*d > c*b).
173  double f1 = a_mod_fee * b_size;
174  double f2 = a_size * b_mod_fee;
175 
176  if (f1 == f2) {
177  return a.GetTx().GetHash() < b.GetTx().GetHash();
178  }
179  return f1 > f2;
180  }
181 
182  // Return the fee/size we're using for sorting this entry.
183  template <typename T>
184  void GetModFeeAndSize(const T &a, double &mod_fee, double &size) const
185  {
186  // Compare feerate with ancestors to feerate of the transaction, and
187  // return the fee/size for the min.
188  double f1 = (double)a.GetModifiedFee() * a.GetSizeWithAncestors();
189  double f2 = (double)a.GetModFeesWithAncestors() * a.GetTxSize();
190 
191  if (f1 > f2) {
192  mod_fee = a.GetModFeesWithAncestors();
193  size = a.GetSizeWithAncestors();
194  } else {
195  mod_fee = a.GetModifiedFee();
196  size = a.GetTxSize();
197  }
198  }
199 };
200 
201 // Multi_index tag names
203 struct entry_time {};
204 struct ancestor_score {};
205 struct index_by_wtxid {};
206 
211 {
214 
216  std::chrono::seconds m_time;
217 
220 
222  int32_t vsize;
223 
225  int64_t nFeeDelta;
226 };
227 
302 {
303 protected:
304  const int m_check_ratio;
305  std::atomic<unsigned int> nTransactionsUpdated{0};
306 
307  uint64_t totalTxSize GUARDED_BY(cs){0};
308  CAmount m_total_fee GUARDED_BY(cs){0};
309  uint64_t cachedInnerUsage GUARDED_BY(cs){0};
310 
311  mutable int64_t lastRollingFeeUpdate GUARDED_BY(cs){GetTime()};
312  mutable bool blockSinceLastRollingFeeBump GUARDED_BY(cs){false};
313  mutable double rollingMinimumFeeRate GUARDED_BY(cs){0};
315 
316  // In-memory counter for external mempool tracking purposes.
317  // This number is incremented once every time a transaction
318  // is added or removed from the mempool for any reason.
319  mutable uint64_t m_sequence_number GUARDED_BY(cs){1};
320 
322 
323  bool m_load_tried GUARDED_BY(cs){false};
324 
325  CFeeRate GetMinFee(size_t sizelimit) const;
326 
327 public:
328 
329  static const int ROLLING_FEE_HALFLIFE = 60 * 60 * 12; // public only for testing
330 
331  typedef boost::multi_index_container<
333  boost::multi_index::indexed_by<
334  // sorted by txid
335  boost::multi_index::hashed_unique<mempoolentry_txid, SaltedTxidHasher>,
336  // sorted by wtxid
337  boost::multi_index::hashed_unique<
338  boost::multi_index::tag<index_by_wtxid>,
341  >,
342  // sorted by fee rate
343  boost::multi_index::ordered_non_unique<
344  boost::multi_index::tag<descendant_score>,
345  boost::multi_index::identity<CTxMemPoolEntry>,
347  >,
348  // sorted by entry time
349  boost::multi_index::ordered_non_unique<
350  boost::multi_index::tag<entry_time>,
351  boost::multi_index::identity<CTxMemPoolEntry>,
353  >,
354  // sorted by fee rate with ancestors
355  boost::multi_index::ordered_non_unique<
356  boost::multi_index::tag<ancestor_score>,
357  boost::multi_index::identity<CTxMemPoolEntry>,
359  >
360  >
362 
392 
393  using txiter = indexed_transaction_set::nth_index<0>::type::const_iterator;
394  std::vector<CTransactionRef> txns_randomized GUARDED_BY(cs);
395 
396  typedef std::set<txiter, CompareIteratorByHash> setEntries;
397 
399 
401 private:
402  typedef std::map<txiter, setEntries, CompareIteratorByHash> cacheMap;
403 
404 
405  void UpdateParent(txiter entry, txiter parent, bool add) EXCLUSIVE_LOCKS_REQUIRED(cs);
406  void UpdateChild(txiter entry, txiter child, bool add) EXCLUSIVE_LOCKS_REQUIRED(cs);
407 
408  std::vector<indexed_transaction_set::const_iterator> GetSortedDepthAndScore() const EXCLUSIVE_LOCKS_REQUIRED(cs);
409 
413  std::set<uint256> m_unbroadcast_txids GUARDED_BY(cs);
414 
415 
428  size_t entry_count,
429  CTxMemPoolEntry::Parents &staged_ancestors,
430  const Limits& limits
431  ) const EXCLUSIVE_LOCKS_REQUIRED(cs);
432 
433 public:
435  std::map<uint256, CAmount> mapDeltas GUARDED_BY(cs);
436 
437  using Options = kernel::MemPoolOptions;
438 
439  const int64_t m_max_size_bytes;
440  const std::chrono::seconds m_expiry;
445  const std::optional<unsigned> m_max_datacarrier_bytes;
446  const bool m_require_standard;
447  const bool m_full_rbf;
448  const bool m_persist_v1_dat;
449 
451 
453 
459  explicit CTxMemPool(const Options& opts);
460 
467  void check(const CCoinsViewCache& active_coins_tip, int64_t spendheight) const EXCLUSIVE_LOCKS_REQUIRED(::cs_main);
468 
469  // addUnchecked must updated state for all ancestors of a given transaction,
470  // to track size/count of descendant transactions. First version of
471  // addUnchecked can be used to have it call CalculateMemPoolAncestors(), and
472  // then invoke the second version.
473  // Note that addUnchecked is ONLY called from ATMP outside of tests
474  // and any other callers may break wallet's in-mempool tracking (due to
475  // lack of CValidationInterface::TransactionAddedToMempool callbacks).
478 
487  void removeForReorg(CChain& chain, std::function<bool(txiter)> filter_final_and_mature) EXCLUSIVE_LOCKS_REQUIRED(cs, cs_main);
489  void removeForBlock(const std::vector<CTransactionRef>& vtx, unsigned int nBlockHeight) EXCLUSIVE_LOCKS_REQUIRED(cs);
490 
491  bool CompareDepthAndScore(const uint256& hasha, const uint256& hashb, bool wtxid=false);
492  bool isSpent(const COutPoint& outpoint) const;
493  unsigned int GetTransactionsUpdated() const;
494  void AddTransactionsUpdated(unsigned int n);
499  bool HasNoInputsOf(const CTransaction& tx) const EXCLUSIVE_LOCKS_REQUIRED(cs);
500 
502  void PrioritiseTransaction(const uint256& hash, const CAmount& nFeeDelta);
503  void ApplyDelta(const uint256& hash, CAmount &nFeeDelta) const EXCLUSIVE_LOCKS_REQUIRED(cs);
505 
506  struct delta_info {
508  const bool in_mempool;
510  const CAmount delta;
512  std::optional<CAmount> modified_fee;
514  const uint256 txid;
515  };
517  std::vector<delta_info> GetPrioritisedTransactions() const EXCLUSIVE_LOCKS_REQUIRED(!cs);
518 
520  const CTransaction* GetConflictTx(const COutPoint& prevout) const EXCLUSIVE_LOCKS_REQUIRED(cs);
521 
523  std::optional<txiter> GetIter(const uint256& txid) const EXCLUSIVE_LOCKS_REQUIRED(cs);
524 
528  setEntries GetIterSet(const std::set<Txid>& hashes) const EXCLUSIVE_LOCKS_REQUIRED(cs);
529 
533  std::vector<txiter> GetIterVec(const std::vector<uint256>& txids) const EXCLUSIVE_LOCKS_REQUIRED(cs);
534 
542  void RemoveStaged(setEntries& stage, bool updateDescendants, MemPoolRemovalReason reason) EXCLUSIVE_LOCKS_REQUIRED(cs);
543 
558 
572  const Limits& limits,
573  bool fSearchForParents = true) const EXCLUSIVE_LOCKS_REQUIRED(cs);
574 
590  std::string_view calling_fn_name,
591  const CTxMemPoolEntry &entry,
592  const Limits& limits,
593  bool fSearchForParents = true) const EXCLUSIVE_LOCKS_REQUIRED(cs);
594 
599  std::vector<txiter> GatherClusters(const std::vector<uint256>& txids) const EXCLUSIVE_LOCKS_REQUIRED(cs);
600 
613  util::Result<void> CheckPackageLimits(const Package& package,
614  int64_t total_vsize) const EXCLUSIVE_LOCKS_REQUIRED(cs);
615 
619  void CalculateDescendants(txiter it, setEntries& setDescendants) const EXCLUSIVE_LOCKS_REQUIRED(cs);
620 
627  CFeeRate GetMinFee() const {
628  return GetMinFee(m_max_size_bytes);
629  }
630 
635  void TrimToSize(size_t sizelimit, std::vector<COutPoint>* pvNoSpendsRemaining = nullptr) EXCLUSIVE_LOCKS_REQUIRED(cs);
636 
638  int Expire(std::chrono::seconds time) EXCLUSIVE_LOCKS_REQUIRED(cs);
639 
646  void GetTransactionAncestry(const uint256& txid, size_t& ancestors, size_t& descendants, size_t* ancestorsize = nullptr, CAmount* ancestorfees = nullptr) const;
647 
652  bool GetLoadTried() const;
653 
658  void SetLoadTried(bool load_tried);
659 
660  unsigned long size() const
661  {
662  LOCK(cs);
663  return mapTx.size();
664  }
665 
667  {
669  return totalTxSize;
670  }
671 
673  {
675  return m_total_fee;
676  }
677 
678  bool exists(const GenTxid& gtxid) const
679  {
680  LOCK(cs);
681  if (gtxid.IsWtxid()) {
682  return (mapTx.get<index_by_wtxid>().count(gtxid.GetHash()) != 0);
683  }
684  return (mapTx.count(gtxid.GetHash()) != 0);
685  }
686 
688 
689  CTransactionRef get(const uint256& hash) const;
691  {
693  return mapTx.project<0>(mapTx.get<index_by_wtxid>().find(wtxid));
694  }
695  TxMempoolInfo info(const GenTxid& gtxid) const;
696 
698  TxMempoolInfo info_for_relay(const GenTxid& gtxid, uint64_t last_sequence) const;
699 
700  std::vector<CTxMemPoolEntryRef> entryAll() const EXCLUSIVE_LOCKS_REQUIRED(cs);
701  std::vector<TxMempoolInfo> infoAll() const;
702 
703  size_t DynamicMemoryUsage() const;
704 
706  void AddUnbroadcastTx(const uint256& txid)
707  {
708  LOCK(cs);
709  // Sanity check the transaction is in the mempool & insert into
710  // unbroadcast set.
711  if (exists(GenTxid::Txid(txid))) m_unbroadcast_txids.insert(txid);
712  };
713 
715  void RemoveUnbroadcastTx(const uint256& txid, const bool unchecked = false);
716 
718  std::set<uint256> GetUnbroadcastTxs() const
719  {
720  LOCK(cs);
721  return m_unbroadcast_txids;
722  }
723 
726  {
728  return m_unbroadcast_txids.count(txid) != 0;
729  }
730 
733  return m_sequence_number++;
734  }
735 
737  return m_sequence_number;
738  }
739 
755  util::Result<std::pair<std::vector<FeeFrac>, std::vector<FeeFrac>>> CalculateFeerateDiagramsForRBF(CAmount replacement_fees, int64_t replacement_vsize, const setEntries& direct_conflicts, const setEntries& all_conflicts) EXCLUSIVE_LOCKS_REQUIRED(cs);
756 
757  /* Check that all direct conflicts are in a cluster size of two or less. Each
758  * direct conflict may be in a separate cluster.
759  */
760  std::optional<std::string> CheckConflictTopology(const setEntries& direct_conflicts);
761 
762 private:
791  void UpdateForDescendants(txiter updateIt, cacheMap& cachedDescendants,
792  const std::set<uint256>& setExclude, std::set<uint256>& descendants_to_remove) EXCLUSIVE_LOCKS_REQUIRED(cs);
794  void UpdateAncestorsOf(bool add, txiter hash, setEntries &setAncestors) EXCLUSIVE_LOCKS_REQUIRED(cs);
800  void UpdateForRemoveFromMempool(const setEntries &entriesToRemove, bool updateDescendants) EXCLUSIVE_LOCKS_REQUIRED(cs);
803 
813 public:
823  {
824  return m_epoch.visited(it->m_epoch_marker);
825  }
826 
827  bool visited(std::optional<txiter> it) const EXCLUSIVE_LOCKS_REQUIRED(cs, m_epoch)
828  {
829  assert(m_epoch.guarded()); // verify guard even when it==nullopt
830  return !it || visited(*it);
831  }
832 };
833 
848 {
853  std::unordered_map<COutPoint, Coin, SaltedOutpointHasher> m_temp_added;
854 
859  mutable std::unordered_set<COutPoint, SaltedOutpointHasher> m_non_base_coins;
860 protected:
862 
863 public:
864  CCoinsViewMemPool(CCoinsView* baseIn, const CTxMemPool& mempoolIn);
867  bool GetCoin(const COutPoint &outpoint, Coin &coin) const override;
870  void PackageAddTransaction(const CTransactionRef& tx);
872  std::unordered_set<COutPoint, SaltedOutpointHasher> GetNonBaseCoins() const { return m_non_base_coins; }
874  void Reset();
875 };
876 #endif // BITCOIN_TXMEMPOOL_H
int64_t CAmount
Amount in satoshis (Can be negative)
Definition: amount.h:12
#define LIFETIMEBOUND
Definition: attributes.h:16
An in-memory indexed chain of blocks.
Definition: chain.h:418
CCoinsView backed by another CCoinsView.
Definition: coins.h:210
CCoinsView that adds a memory cache for transactions to another CCoinsView.
Definition: coins.h:229
Abstract view on the open txout dataset.
Definition: coins.h:173
CCoinsView that brings transactions from a mempool into view.
Definition: txmempool.h:848
bool GetCoin(const COutPoint &outpoint, Coin &coin) const override
GetCoin, returning whether it exists and is not spent.
Definition: txmempool.cpp:990
std::unordered_set< COutPoint, SaltedOutpointHasher > GetNonBaseCoins() const
Get all coins in m_non_base_coins.
Definition: txmempool.h:872
void Reset()
Clear m_temp_added and m_non_base_coins.
Definition: txmempool.cpp:1021
std::unordered_map< COutPoint, Coin, SaltedOutpointHasher > m_temp_added
Coins made available by transactions being validated.
Definition: txmempool.h:853
CCoinsViewMemPool(CCoinsView *baseIn, const CTxMemPool &mempoolIn)
Definition: txmempool.cpp:988
std::unordered_set< COutPoint, SaltedOutpointHasher > m_non_base_coins
Set of all coins that have been fetched from mempool or created using PackageAddTransaction (not base...
Definition: txmempool.h:859
void PackageAddTransaction(const CTransactionRef &tx)
Add the coins created by this transaction.
Definition: txmempool.cpp:1014
const CTxMemPool & mempool
Definition: txmempool.h:861
Fee rate in satoshis per kilovirtualbyte: CAmount / kvB.
Definition: feerate.h:33
An outpoint - a combination of a transaction hash and an index n into its vout.
Definition: transaction.h:29
The basic transaction that is broadcasted on the network and contained in blocks.
Definition: transaction.h:296
const Txid & GetHash() const LIFETIMEBOUND
Definition: transaction.h:343
const Wtxid & GetWitnessHash() const LIFETIMEBOUND
Definition: transaction.h:344
CTxMemPoolEntry stores data about the corresponding transaction, as well as data about all in-mempool...
Definition: mempool_entry.h:66
int64_t GetSizeWithDescendants() const
const CTransaction & GetTx() const
std::chrono::seconds GetTime() const
CAmount GetModFeesWithDescendants() const
int32_t GetTxSize() const
CAmount GetModifiedFee() const
const CAmount & GetFee() const
CTxMemPool stores valid-according-to-the-current-best-chain transactions that may be included in the ...
Definition: txmempool.h:302
void removeConflicts(const CTransaction &tx) EXCLUSIVE_LOCKS_REQUIRED(cs)
Definition: txmempool.cpp:611
std::atomic< unsigned int > nTransactionsUpdated
Used by getblocktemplate to trigger CreateNewBlock() invocation.
Definition: txmempool.h:305
void RemoveUnbroadcastTx(const uint256 &txid, const bool unchecked=false)
Removes a transaction from the unbroadcast set.
Definition: txmempool.cpp:1033
void PrioritiseTransaction(const uint256 &hash, const CAmount &nFeeDelta)
Affect CreateNewBlock prioritisation of transactions.
Definition: txmempool.cpp:876
setEntries AssumeCalculateMemPoolAncestors(std::string_view calling_fn_name, const CTxMemPoolEntry &entry, const Limits &limits, bool fSearchForParents=true) const EXCLUSIVE_LOCKS_REQUIRED(cs)
Same as CalculateMemPoolAncestors, but always returns a (non-optional) setEntries.
Definition: txmempool.cpp:270
bool HasNoInputsOf(const CTransaction &tx) const EXCLUSIVE_LOCKS_REQUIRED(cs)
Check that none of this transactions inputs are in the mempool, and thus the tx is not dependent on o...
Definition: txmempool.cpp:980
const bool m_require_standard
Definition: txmempool.h:446
setEntries GetIterSet(const std::set< Txid > &hashes) const EXCLUSIVE_LOCKS_REQUIRED(cs)
Translate a set of hashes into a set of pool iterators to avoid repeated lookups.
Definition: txmempool.cpp:957
void AddUnbroadcastTx(const uint256 &txid)
Adds a transaction to the unbroadcast set.
Definition: txmempool.h:706
std::vector< txiter > GetIterVec(const std::vector< uint256 > &txids) const EXCLUSIVE_LOCKS_REQUIRED(cs)
Translate a list of hashes into a list of mempool iterators to avoid repeated lookups.
Definition: txmempool.cpp:967
ValidationSignals *const m_signals
Definition: txmempool.h:452
uint64_t cachedInnerUsage GUARDED_BY(cs)
sum of all mempool tx's fees (NOT modified fee)
Definition: txmempool.h:309
void UpdateEntryForAncestors(txiter it, const setEntries &setAncestors) EXCLUSIVE_LOCKS_REQUIRED(cs)
Set ancestor state for an entry.
Definition: txmempool.cpp:299
bool GetLoadTried() const
Definition: txmempool.cpp:1204
bool visited(const txiter it) const EXCLUSIVE_LOCKS_REQUIRED(cs
visited marks a CTxMemPoolEntry as having been traversed during the lifetime of the most recently cre...
bool visited(std::optional< txiter > it) const EXCLUSIVE_LOCKS_REQUIRED(cs
CFeeRate GetMinFee() const
The minimum fee to get into the mempool, which may itself not be enough for larger-sized transactions...
Definition: txmempool.h:627
RecursiveMutex cs
This mutex needs to be locked when accessing mapTx or other members that are guarded by it.
Definition: txmempool.h:390
void ClearPrioritisation(const uint256 &hash) EXCLUSIVE_LOCKS_REQUIRED(cs)
Definition: txmempool.cpp:922
void trackPackageRemoved(const CFeeRate &rate) EXCLUSIVE_LOCKS_REQUIRED(cs)
Definition: txmempool.cpp:1119
util::Result< setEntries > CalculateMemPoolAncestors(const CTxMemPoolEntry &entry, const Limits &limits, bool fSearchForParents=true) const EXCLUSIVE_LOCKS_REQUIRED(cs)
Try to calculate all in-mempool ancestors of entry.
Definition: txmempool.cpp:238
void removeRecursive(const CTransaction &tx, MemPoolRemovalReason reason) EXCLUSIVE_LOCKS_REQUIRED(cs)
Definition: txmempool.cpp:561
bool blockSinceLastRollingFeeBump GUARDED_BY(cs)
Definition: txmempool.h:312
const int m_check_ratio
Value n means that 1 times in n we check.
Definition: txmempool.h:304
void TrimToSize(size_t sizelimit, std::vector< COutPoint > *pvNoSpendsRemaining=nullptr) EXCLUSIVE_LOCKS_REQUIRED(cs)
Remove transactions from the mempool until its dynamic size is <= sizelimit.
Definition: txmempool.cpp:1127
const std::chrono::seconds m_expiry
Definition: txmempool.h:440
const std::optional< unsigned > m_max_datacarrier_bytes
Definition: txmempool.h:445
void UpdateTransactionsFromBlock(const std::vector< uint256 > &vHashesToUpdate) EXCLUSIVE_LOCKS_REQUIRED(cs
UpdateTransactionsFromBlock is called when adding transactions from a disconnected block back to the ...
Definition: txmempool.cpp:103
return !it visited * it
Definition: txmempool.h:830
void AddTransactionsUpdated(unsigned int n)
Definition: txmempool.cpp:426
void UpdateChildrenForRemoval(txiter entry) EXCLUSIVE_LOCKS_REQUIRED(cs)
Sever link between specified transaction and direct children.
Definition: txmempool.cpp:313
std::optional< txiter > GetIter(const uint256 &txid) const EXCLUSIVE_LOCKS_REQUIRED(cs)
Returns an iterator to the given hash, if found.
Definition: txmempool.cpp:950
util::Result< setEntries > CalculateAncestorsAndCheckLimits(int64_t entry_size, size_t entry_count, CTxMemPoolEntry::Parents &staged_ancestors, const Limits &limits) const EXCLUSIVE_LOCKS_REQUIRED(cs)
Helper function to calculate all in-mempool ancestors of staged_ancestors and apply ancestor and desc...
Definition: txmempool.cpp:158
const bool m_full_rbf
Definition: txmempool.h:447
const int64_t m_max_size_bytes
Definition: txmempool.h:439
void cs_main LOCKS_EXCLUDED(m_epoch)
CTransactionRef get(const uint256 &hash) const
Definition: txmempool.cpp:847
size_t DynamicMemoryUsage() const
Definition: txmempool.cpp:1027
Epoch m_epoch GUARDED_BY(cs)
minimum fee to get into the pool, decreases exponentially
Definition: txmempool.h:314
std::vector< TxMempoolInfo > infoAll() const
Definition: txmempool.cpp:826
void GetTransactionAncestry(const uint256 &txid, size_t &ancestors, size_t &descendants, size_t *ancestorsize=nullptr, CAmount *ancestorfees=nullptr) const
Calculate the ancestor and descendant count for the given transaction.
Definition: txmempool.cpp:1192
indexed_transaction_set mapTx GUARDED_BY(cs)
bool IsUnbroadcastTx(const uint256 &txid) const EXCLUSIVE_LOCKS_REQUIRED(cs)
Returns whether a txid is in the unbroadcast set.
Definition: txmempool.h:725
void UpdateParent(txiter entry, txiter parent, bool add) EXCLUSIVE_LOCKS_REQUIRED(cs)
Definition: txmempool.cpp:1084
void removeUnchecked(txiter entry, MemPoolRemovalReason reason) EXCLUSIVE_LOCKS_REQUIRED(cs)
Before calling removeUnchecked for a given transaction, UpdateForRemoveFromMempool must be called on ...
Definition: txmempool.cpp:486
uint64_t totalTxSize GUARDED_BY(cs)
Definition: txmempool.h:307
int Expire(std::chrono::seconds time) EXCLUSIVE_LOCKS_REQUIRED(cs)
Expire all transaction (and their dependencies) in the mempool older than time.
Definition: txmempool.cpp:1050
txiter get_iter_from_wtxid(const uint256 &wtxid) const EXCLUSIVE_LOCKS_REQUIRED(cs)
Definition: txmempool.h:690
void UpdateAncestorsOf(bool add, txiter hash, setEntries &setAncestors) EXCLUSIVE_LOCKS_REQUIRED(cs)
Update ancestors of hash to add/remove it as a descendant transaction.
Definition: txmempool.cpp:284
void removeForReorg(CChain &chain, std::function< bool(txiter)> filter_final_and_mature) EXCLUSIVE_LOCKS_REQUIRED(cs
After reorg, filter the entries that would no longer be valid in the next block, and update the entri...
Definition: txmempool.cpp:591
util::Result< void > CheckPackageLimits(const Package &package, int64_t total_vsize) const EXCLUSIVE_LOCKS_REQUIRED(cs)
Calculate all in-mempool ancestors of a set of transactions not already in the mempool and check ance...
Definition: txmempool.cpp:200
TxMempoolInfo info(const GenTxid &gtxid) const
Definition: txmempool.cpp:856
std::vector< txiter > GatherClusters(const std::vector< uint256 > &txids) const EXCLUSIVE_LOCKS_REQUIRED(cs)
Collect the entire cluster of connected transactions for each transaction in txids.
Definition: txmempool.cpp:1216
void ApplyDelta(const uint256 &hash, CAmount &nFeeDelta) const EXCLUSIVE_LOCKS_REQUIRED(cs)
Definition: txmempool.cpp:912
int64_t lastRollingFeeUpdate GUARDED_BY(cs)
sum of dynamic memory usage of all the map elements (NOT the maps themselves)
Definition: txmempool.h:311
const bool m_permit_bare_multisig
Definition: txmempool.h:444
void UpdateForDescendants(txiter updateIt, cacheMap &cachedDescendants, const std::set< uint256 > &setExclude, std::set< uint256 > &descendants_to_remove) EXCLUSIVE_LOCKS_REQUIRED(cs)
UpdateForDescendants is used by UpdateTransactionsFromBlock to update the descendants for a single tr...
Definition: txmempool.cpp:52
bool m_load_tried GUARDED_BY(cs)
Definition: txmempool.h:323
static const int ROLLING_FEE_HALFLIFE
Definition: txmempool.h:329
std::set< txiter, CompareIteratorByHash > setEntries
Definition: txmempool.h:396
std::vector< indexed_transaction_set::const_iterator > GetSortedDepthAndScore() const EXCLUSIVE_LOCKS_REQUIRED(cs)
Definition: txmempool.cpp:796
void RemoveStaged(setEntries &stage, bool updateDescendants, MemPoolRemovalReason reason) EXCLUSIVE_LOCKS_REQUIRED(cs)
Remove a set of transactions from the mempool.
Definition: txmempool.cpp:1042
void removeForBlock(const std::vector< CTransactionRef > &vtx, unsigned int nBlockHeight) EXCLUSIVE_LOCKS_REQUIRED(cs)
Called when a block is connected.
Definition: txmempool.cpp:631
std::set< uint256 > GetUnbroadcastTxs() const
Returns transactions in unbroadcast set.
Definition: txmempool.h:718
std::vector< delta_info > GetPrioritisedTransactions() const EXCLUSIVE_LOCKS_REQUIRED(!cs)
Return a vector of all entries in mapDeltas with their corresponding delta_info.
Definition: txmempool.cpp:928
const CFeeRate m_min_relay_feerate
Definition: txmempool.h:442
uint64_t GetSequence() const EXCLUSIVE_LOCKS_REQUIRED(cs)
Definition: txmempool.h:736
indexed_transaction_set::nth_index< 0 >::type::const_iterator txiter
Definition: txmempool.h:393
uint64_t GetAndIncrementSequence() const EXCLUSIVE_LOCKS_REQUIRED(cs)
Guards this internal counter for external reporting.
Definition: txmempool.h:732
void UpdateChild(txiter entry, txiter child, bool add) EXCLUSIVE_LOCKS_REQUIRED(cs)
Definition: txmempool.cpp:1073
TxMempoolInfo info_for_relay(const GenTxid &gtxid, uint64_t last_sequence) const
Returns info for a transaction if its entry_sequence < last_sequence.
Definition: txmempool.cpp:865
double rollingMinimumFeeRate GUARDED_BY(cs)
Definition: txmempool.h:313
bool exists(const GenTxid &gtxid) const
Definition: txmempool.h:678
std::map< txiter, setEntries, CompareIteratorByHash > cacheMap
Definition: txmempool.h:402
bool m_epoch
Definition: txmempool.h:823
const CFeeRate m_incremental_relay_feerate
Definition: txmempool.h:441
const CTransaction * GetConflictTx(const COutPoint &prevout) const EXCLUSIVE_LOCKS_REQUIRED(cs)
Get the transaction in the pool that spends the same prevout.
Definition: txmempool.cpp:944
boost::multi_index_container< CTxMemPoolEntry, boost::multi_index::indexed_by< boost::multi_index::hashed_unique< mempoolentry_txid, SaltedTxidHasher >, boost::multi_index::hashed_unique< boost::multi_index::tag< index_by_wtxid >, mempoolentry_wtxid, SaltedTxidHasher >, boost::multi_index::ordered_non_unique< boost::multi_index::tag< descendant_score >, boost::multi_index::identity< CTxMemPoolEntry >, CompareTxMemPoolEntryByDescendantScore >, boost::multi_index::ordered_non_unique< boost::multi_index::tag< entry_time >, boost::multi_index::identity< CTxMemPoolEntry >, CompareTxMemPoolEntryByEntryTime >, boost::multi_index::ordered_non_unique< boost::multi_index::tag< ancestor_score >, boost::multi_index::identity< CTxMemPoolEntry >, CompareTxMemPoolEntryByAncestorFee > > > indexed_transaction_set
Definition: txmempool.h:361
const bool m_persist_v1_dat
Definition: txmempool.h:448
bool CompareDepthAndScore(const uint256 &hasha, const uint256 &hashb, bool wtxid=false)
Definition: txmempool.cpp:760
void CalculateDescendants(txiter it, setEntries &setDescendants) const EXCLUSIVE_LOCKS_REQUIRED(cs)
Populate setDescendants with all in-mempool descendants of hash.
Definition: txmempool.cpp:537
unsigned long size() const
Definition: txmempool.h:660
const Limits m_limits
Definition: txmempool.h:450
std::optional< std::string > CheckConflictTopology(const setEntries &direct_conflicts)
Definition: txmempool.cpp:1243
util::Result< std::pair< std::vector< FeeFrac >, std::vector< FeeFrac > > > CalculateFeerateDiagramsForRBF(CAmount replacement_fees, int64_t replacement_vsize, const setEntries &direct_conflicts, const setEntries &all_conflicts) EXCLUSIVE_LOCKS_REQUIRED(cs)
Calculate the old and new mempool feerate diagrams relating to the clusters that would be affected by...
Definition: txmempool.cpp:1283
void check(const CCoinsViewCache &active_coins_tip, int64_t spendheight) const EXCLUSIVE_LOCKS_REQUIRED(void cs_main
Definition: txmempool.h:476
uint64_t m_sequence_number GUARDED_BY(cs)
Definition: txmempool.h:319
void SetLoadTried(bool load_tried)
Set whether or not an initial attempt to load the persisted mempool was made (regardless of whether t...
Definition: txmempool.cpp:1210
const CFeeRate m_dust_relay_feerate
Definition: txmempool.h:443
void UpdateForRemoveFromMempool(const setEntries &entriesToRemove, bool updateDescendants) EXCLUSIVE_LOCKS_REQUIRED(cs)
For each transaction being removed, update ancestors and any direct children.
Definition: txmempool.cpp:321
std::vector< CTransactionRef > txns_randomized GUARDED_BY(cs)
All transactions in mapTx, in random order.
std::vector< CTxMemPoolEntryRef > entryAll() const EXCLUSIVE_LOCKS_REQUIRED(cs)
Definition: txmempool.cpp:814
CAmount GetTotalFee() const EXCLUSIVE_LOCKS_REQUIRED(cs)
Definition: txmempool.h:672
uint64_t CalculateDescendantMaximum(txiter entry) const EXCLUSIVE_LOCKS_REQUIRED(cs)
Definition: txmempool.cpp:1170
uint64_t GetTotalTxSize() const EXCLUSIVE_LOCKS_REQUIRED(cs)
Definition: txmempool.h:666
bool isSpent(const COutPoint &outpoint) const
Definition: txmempool.cpp:415
const CTxMemPoolEntry * GetEntry(const Txid &txid) const LIFETIMEBOUND EXCLUSIVE_LOCKS_REQUIRED(cs)
Definition: txmempool.cpp:840
unsigned int GetTransactionsUpdated() const
Definition: txmempool.cpp:421
CAmount m_total_fee GUARDED_BY(cs)
sum of all mempool tx's virtual sizes. Differs from serialized tx size since witness data is discount...
Definition: txmempool.h:308
void check(const CCoinsViewCache &active_coins_tip, int64_t spendheight) const EXCLUSIVE_LOCKS_REQUIRED(void addUnchecked(const CTxMemPoolEntry &entry) EXCLUSIVE_LOCKS_REQUIRED(cs
If sanity-checking is turned on, check makes sure the pool is consistent (does not contain two transa...
Definition: txmempool.h:476
A UTXO entry.
Definition: coins.h:32
Definition: txmempool.h:162
bool operator()(const T &a, const T &b) const
Definition: txmempool.h:165
void GetModFeeAndSize(const T &a, double &mod_fee, double &size) const
Definition: txmempool.h:184
Sort an entry by max(score/size of entry's tx, score/size with all descendants).
Definition: txmempool.h:90
bool operator()(const CTxMemPoolEntry &a, const CTxMemPoolEntry &b) const
Definition: txmempool.h:92
void GetModFeeAndSize(const CTxMemPoolEntry &a, double &mod_fee, double &size) const
Definition: txmempool.h:110
Definition: txmempool.h:149
bool operator()(const CTxMemPoolEntry &a, const CTxMemPoolEntry &b) const
Definition: txmempool.h:151
Sort by feerate of entry (fee/size) in descending order This is only used for transaction relay,...
Definition: txmempool.h:135
bool operator()(const CTxMemPoolEntry &a, const CTxMemPoolEntry &b) const
Definition: txmempool.h:137
Epoch: RAII-style guard for using epoch-based graph traversal algorithms.
Definition: epochguard.h:35
A generic txid reference (txid or wtxid).
Definition: transaction.h:428
bool IsWtxid() const
Definition: transaction.h:436
const uint256 & GetHash() const LIFETIMEBOUND
Definition: transaction.h:437
static GenTxid Txid(const uint256 &hash)
Definition: transaction.h:434
256-bit opaque blob.
Definition: uint256.h:106
RecursiveMutex cs_main
Mutex to guard access to validation specific variables, such as reading or changing the chainstate.
Definition: cs_main.cpp:8
LockPoints lp
MemPoolRemovalReason
Reason why a transaction was removed from the mempool, this is passed to the notification signal.
std::vector< CTransactionRef > Package
A package is an ordered list of transactions.
Definition: packages.h:50
std::shared_ptr< const CTransaction > CTransactionRef
Definition: transaction.h:423
const CAmount delta
The fee delta added using PrioritiseTransaction().
Definition: txmempool.h:510
const bool in_mempool
Whether this transaction is in the mempool.
Definition: txmempool.h:508
std::optional< CAmount > modified_fee
The modified fee (base fee + delta) of this entry.
Definition: txmempool.h:512
const uint256 txid
The prioritised transaction's txid.
Definition: txmempool.h:514
Information about a mempool transaction.
Definition: txmempool.h:211
int64_t nFeeDelta
The fee delta.
Definition: txmempool.h:225
int32_t vsize
Virtual size of the transaction.
Definition: txmempool.h:222
CAmount fee
Fee of the transaction.
Definition: txmempool.h:219
CTransactionRef tx
The transaction itself.
Definition: txmempool.h:213
std::chrono::seconds m_time
Time the transaction entered the mempool.
Definition: txmempool.h:216
Options struct containing limit options for a CTxMemPool.
Options struct containing options for constructing a CTxMemPool.
result_type operator()(const CTxMemPoolEntry &entry) const
Definition: txmempool.h:58
uint256 result_type
Definition: txmempool.h:57
uint256 result_type
Definition: txmempool.h:72
result_type operator()(const CTxMemPoolEntry &entry) const
Definition: txmempool.h:73
#define LOCK(cs)
Definition: sync.h:257
#define EXCLUSIVE_LOCKS_REQUIRED(...)
Definition: threadsafety.h:49
int64_t GetTime()
Definition: time.cpp:97
static const uint32_t MEMPOOL_HEIGHT
Fake height value used in Coin to signify they are only in the memory pool (since 0....
Definition: txmempool.h:47
bool TestLockPointValidity(CChain &active_chain, const LockPoints &lp) EXCLUSIVE_LOCKS_REQUIRED(cs_main)
Test whether the LockPoints height and time are still valid on the current chain.
Definition: txmempool.cpp:35
AssertLockHeld(pool.cs)
assert(!tx.IsCoinBase())