Bitcoin Core  26.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 
25 #include <boost/multi_index/hashed_index.hpp>
26 #include <boost/multi_index/identity.hpp>
27 #include <boost/multi_index/indexed_by.hpp>
28 #include <boost/multi_index/ordered_index.hpp>
29 #include <boost/multi_index/sequenced_index.hpp>
30 #include <boost/multi_index/tag.hpp>
31 #include <boost/multi_index_container.hpp>
32 
33 #include <atomic>
34 #include <map>
35 #include <optional>
36 #include <set>
37 #include <string>
38 #include <string_view>
39 #include <utility>
40 #include <vector>
41 
42 class CChain;
43 
45 static const uint32_t MEMPOOL_HEIGHT = 0x7FFFFFFF;
46 
51 
52 // extracts a transaction hash from CTxMemPoolEntry or CTransactionRef
54 {
57  {
58  return entry.GetTx().GetHash();
59  }
60 
62  {
63  return tx->GetHash();
64  }
65 };
66 
67 // extracts a transaction witness-hash from CTxMemPoolEntry or CTransactionRef
69 {
72  {
73  return entry.GetTx().GetWitnessHash();
74  }
75 
77  {
78  return tx->GetWitnessHash();
79  }
80 };
81 
82 
88 {
89 public:
90  bool operator()(const CTxMemPoolEntry& a, const CTxMemPoolEntry& b) const
91  {
92  double a_mod_fee, a_size, b_mod_fee, b_size;
93 
94  GetModFeeAndSize(a, a_mod_fee, a_size);
95  GetModFeeAndSize(b, b_mod_fee, b_size);
96 
97  // Avoid division by rewriting (a/b > c/d) as (a*d > c*b).
98  double f1 = a_mod_fee * b_size;
99  double f2 = a_size * b_mod_fee;
100 
101  if (f1 == f2) {
102  return a.GetTime() >= b.GetTime();
103  }
104  return f1 < f2;
105  }
106 
107  // Return the fee/size we're using for sorting this entry.
108  void GetModFeeAndSize(const CTxMemPoolEntry &a, double &mod_fee, double &size) const
109  {
110  // Compare feerate with descendants to feerate of the transaction, and
111  // return the fee/size for the max.
112  double f1 = (double)a.GetModifiedFee() * a.GetSizeWithDescendants();
113  double f2 = (double)a.GetModFeesWithDescendants() * a.GetTxSize();
114 
115  if (f2 > f1) {
116  mod_fee = a.GetModFeesWithDescendants();
117  size = a.GetSizeWithDescendants();
118  } else {
119  mod_fee = a.GetModifiedFee();
120  size = a.GetTxSize();
121  }
122  }
123 };
124 
133 {
134 public:
135  bool operator()(const CTxMemPoolEntry& a, const CTxMemPoolEntry& b) const
136  {
137  double f1 = (double)a.GetFee() * b.GetTxSize();
138  double f2 = (double)b.GetFee() * a.GetTxSize();
139  if (f1 == f2) {
140  return b.GetTx().GetHash() < a.GetTx().GetHash();
141  }
142  return f1 > f2;
143  }
144 };
145 
147 {
148 public:
149  bool operator()(const CTxMemPoolEntry& a, const CTxMemPoolEntry& b) const
150  {
151  return a.GetTime() < b.GetTime();
152  }
153 };
154 
160 {
161 public:
162  template<typename T>
163  bool operator()(const T& a, const T& b) const
164  {
165  double a_mod_fee, a_size, b_mod_fee, b_size;
166 
167  GetModFeeAndSize(a, a_mod_fee, a_size);
168  GetModFeeAndSize(b, b_mod_fee, b_size);
169 
170  // Avoid division by rewriting (a/b > c/d) as (a*d > c*b).
171  double f1 = a_mod_fee * b_size;
172  double f2 = a_size * b_mod_fee;
173 
174  if (f1 == f2) {
175  return a.GetTx().GetHash() < b.GetTx().GetHash();
176  }
177  return f1 > f2;
178  }
179 
180  // Return the fee/size we're using for sorting this entry.
181  template <typename T>
182  void GetModFeeAndSize(const T &a, double &mod_fee, double &size) const
183  {
184  // Compare feerate with ancestors to feerate of the transaction, and
185  // return the fee/size for the min.
186  double f1 = (double)a.GetModifiedFee() * a.GetSizeWithAncestors();
187  double f2 = (double)a.GetModFeesWithAncestors() * a.GetTxSize();
188 
189  if (f1 > f2) {
190  mod_fee = a.GetModFeesWithAncestors();
191  size = a.GetSizeWithAncestors();
192  } else {
193  mod_fee = a.GetModifiedFee();
194  size = a.GetTxSize();
195  }
196  }
197 };
198 
199 // Multi_index tag names
201 struct entry_time {};
202 struct ancestor_score {};
203 struct index_by_wtxid {};
204 
209 {
212 
214  std::chrono::seconds m_time;
215 
218 
220  int32_t vsize;
221 
223  int64_t nFeeDelta;
224 };
225 
300 {
301 protected:
302  const int m_check_ratio;
303  std::atomic<unsigned int> nTransactionsUpdated{0};
304 
305  uint64_t totalTxSize GUARDED_BY(cs){0};
306  CAmount m_total_fee GUARDED_BY(cs){0};
307  uint64_t cachedInnerUsage GUARDED_BY(cs){0};
308 
309  mutable int64_t lastRollingFeeUpdate GUARDED_BY(cs){GetTime()};
310  mutable bool blockSinceLastRollingFeeBump GUARDED_BY(cs){false};
311  mutable double rollingMinimumFeeRate GUARDED_BY(cs){0};
313 
314  // In-memory counter for external mempool tracking purposes.
315  // This number is incremented once every time a transaction
316  // is added or removed from the mempool for any reason.
317  mutable uint64_t m_sequence_number GUARDED_BY(cs){1};
318 
320 
321  bool m_load_tried GUARDED_BY(cs){false};
322 
323  CFeeRate GetMinFee(size_t sizelimit) const;
324 
325 public:
326 
327  static const int ROLLING_FEE_HALFLIFE = 60 * 60 * 12; // public only for testing
328 
329  typedef boost::multi_index_container<
331  boost::multi_index::indexed_by<
332  // sorted by txid
333  boost::multi_index::hashed_unique<mempoolentry_txid, SaltedTxidHasher>,
334  // sorted by wtxid
335  boost::multi_index::hashed_unique<
336  boost::multi_index::tag<index_by_wtxid>,
339  >,
340  // sorted by fee rate
341  boost::multi_index::ordered_non_unique<
342  boost::multi_index::tag<descendant_score>,
343  boost::multi_index::identity<CTxMemPoolEntry>,
345  >,
346  // sorted by entry time
347  boost::multi_index::ordered_non_unique<
348  boost::multi_index::tag<entry_time>,
349  boost::multi_index::identity<CTxMemPoolEntry>,
351  >,
352  // sorted by fee rate with ancestors
353  boost::multi_index::ordered_non_unique<
354  boost::multi_index::tag<ancestor_score>,
355  boost::multi_index::identity<CTxMemPoolEntry>,
357  >
358  >
360 
390 
391  using txiter = indexed_transaction_set::nth_index<0>::type::const_iterator;
392  std::vector<CTransactionRef> txns_randomized GUARDED_BY(cs);
393 
394  typedef std::set<txiter, CompareIteratorByHash> setEntries;
395 
397 
399 private:
400  typedef std::map<txiter, setEntries, CompareIteratorByHash> cacheMap;
401 
402 
403  void UpdateParent(txiter entry, txiter parent, bool add) EXCLUSIVE_LOCKS_REQUIRED(cs);
404  void UpdateChild(txiter entry, txiter child, bool add) EXCLUSIVE_LOCKS_REQUIRED(cs);
405 
406  std::vector<indexed_transaction_set::const_iterator> GetSortedDepthAndScore() const EXCLUSIVE_LOCKS_REQUIRED(cs);
407 
411  std::set<uint256> m_unbroadcast_txids GUARDED_BY(cs);
412 
413 
426  size_t entry_count,
427  CTxMemPoolEntry::Parents &staged_ancestors,
428  const Limits& limits
429  ) const EXCLUSIVE_LOCKS_REQUIRED(cs);
430 
431 public:
433  std::map<uint256, CAmount> mapDeltas GUARDED_BY(cs);
434 
435  using Options = kernel::MemPoolOptions;
436 
437  const int64_t m_max_size_bytes;
438  const std::chrono::seconds m_expiry;
443  const std::optional<unsigned> m_max_datacarrier_bytes;
444  const bool m_require_standard;
445  const bool m_full_rbf;
446  const bool m_persist_v1_dat;
447 
449 
455  explicit CTxMemPool(const Options& opts);
456 
463  void check(const CCoinsViewCache& active_coins_tip, int64_t spendheight) const EXCLUSIVE_LOCKS_REQUIRED(::cs_main);
464 
465  // addUnchecked must updated state for all ancestors of a given transaction,
466  // to track size/count of descendant transactions. First version of
467  // addUnchecked can be used to have it call CalculateMemPoolAncestors(), and
468  // then invoke the second version.
469  // Note that addUnchecked is ONLY called from ATMP outside of tests
470  // and any other callers may break wallet's in-mempool tracking (due to
471  // lack of CValidationInterface::TransactionAddedToMempool callbacks).
474 
483  void removeForReorg(CChain& chain, std::function<bool(txiter)> filter_final_and_mature) EXCLUSIVE_LOCKS_REQUIRED(cs, cs_main);
485  void removeForBlock(const std::vector<CTransactionRef>& vtx, unsigned int nBlockHeight) EXCLUSIVE_LOCKS_REQUIRED(cs);
486 
487  bool CompareDepthAndScore(const uint256& hasha, const uint256& hashb, bool wtxid=false);
488  bool isSpent(const COutPoint& outpoint) const;
489  unsigned int GetTransactionsUpdated() const;
490  void AddTransactionsUpdated(unsigned int n);
495  bool HasNoInputsOf(const CTransaction& tx) const EXCLUSIVE_LOCKS_REQUIRED(cs);
496 
498  void PrioritiseTransaction(const uint256& hash, const CAmount& nFeeDelta);
499  void ApplyDelta(const uint256& hash, CAmount &nFeeDelta) const EXCLUSIVE_LOCKS_REQUIRED(cs);
501 
502  struct delta_info {
504  const bool in_mempool;
506  const CAmount delta;
508  std::optional<CAmount> modified_fee;
510  const uint256 txid;
511  };
513  std::vector<delta_info> GetPrioritisedTransactions() const EXCLUSIVE_LOCKS_REQUIRED(!cs);
514 
516  const CTransaction* GetConflictTx(const COutPoint& prevout) const EXCLUSIVE_LOCKS_REQUIRED(cs);
517 
519  std::optional<txiter> GetIter(const uint256& txid) const EXCLUSIVE_LOCKS_REQUIRED(cs);
520 
524  setEntries GetIterSet(const std::set<Txid>& hashes) const EXCLUSIVE_LOCKS_REQUIRED(cs);
525 
529  std::vector<txiter> GetIterVec(const std::vector<uint256>& txids) const EXCLUSIVE_LOCKS_REQUIRED(cs);
530 
538  void RemoveStaged(setEntries& stage, bool updateDescendants, MemPoolRemovalReason reason) EXCLUSIVE_LOCKS_REQUIRED(cs);
539 
554 
568  const Limits& limits,
569  bool fSearchForParents = true) const EXCLUSIVE_LOCKS_REQUIRED(cs);
570 
586  std::string_view calling_fn_name,
587  const CTxMemPoolEntry &entry,
588  const Limits& limits,
589  bool fSearchForParents = true) const EXCLUSIVE_LOCKS_REQUIRED(cs);
590 
595  std::vector<txiter> GatherClusters(const std::vector<uint256>& txids) const EXCLUSIVE_LOCKS_REQUIRED(cs);
596 
609  util::Result<void> CheckPackageLimits(const Package& package,
610  int64_t total_vsize) const EXCLUSIVE_LOCKS_REQUIRED(cs);
611 
615  void CalculateDescendants(txiter it, setEntries& setDescendants) const EXCLUSIVE_LOCKS_REQUIRED(cs);
616 
623  CFeeRate GetMinFee() const {
624  return GetMinFee(m_max_size_bytes);
625  }
626 
631  void TrimToSize(size_t sizelimit, std::vector<COutPoint>* pvNoSpendsRemaining = nullptr) EXCLUSIVE_LOCKS_REQUIRED(cs);
632 
634  int Expire(std::chrono::seconds time) EXCLUSIVE_LOCKS_REQUIRED(cs);
635 
642  void GetTransactionAncestry(const uint256& txid, size_t& ancestors, size_t& descendants, size_t* ancestorsize = nullptr, CAmount* ancestorfees = nullptr) const;
643 
648  bool GetLoadTried() const;
649 
654  void SetLoadTried(bool load_tried);
655 
656  unsigned long size() const
657  {
658  LOCK(cs);
659  return mapTx.size();
660  }
661 
663  {
665  return totalTxSize;
666  }
667 
669  {
671  return m_total_fee;
672  }
673 
674  bool exists(const GenTxid& gtxid) const
675  {
676  LOCK(cs);
677  if (gtxid.IsWtxid()) {
678  return (mapTx.get<index_by_wtxid>().count(gtxid.GetHash()) != 0);
679  }
680  return (mapTx.count(gtxid.GetHash()) != 0);
681  }
682 
684 
685  CTransactionRef get(const uint256& hash) const;
687  {
689  return mapTx.project<0>(mapTx.get<index_by_wtxid>().find(wtxid));
690  }
691  TxMempoolInfo info(const GenTxid& gtxid) const;
692 
694  TxMempoolInfo info_for_relay(const GenTxid& gtxid, uint64_t last_sequence) const;
695 
696  std::vector<CTxMemPoolEntryRef> entryAll() const EXCLUSIVE_LOCKS_REQUIRED(cs);
697  std::vector<TxMempoolInfo> infoAll() const;
698 
699  size_t DynamicMemoryUsage() const;
700 
702  void AddUnbroadcastTx(const uint256& txid)
703  {
704  LOCK(cs);
705  // Sanity check the transaction is in the mempool & insert into
706  // unbroadcast set.
707  if (exists(GenTxid::Txid(txid))) m_unbroadcast_txids.insert(txid);
708  };
709 
711  void RemoveUnbroadcastTx(const uint256& txid, const bool unchecked = false);
712 
714  std::set<uint256> GetUnbroadcastTxs() const
715  {
716  LOCK(cs);
717  return m_unbroadcast_txids;
718  }
719 
722  {
724  return m_unbroadcast_txids.count(txid) != 0;
725  }
726 
729  return m_sequence_number++;
730  }
731 
733  return m_sequence_number;
734  }
735 
736 private:
765  void UpdateForDescendants(txiter updateIt, cacheMap& cachedDescendants,
766  const std::set<uint256>& setExclude, std::set<uint256>& descendants_to_remove) EXCLUSIVE_LOCKS_REQUIRED(cs);
768  void UpdateAncestorsOf(bool add, txiter hash, setEntries &setAncestors) EXCLUSIVE_LOCKS_REQUIRED(cs);
774  void UpdateForRemoveFromMempool(const setEntries &entriesToRemove, bool updateDescendants) EXCLUSIVE_LOCKS_REQUIRED(cs);
777 
787 public:
797  {
798  return m_epoch.visited(it->m_epoch_marker);
799  }
800 
801  bool visited(std::optional<txiter> it) const EXCLUSIVE_LOCKS_REQUIRED(cs, m_epoch)
802  {
803  assert(m_epoch.guarded()); // verify guard even when it==nullopt
804  return !it || visited(*it);
805  }
806 };
807 
822 {
827  std::unordered_map<COutPoint, Coin, SaltedOutpointHasher> m_temp_added;
828 
833  mutable std::unordered_set<COutPoint, SaltedOutpointHasher> m_non_base_coins;
834 protected:
836 
837 public:
838  CCoinsViewMemPool(CCoinsView* baseIn, const CTxMemPool& mempoolIn);
841  bool GetCoin(const COutPoint &outpoint, Coin &coin) const override;
844  void PackageAddTransaction(const CTransactionRef& tx);
846  std::unordered_set<COutPoint, SaltedOutpointHasher> GetNonBaseCoins() const { return m_non_base_coins; }
848  void Reset();
849 };
850 #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:447
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:822
bool GetCoin(const COutPoint &outpoint, Coin &coin) const override
GetCoin, returning whether it exists and is not spent.
Definition: txmempool.cpp:986
std::unordered_set< COutPoint, SaltedOutpointHasher > GetNonBaseCoins() const
Get all coins in m_non_base_coins.
Definition: txmempool.h:846
void Reset()
Clear m_temp_added and m_non_base_coins.
Definition: txmempool.cpp:1017
std::unordered_map< COutPoint, Coin, SaltedOutpointHasher > m_temp_added
Coins made available by transactions being validated.
Definition: txmempool.h:827
CCoinsViewMemPool(CCoinsView *baseIn, const CTxMemPool &mempoolIn)
Definition: txmempool.cpp:984
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:833
void PackageAddTransaction(const CTransactionRef &tx)
Add the coins created by this transaction.
Definition: txmempool.cpp:1010
const CTxMemPool & mempool
Definition: txmempool.h:835
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:300
void removeConflicts(const CTransaction &tx) EXCLUSIVE_LOCKS_REQUIRED(cs)
Definition: txmempool.cpp:609
std::atomic< unsigned int > nTransactionsUpdated
Used by getblocktemplate to trigger CreateNewBlock() invocation.
Definition: txmempool.h:303
void RemoveUnbroadcastTx(const uint256 &txid, const bool unchecked=false)
Removes a transaction from the unbroadcast set.
Definition: txmempool.cpp:1029
void PrioritiseTransaction(const uint256 &hash, const CAmount &nFeeDelta)
Affect CreateNewBlock prioritisation of transactions.
Definition: txmempool.cpp:872
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:269
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:976
const bool m_require_standard
Definition: txmempool.h:444
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:953
void AddUnbroadcastTx(const uint256 &txid)
Adds a transaction to the unbroadcast set.
Definition: txmempool.h:702
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:963
uint64_t cachedInnerUsage GUARDED_BY(cs)
sum of all mempool tx's fees (NOT modified fee)
Definition: txmempool.h:307
void UpdateEntryForAncestors(txiter it, const setEntries &setAncestors) EXCLUSIVE_LOCKS_REQUIRED(cs)
Set ancestor state for an entry.
Definition: txmempool.cpp:298
bool GetLoadTried() const
Definition: txmempool.cpp:1200
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:623
RecursiveMutex cs
This mutex needs to be locked when accessing mapTx or other members that are guarded by it.
Definition: txmempool.h:388
void ClearPrioritisation(const uint256 &hash) EXCLUSIVE_LOCKS_REQUIRED(cs)
Definition: txmempool.cpp:918
void trackPackageRemoved(const CFeeRate &rate) EXCLUSIVE_LOCKS_REQUIRED(cs)
Definition: txmempool.cpp:1115
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:237
void removeRecursive(const CTransaction &tx, MemPoolRemovalReason reason) EXCLUSIVE_LOCKS_REQUIRED(cs)
Definition: txmempool.cpp:559
bool blockSinceLastRollingFeeBump GUARDED_BY(cs)
Definition: txmempool.h:310
const int m_check_ratio
Value n means that 1 times in n we check.
Definition: txmempool.h:302
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:1123
const std::chrono::seconds m_expiry
Definition: txmempool.h:438
const std::optional< unsigned > m_max_datacarrier_bytes
Definition: txmempool.h:443
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:102
return !it visited * it
Definition: txmempool.h:804
void AddTransactionsUpdated(unsigned int n)
Definition: txmempool.cpp:424
void UpdateChildrenForRemoval(txiter entry) EXCLUSIVE_LOCKS_REQUIRED(cs)
Sever link between specified transaction and direct children.
Definition: txmempool.cpp:312
std::optional< txiter > GetIter(const uint256 &txid) const EXCLUSIVE_LOCKS_REQUIRED(cs)
Returns an iterator to the given hash, if found.
Definition: txmempool.cpp:946
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:157
const bool m_full_rbf
Definition: txmempool.h:445
const int64_t m_max_size_bytes
Definition: txmempool.h:437
void cs_main LOCKS_EXCLUDED(m_epoch)
CTransactionRef get(const uint256 &hash) const
Definition: txmempool.cpp:843
size_t DynamicMemoryUsage() const
Definition: txmempool.cpp:1023
Epoch m_epoch GUARDED_BY(cs)
minimum fee to get into the pool, decreases exponentially
Definition: txmempool.h:312
std::vector< TxMempoolInfo > infoAll() const
Definition: txmempool.cpp:822
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:1188
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:721
void UpdateParent(txiter entry, txiter parent, bool add) EXCLUSIVE_LOCKS_REQUIRED(cs)
Definition: txmempool.cpp:1080
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:484
uint64_t totalTxSize GUARDED_BY(cs)
Definition: txmempool.h:305
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:1046
txiter get_iter_from_wtxid(const uint256 &wtxid) const EXCLUSIVE_LOCKS_REQUIRED(cs)
Definition: txmempool.h:686
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:283
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:589
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:199
TxMempoolInfo info(const GenTxid &gtxid) const
Definition: txmempool.cpp:852
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:1212
void ApplyDelta(const uint256 &hash, CAmount &nFeeDelta) const EXCLUSIVE_LOCKS_REQUIRED(cs)
Definition: txmempool.cpp:908
int64_t lastRollingFeeUpdate GUARDED_BY(cs)
sum of dynamic memory usage of all the map elements (NOT the maps themselves)
Definition: txmempool.h:309
const bool m_permit_bare_multisig
Definition: txmempool.h:442
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:51
bool m_load_tried GUARDED_BY(cs)
Definition: txmempool.h:321
static const int ROLLING_FEE_HALFLIFE
Definition: txmempool.h:327
std::set< txiter, CompareIteratorByHash > setEntries
Definition: txmempool.h:394
std::vector< indexed_transaction_set::const_iterator > GetSortedDepthAndScore() const EXCLUSIVE_LOCKS_REQUIRED(cs)
Definition: txmempool.cpp:792
void RemoveStaged(setEntries &stage, bool updateDescendants, MemPoolRemovalReason reason) EXCLUSIVE_LOCKS_REQUIRED(cs)
Remove a set of transactions from the mempool.
Definition: txmempool.cpp:1038
void removeForBlock(const std::vector< CTransactionRef > &vtx, unsigned int nBlockHeight) EXCLUSIVE_LOCKS_REQUIRED(cs)
Called when a block is connected.
Definition: txmempool.cpp:629
std::set< uint256 > GetUnbroadcastTxs() const
Returns transactions in unbroadcast set.
Definition: txmempool.h:714
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:924
const CFeeRate m_min_relay_feerate
Definition: txmempool.h:440
uint64_t GetSequence() const EXCLUSIVE_LOCKS_REQUIRED(cs)
Definition: txmempool.h:732
indexed_transaction_set::nth_index< 0 >::type::const_iterator txiter
Definition: txmempool.h:391
uint64_t GetAndIncrementSequence() const EXCLUSIVE_LOCKS_REQUIRED(cs)
Guards this internal counter for external reporting.
Definition: txmempool.h:728
void UpdateChild(txiter entry, txiter child, bool add) EXCLUSIVE_LOCKS_REQUIRED(cs)
Definition: txmempool.cpp:1069
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:861
double rollingMinimumFeeRate GUARDED_BY(cs)
Definition: txmempool.h:311
bool exists(const GenTxid &gtxid) const
Definition: txmempool.h:674
std::map< txiter, setEntries, CompareIteratorByHash > cacheMap
Definition: txmempool.h:400
bool m_epoch
Definition: txmempool.h:797
const CFeeRate m_incremental_relay_feerate
Definition: txmempool.h:439
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:940
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:359
const bool m_persist_v1_dat
Definition: txmempool.h:446
bool CompareDepthAndScore(const uint256 &hasha, const uint256 &hashb, bool wtxid=false)
Definition: txmempool.cpp:756
void CalculateDescendants(txiter it, setEntries &setDescendants) const EXCLUSIVE_LOCKS_REQUIRED(cs)
Populate setDescendants with all in-mempool descendants of hash.
Definition: txmempool.cpp:535
unsigned long size() const
Definition: txmempool.h:656
const Limits m_limits
Definition: txmempool.h:448
void check(const CCoinsViewCache &active_coins_tip, int64_t spendheight) const EXCLUSIVE_LOCKS_REQUIRED(void cs_main
Definition: txmempool.h:472
uint64_t m_sequence_number GUARDED_BY(cs)
Definition: txmempool.h:317
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:1206
const CFeeRate m_dust_relay_feerate
Definition: txmempool.h:441
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:320
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:810
CAmount GetTotalFee() const EXCLUSIVE_LOCKS_REQUIRED(cs)
Definition: txmempool.h:668
uint64_t CalculateDescendantMaximum(txiter entry) const EXCLUSIVE_LOCKS_REQUIRED(cs)
Definition: txmempool.cpp:1166
uint64_t GetTotalTxSize() const EXCLUSIVE_LOCKS_REQUIRED(cs)
Definition: txmempool.h:662
bool isSpent(const COutPoint &outpoint) const
Definition: txmempool.cpp:413
const CTxMemPoolEntry * GetEntry(const Txid &txid) const LIFETIMEBOUND EXCLUSIVE_LOCKS_REQUIRED(cs)
Definition: txmempool.cpp:836
unsigned int GetTransactionsUpdated() const
Definition: txmempool.cpp:419
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:306
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:472
A UTXO entry.
Definition: coins.h:32
Definition: txmempool.h:160
bool operator()(const T &a, const T &b) const
Definition: txmempool.h:163
void GetModFeeAndSize(const T &a, double &mod_fee, double &size) const
Definition: txmempool.h:182
Sort an entry by max(score/size of entry's tx, score/size with all descendants).
Definition: txmempool.h:88
bool operator()(const CTxMemPoolEntry &a, const CTxMemPoolEntry &b) const
Definition: txmempool.h:90
void GetModFeeAndSize(const CTxMemPoolEntry &a, double &mod_fee, double &size) const
Definition: txmempool.h:108
Definition: txmempool.h:147
bool operator()(const CTxMemPoolEntry &a, const CTxMemPoolEntry &b) const
Definition: txmempool.h:149
Sort by feerate of entry (fee/size) in descending order This is only used for transaction relay,...
Definition: txmempool.h:133
bool operator()(const CTxMemPoolEntry &a, const CTxMemPoolEntry &b) const
Definition: txmempool.h:135
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:506
const bool in_mempool
Whether this transaction is in the mempool.
Definition: txmempool.h:504
std::optional< CAmount > modified_fee
The modified fee (base fee + delta) of this entry.
Definition: txmempool.h:508
const uint256 txid
The prioritised transaction's txid.
Definition: txmempool.h:510
Information about a mempool transaction.
Definition: txmempool.h:209
int64_t nFeeDelta
The fee delta.
Definition: txmempool.h:223
int32_t vsize
Virtual size of the transaction.
Definition: txmempool.h:220
CAmount fee
Fee of the transaction.
Definition: txmempool.h:217
CTransactionRef tx
The transaction itself.
Definition: txmempool.h:211
std::chrono::seconds m_time
Time the transaction entered the mempool.
Definition: txmempool.h:214
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:56
uint256 result_type
Definition: txmempool.h:55
uint256 result_type
Definition: txmempool.h:70
result_type operator()(const CTxMemPoolEntry &entry) const
Definition: txmempool.h:71
#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:45
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:34
AssertLockHeld(pool.cs)
assert(!tx.IsCoinBase())