Branch data Line data Source code
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 : :
5 : : #include <consensus/validation.h>
6 : : #include <node/context.h>
7 : : #include <node/mempool_args.h>
8 : : #include <node/miner.h>
9 : : #include <policy/truc_policy.h>
10 : : #include <test/fuzz/FuzzedDataProvider.h>
11 : : #include <test/fuzz/fuzz.h>
12 : : #include <test/fuzz/util.h>
13 : : #include <test/fuzz/util/mempool.h>
14 : : #include <test/util/mining.h>
15 : : #include <test/util/script.h>
16 : : #include <test/util/setup_common.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 : :
24 : : using node::BlockAssembler;
25 : : using node::NodeContext;
26 : : using util::ToString;
27 : :
28 : : namespace {
29 : :
30 : : const TestingSetup* g_setup;
31 : : std::vector<COutPoint> g_outpoints_coinbase_init_mature;
32 : : std::vector<COutPoint> g_outpoints_coinbase_init_immature;
33 : :
34 : : struct MockedTxPool : public CTxMemPool {
35 : 281429 : void RollingFeeUpdate() EXCLUSIVE_LOCKS_REQUIRED(!cs)
36 : : {
37 : 281429 : LOCK(cs);
38 [ + - ]: 281429 : lastRollingFeeUpdate = GetTime();
39 [ + - ]: 281429 : blockSinceLastRollingFeeBump = true;
40 : 281429 : }
41 : : };
42 : :
43 : 2 : void initialize_tx_pool()
44 : : {
45 [ + - + - ]: 4 : static const auto testing_setup = MakeNoLogFileContext<const TestingSetup>();
46 : 2 : g_setup = testing_setup.get();
47 [ + - + - ]: 6 : SetMockTime(WITH_LOCK(g_setup->m_node.chainman->GetMutex(), return g_setup->m_node.chainman->ActiveTip()->Time()));
48 : :
49 : 2 : BlockAssembler::Options options;
50 : 2 : options.coinbase_output_script = P2WSH_OP_TRUE;
51 : :
52 [ + + ]: 402 : for (int i = 0; i < 2 * COINBASE_MATURITY; ++i) {
53 [ + - ]: 400 : COutPoint prevout{MineBlock(g_setup->m_node, options)};
54 : : // Remember the txids to avoid expensive disk access later on
55 [ + + ]: 400 : auto& outpoints = i < COINBASE_MATURITY ?
56 : : g_outpoints_coinbase_init_mature :
57 : : g_outpoints_coinbase_init_immature;
58 [ + - ]: 400 : outpoints.push_back(prevout);
59 : : }
60 [ + - ]: 2 : g_setup->m_node.validation_signals->SyncWithValidationInterfaceQueue();
61 [ + - ]: 4 : }
62 : :
63 : : struct TransactionsDelta final : public CValidationInterface {
64 : : std::set<CTransactionRef>& m_removed;
65 : : std::set<CTransactionRef>& m_added;
66 : :
67 : 122975 : explicit TransactionsDelta(std::set<CTransactionRef>& r, std::set<CTransactionRef>& a)
68 : 122975 : : m_removed{r}, m_added{a} {}
69 : :
70 : 25721 : void TransactionAddedToMempool(const NewMempoolTransactionInfo& tx, uint64_t /* mempool_sequence */) override
71 : : {
72 : 25721 : Assert(m_added.insert(tx.info.m_tx).second);
73 : 25721 : }
74 : :
75 : 20361 : void TransactionRemovedFromMempool(const CTransactionRef& tx, MemPoolRemovalReason reason, uint64_t /* mempool_sequence */) override
76 : : {
77 : 20361 : Assert(m_removed.insert(tx).second);
78 : 20361 : }
79 : : };
80 : :
81 : 7288 : void SetMempoolConstraints(ArgsManager& args, FuzzedDataProvider& fuzzed_data_provider)
82 : : {
83 [ + - + - ]: 14576 : args.ForceSetArg("-limitancestorcount",
84 [ + - ]: 7288 : ToString(fuzzed_data_provider.ConsumeIntegralInRange<unsigned>(0, 50)));
85 [ + - + - ]: 14576 : args.ForceSetArg("-limitancestorsize",
86 [ + - ]: 7288 : ToString(fuzzed_data_provider.ConsumeIntegralInRange<unsigned>(0, 202)));
87 [ + - + - ]: 14576 : args.ForceSetArg("-limitdescendantcount",
88 [ + - ]: 7288 : ToString(fuzzed_data_provider.ConsumeIntegralInRange<unsigned>(0, 50)));
89 [ + - + - ]: 14576 : args.ForceSetArg("-limitdescendantsize",
90 [ + - ]: 7288 : ToString(fuzzed_data_provider.ConsumeIntegralInRange<unsigned>(0, 202)));
91 [ + - + - ]: 14576 : args.ForceSetArg("-maxmempool",
92 [ + - ]: 7288 : ToString(fuzzed_data_provider.ConsumeIntegralInRange<unsigned>(0, 200)));
93 [ + - + - ]: 14576 : args.ForceSetArg("-mempoolexpiry",
94 [ + - ]: 7288 : ToString(fuzzed_data_provider.ConsumeIntegralInRange<unsigned>(0, 999)));
95 : 7288 : }
96 : :
97 : 7288 : void Finish(FuzzedDataProvider& fuzzed_data_provider, MockedTxPool& tx_pool, Chainstate& chainstate)
98 : : {
99 [ + - + - ]: 21864 : WITH_LOCK(::cs_main, tx_pool.check(chainstate.CoinsTip(), chainstate.m_chain.Height() + 1));
100 : 7288 : {
101 : 7288 : BlockAssembler::Options options;
102 : 7288 : options.nBlockMaxWeight = fuzzed_data_provider.ConsumeIntegralInRange(0U, MAX_BLOCK_WEIGHT);
103 [ + - ]: 7288 : options.blockMinFeeRate = CFeeRate{ConsumeMoney(fuzzed_data_provider, /*max=*/COIN)};
104 [ + - ]: 7288 : auto assembler = BlockAssembler{chainstate, &tx_pool, options};
105 [ + - ]: 7288 : auto block_template = assembler.CreateNewBlock();
106 [ + - ]: 7288 : Assert(block_template->block.vtx.size() >= 1);
107 : 7288 : }
108 : 7288 : const auto info_all = tx_pool.infoAll();
109 [ + + ]: 7288 : if (!info_all.empty()) {
110 [ + - ]: 3829 : const auto& tx_to_remove = *PickValue(fuzzed_data_provider, info_all).tx;
111 [ + - + - ]: 11487 : WITH_LOCK(tx_pool.cs, tx_pool.removeRecursive(tx_to_remove, MemPoolRemovalReason::BLOCK /* dummy */));
112 [ + - - + ]: 3829 : assert(tx_pool.size() < info_all.size());
113 [ + - + - : 11487 : WITH_LOCK(::cs_main, tx_pool.check(chainstate.CoinsTip(), chainstate.m_chain.Height() + 1));
+ - ]
114 : : }
115 [ + - ]: 7288 : g_setup->m_node.validation_signals->SyncWithValidationInterfaceQueue();
116 : 7288 : }
117 : :
118 : 272149 : void MockTime(FuzzedDataProvider& fuzzed_data_provider, const Chainstate& chainstate)
119 : : {
120 : 272149 : const auto time = ConsumeTime(fuzzed_data_provider,
121 [ + - ]: 544298 : chainstate.m_chain.Tip()->GetMedianTimePast() + 1,
122 [ + - ]: 272149 : std::numeric_limits<decltype(chainstate.m_chain.Tip()->nTime)>::max());
123 : 272149 : SetMockTime(time);
124 : 272149 : }
125 : :
126 : 7288 : std::unique_ptr<CTxMemPool> MakeMempool(FuzzedDataProvider& fuzzed_data_provider, const NodeContext& node)
127 : : {
128 : : // Take the default options for tests...
129 : 7288 : CTxMemPool::Options mempool_opts{MemPoolOptionsForTest(node)};
130 : :
131 : : // ...override specific options for this specific fuzz suite
132 : 7288 : mempool_opts.check_ratio = 1;
133 : 7288 : mempool_opts.require_standard = fuzzed_data_provider.ConsumeBool();
134 : :
135 : : // ...and construct a CTxMemPool from it
136 [ + - ]: 7288 : bilingual_str error;
137 [ + - ]: 7288 : 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 [ + + + - : 8348 : Assert(error.empty() || error.original.starts_with("-maxmempool must be at least "));
+ - ]
141 : 7288 : return mempool;
142 : 7288 : }
143 : :
144 : 122975 : void CheckATMPInvariants(const MempoolAcceptResult& res, bool txid_in_mempool, bool wtxid_in_mempool)
145 : : {
146 : :
147 [ + + - - : 122975 : switch (res.m_result_type) {
- ]
148 : 25721 : case MempoolAcceptResult::ResultType::VALID:
149 : 25721 : {
150 : 25721 : Assert(txid_in_mempool);
151 : 25721 : Assert(wtxid_in_mempool);
152 : 25721 : Assert(res.m_state.IsValid());
153 : 25721 : Assert(!res.m_state.IsInvalid());
154 : 25721 : Assert(res.m_vsize);
155 : 25721 : Assert(res.m_base_fees);
156 : 25721 : Assert(res.m_effective_feerate);
157 : 25721 : Assert(res.m_wtxids_fee_calculations);
158 : 25721 : Assert(!res.m_other_wtxid);
159 : 25721 : break;
160 : : }
161 : 97254 : case MempoolAcceptResult::ResultType::INVALID:
162 : 97254 : {
163 : : // It may be already in the mempool since in ATMP cases we don't set MEMPOOL_ENTRY or DIFFERENT_WITNESS
164 : 97254 : Assert(!res.m_state.IsValid());
165 : 97254 : Assert(res.m_state.IsInvalid());
166 : :
167 : 97254 : const bool is_reconsiderable{res.m_state.GetResult() == TxValidationResult::TX_RECONSIDERABLE};
168 : 97254 : Assert(!res.m_vsize);
169 : 97254 : 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 : 97254 : Assert(res.m_effective_feerate.has_value() == is_reconsiderable);
173 : 97254 : Assert(res.m_wtxids_fee_calculations.has_value() == is_reconsiderable);
174 : 97254 : Assert(!res.m_other_wtxid);
175 : 97254 : break;
176 : : }
177 : 0 : case MempoolAcceptResult::ResultType::MEMPOOL_ENTRY:
178 : 0 : {
179 : : // ATMP never sets this; only set in package settings
180 : 0 : Assert(false);
181 : 0 : break;
182 : : }
183 : 0 : case MempoolAcceptResult::ResultType::DIFFERENT_WITNESS:
184 : 0 : {
185 : : // ATMP never sets this; only set in package settings
186 : 0 : Assert(false);
187 : 0 : break;
188 : : }
189 : : }
190 : 122975 : }
191 : :
192 [ + - ]: 2372 : FUZZ_TARGET(tx_pool_standard, .init = initialize_tx_pool)
193 : : {
194 : 1918 : SeedRandomStateForTest(SeedRand::ZEROS);
195 : 1918 : FuzzedDataProvider fuzzed_data_provider(buffer.data(), buffer.size());
196 : 1918 : const auto& node = g_setup->m_node;
197 : 1918 : auto& chainstate{static_cast<DummyChainState&>(node.chainman->ActiveChainstate())};
198 : :
199 : 1918 : MockTime(fuzzed_data_provider, chainstate);
200 : :
201 : : // All RBF-spendable outpoints
202 : 1918 : std::set<COutPoint> outpoints_rbf;
203 : : // All outpoints counting toward the total supply (subset of outpoints_rbf)
204 : 1918 : std::set<COutPoint> outpoints_supply;
205 [ + + ]: 193718 : for (const auto& outpoint : g_outpoints_coinbase_init_mature) {
206 [ + - + - ]: 191800 : Assert(outpoints_supply.insert(outpoint).second);
207 : : }
208 [ + - ]: 1918 : outpoints_rbf = outpoints_supply;
209 : :
210 : : // The sum of the values of all spendable outpoints
211 : 1918 : constexpr CAmount SUPPLY_TOTAL{COINBASE_MATURITY * 50 * COIN};
212 : :
213 [ + - ]: 1918 : SetMempoolConstraints(*node.args, fuzzed_data_provider);
214 [ + - ]: 1918 : auto tx_pool_{MakeMempool(fuzzed_data_provider, node)};
215 [ + - ]: 1918 : MockedTxPool& tx_pool = *static_cast<MockedTxPool*>(tx_pool_.get());
216 : :
217 [ + - ]: 1918 : chainstate.SetMempool(&tx_pool);
218 : :
219 : : // Helper to query an amount
220 [ + - + - ]: 5754 : const CCoinsViewMemPool amount_view{WITH_LOCK(::cs_main, return &chainstate.CoinsTip()), tx_pool};
221 : 26626987 : const auto GetAmount = [&](const COutPoint& outpoint) {
222 [ + - ]: 26625069 : auto coin{amount_view.GetCoin(outpoint).value()};
223 : 26625069 : return coin.out.nValue;
224 : 26626987 : };
225 : :
226 [ + + + + ]: 124893 : LIMITED_WHILE(fuzzed_data_provider.ConsumeBool(), 300)
227 : : {
228 : 122975 : {
229 : : // Total supply is the mempool fee + all outpoints
230 [ + - ]: 245950 : CAmount supply_now{WITH_LOCK(tx_pool.cs, return tx_pool.GetTotalFee())};
231 [ + + ]: 23424211 : for (const auto& op : outpoints_supply) {
232 [ + - ]: 23301236 : supply_now += GetAmount(op);
233 : : }
234 [ + - ]: 122975 : Assert(supply_now == SUPPLY_TOTAL);
235 : : }
236 [ + - ]: 122975 : Assert(!outpoints_supply.empty());
237 : :
238 : : // Create transaction to add to the mempool
239 : 245950 : const CTransactionRef tx = [&] {
240 : 122975 : CMutableTransaction tx_mut;
241 [ + + ]: 122975 : tx_mut.version = fuzzed_data_provider.ConsumeBool() ? TRUC_VERSION : CTransaction::CURRENT_VERSION;
242 [ + + ]: 122975 : tx_mut.nLockTime = fuzzed_data_provider.ConsumeBool() ? 0 : fuzzed_data_provider.ConsumeIntegral<uint32_t>();
243 : 122975 : const auto num_in = fuzzed_data_provider.ConsumeIntegralInRange<int>(1, outpoints_rbf.size());
244 : 122975 : const auto num_out = fuzzed_data_provider.ConsumeIntegralInRange<int>(1, outpoints_rbf.size() * 2);
245 : :
246 : 122975 : CAmount amount_in{0};
247 [ + + ]: 3446808 : for (int i = 0; i < num_in; ++i) {
248 : : // Pop random outpoint
249 : 3323833 : auto pop = outpoints_rbf.begin();
250 : 3323833 : std::advance(pop, fuzzed_data_provider.ConsumeIntegralInRange<size_t>(0, outpoints_rbf.size() - 1));
251 : 3323833 : const auto outpoint = *pop;
252 : 3323833 : outpoints_rbf.erase(pop);
253 [ + - ]: 3323833 : amount_in += GetAmount(outpoint);
254 : :
255 : : // Create input
256 : 3323833 : const auto sequence = ConsumeSequence(fuzzed_data_provider);
257 : 3323833 : const auto script_sig = CScript{};
258 [ + - + + : 9971499 : const auto script_wit_stack = std::vector<std::vector<uint8_t>>{WITNESS_STACK_ELEM_OP_TRUE};
- - ]
259 : 3323833 : CTxIn in;
260 : 3323833 : in.prevout = outpoint;
261 : 3323833 : in.nSequence = sequence;
262 : 3323833 : in.scriptSig = script_sig;
263 [ + - ]: 3323833 : in.scriptWitness.stack = script_wit_stack;
264 : :
265 [ + - ]: 3323833 : tx_mut.vin.push_back(in);
266 : 3323833 : }
267 : 122975 : const auto amount_fee = fuzzed_data_provider.ConsumeIntegralInRange<CAmount>(-1000, amount_in);
268 : 122975 : const auto amount_out = (amount_in - amount_fee) / num_out;
269 [ + + ]: 15354656 : for (int i = 0; i < num_out; ++i) {
270 [ + - ]: 15231681 : tx_mut.vout.emplace_back(amount_out, P2WSH_OP_TRUE);
271 : : }
272 [ + - ]: 122975 : auto tx = MakeTransactionRef(tx_mut);
273 : : // Restore previously removed outpoints
274 [ + + ]: 3446808 : for (const auto& in : tx->vin) {
275 [ + - + - ]: 3323833 : Assert(outpoints_rbf.insert(in.prevout).second);
276 : : }
277 : 122975 : return tx;
278 [ + - ]: 3569783 : }();
279 : :
280 [ + + ]: 122975 : if (fuzzed_data_provider.ConsumeBool()) {
281 [ + - ]: 109445 : MockTime(fuzzed_data_provider, chainstate);
282 : : }
283 [ + + ]: 122975 : if (fuzzed_data_provider.ConsumeBool()) {
284 [ + - ]: 86216 : tx_pool.RollingFeeUpdate();
285 : : }
286 [ + + ]: 122975 : if (fuzzed_data_provider.ConsumeBool()) {
287 [ + + ]: 94439 : const auto& txid = fuzzed_data_provider.ConsumeBool() ?
288 : 83447 : tx->GetHash() :
289 : 5496 : PickValue(fuzzed_data_provider, outpoints_rbf).hash;
290 : 88943 : const auto delta = fuzzed_data_provider.ConsumeIntegralInRange<CAmount>(-50 * COIN, +50 * COIN);
291 [ + - ]: 88943 : tx_pool.PrioritiseTransaction(txid.ToUint256(), delta);
292 : : }
293 : :
294 : : // Remember all removed and added transactions
295 [ + - ]: 122975 : std::set<CTransactionRef> removed;
296 : 122975 : std::set<CTransactionRef> added;
297 [ + - ]: 122975 : auto txr = std::make_shared<TransactionsDelta>(removed, added);
298 [ + - + - ]: 245950 : node.validation_signals->RegisterSharedValidationInterface(txr);
299 : 122975 : 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 [ + - + - : 614875 : 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 [ + - ]: 122975 : if (result_package.m_state.GetResult() != PackageValidationResult::PCKG_POLICY) {
308 : 122975 : auto it = result_package.m_tx_results.find(tx->GetWitnessHash());
309 [ + - ]: 122975 : Assert(it != result_package.m_tx_results.end());
310 [ + + + - : 226078 : Assert(it->second.m_result_type == MempoolAcceptResult::ResultType::VALID ||
+ - ]
311 : : it->second.m_result_type == MempoolAcceptResult::ResultType::INVALID);
312 : : }
313 : :
314 [ + - + - ]: 368925 : const auto res = WITH_LOCK(::cs_main, return AcceptToMemoryPool(chainstate, tx, GetTime(), bypass_limits, /*test_accept=*/false));
315 : 122975 : const bool accepted = res.m_result_type == MempoolAcceptResult::ResultType::VALID;
316 [ + - ]: 122975 : node.validation_signals->SyncWithValidationInterfaceQueue();
317 [ + - + - ]: 245950 : node.validation_signals->UnregisterSharedValidationInterface(txr);
318 : :
319 [ + - ]: 122975 : bool txid_in_mempool = tx_pool.exists(tx->GetHash());
320 [ + - ]: 122975 : bool wtxid_in_mempool = tx_pool.exists(tx->GetWitnessHash());
321 [ + - ]: 122975 : CheckATMPInvariants(res, txid_in_mempool, wtxid_in_mempool);
322 : :
323 [ + - ]: 122975 : Assert(accepted != added.empty());
324 [ + + ]: 122975 : if (accepted) {
325 [ + - ]: 25721 : Assert(added.size() == 1); // For now, no package acceptance
326 [ + - ]: 25721 : Assert(tx == *added.begin());
327 [ + - ]: 25721 : CheckMempoolTRUCInvariants(tx_pool);
328 : : } else {
329 : : // Do not consider rejected transaction removed
330 : 97254 : removed.erase(tx);
331 : : }
332 : :
333 : : // Helper to insert spent and created outpoints of a tx into collections
334 : 122975 : using Sets = std::vector<std::reference_wrapper<std::set<COutPoint>>>;
335 : 164541 : const auto insert_tx = [](Sets created_by_tx, Sets consumed_by_tx, const auto& tx) {
336 [ + + ]: 1728491 : for (size_t i{0}; i < tx.vout.size(); ++i) {
337 [ + + ]: 4788725 : for (auto& set : created_by_tx) {
338 : 3101800 : Assert(set.get().emplace(tx.GetHash(), i).second);
339 : : }
340 : : }
341 [ + + ]: 119596 : for (const auto& in : tx.vin) {
342 [ + + ]: 156060 : for (auto& set : consumed_by_tx) {
343 : 78030 : Assert(set.get().insert(in.prevout).second);
344 : : }
345 : : }
346 : 41566 : };
347 : : // Add created outpoints, remove spent outpoints
348 : 122975 : {
349 : : // Outpoints that no longer exist at all
350 : 122975 : std::set<COutPoint> consumed_erased;
351 : : // Outpoints that no longer count toward the total supply
352 : 122975 : std::set<COutPoint> consumed_supply;
353 [ + + ]: 138820 : for (const auto& removed_tx : removed) {
354 [ + - + - : 31690 : insert_tx(/*created_by_tx=*/{consumed_erased}, /*consumed_by_tx=*/{outpoints_supply}, /*tx=*/*removed_tx);
+ - ]
355 : : }
356 [ + + ]: 148696 : for (const auto& added_tx : added) {
357 [ + - + - : 51442 : insert_tx(/*created_by_tx=*/{outpoints_supply, outpoints_rbf}, /*consumed_by_tx=*/{consumed_supply}, /*tx=*/*added_tx);
+ - ]
358 : : }
359 [ + + ]: 395025 : for (const auto& p : consumed_erased) {
360 [ + - ]: 272050 : Assert(outpoints_supply.erase(p) == 1);
361 [ + - ]: 272050 : Assert(outpoints_rbf.erase(p) == 1);
362 : : }
363 [ + + ]: 175445 : for (const auto& p : consumed_supply) {
364 [ + - ]: 52470 : Assert(outpoints_supply.erase(p) == 1);
365 : : }
366 : 122975 : }
367 [ + - + - ]: 368925 : }
368 [ + - ]: 1918 : Finish(fuzzed_data_provider, tx_pool, chainstate);
369 : 1918 : }
370 : :
371 [ + - ]: 5824 : FUZZ_TARGET(tx_pool, .init = initialize_tx_pool)
372 : : {
373 : 5370 : SeedRandomStateForTest(SeedRand::ZEROS);
374 : 5370 : FuzzedDataProvider fuzzed_data_provider(buffer.data(), buffer.size());
375 : 5370 : const auto& node = g_setup->m_node;
376 : 5370 : auto& chainstate{static_cast<DummyChainState&>(node.chainman->ActiveChainstate())};
377 : :
378 : 5370 : MockTime(fuzzed_data_provider, chainstate);
379 : :
380 : 5370 : std::vector<Txid> txids;
381 [ + - ]: 5370 : txids.reserve(g_outpoints_coinbase_init_mature.size());
382 [ + + ]: 542370 : for (const auto& outpoint : g_outpoints_coinbase_init_mature) {
383 [ + - ]: 537000 : txids.push_back(outpoint.hash);
384 : : }
385 [ + + ]: 26850 : for (int i{0}; i <= 3; ++i) {
386 : : // Add some immature and non-existent outpoints
387 [ + - + - ]: 21480 : txids.push_back(g_outpoints_coinbase_init_immature.at(i).hash);
388 [ + - ]: 21480 : txids.push_back(Txid::FromUint256(ConsumeUInt256(fuzzed_data_provider)));
389 : : }
390 : :
391 [ + - ]: 5370 : SetMempoolConstraints(*node.args, fuzzed_data_provider);
392 [ + - ]: 5370 : auto tx_pool_{MakeMempool(fuzzed_data_provider, node)};
393 : 5370 : MockedTxPool& tx_pool = *static_cast<MockedTxPool*>(tx_pool_.get());
394 : :
395 : 5370 : chainstate.SetMempool(&tx_pool);
396 : :
397 [ + + + + ]: 296628 : LIMITED_WHILE(fuzzed_data_provider.ConsumeBool(), 300)
398 : : {
399 [ + - ]: 291258 : const auto mut_tx = ConsumeTransaction(fuzzed_data_provider, txids);
400 : :
401 [ + + ]: 291258 : if (fuzzed_data_provider.ConsumeBool()) {
402 [ + - ]: 155416 : MockTime(fuzzed_data_provider, chainstate);
403 : : }
404 [ + + ]: 291258 : if (fuzzed_data_provider.ConsumeBool()) {
405 [ + - ]: 195213 : tx_pool.RollingFeeUpdate();
406 : : }
407 [ + + ]: 291258 : if (fuzzed_data_provider.ConsumeBool()) {
408 [ + + ]: 169887 : const auto txid = fuzzed_data_provider.ConsumeBool() ?
409 [ + - ]: 131411 : mut_tx.GetHash() :
410 : 38476 : PickValue(fuzzed_data_provider, txids);
411 : 169887 : const auto delta = fuzzed_data_provider.ConsumeIntegralInRange<CAmount>(-50 * COIN, +50 * COIN);
412 [ + - ]: 169887 : tx_pool.PrioritiseTransaction(txid.ToUint256(), delta);
413 : : }
414 : :
415 [ + - ]: 291258 : const auto tx = MakeTransactionRef(mut_tx);
416 : 291258 : const bool bypass_limits = fuzzed_data_provider.ConsumeBool();
417 [ + - + - ]: 873774 : const auto res = WITH_LOCK(::cs_main, return AcceptToMemoryPool(chainstate, tx, GetTime(), bypass_limits, /*test_accept=*/false));
418 : 291258 : const bool accepted = res.m_result_type == MempoolAcceptResult::ResultType::VALID;
419 [ + + ]: 291258 : if (accepted) {
420 [ + - ]: 51950 : txids.push_back(tx->GetHash());
421 [ + - ]: 51950 : CheckMempoolTRUCInvariants(tx_pool);
422 : : }
423 [ + - ]: 873774 : }
424 [ + - ]: 5370 : Finish(fuzzed_data_provider, tx_pool, chainstate);
425 : 5370 : }
426 : : } // namespace
|
