Bitcoin Core  27.99.0
P2P Digital Currency
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
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>
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>
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>
43 class CChain;
44 class ValidationSignals;
47 static const uint32_t MEMPOOL_HEIGHT = 0x7FFFFFFF;
54 // extracts a transaction hash from CTxMemPoolEntry or CTransactionRef
56 {
59  {
60  return entry.GetTx().GetHash();
61  }
64  {
65  return tx->GetHash();
66  }
67 };
69 // extracts a transaction witness-hash from CTxMemPoolEntry or CTransactionRef
71 {
74  {
75  return entry.GetTx().GetWitnessHash();
76  }
79  {
80  return tx->GetWitnessHash();
81  }
82 };
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;
96  GetModFeeAndSize(a, a_mod_fee, a_size);
97  GetModFeeAndSize(b, b_mod_fee, b_size);
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;
103  if (f1 == f2) {
104  return a.GetTime() >= b.GetTime();
105  }
106  return f1 < f2;
107  }
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();
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 };
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 };
149 {
150 public:
151  bool operator()(const CTxMemPoolEntry& a, const CTxMemPoolEntry& b) const
152  {
153  return a.GetTime() < b.GetTime();
154  }
155 };
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;
169  GetModFeeAndSize(a, a_mod_fee, a_size);
170  GetModFeeAndSize(b, b_mod_fee, b_size);
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;
176  if (f1 == f2) {
177  return a.GetTx().GetHash() < b.GetTx().GetHash();
178  }
179  return f1 > f2;
180  }
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();
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 };
201 // Multi_index tag names
203 struct entry_time {};
204 struct ancestor_score {};
205 struct index_by_wtxid {};
211 {
216  std::chrono::seconds m_time;
222  int32_t vsize;
225  int64_t nFeeDelta;
226 };
302 {
303 protected:
304  std::atomic<unsigned int> nTransactionsUpdated{0};
306  uint64_t totalTxSize GUARDED_BY(cs){0};
307  CAmount m_total_fee GUARDED_BY(cs){0};
308  uint64_t cachedInnerUsage GUARDED_BY(cs){0};
310  mutable int64_t lastRollingFeeUpdate GUARDED_BY(cs){GetTime()};
311  mutable bool blockSinceLastRollingFeeBump GUARDED_BY(cs){false};
312  mutable double rollingMinimumFeeRate GUARDED_BY(cs){0};
315  // In-memory counter for external mempool tracking purposes.
316  // This number is incremented once every time a transaction
317  // is added or removed from the mempool for any reason.
318  mutable uint64_t m_sequence_number GUARDED_BY(cs){1};
322  bool m_load_tried GUARDED_BY(cs){false};
324  CFeeRate GetMinFee(size_t sizelimit) const;
326 public:
328  static const int ROLLING_FEE_HALFLIFE = 60 * 60 * 12; // public only for testing
330  typedef boost::multi_index_container<
332  boost::multi_index::indexed_by<
333  // sorted by txid
334  boost::multi_index::hashed_unique<mempoolentry_txid, SaltedTxidHasher>,
335  // sorted by wtxid
336  boost::multi_index::hashed_unique<
337  boost::multi_index::tag<index_by_wtxid>,
340  >,
341  // sorted by fee rate
342  boost::multi_index::ordered_non_unique<
343  boost::multi_index::tag<descendant_score>,
344  boost::multi_index::identity<CTxMemPoolEntry>,
346  >,
347  // sorted by entry time
348  boost::multi_index::ordered_non_unique<
349  boost::multi_index::tag<entry_time>,
350  boost::multi_index::identity<CTxMemPoolEntry>,
352  >,
353  // sorted by fee rate with ancestors
354  boost::multi_index::ordered_non_unique<
355  boost::multi_index::tag<ancestor_score>,
356  boost::multi_index::identity<CTxMemPoolEntry>,
358  >
359  >
392  using txiter = indexed_transaction_set::nth_index<0>::type::const_iterator;
393  std::vector<CTransactionRef> txns_randomized GUARDED_BY(cs);
395  typedef std::set<txiter, CompareIteratorByHash> setEntries;
400 private:
401  typedef std::map<txiter, setEntries, CompareIteratorByHash> cacheMap;
404  void UpdateParent(txiter entry, txiter parent, bool add) EXCLUSIVE_LOCKS_REQUIRED(cs);
405  void UpdateChild(txiter entry, txiter child, bool add) EXCLUSIVE_LOCKS_REQUIRED(cs);
407  std::vector<indexed_transaction_set::const_iterator> GetSortedDepthAndScore() const EXCLUSIVE_LOCKS_REQUIRED(cs);
412  std::set<uint256> m_unbroadcast_txids GUARDED_BY(cs);
427  size_t entry_count,
428  CTxMemPoolEntry::Parents &staged_ancestors,
429  const Limits& limits
432 public:
434  std::map<uint256, CAmount> mapDeltas GUARDED_BY(cs);
436  using Options = kernel::MemPoolOptions;
445  explicit CTxMemPool(const Options& opts);
453  void check(const CCoinsViewCache& active_coins_tip, int64_t spendheight) const EXCLUSIVE_LOCKS_REQUIRED(::cs_main);
455  // addUnchecked must updated state for all ancestors of a given transaction,
456  // to track size/count of descendant transactions. First version of
457  // addUnchecked can be used to have it call CalculateMemPoolAncestors(), and
458  // then invoke the second version.
459  // Note that addUnchecked is ONLY called from ATMP outside of tests
460  // and any other callers may break wallet's in-mempool tracking (due to
461  // lack of CValidationInterface::TransactionAddedToMempool callbacks).
473  void removeForReorg(CChain& chain, std::function<bool(txiter)> filter_final_and_mature) EXCLUSIVE_LOCKS_REQUIRED(cs, cs_main);
475  void removeForBlock(const std::vector<CTransactionRef>& vtx, unsigned int nBlockHeight) EXCLUSIVE_LOCKS_REQUIRED(cs);
477  bool CompareDepthAndScore(const uint256& hasha, const uint256& hashb, bool wtxid=false);
478  bool isSpent(const COutPoint& outpoint) const;
479  unsigned int GetTransactionsUpdated() const;
480  void AddTransactionsUpdated(unsigned int n);
485  bool HasNoInputsOf(const CTransaction& tx) const EXCLUSIVE_LOCKS_REQUIRED(cs);
488  void PrioritiseTransaction(const uint256& hash, const CAmount& nFeeDelta);
489  void ApplyDelta(const uint256& hash, CAmount &nFeeDelta) const EXCLUSIVE_LOCKS_REQUIRED(cs);
492  struct delta_info {
494  const bool in_mempool;
496  const CAmount delta;
498  std::optional<CAmount> modified_fee;
500  const uint256 txid;
501  };
503  std::vector<delta_info> GetPrioritisedTransactions() const EXCLUSIVE_LOCKS_REQUIRED(!cs);
506  const CTransaction* GetConflictTx(const COutPoint& prevout) const EXCLUSIVE_LOCKS_REQUIRED(cs);
509  std::optional<txiter> GetIter(const uint256& txid) const EXCLUSIVE_LOCKS_REQUIRED(cs);
514  setEntries GetIterSet(const std::set<Txid>& hashes) const EXCLUSIVE_LOCKS_REQUIRED(cs);
519  std::vector<txiter> GetIterVec(const std::vector<uint256>& txids) const EXCLUSIVE_LOCKS_REQUIRED(cs);
528  void RemoveStaged(setEntries& stage, bool updateDescendants, MemPoolRemovalReason reason) EXCLUSIVE_LOCKS_REQUIRED(cs);
558  const Limits& limits,
559  bool fSearchForParents = true) const EXCLUSIVE_LOCKS_REQUIRED(cs);
576  std::string_view calling_fn_name,
577  const CTxMemPoolEntry &entry,
578  const Limits& limits,
579  bool fSearchForParents = true) const EXCLUSIVE_LOCKS_REQUIRED(cs);
585  std::vector<txiter> GatherClusters(const std::vector<uint256>& txids) const EXCLUSIVE_LOCKS_REQUIRED(cs);
599  util::Result<void> CheckPackageLimits(const Package& package,
600  int64_t total_vsize) const EXCLUSIVE_LOCKS_REQUIRED(cs);
605  void CalculateDescendants(txiter it, setEntries& setDescendants) const EXCLUSIVE_LOCKS_REQUIRED(cs);
613  CFeeRate GetMinFee() const {
615  }
621  void TrimToSize(size_t sizelimit, std::vector<COutPoint>* pvNoSpendsRemaining = nullptr) EXCLUSIVE_LOCKS_REQUIRED(cs);
624  int Expire(std::chrono::seconds time) EXCLUSIVE_LOCKS_REQUIRED(cs);
632  void GetTransactionAncestry(const uint256& txid, size_t& ancestors, size_t& descendants, size_t* ancestorsize = nullptr, CAmount* ancestorfees = nullptr) const;
638  bool GetLoadTried() const;
644  void SetLoadTried(bool load_tried);
646  unsigned long size() const
647  {
648  LOCK(cs);
649  return mapTx.size();
650  }
653  {
655  return totalTxSize;
656  }
659  {
661  return m_total_fee;
662  }
664  bool exists(const GenTxid& gtxid) const
665  {
666  LOCK(cs);
667  if (gtxid.IsWtxid()) {
668  return (mapTx.get<index_by_wtxid>().count(gtxid.GetHash()) != 0);
669  }
670  return (mapTx.count(gtxid.GetHash()) != 0);
671  }
675  CTransactionRef get(const uint256& hash) const;
677  {
679  return mapTx.project<0>(mapTx.get<index_by_wtxid>().find(wtxid));
680  }
681  TxMempoolInfo info(const GenTxid& gtxid) const;
684  TxMempoolInfo info_for_relay(const GenTxid& gtxid, uint64_t last_sequence) const;
686  std::vector<CTxMemPoolEntryRef> entryAll() const EXCLUSIVE_LOCKS_REQUIRED(cs);
687  std::vector<TxMempoolInfo> infoAll() const;
689  size_t DynamicMemoryUsage() const;
692  void AddUnbroadcastTx(const uint256& txid)
693  {
694  LOCK(cs);
695  // Sanity check the transaction is in the mempool & insert into
696  // unbroadcast set.
697  if (exists(GenTxid::Txid(txid))) m_unbroadcast_txids.insert(txid);
698  };
701  void RemoveUnbroadcastTx(const uint256& txid, const bool unchecked = false);
704  std::set<uint256> GetUnbroadcastTxs() const
705  {
706  LOCK(cs);
707  return m_unbroadcast_txids;
708  }
712  {
714  return m_unbroadcast_txids.count(txid) != 0;
715  }
719  return m_sequence_number++;
720  }
723  return m_sequence_number;
724  }
741  util::Result<std::pair<std::vector<FeeFrac>, std::vector<FeeFrac>>> CalculateChunksForRBF(CAmount replacement_fees, int64_t replacement_vsize, const setEntries& direct_conflicts, const setEntries& all_conflicts) EXCLUSIVE_LOCKS_REQUIRED(cs);
743  /* Check that all direct conflicts are in a cluster size of two or less. Each
744  * direct conflict may be in a separate cluster.
745  */
746  std::optional<std::string> CheckConflictTopology(const setEntries& direct_conflicts);
748 private:
777  void UpdateForDescendants(txiter updateIt, cacheMap& cachedDescendants,
778  const std::set<uint256>& setExclude, std::set<uint256>& descendants_to_remove) EXCLUSIVE_LOCKS_REQUIRED(cs);
780  void UpdateAncestorsOf(bool add, txiter hash, setEntries &setAncestors) EXCLUSIVE_LOCKS_REQUIRED(cs);
786  void UpdateForRemoveFromMempool(const setEntries &entriesToRemove, bool updateDescendants) EXCLUSIVE_LOCKS_REQUIRED(cs);
799 public:
809  {
810  return m_epoch.visited(it->m_epoch_marker);
811  }
813  bool visited(std::optional<txiter> it) const EXCLUSIVE_LOCKS_REQUIRED(cs, m_epoch)
814  {
815  assert(m_epoch.guarded()); // verify guard even when it==nullopt
816  return !it || visited(*it);
817  }
818 };
834 {
839  std::unordered_map<COutPoint, Coin, SaltedOutpointHasher> m_temp_added;
845  mutable std::unordered_set<COutPoint, SaltedOutpointHasher> m_non_base_coins;
846 protected:
849 public:
850  CCoinsViewMemPool(CCoinsView* baseIn, const CTxMemPool& mempoolIn);
853  bool GetCoin(const COutPoint &outpoint, Coin &coin) const override;
856  void PackageAddTransaction(const CTransactionRef& tx);
858  std::unordered_set<COutPoint, SaltedOutpointHasher> GetNonBaseCoins() const { return m_non_base_coins; }
860  void Reset();
861 };
int64_t CAmount
Amount in satoshis (Can be negative)
Definition: amount.h:12
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:834
bool GetCoin(const COutPoint &outpoint, Coin &coin) const override
GetCoin, returning whether it exists and is not spent.
Definition: txmempool.cpp:978
std::unordered_set< COutPoint, SaltedOutpointHasher > GetNonBaseCoins() const
Get all coins in m_non_base_coins.
Definition: txmempool.h:858
void Reset()
Clear m_temp_added and m_non_base_coins.
Definition: txmempool.cpp:1009
std::unordered_map< COutPoint, Coin, SaltedOutpointHasher > m_temp_added
Coins made available by transactions being validated.
Definition: txmempool.h:839
CCoinsViewMemPool(CCoinsView *baseIn, const CTxMemPool &mempoolIn)
Definition: txmempool.cpp:976
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:845
void PackageAddTransaction(const CTransactionRef &tx)
Add the coins created by this transaction.
Definition: txmempool.cpp:1002
const CTxMemPool & mempool
Definition: txmempool.h:847
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:599
std::atomic< unsigned int > nTransactionsUpdated
Used by getblocktemplate to trigger CreateNewBlock() invocation.
Definition: txmempool.h:304
void RemoveUnbroadcastTx(const uint256 &txid, const bool unchecked=false)
Removes a transaction from the unbroadcast set.
Definition: txmempool.cpp:1021
void PrioritiseTransaction(const uint256 &hash, const CAmount &nFeeDelta)
Affect CreateNewBlock prioritisation of transactions.
Definition: txmempool.cpp:864
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:968
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:945
void AddUnbroadcastTx(const uint256 &txid)
Adds a transaction to the unbroadcast set.
Definition: txmempool.h:692
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:955
uint64_t cachedInnerUsage GUARDED_BY(cs)
sum of all mempool tx's fees (NOT modified fee)
Definition: txmempool.h:308
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:1192
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:613
RecursiveMutex cs
This mutex needs to be locked when accessing mapTx or other members that are guarded by it.
Definition: txmempool.h:389
void ClearPrioritisation(const uint256 &hash) EXCLUSIVE_LOCKS_REQUIRED(cs)
Definition: txmempool.cpp:910
void trackPackageRemoved(const CFeeRate &rate) EXCLUSIVE_LOCKS_REQUIRED(cs)
Definition: txmempool.cpp:1107
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:549
bool blockSinceLastRollingFeeBump GUARDED_BY(cs)
Definition: txmempool.h:311
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:1115
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:816
void AddTransactionsUpdated(unsigned int n)
Definition: txmempool.cpp:414
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:938
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
void cs_main LOCKS_EXCLUDED(m_epoch)
CTransactionRef get(const uint256 &hash) const
Definition: txmempool.cpp:835
size_t DynamicMemoryUsage() const
Definition: txmempool.cpp:1015
const Options m_opts
Definition: txmempool.h:438
Epoch m_epoch GUARDED_BY(cs)
minimum fee to get into the pool, decreases exponentially
Definition: txmempool.h:313
std::vector< TxMempoolInfo > infoAll() const
Definition: txmempool.cpp:814
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:1180
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:711
void UpdateParent(txiter entry, txiter parent, bool add) EXCLUSIVE_LOCKS_REQUIRED(cs)
Definition: txmempool.cpp:1072
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:474
uint64_t totalTxSize GUARDED_BY(cs)
Definition: txmempool.h:306
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:1038
txiter get_iter_from_wtxid(const uint256 &wtxid) const EXCLUSIVE_LOCKS_REQUIRED(cs)
Definition: txmempool.h:676
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:579
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:844
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:1204
void ApplyDelta(const uint256 &hash, CAmount &nFeeDelta) const EXCLUSIVE_LOCKS_REQUIRED(cs)
Definition: txmempool.cpp:900
int64_t lastRollingFeeUpdate GUARDED_BY(cs)
sum of dynamic memory usage of all the map elements (NOT the maps themselves)
Definition: txmempool.h:310
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
util::Result< std::pair< std::vector< FeeFrac >, std::vector< FeeFrac > > > CalculateChunksForRBF(CAmount replacement_fees, int64_t replacement_vsize, const setEntries &direct_conflicts, const setEntries &all_conflicts) EXCLUSIVE_LOCKS_REQUIRED(cs)
Calculate the sorted chunks for the old and new mempool relating to the clusters that would be affect...
Definition: txmempool.cpp:1271
bool m_load_tried GUARDED_BY(cs)
Definition: txmempool.h:322
static const int ROLLING_FEE_HALFLIFE
Definition: txmempool.h:328
std::set< txiter, CompareIteratorByHash > setEntries
Definition: txmempool.h:395
std::vector< indexed_transaction_set::const_iterator > GetSortedDepthAndScore() const EXCLUSIVE_LOCKS_REQUIRED(cs)
Definition: txmempool.cpp:784
void RemoveStaged(setEntries &stage, bool updateDescendants, MemPoolRemovalReason reason) EXCLUSIVE_LOCKS_REQUIRED(cs)
Remove a set of transactions from the mempool.
Definition: txmempool.cpp:1030
void removeForBlock(const std::vector< CTransactionRef > &vtx, unsigned int nBlockHeight) EXCLUSIVE_LOCKS_REQUIRED(cs)
Called when a block is connected.
Definition: txmempool.cpp:619
std::set< uint256 > GetUnbroadcastTxs() const
Returns transactions in unbroadcast set.
Definition: txmempool.h:704
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:916
uint64_t GetSequence() const EXCLUSIVE_LOCKS_REQUIRED(cs)
Definition: txmempool.h:722
indexed_transaction_set::nth_index< 0 >::type::const_iterator txiter
Definition: txmempool.h:392
uint64_t GetAndIncrementSequence() const EXCLUSIVE_LOCKS_REQUIRED(cs)
Guards this internal counter for external reporting.
Definition: txmempool.h:718
void UpdateChild(txiter entry, txiter child, bool add) EXCLUSIVE_LOCKS_REQUIRED(cs)
Definition: txmempool.cpp:1061
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:853
double rollingMinimumFeeRate GUARDED_BY(cs)
Definition: txmempool.h:312
bool exists(const GenTxid &gtxid) const
Definition: txmempool.h:664
std::map< txiter, setEntries, CompareIteratorByHash > cacheMap
Definition: txmempool.h:401
bool m_epoch
Definition: txmempool.h:809
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:932
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:360
bool CompareDepthAndScore(const uint256 &hasha, const uint256 &hashb, bool wtxid=false)
Definition: txmempool.cpp:748
void CalculateDescendants(txiter it, setEntries &setDescendants) const EXCLUSIVE_LOCKS_REQUIRED(cs)
Populate setDescendants with all in-mempool descendants of hash.
Definition: txmempool.cpp:525
unsigned long size() const
Definition: txmempool.h:646
std::optional< std::string > CheckConflictTopology(const setEntries &direct_conflicts)
Definition: txmempool.cpp:1231
void check(const CCoinsViewCache &active_coins_tip, int64_t spendheight) const EXCLUSIVE_LOCKS_REQUIRED(void cs_main
Definition: txmempool.h:462
uint64_t m_sequence_number GUARDED_BY(cs)
Definition: txmempool.h:318
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:1198
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:802
CAmount GetTotalFee() const EXCLUSIVE_LOCKS_REQUIRED(cs)
Definition: txmempool.h:658
uint64_t CalculateDescendantMaximum(txiter entry) const EXCLUSIVE_LOCKS_REQUIRED(cs)
Definition: txmempool.cpp:1158
uint64_t GetTotalTxSize() const EXCLUSIVE_LOCKS_REQUIRED(cs)
Definition: txmempool.h:652
bool isSpent(const COutPoint &outpoint) const
Definition: txmempool.cpp:403
const CTxMemPoolEntry * GetEntry(const Txid &txid) const LIFETIMEBOUND EXCLUSIVE_LOCKS_REQUIRED(cs)
Definition: txmempool.cpp:828
unsigned int GetTransactionsUpdated() const
Definition: txmempool.cpp:409
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:307
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:462
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
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:496
const bool in_mempool
Whether this transaction is in the mempool.
Definition: txmempool.h:494
std::optional< CAmount > modified_fee
The modified fee (base fee + delta) of this entry.
Definition: txmempool.h:498
const uint256 txid
The prioritised transaction's txid.
Definition: txmempool.h:500
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
Definition: threadsafety.h:49
int64_t GetTime()
Definition: time.cpp:44
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