Bitcoin Core 29.99.0
P2P Digital Currency
tx_pool.cpp
Go to the documentation of this file.
1// Copyright (c) 2021-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
6#include <node/context.h>
7#include <node/mempool_args.h>
8#include <node/miner.h>
11#include <test/fuzz/fuzz.h>
12#include <test/fuzz/util.h>
14#include <test/util/mining.h>
15#include <test/util/script.h>
17#include <test/util/txmempool.h>
18#include <util/check.h>
19#include <util/rbf.h>
20#include <util/translation.h>
21#include <validation.h>
22#include <validationinterface.h>
23
26using util::ToString;
27
28namespace {
29
30const TestingSetup* g_setup;
31std::vector<COutPoint> g_outpoints_coinbase_init_mature;
32std::vector<COutPoint> g_outpoints_coinbase_init_immature;
33
34struct MockedTxPool : public CTxMemPool {
35 void RollingFeeUpdate() EXCLUSIVE_LOCKS_REQUIRED(!cs)
36 {
37 LOCK(cs);
38 lastRollingFeeUpdate = GetTime();
39 blockSinceLastRollingFeeBump = true;
40 }
41};
42
43void initialize_tx_pool()
44{
45 static const auto testing_setup = MakeNoLogFileContext<const TestingSetup>();
46 g_setup = testing_setup.get();
47 SetMockTime(WITH_LOCK(g_setup->m_node.chainman->GetMutex(), return g_setup->m_node.chainman->ActiveTip()->Time()));
48
49 BlockAssembler::Options options;
50 options.coinbase_output_script = P2WSH_OP_TRUE;
51
52 for (int i = 0; i < 2 * COINBASE_MATURITY; ++i) {
53 COutPoint prevout{MineBlock(g_setup->m_node, options)};
54 // Remember the txids to avoid expensive disk access later on
55 auto& outpoints = i < COINBASE_MATURITY ?
56 g_outpoints_coinbase_init_mature :
57 g_outpoints_coinbase_init_immature;
58 outpoints.push_back(prevout);
59 }
60 g_setup->m_node.validation_signals->SyncWithValidationInterfaceQueue();
61}
62
63struct TransactionsDelta final : public CValidationInterface {
64 std::set<CTransactionRef>& m_removed;
65 std::set<CTransactionRef>& m_added;
66
67 explicit TransactionsDelta(std::set<CTransactionRef>& r, std::set<CTransactionRef>& a)
68 : m_removed{r}, m_added{a} {}
69
70 void TransactionAddedToMempool(const NewMempoolTransactionInfo& tx, uint64_t /* mempool_sequence */) override
71 {
72 Assert(m_added.insert(tx.info.m_tx).second);
73 }
74
75 void TransactionRemovedFromMempool(const CTransactionRef& tx, MemPoolRemovalReason reason, uint64_t /* mempool_sequence */) override
76 {
77 Assert(m_removed.insert(tx).second);
78 }
79};
80
81void SetMempoolConstraints(ArgsManager& args, FuzzedDataProvider& fuzzed_data_provider)
82{
83 args.ForceSetArg("-limitancestorcount",
84 ToString(fuzzed_data_provider.ConsumeIntegralInRange<unsigned>(0, 50)));
85 args.ForceSetArg("-limitancestorsize",
86 ToString(fuzzed_data_provider.ConsumeIntegralInRange<unsigned>(0, 202)));
87 args.ForceSetArg("-limitdescendantcount",
88 ToString(fuzzed_data_provider.ConsumeIntegralInRange<unsigned>(0, 50)));
89 args.ForceSetArg("-limitdescendantsize",
90 ToString(fuzzed_data_provider.ConsumeIntegralInRange<unsigned>(0, 202)));
91 args.ForceSetArg("-maxmempool",
92 ToString(fuzzed_data_provider.ConsumeIntegralInRange<unsigned>(0, 200)));
93 args.ForceSetArg("-mempoolexpiry",
94 ToString(fuzzed_data_provider.ConsumeIntegralInRange<unsigned>(0, 999)));
95}
96
97void Finish(FuzzedDataProvider& fuzzed_data_provider, MockedTxPool& tx_pool, Chainstate& chainstate)
98{
99 WITH_LOCK(::cs_main, tx_pool.check(chainstate.CoinsTip(), chainstate.m_chain.Height() + 1));
100 {
101 BlockAssembler::Options options;
102 options.nBlockMaxWeight = fuzzed_data_provider.ConsumeIntegralInRange(0U, MAX_BLOCK_WEIGHT);
103 options.blockMinFeeRate = CFeeRate{ConsumeMoney(fuzzed_data_provider, /*max=*/COIN)};
104 auto assembler = BlockAssembler{chainstate, &tx_pool, options};
105 auto block_template = assembler.CreateNewBlock();
106 Assert(block_template->block.vtx.size() >= 1);
107 }
108 const auto info_all = tx_pool.infoAll();
109 if (!info_all.empty()) {
110 const auto& tx_to_remove = *PickValue(fuzzed_data_provider, info_all).tx;
111 WITH_LOCK(tx_pool.cs, tx_pool.removeRecursive(tx_to_remove, MemPoolRemovalReason::BLOCK /* dummy */));
112 assert(tx_pool.size() < info_all.size());
113 WITH_LOCK(::cs_main, tx_pool.check(chainstate.CoinsTip(), chainstate.m_chain.Height() + 1));
114 }
115 g_setup->m_node.validation_signals->SyncWithValidationInterfaceQueue();
116}
117
118void MockTime(FuzzedDataProvider& fuzzed_data_provider, const Chainstate& chainstate)
119{
120 const auto time = ConsumeTime(fuzzed_data_provider,
121 chainstate.m_chain.Tip()->GetMedianTimePast() + 1,
122 std::numeric_limits<decltype(chainstate.m_chain.Tip()->nTime)>::max());
123 SetMockTime(time);
124}
125
126std::unique_ptr<CTxMemPool> MakeMempool(FuzzedDataProvider& fuzzed_data_provider, const NodeContext& node)
127{
128 // Take the default options for tests...
130
131 // ...override specific options for this specific fuzz suite
132 mempool_opts.check_ratio = 1;
133 mempool_opts.require_standard = fuzzed_data_provider.ConsumeBool();
134
135 // ...and construct a CTxMemPool from it
136 bilingual_str error;
137 auto mempool{std::make_unique<CTxMemPool>(std::move(mempool_opts), error)};
138 // ... ignore the error since it might be beneficial to fuzz even when the
139 // mempool size is unreasonably small
140 Assert(error.empty() || error.original.starts_with("-maxmempool must be at least "));
141 return mempool;
142}
143
144void CheckATMPInvariants(const MempoolAcceptResult& res, bool txid_in_mempool, bool wtxid_in_mempool)
145{
146
147 switch (res.m_result_type) {
149 {
150 Assert(txid_in_mempool);
151 Assert(wtxid_in_mempool);
152 Assert(res.m_state.IsValid());
153 Assert(!res.m_state.IsInvalid());
154 Assert(res.m_vsize);
155 Assert(res.m_base_fees);
158 Assert(!res.m_other_wtxid);
159 break;
160 }
162 {
163 // It may be already in the mempool since in ATMP cases we don't set MEMPOOL_ENTRY or DIFFERENT_WITNESS
164 Assert(!res.m_state.IsValid());
165 Assert(res.m_state.IsInvalid());
166
167 const bool is_reconsiderable{res.m_state.GetResult() == TxValidationResult::TX_RECONSIDERABLE};
168 Assert(!res.m_vsize);
169 Assert(!res.m_base_fees);
170 // Fee information is provided if the failure is TX_RECONSIDERABLE.
171 // In other cases, validation may be unable or unwilling to calculate the fees.
172 Assert(res.m_effective_feerate.has_value() == is_reconsiderable);
173 Assert(res.m_wtxids_fee_calculations.has_value() == is_reconsiderable);
174 Assert(!res.m_other_wtxid);
175 break;
176 }
178 {
179 // ATMP never sets this; only set in package settings
180 Assert(false);
181 break;
182 }
184 {
185 // ATMP never sets this; only set in package settings
186 Assert(false);
187 break;
188 }
189 }
190}
191
192FUZZ_TARGET(tx_pool_standard, .init = initialize_tx_pool)
193{
195 FuzzedDataProvider fuzzed_data_provider(buffer.data(), buffer.size());
196 const auto& node = g_setup->m_node;
197 auto& chainstate{static_cast<DummyChainState&>(node.chainman->ActiveChainstate())};
198
199 MockTime(fuzzed_data_provider, chainstate);
200
201 // All RBF-spendable outpoints
202 std::set<COutPoint> outpoints_rbf;
203 // All outpoints counting toward the total supply (subset of outpoints_rbf)
204 std::set<COutPoint> outpoints_supply;
205 for (const auto& outpoint : g_outpoints_coinbase_init_mature) {
206 Assert(outpoints_supply.insert(outpoint).second);
207 }
208 outpoints_rbf = outpoints_supply;
209
210 // The sum of the values of all spendable outpoints
211 constexpr CAmount SUPPLY_TOTAL{COINBASE_MATURITY * 50 * COIN};
212
213 SetMempoolConstraints(*node.args, fuzzed_data_provider);
214 auto tx_pool_{MakeMempool(fuzzed_data_provider, node)};
215 MockedTxPool& tx_pool = *static_cast<MockedTxPool*>(tx_pool_.get());
216
217 chainstate.SetMempool(&tx_pool);
218
219 // Helper to query an amount
220 const CCoinsViewMemPool amount_view{WITH_LOCK(::cs_main, return &chainstate.CoinsTip()), tx_pool};
221 const auto GetAmount = [&](const COutPoint& outpoint) {
222 auto coin{amount_view.GetCoin(outpoint).value()};
223 return coin.out.nValue;
224 };
225
226 LIMITED_WHILE(fuzzed_data_provider.ConsumeBool(), 300)
227 {
228 {
229 // Total supply is the mempool fee + all outpoints
230 CAmount supply_now{WITH_LOCK(tx_pool.cs, return tx_pool.GetTotalFee())};
231 for (const auto& op : outpoints_supply) {
232 supply_now += GetAmount(op);
233 }
234 Assert(supply_now == SUPPLY_TOTAL);
235 }
236 Assert(!outpoints_supply.empty());
237
238 // Create transaction to add to the mempool
239 const CTransactionRef tx = [&] {
240 CMutableTransaction tx_mut;
241 tx_mut.version = fuzzed_data_provider.ConsumeBool() ? TRUC_VERSION : CTransaction::CURRENT_VERSION;
242 tx_mut.nLockTime = fuzzed_data_provider.ConsumeBool() ? 0 : fuzzed_data_provider.ConsumeIntegral<uint32_t>();
243 const auto num_in = fuzzed_data_provider.ConsumeIntegralInRange<int>(1, outpoints_rbf.size());
244 const auto num_out = fuzzed_data_provider.ConsumeIntegralInRange<int>(1, outpoints_rbf.size() * 2);
245
246 CAmount amount_in{0};
247 for (int i = 0; i < num_in; ++i) {
248 // Pop random outpoint
249 auto pop = outpoints_rbf.begin();
250 std::advance(pop, fuzzed_data_provider.ConsumeIntegralInRange<size_t>(0, outpoints_rbf.size() - 1));
251 const auto outpoint = *pop;
252 outpoints_rbf.erase(pop);
253 amount_in += GetAmount(outpoint);
254
255 // Create input
256 const auto sequence = ConsumeSequence(fuzzed_data_provider);
257 const auto script_sig = CScript{};
258 const auto script_wit_stack = std::vector<std::vector<uint8_t>>{WITNESS_STACK_ELEM_OP_TRUE};
259 CTxIn in;
260 in.prevout = outpoint;
261 in.nSequence = sequence;
262 in.scriptSig = script_sig;
263 in.scriptWitness.stack = script_wit_stack;
264
265 tx_mut.vin.push_back(in);
266 }
267 const auto amount_fee = fuzzed_data_provider.ConsumeIntegralInRange<CAmount>(-1000, amount_in);
268 const auto amount_out = (amount_in - amount_fee) / num_out;
269 for (int i = 0; i < num_out; ++i) {
270 tx_mut.vout.emplace_back(amount_out, P2WSH_OP_TRUE);
271 }
272 auto tx = MakeTransactionRef(tx_mut);
273 // Restore previously removed outpoints
274 for (const auto& in : tx->vin) {
275 Assert(outpoints_rbf.insert(in.prevout).second);
276 }
277 return tx;
278 }();
279
280 if (fuzzed_data_provider.ConsumeBool()) {
281 MockTime(fuzzed_data_provider, chainstate);
282 }
283 if (fuzzed_data_provider.ConsumeBool()) {
284 tx_pool.RollingFeeUpdate();
285 }
286 if (fuzzed_data_provider.ConsumeBool()) {
287 const auto& txid = fuzzed_data_provider.ConsumeBool() ?
288 tx->GetHash() :
289 PickValue(fuzzed_data_provider, outpoints_rbf).hash;
290 const auto delta = fuzzed_data_provider.ConsumeIntegralInRange<CAmount>(-50 * COIN, +50 * COIN);
291 tx_pool.PrioritiseTransaction(txid, delta);
292 }
293
294 // Remember all removed and added transactions
295 std::set<CTransactionRef> removed;
296 std::set<CTransactionRef> added;
297 auto txr = std::make_shared<TransactionsDelta>(removed, added);
298 node.validation_signals->RegisterSharedValidationInterface(txr);
299 const bool bypass_limits = fuzzed_data_provider.ConsumeBool();
300
301 // Make sure ProcessNewPackage on one transaction works.
302 // The result is not guaranteed to be the same as what is returned by ATMP.
303 const auto result_package = WITH_LOCK(::cs_main,
304 return ProcessNewPackage(chainstate, tx_pool, {tx}, true, /*client_maxfeerate=*/{}));
305 // If something went wrong due to a package-specific policy, it might not return a
306 // validation result for the transaction.
307 if (result_package.m_state.GetResult() != PackageValidationResult::PCKG_POLICY) {
308 auto it = result_package.m_tx_results.find(tx->GetWitnessHash());
309 Assert(it != result_package.m_tx_results.end());
310 Assert(it->second.m_result_type == MempoolAcceptResult::ResultType::VALID ||
311 it->second.m_result_type == MempoolAcceptResult::ResultType::INVALID);
312 }
313
314 const auto res = WITH_LOCK(::cs_main, return AcceptToMemoryPool(chainstate, tx, GetTime(), bypass_limits, /*test_accept=*/false));
315 const bool accepted = res.m_result_type == MempoolAcceptResult::ResultType::VALID;
316 node.validation_signals->SyncWithValidationInterfaceQueue();
317 node.validation_signals->UnregisterSharedValidationInterface(txr);
318
319 bool txid_in_mempool = tx_pool.exists(tx->GetHash());
320 bool wtxid_in_mempool = tx_pool.exists(tx->GetWitnessHash());
321 CheckATMPInvariants(res, txid_in_mempool, wtxid_in_mempool);
322
323 Assert(accepted != added.empty());
324 if (accepted) {
325 Assert(added.size() == 1); // For now, no package acceptance
326 Assert(tx == *added.begin());
328 } else {
329 // Do not consider rejected transaction removed
330 removed.erase(tx);
331 }
332
333 // Helper to insert spent and created outpoints of a tx into collections
334 using Sets = std::vector<std::reference_wrapper<std::set<COutPoint>>>;
335 const auto insert_tx = [](Sets created_by_tx, Sets consumed_by_tx, const auto& tx) {
336 for (size_t i{0}; i < tx.vout.size(); ++i) {
337 for (auto& set : created_by_tx) {
338 Assert(set.get().emplace(tx.GetHash(), i).second);
339 }
340 }
341 for (const auto& in : tx.vin) {
342 for (auto& set : consumed_by_tx) {
343 Assert(set.get().insert(in.prevout).second);
344 }
345 }
346 };
347 // Add created outpoints, remove spent outpoints
348 {
349 // Outpoints that no longer exist at all
350 std::set<COutPoint> consumed_erased;
351 // Outpoints that no longer count toward the total supply
352 std::set<COutPoint> consumed_supply;
353 for (const auto& removed_tx : removed) {
354 insert_tx(/*created_by_tx=*/{consumed_erased}, /*consumed_by_tx=*/{outpoints_supply}, /*tx=*/*removed_tx);
355 }
356 for (const auto& added_tx : added) {
357 insert_tx(/*created_by_tx=*/{outpoints_supply, outpoints_rbf}, /*consumed_by_tx=*/{consumed_supply}, /*tx=*/*added_tx);
358 }
359 for (const auto& p : consumed_erased) {
360 Assert(outpoints_supply.erase(p) == 1);
361 Assert(outpoints_rbf.erase(p) == 1);
362 }
363 for (const auto& p : consumed_supply) {
364 Assert(outpoints_supply.erase(p) == 1);
365 }
366 }
367 }
368 Finish(fuzzed_data_provider, tx_pool, chainstate);
369}
370
371FUZZ_TARGET(tx_pool, .init = initialize_tx_pool)
372{
374 FuzzedDataProvider fuzzed_data_provider(buffer.data(), buffer.size());
375 const auto& node = g_setup->m_node;
376 auto& chainstate{static_cast<DummyChainState&>(node.chainman->ActiveChainstate())};
377
378 MockTime(fuzzed_data_provider, chainstate);
379
380 std::vector<Txid> txids;
381 txids.reserve(g_outpoints_coinbase_init_mature.size());
382 for (const auto& outpoint : g_outpoints_coinbase_init_mature) {
383 txids.push_back(outpoint.hash);
384 }
385 for (int i{0}; i <= 3; ++i) {
386 // Add some immature and non-existent outpoints
387 txids.push_back(g_outpoints_coinbase_init_immature.at(i).hash);
388 txids.push_back(Txid::FromUint256(ConsumeUInt256(fuzzed_data_provider)));
389 }
390
391 SetMempoolConstraints(*node.args, fuzzed_data_provider);
392 auto tx_pool_{MakeMempool(fuzzed_data_provider, node)};
393 MockedTxPool& tx_pool = *static_cast<MockedTxPool*>(tx_pool_.get());
394
395 chainstate.SetMempool(&tx_pool);
396
397 LIMITED_WHILE(fuzzed_data_provider.ConsumeBool(), 300)
398 {
399 const auto mut_tx = ConsumeTransaction(fuzzed_data_provider, txids);
400
401 if (fuzzed_data_provider.ConsumeBool()) {
402 MockTime(fuzzed_data_provider, chainstate);
403 }
404 if (fuzzed_data_provider.ConsumeBool()) {
405 tx_pool.RollingFeeUpdate();
406 }
407 if (fuzzed_data_provider.ConsumeBool()) {
408 const auto txid = fuzzed_data_provider.ConsumeBool() ?
409 mut_tx.GetHash() :
410 PickValue(fuzzed_data_provider, txids);
411 const auto delta = fuzzed_data_provider.ConsumeIntegralInRange<CAmount>(-50 * COIN, +50 * COIN);
412 tx_pool.PrioritiseTransaction(txid, delta);
413 }
414
415 const auto tx = MakeTransactionRef(mut_tx);
416 const bool bypass_limits = fuzzed_data_provider.ConsumeBool();
417 const auto res = WITH_LOCK(::cs_main, return AcceptToMemoryPool(chainstate, tx, GetTime(), bypass_limits, /*test_accept=*/false));
418 const bool accepted = res.m_result_type == MempoolAcceptResult::ResultType::VALID;
419 if (accepted) {
420 txids.push_back(tx->GetHash());
422 }
423 }
424 Finish(fuzzed_data_provider, tx_pool, chainstate);
425}
426} // namespace
int64_t CAmount
Amount in satoshis (Can be negative)
Definition: amount.h:12
static constexpr CAmount COIN
The amount of satoshis in one BTC.
Definition: amount.h:15
static void pool cs
ArgsManager & args
Definition: bitcoind.cpp:277
#define Assert(val)
Identity function.
Definition: check.h:106
void ForceSetArg(const std::string &strArg, const std::string &strValue)
Definition: args.cpp:546
uint32_t nTime
Definition: chain.h:189
int64_t GetMedianTimePast() const
Definition: chain.h:278
CBlockIndex * Tip() const
Returns the index entry for the tip of this chain, or nullptr if none.
Definition: chain.h:433
int Height() const
Return the maximal height in the chain.
Definition: chain.h:462
CCoinsView that brings transactions from a mempool into view.
Definition: txmempool.h:919
Fee rate in satoshis per virtualbyte: CAmount / vB the feerate is represented internally as FeeFrac.
Definition: feerate.h:35
An outpoint - a combination of a transaction hash and an index n into its vout.
Definition: transaction.h:29
Serialized script, used inside transaction inputs and outputs.
Definition: script.h:413
static const uint32_t CURRENT_VERSION
Definition: transaction.h:299
An input of a transaction.
Definition: transaction.h:67
uint32_t nSequence
Definition: transaction.h:71
CScript scriptSig
Definition: transaction.h:70
CScriptWitness scriptWitness
Only serialized through CTransaction.
Definition: transaction.h:72
COutPoint prevout
Definition: transaction.h:69
CTxMemPool stores valid-according-to-the-current-best-chain transactions that may be included in the ...
Definition: txmempool.h:281
Implement this to subscribe to events generated in validation and mempool.
virtual void TransactionRemovedFromMempool(const CTransactionRef &tx, MemPoolRemovalReason reason, uint64_t mempool_sequence)
Notifies listeners of a transaction leaving mempool.
virtual void TransactionAddedToMempool(const NewMempoolTransactionInfo &tx, uint64_t mempool_sequence)
Notifies listeners of a transaction having been added to mempool.
Chainstate stores and provides an API to update our local knowledge of the current best chain.
Definition: validation.h:531
CChain m_chain
The current chain of blockheaders we consult and build on.
Definition: validation.h:613
CCoinsViewCache & CoinsTip() EXCLUSIVE_LOCKS_REQUIRED(
Definition: validation.h:639
T ConsumeIntegralInRange(T min, T max)
bool IsValid() const
Definition: validation.h:105
Result GetResult() const
Definition: validation.h:108
bool IsInvalid() const
Definition: validation.h:106
Generate a new block, without valid proof-of-work.
Definition: miner.h:151
static transaction_identifier FromUint256(const uint256 &id)
@ TX_RECONSIDERABLE
fails some policy, but might be acceptable if submitted in a (different) package
static const unsigned int MAX_BLOCK_WEIGHT
The maximum allowed weight for a block, see BIP 141 (network rule)
Definition: consensus.h:15
static const int COINBASE_MATURITY
Coinbase transaction outputs can only be spent after this number of new blocks (network rule)
Definition: consensus.h:19
RecursiveMutex cs_main
Mutex to guard access to validation specific variables, such as reading or changing the chainstate.
Definition: cs_main.cpp:8
#define FUZZ_TARGET(...)
Definition: fuzz.h:35
#define LIMITED_WHILE(condition, limit)
Can be used to limit a theoretically unbounded loop.
Definition: fuzz.h:22
uint64_t sequence
MemPoolRemovalReason
Reason why a transaction was removed from the mempool, this is passed to the notification signal.
@ BLOCK
Removed for block.
Definition: messages.h:20
std::string ToString(const T &t)
Locale-independent version of std::to_string.
Definition: string.h:245
@ PCKG_POLICY
The package itself is invalid (e.g. too many transactions).
static CTransactionRef MakeTransactionRef(Tx &&txIn)
Definition: transaction.h:424
std::shared_ptr< const CTransaction > CTransactionRef
Definition: transaction.h:423
node::NodeContext m_node
Definition: setup_common.h:66
A mutable version of CTransaction.
Definition: transaction.h:378
std::vector< CTxOut > vout
Definition: transaction.h:380
std::vector< CTxIn > vin
Definition: transaction.h:379
std::vector< std::vector< unsigned char > > stack
Definition: script.h:588
Validation result for a transaction evaluated by MemPoolAccept (single or package).
Definition: validation.h:126
const std::optional< int64_t > m_vsize
Virtual size as used by the mempool, calculated using serialized size and sigops.
Definition: validation.h:143
const ResultType m_result_type
Result type.
Definition: validation.h:135
const std::optional< CAmount > m_base_fees
Raw base fees in satoshis.
Definition: validation.h:145
const TxValidationState m_state
Contains information about why the transaction failed.
Definition: validation.h:138
@ DIFFERENT_WITNESS
‍Valid, transaction was already in the mempool.
@ INVALID
‍Fully validated, valid.
const std::optional< CFeeRate > m_effective_feerate
The feerate at which this transaction was considered.
Definition: validation.h:151
const std::optional< Wtxid > m_other_wtxid
The wtxid of the transaction in the mempool which has the same txid but different witness.
Definition: validation.h:160
const std::optional< std::vector< Wtxid > > m_wtxids_fee_calculations
Contains the wtxids of the transactions used for fee-related checks.
Definition: validation.h:157
Testing setup that configures a complete environment.
Definition: setup_common.h:121
const CTransactionRef m_tx
Bilingual messages:
Definition: translation.h:24
bool empty() const
Definition: translation.h:35
std::string original
Definition: translation.h:25
Options struct containing options for constructing a CTxMemPool.
NodeContext struct containing references to chain state and connection state.
Definition: context.h:56
std::unique_ptr< ValidationSignals > validation_signals
Issues calls about blocks and transactions.
Definition: context.h:88
std::unique_ptr< ChainstateManager > chainman
Definition: context.h:72
#define LOCK(cs)
Definition: sync.h:259
#define WITH_LOCK(cs, code)
Run code while locking a mutex.
Definition: sync.h:290
uint32_t ConsumeSequence(FuzzedDataProvider &fuzzed_data_provider) noexcept
Definition: util.cpp:155
int64_t ConsumeTime(FuzzedDataProvider &fuzzed_data_provider, const std::optional< int64_t > &min, const std::optional< int64_t > &max) noexcept
Definition: util.cpp:34
CMutableTransaction ConsumeTransaction(FuzzedDataProvider &fuzzed_data_provider, const std::optional< std::vector< Txid > > &prevout_txids, const int max_num_in, const int max_num_out) noexcept
Definition: util.cpp:42
CAmount ConsumeMoney(FuzzedDataProvider &fuzzed_data_provider, const std::optional< CAmount > &max) noexcept
Definition: util.cpp:29
auto & PickValue(FuzzedDataProvider &fuzzed_data_provider, Collection &col)
Definition: util.h:47
uint256 ConsumeUInt256(FuzzedDataProvider &fuzzed_data_provider) noexcept
Definition: util.h:171
COutPoint MineBlock(const NodeContext &node, const node::BlockAssembler::Options &assembler_options)
Returns the generated coin.
Definition: mining.cpp:70
void SeedRandomStateForTest(SeedRand seedtype)
Seed the global RNG state for testing and log the seed value.
Definition: random.cpp:19
@ ZEROS
Seed with a compile time constant of zeros.
static const std::vector< uint8_t > WITNESS_STACK_ELEM_OP_TRUE
Definition: script.h:11
static const CScript P2WSH_OP_TRUE
Definition: script.h:12
void CheckMempoolTRUCInvariants(const CTxMemPool &tx_pool)
For every transaction in tx_pool, check TRUC invariants:
Definition: txmempool.cpp:181
CTxMemPool::Options MemPoolOptionsForTest(const NodeContext &node)
Definition: txmempool.cpp:20
#define EXCLUSIVE_LOCKS_REQUIRED(...)
Definition: threadsafety.h:51
static constexpr decltype(CTransaction::version) TRUC_VERSION
Definition: truc_policy.h:20
int64_t GetTime()
DEPRECATED Use either ClockType::now() or Now<TimePointType>() if a cast is needed.
Definition: time.cpp:77
void SetMockTime(int64_t nMockTimeIn)
DEPRECATED Use SetMockTime with chrono type.
Definition: time.cpp:40
PackageMempoolAcceptResult ProcessNewPackage(Chainstate &active_chainstate, CTxMemPool &pool, const Package &package, bool test_accept, const std::optional< CFeeRate > &client_maxfeerate)
Validate (and maybe submit) a package to the mempool.
MempoolAcceptResult AcceptToMemoryPool(Chainstate &active_chainstate, const CTransactionRef &tx, int64_t accept_time, bool bypass_limits, bool test_accept)
Try to add a transaction to the mempool.
assert(!tx.IsCoinBase())