Bitcoin Core  27.99.0
P2P Digital Currency
txmempool.cpp
Go to the documentation of this file.
1 // Copyright (c) 2022 The Bitcoin Core developers
2 // Distributed under the MIT software license, see the accompanying
3 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
4 
5 #include <test/util/txmempool.h>
6 
7 #include <chainparams.h>
8 #include <node/context.h>
9 #include <node/mempool_args.h>
10 #include <policy/rbf.h>
11 #include <policy/v3_policy.h>
12 #include <txmempool.h>
13 #include <util/check.h>
14 #include <util/time.h>
15 #include <util/translation.h>
16 #include <validation.h>
17 
18 using node::NodeContext;
19 
21 {
22  CTxMemPool::Options mempool_opts{
23  // Default to always checking mempool regardless of
24  // chainparams.DefaultConsistencyChecks for tests
25  .check_ratio = 1,
26  .signals = node.validation_signals.get(),
27  };
28  const auto result{ApplyArgsManOptions(*node.args, ::Params(), mempool_opts)};
29  Assert(result);
30  return mempool_opts;
31 }
32 
34 {
35  return FromTx(MakeTransactionRef(tx));
36 }
37 
39 {
40  return CTxMemPoolEntry{tx, nFee, TicksSinceEpoch<std::chrono::seconds>(time), nHeight, m_sequence, spendsCoinbase, sigOpCost, lp};
41 }
42 
43 std::optional<std::string> CheckPackageMempoolAcceptResult(const Package& txns,
44  const PackageMempoolAcceptResult& result,
45  bool expect_valid,
46  const CTxMemPool* mempool)
47 {
48  if (expect_valid) {
49  if (result.m_state.IsInvalid()) {
50  return strprintf("Package validation unexpectedly failed: %s", result.m_state.ToString());
51  }
52  } else {
53  if (result.m_state.IsValid()) {
54  return strprintf("Package validation unexpectedly succeeded. %s", result.m_state.ToString());
55  }
56  }
57  if (result.m_state.GetResult() != PackageValidationResult::PCKG_POLICY && txns.size() != result.m_tx_results.size()) {
58  return strprintf("txns size %u does not match tx results size %u", txns.size(), result.m_tx_results.size());
59  }
60  for (const auto& tx : txns) {
61  const auto& wtxid = tx->GetWitnessHash();
62  if (result.m_tx_results.count(wtxid) == 0) {
63  return strprintf("result not found for tx %s", wtxid.ToString());
64  }
65 
66  const auto& atmp_result = result.m_tx_results.at(wtxid);
67  const bool valid{atmp_result.m_result_type == MempoolAcceptResult::ResultType::VALID};
68  if (expect_valid && atmp_result.m_state.IsInvalid()) {
69  return strprintf("tx %s unexpectedly failed: %s", wtxid.ToString(), atmp_result.m_state.ToString());
70  }
71 
72  // Each subpackage is allowed MAX_REPLACEMENT_CANDIDATES replacements (only checking individually here)
73  if (atmp_result.m_replaced_transactions.size() > MAX_REPLACEMENT_CANDIDATES) {
74  return strprintf("tx %s result replaced too many transactions",
75  wtxid.ToString());
76  }
77 
78  // Replacements can't happen for subpackages larger than 2
79  if (!atmp_result.m_replaced_transactions.empty() &&
80  atmp_result.m_wtxids_fee_calculations.has_value() && atmp_result.m_wtxids_fee_calculations.value().size() > 2) {
81  return strprintf("tx %s was part of a too-large package RBF subpackage",
82  wtxid.ToString());
83  }
84 
85  if (!atmp_result.m_replaced_transactions.empty() && mempool) {
86  LOCK(mempool->cs);
87  // If replacements occurred and it used 2 transactions, this is a package RBF and should result in a cluster of size 2
88  if (atmp_result.m_wtxids_fee_calculations.has_value() && atmp_result.m_wtxids_fee_calculations.value().size() == 2) {
89  const auto cluster = mempool->GatherClusters({tx->GetHash()});
90  if (cluster.size() != 2) return strprintf("tx %s has too many ancestors or descendants for a package rbf", wtxid.ToString());
91  }
92  }
93 
94  // m_vsize and m_base_fees should exist iff the result was VALID or MEMPOOL_ENTRY
95  const bool mempool_entry{atmp_result.m_result_type == MempoolAcceptResult::ResultType::MEMPOOL_ENTRY};
96  if (atmp_result.m_base_fees.has_value() != (valid || mempool_entry)) {
97  return strprintf("tx %s result should %shave m_base_fees", wtxid.ToString(), valid || mempool_entry ? "" : "not ");
98  }
99  if (atmp_result.m_vsize.has_value() != (valid || mempool_entry)) {
100  return strprintf("tx %s result should %shave m_vsize", wtxid.ToString(), valid || mempool_entry ? "" : "not ");
101  }
102 
103  // m_other_wtxid should exist iff the result was DIFFERENT_WITNESS
104  const bool diff_witness{atmp_result.m_result_type == MempoolAcceptResult::ResultType::DIFFERENT_WITNESS};
105  if (atmp_result.m_other_wtxid.has_value() != diff_witness) {
106  return strprintf("tx %s result should %shave m_other_wtxid", wtxid.ToString(), diff_witness ? "" : "not ");
107  }
108 
109  // m_effective_feerate and m_wtxids_fee_calculations should exist iff the result was valid
110  // or if the failure was TX_RECONSIDERABLE
111  const bool valid_or_reconsiderable{atmp_result.m_result_type == MempoolAcceptResult::ResultType::VALID ||
112  atmp_result.m_state.GetResult() == TxValidationResult::TX_RECONSIDERABLE};
113  if (atmp_result.m_effective_feerate.has_value() != valid_or_reconsiderable) {
114  return strprintf("tx %s result should %shave m_effective_feerate",
115  wtxid.ToString(), valid ? "" : "not ");
116  }
117  if (atmp_result.m_wtxids_fee_calculations.has_value() != valid_or_reconsiderable) {
118  return strprintf("tx %s result should %shave m_effective_feerate",
119  wtxid.ToString(), valid ? "" : "not ");
120  }
121 
122  if (mempool) {
123  // The tx by txid should be in the mempool iff the result was not INVALID.
124  const bool txid_in_mempool{atmp_result.m_result_type != MempoolAcceptResult::ResultType::INVALID};
125  if (mempool->exists(GenTxid::Txid(tx->GetHash())) != txid_in_mempool) {
126  return strprintf("tx %s should %sbe in mempool", wtxid.ToString(), txid_in_mempool ? "" : "not ");
127  }
128  // Additionally, if the result was DIFFERENT_WITNESS, we shouldn't be able to find the tx in mempool by wtxid.
129  if (tx->HasWitness() && atmp_result.m_result_type == MempoolAcceptResult::ResultType::DIFFERENT_WITNESS) {
130  if (mempool->exists(GenTxid::Wtxid(wtxid))) {
131  return strprintf("wtxid %s should not be in mempool", wtxid.ToString());
132  }
133  }
134  for (const auto& tx_ref : atmp_result.m_replaced_transactions) {
135  if (mempool->exists(GenTxid::Txid(tx_ref->GetHash()))) {
136  return strprintf("tx %s should not be in mempool as it was replaced", tx_ref->GetWitnessHash().ToString());
137  }
138  }
139  }
140  }
141  return std::nullopt;
142 }
143 
145 {
146  LOCK(tx_pool.cs);
147  for (const auto& tx_info : tx_pool.infoAll()) {
148  const auto& entry = *Assert(tx_pool.GetEntry(tx_info.tx->GetHash()));
149  if (tx_info.tx->version == TRUC_VERSION) {
150  // Check that special maximum virtual size is respected
151  Assert(entry.GetTxSize() <= V3_MAX_VSIZE);
152 
153  // Check that special v3 ancestor/descendant limits and rules are always respected
154  Assert(entry.GetCountWithDescendants() <= V3_DESCENDANT_LIMIT);
155  Assert(entry.GetCountWithAncestors() <= V3_ANCESTOR_LIMIT);
156  Assert(entry.GetSizeWithDescendants() <= V3_MAX_VSIZE + V3_CHILD_MAX_VSIZE);
157  Assert(entry.GetSizeWithAncestors() <= V3_MAX_VSIZE + V3_CHILD_MAX_VSIZE);
158 
159  // If this transaction has at least 1 ancestor, it's a "child" and has restricted weight.
160  if (entry.GetCountWithAncestors() > 1) {
161  Assert(entry.GetTxSize() <= V3_CHILD_MAX_VSIZE);
162  // All v3 transactions must only have v3 unconfirmed parents.
163  const auto& parents = entry.GetMemPoolParentsConst();
164  Assert(parents.begin()->get().GetSharedTx()->version == TRUC_VERSION);
165  }
166  } else if (entry.GetCountWithAncestors() > 1) {
167  // All non-v3 transactions must only have non-v3 unconfirmed parents.
168  for (const auto& parent : entry.GetMemPoolParentsConst()) {
169  Assert(parent.get().GetSharedTx()->version != TRUC_VERSION);
170  }
171  }
172  }
173 }
const CChainParams & Params()
Return the currently selected parameters.
#define Assert(val)
Identity function.
Definition: check.h:77
CTxMemPoolEntry stores data about the corresponding transaction, as well as data about all in-mempool...
Definition: mempool_entry.h:66
CTxMemPool stores valid-according-to-the-current-best-chain transactions that may be included in the ...
Definition: txmempool.h:304
RecursiveMutex cs
This mutex needs to be locked when accessing mapTx or other members that are guarded by it.
Definition: txmempool.h:391
std::vector< TxMempoolInfo > infoAll() const
Definition: txmempool.cpp:827
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:1217
bool exists(const GenTxid &gtxid) const
Definition: txmempool.h:666
const CTxMemPoolEntry * GetEntry(const Txid &txid) const LIFETIMEBOUND EXCLUSIVE_LOCKS_REQUIRED(cs)
Definition: txmempool.cpp:841
static GenTxid Wtxid(const uint256 &hash)
Definition: transaction.h:435
static GenTxid Txid(const uint256 &hash)
Definition: transaction.h:434
bool IsValid() const
Definition: validation.h:122
Result GetResult() const
Definition: validation.h:125
std::string ToString() const
Definition: validation.h:128
bool IsInvalid() const
Definition: validation.h:123
@ TX_RECONSIDERABLE
fails some policy, but might be acceptable if submitted in a (different) package
Definition: messages.h:20
util::Result< void > ApplyArgsManOptions(const ArgsManager &args, BlockManager::Options &opts)
std::vector< CTransactionRef > Package
A package is an ordered list of transactions.
Definition: packages.h:50
@ PCKG_POLICY
The package itself is invalid (e.g. too many transactions).
static constexpr uint32_t MAX_REPLACEMENT_CANDIDATES
Maximum number of transactions that can be replaced by RBF (Rule #5).
Definition: rbf.h:26
static CTransactionRef MakeTransactionRef(Tx &&txIn)
Definition: transaction.h:424
std::shared_ptr< const CTransaction > CTransactionRef
Definition: transaction.h:423
A mutable version of CTransaction.
Definition: transaction.h:378
@ DIFFERENT_WITNESS
Valid, transaction was already in the mempool.
@ INVALID
Fully validated, valid.
Validation result for package mempool acceptance.
Definition: validation.h:232
PackageValidationState m_state
Definition: validation.h:233
std::map< uint256, MempoolAcceptResult > m_tx_results
Map from wtxid to finished MempoolAcceptResults.
Definition: validation.h:240
CAmount nFee
Definition: txmempool.h:21
bool spendsCoinbase
Definition: txmempool.h:25
LockPoints lp
Definition: txmempool.h:27
CTxMemPoolEntry FromTx(const CMutableTransaction &tx) const
Definition: txmempool.cpp:33
unsigned int nHeight
Definition: txmempool.h:23
unsigned int sigOpCost
Definition: txmempool.h:26
NodeSeconds time
Definition: txmempool.h:22
uint64_t m_sequence
Definition: txmempool.h:24
Options struct containing options for constructing a CTxMemPool.
NodeContext struct containing references to chain state and connection state.
Definition: context.h:54
#define LOCK(cs)
Definition: sync.h:257
CTxMemPool::Options MemPoolOptionsForTest(const NodeContext &node)
Definition: txmempool.cpp:20
std::optional< std::string > CheckPackageMempoolAcceptResult(const Package &txns, const PackageMempoolAcceptResult &result, bool expect_valid, const CTxMemPool *mempool)
Check expected properties for every PackageMempoolAcceptResult, regardless of value.
Definition: txmempool.cpp:43
void CheckMempoolV3Invariants(const CTxMemPool &tx_pool)
For every transaction in tx_pool, check v3 invariants:
Definition: txmempool.cpp:144
#define strprintf
Format arguments and return the string or write to given std::ostream (see tinyformat::format doc for...
Definition: tinyformat.h:1162
static constexpr unsigned int V3_DESCENDANT_LIMIT
Maximum number of transactions including an unconfirmed tx and its descendants.
Definition: v3_policy.h:24
static constexpr int64_t V3_CHILD_MAX_VSIZE
Maximum sigop-adjusted virtual size of a tx which spends from an unconfirmed v3 transaction.
Definition: v3_policy.h:31
static constexpr decltype(CTransaction::version) TRUC_VERSION
Definition: v3_policy.h:20
static constexpr int64_t V3_MAX_VSIZE
Maximum sigop-adjusted virtual size of all v3 transactions.
Definition: v3_policy.h:29
static constexpr unsigned int V3_ANCESTOR_LIMIT
Maximum number of transactions including a V3 tx and all its mempool ancestors.
Definition: v3_policy.h:26