txmempool.cpp raw
1 // Copyright (c) 2022 The Limenka 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/truc_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
20 CTxMemPool::Options MemPoolOptionsForTest(const NodeContext& node)
21 {
22 CTxMemPool::Options mempool_opts{
23 // Default to always checking mempool regardless of
24 // chainparams.DefaultConsistencyChecks for tests
25 .check_ratio = 1,
26 .truc_policy = TRUCPolicy::Enforce,
27 .signals = node.validation_signals.get(),
28 };
29 const auto result{ApplyArgsManOptions(*node.args, ::Params(), mempool_opts)};
30 Assert(result);
31 return mempool_opts;
32 }
33
34 CTxMemPoolEntry TestMemPoolEntryHelper::FromTx(const CMutableTransaction& tx) const
35 {
36 return FromTx(MakeTransactionRef(tx));
37 }
38
39 CTxMemPoolEntry TestMemPoolEntryHelper::FromTx(const CTransactionRef& tx) const
40 {
41 return CTxMemPoolEntry{tx, nFee, TicksSinceEpoch<std::chrono::seconds>(time), nHeight, m_sequence, COIN_AGE_CACHE_ZERO, spendsCoinbase, /*extra_weight=*/0, sigOpCost, lp};
42 }
43
44 std::optional<std::string> CheckPackageMempoolAcceptResult(const Package& txns,
45 const PackageMempoolAcceptResult& result,
46 bool expect_valid,
47 const CTxMemPool* mempool)
48 {
49 if (expect_valid) {
50 if (result.m_state.IsInvalid()) {
51 return strprintf("Package validation unexpectedly failed: %s", result.m_state.ToString());
52 }
53 } else {
54 if (result.m_state.IsValid()) {
55 return strprintf("Package validation unexpectedly succeeded. %s", result.m_state.ToString());
56 }
57 }
58 if (result.m_state.GetResult() != PackageValidationResult::PCKG_POLICY && txns.size() != result.m_tx_results.size()) {
59 return strprintf("txns size %u does not match tx results size %u", txns.size(), result.m_tx_results.size());
60 }
61 for (const auto& tx : txns) {
62 const auto& wtxid = tx->GetWitnessHash();
63 if (result.m_tx_results.count(wtxid) == 0) {
64 return strprintf("result not found for tx %s", wtxid.ToString());
65 }
66
67 const auto& atmp_result = result.m_tx_results.at(wtxid);
68 const bool valid{atmp_result.m_result_type == MempoolAcceptResult::ResultType::VALID};
69 if (expect_valid && atmp_result.m_state.IsInvalid()) {
70 return strprintf("tx %s unexpectedly failed: %s", wtxid.ToString(), atmp_result.m_state.ToString());
71 }
72
73 // Each subpackage is allowed MAX_REPLACEMENT_CANDIDATES replacements (only checking individually here)
74 if (atmp_result.m_replaced_transactions.size() > MAX_REPLACEMENT_CANDIDATES) {
75 return strprintf("tx %s result replaced too many transactions",
76 wtxid.ToString());
77 }
78
79 // Replacements can't happen for subpackages larger than 2
80 if (!atmp_result.m_replaced_transactions.empty() &&
81 atmp_result.m_wtxids_fee_calculations.has_value() && atmp_result.m_wtxids_fee_calculations.value().size() > 2) {
82 return strprintf("tx %s was part of a too-large package RBF subpackage",
83 wtxid.ToString());
84 }
85
86 if (!atmp_result.m_replaced_transactions.empty() && mempool) {
87 LOCK(mempool->cs);
88 // If replacements occurred and it used 2 transactions, this is a package RBF and should result in a cluster of size 2
89 if (atmp_result.m_wtxids_fee_calculations.has_value() && atmp_result.m_wtxids_fee_calculations.value().size() == 2) {
90 const auto cluster = mempool->GatherClusters({tx->GetHash()});
91 if (cluster.size() != 2) return strprintf("tx %s has too many ancestors or descendants for a package rbf", wtxid.ToString());
92 }
93 }
94
95 // m_vsize and m_base_fees should exist iff the result was VALID or MEMPOOL_ENTRY
96 const bool mempool_entry{atmp_result.m_result_type == MempoolAcceptResult::ResultType::MEMPOOL_ENTRY};
97 if (atmp_result.m_base_fees.has_value() != (valid || mempool_entry)) {
98 return strprintf("tx %s result should %shave m_base_fees", wtxid.ToString(), valid || mempool_entry ? "" : "not ");
99 }
100 if (atmp_result.m_vsize.has_value() != (valid || mempool_entry)) {
101 return strprintf("tx %s result should %shave m_vsize", wtxid.ToString(), valid || mempool_entry ? "" : "not ");
102 }
103
104 // m_other_wtxid should exist iff the result was DIFFERENT_WITNESS
105 const bool diff_witness{atmp_result.m_result_type == MempoolAcceptResult::ResultType::DIFFERENT_WITNESS};
106 if (atmp_result.m_other_wtxid.has_value() != diff_witness) {
107 return strprintf("tx %s result should %shave m_other_wtxid", wtxid.ToString(), diff_witness ? "" : "not ");
108 }
109
110 // m_effective_feerate and m_wtxids_fee_calculations should exist iff the result was valid
111 // or if the failure was TX_RECONSIDERABLE
112 const bool valid_or_reconsiderable{atmp_result.m_result_type == MempoolAcceptResult::ResultType::VALID ||
113 atmp_result.m_state.GetResult() == TxValidationResult::TX_RECONSIDERABLE};
114 if (atmp_result.m_effective_feerate.has_value() != valid_or_reconsiderable) {
115 return strprintf("tx %s result should %shave m_effective_feerate",
116 wtxid.ToString(), valid ? "" : "not ");
117 }
118 if (atmp_result.m_wtxids_fee_calculations.has_value() != valid_or_reconsiderable) {
119 return strprintf("tx %s result should %shave m_effective_feerate",
120 wtxid.ToString(), valid ? "" : "not ");
121 }
122
123 if (mempool) {
124 // The tx by txid should be in the mempool iff the result was not INVALID.
125 const bool txid_in_mempool{atmp_result.m_result_type != MempoolAcceptResult::ResultType::INVALID};
126 if (mempool->exists(GenTxid::Txid(tx->GetHash())) != txid_in_mempool) {
127 return strprintf("tx %s should %sbe in mempool", wtxid.ToString(), txid_in_mempool ? "" : "not ");
128 }
129 // Additionally, if the result was DIFFERENT_WITNESS, we shouldn't be able to find the tx in mempool by wtxid.
130 if (tx->HasWitness() && atmp_result.m_result_type == MempoolAcceptResult::ResultType::DIFFERENT_WITNESS) {
131 if (mempool->exists(GenTxid::Wtxid(wtxid))) {
132 return strprintf("wtxid %s should not be in mempool", wtxid.ToString());
133 }
134 }
135 for (const auto& tx_ref : atmp_result.m_replaced_transactions) {
136 if (mempool->exists(GenTxid::Txid(tx_ref->GetHash()))) {
137 return strprintf("tx %s should not be in mempool as it was replaced", tx_ref->GetWitnessHash().ToString());
138 }
139 }
140 }
141 }
142 return std::nullopt;
143 }
144
145 void CheckMempoolEphemeralInvariants(const CTxMemPool& tx_pool)
146 {
147 LOCK(tx_pool.cs);
148 for (const auto& tx_info : tx_pool.infoAll()) {
149 const auto& entry = *Assert(tx_pool.GetEntry(tx_info.tx->GetHash()));
150
151 std::vector<uint32_t> dust_indexes = GetDust(*tx_info.tx, tx_pool.m_opts.dust_relay_feerate);
152
153 Assert(dust_indexes.size() < 2);
154
155 if (dust_indexes.empty()) continue;
156
157 // Transaction must have no base fee
158 Assert(entry.GetFee() == 0 && entry.GetModifiedFee() == 0);
159
160 // Transaction has single dust; make sure it's swept or will not be mined
161 const auto& children = entry.GetMemPoolChildrenConst();
162
163 // Multiple children should never happen as non-dust-spending child
164 // can get mined as package
165 Assert(children.size() < 2);
166
167 if (children.empty()) {
168 // No children and no fees; modified fees aside won't get mined so it's fine
169 // Happens naturally if child spend is RBF cycled away.
170 continue;
171 }
172
173 // Only-child should be spending the dust
174 const auto& only_child = children.begin()->get().GetTx();
175 COutPoint dust_outpoint{tx_info.tx->GetHash(), dust_indexes[0]};
176 Assert(std::any_of(only_child.vin.begin(), only_child.vin.end(), [&dust_outpoint](const CTxIn& txin) {
177 return txin.prevout == dust_outpoint;
178 }));
179 }
180 }
181
182 void CheckMempoolTRUCInvariants(const CTxMemPool& tx_pool)
183 {
184 LOCK(tx_pool.cs);
185 for (const auto& tx_info : tx_pool.infoAll()) {
186 const auto& entry = *Assert(tx_pool.GetEntry(tx_info.tx->GetHash()));
187 if (tx_info.tx->version == TRUC_VERSION) {
188 // Check that special maximum virtual size is respected
189 Assert(entry.GetTxSize() <= TRUC_MAX_VSIZE);
190
191 // Check that special TRUC ancestor/descendant limits and rules are always respected
192 Assert(entry.GetCountWithDescendants() <= TRUC_DESCENDANT_LIMIT);
193 Assert(entry.GetCountWithAncestors() <= TRUC_ANCESTOR_LIMIT);
194 Assert(entry.GetSizeWithDescendants() <= TRUC_MAX_VSIZE + TRUC_CHILD_MAX_VSIZE);
195 Assert(entry.GetSizeWithAncestors() <= TRUC_MAX_VSIZE + TRUC_CHILD_MAX_VSIZE);
196
197 // If this transaction has at least 1 ancestor, it's a "child" and has restricted weight.
198 if (entry.GetCountWithAncestors() > 1) {
199 Assert(entry.GetTxSize() <= TRUC_CHILD_MAX_VSIZE);
200 // All TRUC transactions must only have TRUC unconfirmed parents.
201 const auto& parents = entry.GetMemPoolParentsConst();
202 Assert(parents.begin()->get().GetSharedTx()->version == TRUC_VERSION);
203 }
204 } else if (entry.GetCountWithAncestors() > 1) {
205 // All non-TRUC transactions must only have non-TRUC unconfirmed parents.
206 for (const auto& parent : entry.GetMemPoolParentsConst()) {
207 Assert(parent.get().GetSharedTx()->version != TRUC_VERSION);
208 }
209 }
210 }
211 }
212
213 void AddToMempool(CTxMemPool& tx_pool, const CTxMemPoolEntry& entry)
214 {
215 const auto entry_coin_age_cache = entry.GetInternalCoinAgeCache();
216 LOCK2(cs_main, tx_pool.cs);
217 auto changeset = tx_pool.GetChangeSet();
218 changeset->StageAddition(entry.GetSharedTx(), entry.GetFee(),
219 entry.GetTime().count(), entry.GetHeight(), entry.GetSequence(),
220 entry_coin_age_cache,
221 /*spends_coinbase=*/ entry.GetSpendsCoinbase(),
222 /*extra_weight=*/ entry.GetExtraWeight(),
223 /*sigops_cost=*/ entry.GetSigOpCost(),
224 /*lp=*/ entry.GetLockPoints());
225 changeset->Apply();
226 }
227