Bitcoin Core 29.99.0
P2P Digital Currency
miner_tests.cpp
Go to the documentation of this file.
1// Copyright (c) 2011-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 <addresstype.h>
6#include <coins.h>
7#include <common/system.h>
9#include <consensus/merkle.h>
10#include <consensus/tx_verify.h>
11#include <interfaces/mining.h>
12#include <node/miner.h>
13#include <policy/policy.h>
14#include <test/util/random.h>
16#include <test/util/txmempool.h>
17#include <txmempool.h>
18#include <uint256.h>
19#include <util/check.h>
20#include <util/feefrac.h>
21#include <util/strencodings.h>
22#include <util/time.h>
23#include <util/translation.h>
24#include <validation.h>
25#include <versionbits.h>
26#include <pow.h>
27
29
30#include <memory>
31#include <vector>
32
33#include <boost/test/unit_test.hpp>
34
35using namespace util::hex_literals;
39
40namespace miner_tests {
42 void TestPackageSelection(const CScript& scriptPubKey, const std::vector<CTransactionRef>& txFirst) EXCLUSIVE_LOCKS_REQUIRED(::cs_main);
43 void TestBasicMining(const CScript& scriptPubKey, const std::vector<CTransactionRef>& txFirst, int baseheight) EXCLUSIVE_LOCKS_REQUIRED(::cs_main);
44 void TestPrioritisedMining(const CScript& scriptPubKey, const std::vector<CTransactionRef>& txFirst) EXCLUSIVE_LOCKS_REQUIRED(::cs_main);
46 {
47 CCoinsViewMemPool view_mempool{&m_node.chainman->ActiveChainstate().CoinsTip(), tx_mempool};
48 CBlockIndex* tip{m_node.chainman->ActiveChain().Tip()};
49 const std::optional<LockPoints> lock_points{CalculateLockPointsAtTip(tip, view_mempool, tx)};
50 return lock_points.has_value() && CheckSequenceLocksAtTip(tip, *lock_points);
51 }
53 {
54 // Delete the previous mempool to ensure with valgrind that the old
55 // pointer is not accessed, when the new one should be accessed
56 // instead.
57 m_node.mempool.reset();
58 bilingual_str error;
59 m_node.mempool = std::make_unique<CTxMemPool>(MemPoolOptionsForTest(m_node), error);
60 Assert(error.empty());
61 return *m_node.mempool;
62 }
63 std::unique_ptr<Mining> MakeMining()
64 {
66 }
67};
68} // namespace miner_tests
69
70BOOST_FIXTURE_TEST_SUITE(miner_tests, MinerTestingSetup)
71
73
74constexpr static struct {
75 unsigned int extranonce;
76 unsigned int nonce;
77} BLOCKINFO[]{{0, 3552706918}, {500, 37506755}, {1000, 948987788}, {400, 524762339}, {800, 258510074}, {300, 102309278},
78 {1300, 54365202}, {600, 1107740426}, {1000, 203094491}, {900, 391178848}, {800, 381177271}, {600, 87188412},
79 {0, 66522866}, {800, 874942736}, {1000, 89200838}, {400, 312638088}, {400, 66263693}, {500, 924648304},
80 {400, 369913599}, {500, 47630099}, {500, 115045364}, {100, 277026602}, {1100, 809621409}, {700, 155345322},
81 {800, 943579953}, {400, 28200730}, {900, 77200495}, {0, 105935488}, {400, 698721821}, {500, 111098863},
82 {1300, 445389594}, {500, 621849894}, {1400, 56010046}, {1100, 370669776}, {1200, 380301940}, {1200, 110654905},
83 {400, 213771024}, {1500, 120014726}, {1200, 835019014}, {1500, 624817237}, {900, 1404297}, {400, 189414558},
84 {400, 293178348}, {1100, 15393789}, {600, 396764180}, {800, 1387046371}, {800, 199368303}, {700, 111496662},
85 {100, 129759616}, {200, 536577982}, {500, 125881300}, {500, 101053391}, {1200, 471590548}, {900, 86957729},
86 {1200, 179604104}, {600, 68658642}, {1000, 203295701}, {500, 139615361}, {900, 233693412}, {300, 153225163},
87 {0, 27616254}, {1200, 9856191}, {100, 220392722}, {200, 66257599}, {1100, 145489641}, {1300, 37859442},
88 {400, 5816075}, {1200, 215752117}, {1400, 32361482}, {1400, 6529223}, {500, 143332977}, {800, 878392},
89 {700, 159290408}, {400, 123197595}, {700, 43988693}, {300, 304224916}, {700, 214771621}, {1100, 274148273},
90 {400, 285632418}, {1100, 923451065}, {600, 12818092}, {1200, 736282054}, {1000, 246683167}, {600, 92950402},
91 {1400, 29223405}, {1000, 841327192}, {700, 174301283}, {1400, 214009854}, {1000, 6989517}, {1200, 278226956},
92 {700, 540219613}, {400, 93663104}, {1100, 152345635}, {1500, 464194499}, {1300, 333850111}, {600, 258311263},
93 {600, 90173162}, {1000, 33590797}, {1500, 332866027}, {100, 204704427}, {1000, 463153545}, {800, 303244785},
94 {600, 88096214}, {0, 137477892}, {1200, 195514506}, {300, 704114595}, {900, 292087369}, {1400, 758684870},
95 {1300, 163493028}, {1200, 53151293}};
96
97static std::unique_ptr<CBlockIndex> CreateBlockIndex(int nHeight, CBlockIndex* active_chain_tip) EXCLUSIVE_LOCKS_REQUIRED(cs_main)
98{
99 auto index{std::make_unique<CBlockIndex>()};
100 index->nHeight = nHeight;
101 index->pprev = active_chain_tip;
102 return index;
103}
104
105// Test suite for ancestor feerate transaction selection.
106// Implemented as an additional function, rather than a separate test case,
107// to allow reusing the blockchain created in CreateNewBlock_validity.
108void MinerTestingSetup::TestPackageSelection(const CScript& scriptPubKey, const std::vector<CTransactionRef>& txFirst)
109{
110 CTxMemPool& tx_mempool{MakeMempool()};
111 auto mining{MakeMining()};
112 BlockAssembler::Options options;
113 options.coinbase_output_script = scriptPubKey;
114
115 LOCK(tx_mempool.cs);
116 // Test the ancestor feerate transaction selection.
118
119 // Test that a medium fee transaction will be selected after a higher fee
120 // rate package with a low fee rate parent.
122 tx.vin.resize(1);
123 tx.vin[0].scriptSig = CScript() << OP_1;
124 tx.vin[0].prevout.hash = txFirst[0]->GetHash();
125 tx.vin[0].prevout.n = 0;
126 tx.vout.resize(1);
127 tx.vout[0].nValue = 5000000000LL - 1000;
128 // This tx has a low fee: 1000 satoshis
129 Txid hashParentTx = tx.GetHash(); // save this txid for later use
130 const auto parent_tx{entry.Fee(1000).Time(Now<NodeSeconds>()).SpendsCoinbase(true).FromTx(tx)};
131 AddToMempool(tx_mempool, parent_tx);
132
133 // This tx has a medium fee: 10000 satoshis
134 tx.vin[0].prevout.hash = txFirst[1]->GetHash();
135 tx.vout[0].nValue = 5000000000LL - 10000;
136 Txid hashMediumFeeTx = tx.GetHash();
137 const auto medium_fee_tx{entry.Fee(10000).Time(Now<NodeSeconds>()).SpendsCoinbase(true).FromTx(tx)};
138 AddToMempool(tx_mempool, medium_fee_tx);
139
140 // This tx has a high fee, but depends on the first transaction
141 tx.vin[0].prevout.hash = hashParentTx;
142 tx.vout[0].nValue = 5000000000LL - 1000 - 50000; // 50k satoshi fee
143 Txid hashHighFeeTx = tx.GetHash();
144 const auto high_fee_tx{entry.Fee(50000).Time(Now<NodeSeconds>()).SpendsCoinbase(false).FromTx(tx)};
145 AddToMempool(tx_mempool, high_fee_tx);
146
147 std::unique_ptr<BlockTemplate> block_template = mining->createNewBlock(options);
148 BOOST_REQUIRE(block_template);
149 CBlock block{block_template->getBlock()};
150 BOOST_REQUIRE_EQUAL(block.vtx.size(), 4U);
151 BOOST_CHECK(block.vtx[1]->GetHash() == hashParentTx);
152 BOOST_CHECK(block.vtx[2]->GetHash() == hashHighFeeTx);
153 BOOST_CHECK(block.vtx[3]->GetHash() == hashMediumFeeTx);
154
155 // Test the inclusion of package feerates in the block template and ensure they are sequential.
156 const auto block_package_feerates = BlockAssembler{m_node.chainman->ActiveChainstate(), &tx_mempool, options}.CreateNewBlock()->m_package_feerates;
157 BOOST_CHECK(block_package_feerates.size() == 2);
158
159 // parent_tx and high_fee_tx are added to the block as a package.
160 const auto combined_txs_fee = parent_tx.GetFee() + high_fee_tx.GetFee();
161 const auto combined_txs_size = parent_tx.GetTxSize() + high_fee_tx.GetTxSize();
162 FeeFrac package_feefrac{combined_txs_fee, combined_txs_size};
163 // The package should be added first.
164 BOOST_CHECK(block_package_feerates[0] == package_feefrac);
165
166 // The medium_fee_tx should be added next.
167 FeeFrac medium_tx_feefrac{medium_fee_tx.GetFee(), medium_fee_tx.GetTxSize()};
168 BOOST_CHECK(block_package_feerates[1] == medium_tx_feefrac);
169
170 // Test that a package below the block min tx fee doesn't get included
171 tx.vin[0].prevout.hash = hashHighFeeTx;
172 tx.vout[0].nValue = 5000000000LL - 1000 - 50000; // 0 fee
173 Txid hashFreeTx = tx.GetHash();
174 AddToMempool(tx_mempool, entry.Fee(0).FromTx(tx));
175 size_t freeTxSize = ::GetSerializeSize(TX_WITH_WITNESS(tx));
176
177 // Calculate a fee on child transaction that will put the package just
178 // below the block min tx fee (assuming 1 child tx of the same size).
179 CAmount feeToUse = blockMinFeeRate.GetFee(2*freeTxSize) - 1;
180
181 tx.vin[0].prevout.hash = hashFreeTx;
182 tx.vout[0].nValue = 5000000000LL - 1000 - 50000 - feeToUse;
183 Txid hashLowFeeTx = tx.GetHash();
184 AddToMempool(tx_mempool, entry.Fee(feeToUse).FromTx(tx));
185
186 // waitNext() should return nullptr because there is no better template
187 auto should_be_nullptr = block_template->waitNext({.timeout = MillisecondsDouble{0}, .fee_threshold = 1});
188 BOOST_REQUIRE(should_be_nullptr == nullptr);
189
190 block = block_template->getBlock();
191 // Verify that the free tx and the low fee tx didn't get selected
192 for (size_t i=0; i<block.vtx.size(); ++i) {
193 BOOST_CHECK(block.vtx[i]->GetHash() != hashFreeTx);
194 BOOST_CHECK(block.vtx[i]->GetHash() != hashLowFeeTx);
195 }
196
197 // Test that packages above the min relay fee do get included, even if one
198 // of the transactions is below the min relay fee
199 // Remove the low fee transaction and replace with a higher fee transaction
200 tx_mempool.removeRecursive(CTransaction(tx), MemPoolRemovalReason::REPLACED);
201 tx.vout[0].nValue -= 2; // Now we should be just over the min relay fee
202 hashLowFeeTx = tx.GetHash();
203 AddToMempool(tx_mempool, entry.Fee(feeToUse + 2).FromTx(tx));
204
205 // waitNext() should return if fees for the new template are at least 1 sat up
206 block_template = block_template->waitNext({.fee_threshold = 1});
207 BOOST_REQUIRE(block_template);
208 block = block_template->getBlock();
209 BOOST_REQUIRE_EQUAL(block.vtx.size(), 6U);
210 BOOST_CHECK(block.vtx[4]->GetHash() == hashFreeTx);
211 BOOST_CHECK(block.vtx[5]->GetHash() == hashLowFeeTx);
212
213 // Test that transaction selection properly updates ancestor fee
214 // calculations as ancestor transactions get included in a block.
215 // Add a 0-fee transaction that has 2 outputs.
216 tx.vin[0].prevout.hash = txFirst[2]->GetHash();
217 tx.vout.resize(2);
218 tx.vout[0].nValue = 5000000000LL - 100000000;
219 tx.vout[1].nValue = 100000000; // 1BTC output
220 // Increase size to avoid rounding errors: when the feerate is extremely small (i.e. 1sat/kvB), evaluating the fee
221 // at smaller sizes gives us rounded values that are equal to each other, which means we incorrectly include
222 // hashFreeTx2 + hashLowFeeTx2.
223 BulkTransaction(tx, 4000);
224 Txid hashFreeTx2 = tx.GetHash();
225 AddToMempool(tx_mempool, entry.Fee(0).SpendsCoinbase(true).FromTx(tx));
226
227 // This tx can't be mined by itself
228 tx.vin[0].prevout.hash = hashFreeTx2;
229 tx.vout.resize(1);
230 feeToUse = blockMinFeeRate.GetFee(freeTxSize);
231 tx.vout[0].nValue = 5000000000LL - 100000000 - feeToUse;
232 Txid hashLowFeeTx2 = tx.GetHash();
233 AddToMempool(tx_mempool, entry.Fee(feeToUse).SpendsCoinbase(false).FromTx(tx));
234 block_template = mining->createNewBlock(options);
235 BOOST_REQUIRE(block_template);
236 block = block_template->getBlock();
237
238 // Verify that this tx isn't selected.
239 for (size_t i=0; i<block.vtx.size(); ++i) {
240 BOOST_CHECK(block.vtx[i]->GetHash() != hashFreeTx2);
241 BOOST_CHECK(block.vtx[i]->GetHash() != hashLowFeeTx2);
242 }
243
244 // This tx will be mineable, and should cause hashLowFeeTx2 to be selected
245 // as well.
246 tx.vin[0].prevout.n = 1;
247 tx.vout[0].nValue = 100000000 - 10000; // 10k satoshi fee
248 AddToMempool(tx_mempool, entry.Fee(10000).FromTx(tx));
249 block_template = mining->createNewBlock(options);
250 BOOST_REQUIRE(block_template);
251 block = block_template->getBlock();
252 BOOST_REQUIRE_EQUAL(block.vtx.size(), 9U);
253 BOOST_CHECK(block.vtx[8]->GetHash() == hashLowFeeTx2);
254}
255
256void MinerTestingSetup::TestBasicMining(const CScript& scriptPubKey, const std::vector<CTransactionRef>& txFirst, int baseheight)
257{
258 Txid hash;
261 entry.nFee = 11;
262 entry.nHeight = 11;
263
264 const CAmount BLOCKSUBSIDY = 50 * COIN;
265 const CAmount LOWFEE = CENT;
266 const CAmount HIGHFEE = COIN;
267 const CAmount HIGHERFEE = 4 * COIN;
268
269 auto mining{MakeMining()};
270 BOOST_REQUIRE(mining);
271
272 BlockAssembler::Options options;
273 options.coinbase_output_script = scriptPubKey;
274
275 {
276 CTxMemPool& tx_mempool{MakeMempool()};
277 LOCK(tx_mempool.cs);
278
279 // Just to make sure we can still make simple blocks
280 auto block_template{mining->createNewBlock(options)};
281 BOOST_REQUIRE(block_template);
282 CBlock block{block_template->getBlock()};
283
284 // block sigops > limit: 1000 CHECKMULTISIG + 1
285 tx.vin.resize(1);
286 // NOTE: OP_NOP is used to force 20 SigOps for the CHECKMULTISIG
287 tx.vin[0].scriptSig = CScript() << OP_0 << OP_0 << OP_0 << OP_NOP << OP_CHECKMULTISIG << OP_1;
288 tx.vin[0].prevout.hash = txFirst[0]->GetHash();
289 tx.vin[0].prevout.n = 0;
290 tx.vout.resize(1);
291 tx.vout[0].nValue = BLOCKSUBSIDY;
292 for (unsigned int i = 0; i < 1001; ++i) {
293 tx.vout[0].nValue -= LOWFEE;
294 hash = tx.GetHash();
295 bool spendsCoinbase = i == 0; // only first tx spends coinbase
296 // If we don't set the # of sig ops in the CTxMemPoolEntry, template creation fails
297 AddToMempool(tx_mempool, entry.Fee(LOWFEE).Time(Now<NodeSeconds>()).SpendsCoinbase(spendsCoinbase).FromTx(tx));
298 tx.vin[0].prevout.hash = hash;
299 }
300
301 BOOST_CHECK_EXCEPTION(mining->createNewBlock(options), std::runtime_error, HasReason("bad-blk-sigops"));
302 }
303
304 {
305 CTxMemPool& tx_mempool{MakeMempool()};
306 LOCK(tx_mempool.cs);
307
308 tx.vin[0].prevout.hash = txFirst[0]->GetHash();
309 tx.vout[0].nValue = BLOCKSUBSIDY;
310 for (unsigned int i = 0; i < 1001; ++i) {
311 tx.vout[0].nValue -= LOWFEE;
312 hash = tx.GetHash();
313 bool spendsCoinbase = i == 0; // only first tx spends coinbase
314 // If we do set the # of sig ops in the CTxMemPoolEntry, template creation passes
315 AddToMempool(tx_mempool, entry.Fee(LOWFEE).Time(Now<NodeSeconds>()).SpendsCoinbase(spendsCoinbase).SigOpsCost(80).FromTx(tx));
316 tx.vin[0].prevout.hash = hash;
317 }
318 BOOST_REQUIRE(mining->createNewBlock(options));
319 }
320
321 {
322 CTxMemPool& tx_mempool{MakeMempool()};
323 LOCK(tx_mempool.cs);
324
325 // block size > limit
326 tx.vin[0].scriptSig = CScript();
327 // 18 * (520char + DROP) + OP_1 = 9433 bytes
328 std::vector<unsigned char> vchData(520);
329 for (unsigned int i = 0; i < 18; ++i) {
330 tx.vin[0].scriptSig << vchData << OP_DROP;
331 }
332 tx.vin[0].scriptSig << OP_1;
333 tx.vin[0].prevout.hash = txFirst[0]->GetHash();
334 tx.vout[0].nValue = BLOCKSUBSIDY;
335 for (unsigned int i = 0; i < 128; ++i) {
336 tx.vout[0].nValue -= LOWFEE;
337 hash = tx.GetHash();
338 bool spendsCoinbase = i == 0; // only first tx spends coinbase
339 AddToMempool(tx_mempool, entry.Fee(LOWFEE).Time(Now<NodeSeconds>()).SpendsCoinbase(spendsCoinbase).FromTx(tx));
340 tx.vin[0].prevout.hash = hash;
341 }
342 BOOST_REQUIRE(mining->createNewBlock(options));
343 }
344
345 {
346 CTxMemPool& tx_mempool{MakeMempool()};
347 LOCK(tx_mempool.cs);
348
349 // orphan in tx_mempool, template creation fails
350 hash = tx.GetHash();
351 AddToMempool(tx_mempool, entry.Fee(LOWFEE).Time(Now<NodeSeconds>()).FromTx(tx));
352 BOOST_CHECK_EXCEPTION(mining->createNewBlock(options), std::runtime_error, HasReason("bad-txns-inputs-missingorspent"));
353 }
354
355 {
356 CTxMemPool& tx_mempool{MakeMempool()};
357 LOCK(tx_mempool.cs);
358
359 // child with higher feerate than parent
360 tx.vin[0].scriptSig = CScript() << OP_1;
361 tx.vin[0].prevout.hash = txFirst[1]->GetHash();
362 tx.vout[0].nValue = BLOCKSUBSIDY - HIGHFEE;
363 hash = tx.GetHash();
364 AddToMempool(tx_mempool, entry.Fee(HIGHFEE).Time(Now<NodeSeconds>()).SpendsCoinbase(true).FromTx(tx));
365 tx.vin[0].prevout.hash = hash;
366 tx.vin.resize(2);
367 tx.vin[1].scriptSig = CScript() << OP_1;
368 tx.vin[1].prevout.hash = txFirst[0]->GetHash();
369 tx.vin[1].prevout.n = 0;
370 tx.vout[0].nValue = tx.vout[0].nValue + BLOCKSUBSIDY - HIGHERFEE; // First txn output + fresh coinbase - new txn fee
371 hash = tx.GetHash();
372 AddToMempool(tx_mempool, entry.Fee(HIGHERFEE).Time(Now<NodeSeconds>()).SpendsCoinbase(true).FromTx(tx));
373 BOOST_REQUIRE(mining->createNewBlock(options));
374 }
375
376 {
377 CTxMemPool& tx_mempool{MakeMempool()};
378 LOCK(tx_mempool.cs);
379
380 // coinbase in tx_mempool, template creation fails
381 tx.vin.resize(1);
382 tx.vin[0].prevout.SetNull();
383 tx.vin[0].scriptSig = CScript() << OP_0 << OP_1;
384 tx.vout[0].nValue = 0;
385 hash = tx.GetHash();
386 // give it a fee so it'll get mined
387 AddToMempool(tx_mempool, entry.Fee(LOWFEE).Time(Now<NodeSeconds>()).SpendsCoinbase(false).FromTx(tx));
388 // Should throw bad-cb-multiple
389 BOOST_CHECK_EXCEPTION(mining->createNewBlock(options), std::runtime_error, HasReason("bad-cb-multiple"));
390 }
391
392 {
393 CTxMemPool& tx_mempool{MakeMempool()};
394 LOCK(tx_mempool.cs);
395
396 // double spend txn pair in tx_mempool, template creation fails
397 tx.vin[0].prevout.hash = txFirst[0]->GetHash();
398 tx.vin[0].scriptSig = CScript() << OP_1;
399 tx.vout[0].nValue = BLOCKSUBSIDY - HIGHFEE;
400 tx.vout[0].scriptPubKey = CScript() << OP_1;
401 hash = tx.GetHash();
402 AddToMempool(tx_mempool, entry.Fee(HIGHFEE).Time(Now<NodeSeconds>()).SpendsCoinbase(true).FromTx(tx));
403 tx.vout[0].scriptPubKey = CScript() << OP_2;
404 hash = tx.GetHash();
405 AddToMempool(tx_mempool, entry.Fee(HIGHFEE).Time(Now<NodeSeconds>()).SpendsCoinbase(true).FromTx(tx));
406 BOOST_CHECK_EXCEPTION(mining->createNewBlock(options), std::runtime_error, HasReason("bad-txns-inputs-missingorspent"));
407 }
408
409 {
410 CTxMemPool& tx_mempool{MakeMempool()};
411 LOCK(tx_mempool.cs);
412
413 // subsidy changing
414 int nHeight = m_node.chainman->ActiveChain().Height();
415 // Create an actual 209999-long block chain (without valid blocks).
416 while (m_node.chainman->ActiveChain().Tip()->nHeight < 209999) {
417 CBlockIndex* prev = m_node.chainman->ActiveChain().Tip();
418 CBlockIndex* next = new CBlockIndex();
419 next->phashBlock = new uint256(m_rng.rand256());
420 m_node.chainman->ActiveChainstate().CoinsTip().SetBestBlock(next->GetBlockHash());
421 next->pprev = prev;
422 next->nHeight = prev->nHeight + 1;
423 next->BuildSkip();
424 m_node.chainman->ActiveChain().SetTip(*next);
425 }
426 BOOST_REQUIRE(mining->createNewBlock(options));
427 // Extend to a 210000-long block chain.
428 while (m_node.chainman->ActiveChain().Tip()->nHeight < 210000) {
429 CBlockIndex* prev = m_node.chainman->ActiveChain().Tip();
430 CBlockIndex* next = new CBlockIndex();
431 next->phashBlock = new uint256(m_rng.rand256());
432 m_node.chainman->ActiveChainstate().CoinsTip().SetBestBlock(next->GetBlockHash());
433 next->pprev = prev;
434 next->nHeight = prev->nHeight + 1;
435 next->BuildSkip();
436 m_node.chainman->ActiveChain().SetTip(*next);
437 }
438 BOOST_REQUIRE(mining->createNewBlock(options));
439
440 // invalid p2sh txn in tx_mempool, template creation fails
441 tx.vin[0].prevout.hash = txFirst[0]->GetHash();
442 tx.vin[0].prevout.n = 0;
443 tx.vin[0].scriptSig = CScript() << OP_1;
444 tx.vout[0].nValue = BLOCKSUBSIDY - LOWFEE;
445 CScript script = CScript() << OP_0;
446 tx.vout[0].scriptPubKey = GetScriptForDestination(ScriptHash(script));
447 hash = tx.GetHash();
448 AddToMempool(tx_mempool, entry.Fee(LOWFEE).Time(Now<NodeSeconds>()).SpendsCoinbase(true).FromTx(tx));
449 tx.vin[0].prevout.hash = hash;
450 tx.vin[0].scriptSig = CScript() << std::vector<unsigned char>(script.begin(), script.end());
451 tx.vout[0].nValue -= LOWFEE;
452 hash = tx.GetHash();
453 AddToMempool(tx_mempool, entry.Fee(LOWFEE).Time(Now<NodeSeconds>()).SpendsCoinbase(false).FromTx(tx));
454 BOOST_CHECK_EXCEPTION(mining->createNewBlock(options), std::runtime_error, HasReason("block-script-verify-flag-failed"));
455
456 // Delete the dummy blocks again.
457 while (m_node.chainman->ActiveChain().Tip()->nHeight > nHeight) {
458 CBlockIndex* del = m_node.chainman->ActiveChain().Tip();
459 m_node.chainman->ActiveChain().SetTip(*Assert(del->pprev));
460 m_node.chainman->ActiveChainstate().CoinsTip().SetBestBlock(del->pprev->GetBlockHash());
461 delete del->phashBlock;
462 delete del;
463 }
464 }
465
466 CTxMemPool& tx_mempool{MakeMempool()};
467 LOCK(tx_mempool.cs);
468
469 // non-final txs in mempool
470 SetMockTime(m_node.chainman->ActiveChain().Tip()->GetMedianTimePast() + 1);
472 // height map
473 std::vector<int> prevheights;
474
475 // relative height locked
476 tx.version = 2;
477 tx.vin.resize(1);
478 prevheights.resize(1);
479 tx.vin[0].prevout.hash = txFirst[0]->GetHash(); // only 1 transaction
480 tx.vin[0].prevout.n = 0;
481 tx.vin[0].scriptSig = CScript() << OP_1;
482 tx.vin[0].nSequence = m_node.chainman->ActiveChain().Tip()->nHeight + 1; // txFirst[0] is the 2nd block
483 prevheights[0] = baseheight + 1;
484 tx.vout.resize(1);
485 tx.vout[0].nValue = BLOCKSUBSIDY-HIGHFEE;
486 tx.vout[0].scriptPubKey = CScript() << OP_1;
487 tx.nLockTime = 0;
488 hash = tx.GetHash();
489 AddToMempool(tx_mempool, entry.Fee(HIGHFEE).Time(Now<NodeSeconds>()).SpendsCoinbase(true).FromTx(tx));
490 BOOST_CHECK(CheckFinalTxAtTip(*Assert(m_node.chainman->ActiveChain().Tip()), CTransaction{tx})); // Locktime passes
491 BOOST_CHECK(!TestSequenceLocks(CTransaction{tx}, tx_mempool)); // Sequence locks fail
492
493 {
494 CBlockIndex* active_chain_tip = m_node.chainman->ActiveChain().Tip();
495 BOOST_CHECK(SequenceLocks(CTransaction(tx), flags, prevheights, *CreateBlockIndex(active_chain_tip->nHeight + 2, active_chain_tip))); // Sequence locks pass on 2nd block
496 }
497
498 // relative time locked
499 tx.vin[0].prevout.hash = txFirst[1]->GetHash();
500 tx.vin[0].nSequence = CTxIn::SEQUENCE_LOCKTIME_TYPE_FLAG | (((m_node.chainman->ActiveChain().Tip()->GetMedianTimePast()+1-m_node.chainman->ActiveChain()[1]->GetMedianTimePast()) >> CTxIn::SEQUENCE_LOCKTIME_GRANULARITY) + 1); // txFirst[1] is the 3rd block
501 prevheights[0] = baseheight + 2;
502 hash = tx.GetHash();
503 AddToMempool(tx_mempool, entry.Time(Now<NodeSeconds>()).FromTx(tx));
504 BOOST_CHECK(CheckFinalTxAtTip(*Assert(m_node.chainman->ActiveChain().Tip()), CTransaction{tx})); // Locktime passes
505 BOOST_CHECK(!TestSequenceLocks(CTransaction{tx}, tx_mempool)); // Sequence locks fail
506
507 const int SEQUENCE_LOCK_TIME = 512; // Sequence locks pass 512 seconds later
508 for (int i = 0; i < CBlockIndex::nMedianTimeSpan; ++i)
509 m_node.chainman->ActiveChain().Tip()->GetAncestor(m_node.chainman->ActiveChain().Tip()->nHeight - i)->nTime += SEQUENCE_LOCK_TIME; // Trick the MedianTimePast
510 {
511 CBlockIndex* active_chain_tip = m_node.chainman->ActiveChain().Tip();
512 BOOST_CHECK(SequenceLocks(CTransaction(tx), flags, prevheights, *CreateBlockIndex(active_chain_tip->nHeight + 1, active_chain_tip)));
513 }
514
515 for (int i = 0; i < CBlockIndex::nMedianTimeSpan; ++i) {
516 CBlockIndex* ancestor{Assert(m_node.chainman->ActiveChain().Tip()->GetAncestor(m_node.chainman->ActiveChain().Tip()->nHeight - i))};
517 ancestor->nTime -= SEQUENCE_LOCK_TIME; // undo tricked MTP
518 }
519
520 // absolute height locked
521 tx.vin[0].prevout.hash = txFirst[2]->GetHash();
522 tx.vin[0].nSequence = CTxIn::MAX_SEQUENCE_NONFINAL;
523 prevheights[0] = baseheight + 3;
524 tx.nLockTime = m_node.chainman->ActiveChain().Tip()->nHeight + 1;
525 hash = tx.GetHash();
526 AddToMempool(tx_mempool, entry.Time(Now<NodeSeconds>()).FromTx(tx));
527 BOOST_CHECK(!CheckFinalTxAtTip(*Assert(m_node.chainman->ActiveChain().Tip()), CTransaction{tx})); // Locktime fails
528 BOOST_CHECK(TestSequenceLocks(CTransaction{tx}, tx_mempool)); // Sequence locks pass
529 BOOST_CHECK(IsFinalTx(CTransaction(tx), m_node.chainman->ActiveChain().Tip()->nHeight + 2, m_node.chainman->ActiveChain().Tip()->GetMedianTimePast())); // Locktime passes on 2nd block
530
531 // ensure tx is final for a specific case where there is no locktime and block height is zero
532 tx.nLockTime = 0;
533 BOOST_CHECK(IsFinalTx(CTransaction(tx), /*nBlockHeight=*/0, m_node.chainman->ActiveChain().Tip()->GetMedianTimePast()));
534
535 // absolute time locked
536 tx.vin[0].prevout.hash = txFirst[3]->GetHash();
537 tx.nLockTime = m_node.chainman->ActiveChain().Tip()->GetMedianTimePast();
538 prevheights.resize(1);
539 prevheights[0] = baseheight + 4;
540 hash = tx.GetHash();
541 AddToMempool(tx_mempool, entry.Time(Now<NodeSeconds>()).FromTx(tx));
542 BOOST_CHECK(!CheckFinalTxAtTip(*Assert(m_node.chainman->ActiveChain().Tip()), CTransaction{tx})); // Locktime fails
543 BOOST_CHECK(TestSequenceLocks(CTransaction{tx}, tx_mempool)); // Sequence locks pass
544 BOOST_CHECK(IsFinalTx(CTransaction(tx), m_node.chainman->ActiveChain().Tip()->nHeight + 2, m_node.chainman->ActiveChain().Tip()->GetMedianTimePast() + 1)); // Locktime passes 1 second later
545
546 // mempool-dependent transactions (not added)
547 tx.vin[0].prevout.hash = hash;
548 prevheights[0] = m_node.chainman->ActiveChain().Tip()->nHeight + 1;
549 tx.nLockTime = 0;
550 tx.vin[0].nSequence = 0;
551 BOOST_CHECK(CheckFinalTxAtTip(*Assert(m_node.chainman->ActiveChain().Tip()), CTransaction{tx})); // Locktime passes
552 BOOST_CHECK(TestSequenceLocks(CTransaction{tx}, tx_mempool)); // Sequence locks pass
553 tx.vin[0].nSequence = 1;
554 BOOST_CHECK(!TestSequenceLocks(CTransaction{tx}, tx_mempool)); // Sequence locks fail
555 tx.vin[0].nSequence = CTxIn::SEQUENCE_LOCKTIME_TYPE_FLAG;
556 BOOST_CHECK(TestSequenceLocks(CTransaction{tx}, tx_mempool)); // Sequence locks pass
557 tx.vin[0].nSequence = CTxIn::SEQUENCE_LOCKTIME_TYPE_FLAG | 1;
558 BOOST_CHECK(!TestSequenceLocks(CTransaction{tx}, tx_mempool)); // Sequence locks fail
559
560 auto block_template = mining->createNewBlock(options);
561 BOOST_REQUIRE(block_template);
562
563 // None of the of the absolute height/time locked tx should have made
564 // it into the template because we still check IsFinalTx in CreateNewBlock,
565 // but relative locked txs will if inconsistently added to mempool.
566 // For now these will still generate a valid template until BIP68 soft fork
567 CBlock block{block_template->getBlock()};
568 BOOST_CHECK_EQUAL(block.vtx.size(), 3U);
569 // However if we advance height by 1 and time by SEQUENCE_LOCK_TIME, all of them should be mined
570 for (int i = 0; i < CBlockIndex::nMedianTimeSpan; ++i) {
571 CBlockIndex* ancestor{Assert(m_node.chainman->ActiveChain().Tip()->GetAncestor(m_node.chainman->ActiveChain().Tip()->nHeight - i))};
572 ancestor->nTime += SEQUENCE_LOCK_TIME; // Trick the MedianTimePast
573 }
574 m_node.chainman->ActiveChain().Tip()->nHeight++;
575 SetMockTime(m_node.chainman->ActiveChain().Tip()->GetMedianTimePast() + 1);
576
577 block_template = mining->createNewBlock(options);
578 BOOST_REQUIRE(block_template);
579 block = block_template->getBlock();
580 BOOST_CHECK_EQUAL(block.vtx.size(), 5U);
581}
582
583void MinerTestingSetup::TestPrioritisedMining(const CScript& scriptPubKey, const std::vector<CTransactionRef>& txFirst)
584{
585 auto mining{MakeMining()};
586 BOOST_REQUIRE(mining);
587
588 BlockAssembler::Options options;
589 options.coinbase_output_script = scriptPubKey;
590
591 CTxMemPool& tx_mempool{MakeMempool()};
592 LOCK(tx_mempool.cs);
593
595
596 // Test that a tx below min fee but prioritised is included
598 tx.vin.resize(1);
599 tx.vin[0].prevout.hash = txFirst[0]->GetHash();
600 tx.vin[0].prevout.n = 0;
601 tx.vin[0].scriptSig = CScript() << OP_1;
602 tx.vout.resize(1);
603 tx.vout[0].nValue = 5000000000LL; // 0 fee
604 Txid hashFreePrioritisedTx = tx.GetHash();
605 AddToMempool(tx_mempool, entry.Fee(0).Time(Now<NodeSeconds>()).SpendsCoinbase(true).FromTx(tx));
606 tx_mempool.PrioritiseTransaction(hashFreePrioritisedTx, 5 * COIN);
607
608 tx.vin[0].prevout.hash = txFirst[1]->GetHash();
609 tx.vin[0].prevout.n = 0;
610 tx.vout[0].nValue = 5000000000LL - 1000;
611 // This tx has a low fee: 1000 satoshis
612 Txid hashParentTx = tx.GetHash(); // save this txid for later use
613 AddToMempool(tx_mempool, entry.Fee(1000).Time(Now<NodeSeconds>()).SpendsCoinbase(true).FromTx(tx));
614
615 // This tx has a medium fee: 10000 satoshis
616 tx.vin[0].prevout.hash = txFirst[2]->GetHash();
617 tx.vout[0].nValue = 5000000000LL - 10000;
618 Txid hashMediumFeeTx = tx.GetHash();
619 AddToMempool(tx_mempool, entry.Fee(10000).Time(Now<NodeSeconds>()).SpendsCoinbase(true).FromTx(tx));
620 tx_mempool.PrioritiseTransaction(hashMediumFeeTx, -5 * COIN);
621
622 // This tx also has a low fee, but is prioritised
623 tx.vin[0].prevout.hash = hashParentTx;
624 tx.vout[0].nValue = 5000000000LL - 1000 - 1000; // 1000 satoshi fee
625 Txid hashPrioritsedChild = tx.GetHash();
626 AddToMempool(tx_mempool, entry.Fee(1000).Time(Now<NodeSeconds>()).SpendsCoinbase(false).FromTx(tx));
627 tx_mempool.PrioritiseTransaction(hashPrioritsedChild, 2 * COIN);
628
629 // Test that transaction selection properly updates ancestor fee calculations as prioritised
630 // parents get included in a block. Create a transaction with two prioritised ancestors, each
631 // included by itself: FreeParent <- FreeChild <- FreeGrandchild.
632 // When FreeParent is added, a modified entry will be created for FreeChild + FreeGrandchild
633 // FreeParent's prioritisation should not be included in that entry.
634 // When FreeChild is included, FreeChild's prioritisation should also not be included.
635 tx.vin[0].prevout.hash = txFirst[3]->GetHash();
636 tx.vout[0].nValue = 5000000000LL; // 0 fee
637 Txid hashFreeParent = tx.GetHash();
638 AddToMempool(tx_mempool, entry.Fee(0).SpendsCoinbase(true).FromTx(tx));
639 tx_mempool.PrioritiseTransaction(hashFreeParent, 10 * COIN);
640
641 tx.vin[0].prevout.hash = hashFreeParent;
642 tx.vout[0].nValue = 5000000000LL; // 0 fee
643 Txid hashFreeChild = tx.GetHash();
644 AddToMempool(tx_mempool, entry.Fee(0).SpendsCoinbase(false).FromTx(tx));
645 tx_mempool.PrioritiseTransaction(hashFreeChild, 1 * COIN);
646
647 tx.vin[0].prevout.hash = hashFreeChild;
648 tx.vout[0].nValue = 5000000000LL; // 0 fee
649 Txid hashFreeGrandchild = tx.GetHash();
650 AddToMempool(tx_mempool, entry.Fee(0).SpendsCoinbase(false).FromTx(tx));
651
652 auto block_template = mining->createNewBlock(options);
653 BOOST_REQUIRE(block_template);
654 CBlock block{block_template->getBlock()};
655 BOOST_REQUIRE_EQUAL(block.vtx.size(), 6U);
656 BOOST_CHECK(block.vtx[1]->GetHash() == hashFreeParent);
657 BOOST_CHECK(block.vtx[2]->GetHash() == hashFreePrioritisedTx);
658 BOOST_CHECK(block.vtx[3]->GetHash() == hashParentTx);
659 BOOST_CHECK(block.vtx[4]->GetHash() == hashPrioritsedChild);
660 BOOST_CHECK(block.vtx[5]->GetHash() == hashFreeChild);
661 for (size_t i=0; i<block.vtx.size(); ++i) {
662 // The FreeParent and FreeChild's prioritisations should not impact the child.
663 BOOST_CHECK(block.vtx[i]->GetHash() != hashFreeGrandchild);
664 // De-prioritised transaction should not be included.
665 BOOST_CHECK(block.vtx[i]->GetHash() != hashMediumFeeTx);
666 }
667}
668
669// NOTE: These tests rely on CreateNewBlock doing its own self-validation!
670BOOST_AUTO_TEST_CASE(CreateNewBlock_validity)
671{
672 auto mining{MakeMining()};
673 BOOST_REQUIRE(mining);
674
675 // Note that by default, these tests run with size accounting enabled.
676 CScript scriptPubKey = CScript() << "04678afdb0fe5548271967f1a67130b7105cd6a828e03909a67962e0ea1f61deb649f6bc3f4cef38c4f35504e51ec112de5c384df7ba0b8d578a4c702b6bf11d5f"_hex << OP_CHECKSIG;
677 BlockAssembler::Options options;
678 options.coinbase_output_script = scriptPubKey;
679
680 // Create and check a simple template
681 std::unique_ptr<BlockTemplate> block_template = mining->createNewBlock(options);
682 BOOST_REQUIRE(block_template);
683 {
684 CBlock block{block_template->getBlock()};
685 {
686 std::string reason;
687 std::string debug;
688 BOOST_REQUIRE(!mining->checkBlock(block, {.check_pow = false}, reason, debug));
689 BOOST_REQUIRE_EQUAL(reason, "bad-txnmrklroot");
690 BOOST_REQUIRE_EQUAL(debug, "hashMerkleRoot mismatch");
691 }
692
693 block.hashMerkleRoot = BlockMerkleRoot(block);
694
695 {
696 std::string reason;
697 std::string debug;
698 BOOST_REQUIRE(mining->checkBlock(block, {.check_pow = false}, reason, debug));
699 BOOST_REQUIRE_EQUAL(reason, "");
700 BOOST_REQUIRE_EQUAL(debug, "");
701 }
702
703 {
704 // A block template does not have proof-of-work, but it might pass
705 // verification by coincidence. Grind the nonce if needed:
706 while (CheckProofOfWork(block.GetHash(), block.nBits, Assert(m_node.chainman)->GetParams().GetConsensus())) {
707 block.nNonce++;
708 }
709
710 std::string reason;
711 std::string debug;
712 BOOST_REQUIRE(!mining->checkBlock(block, {.check_pow = true}, reason, debug));
713 BOOST_REQUIRE_EQUAL(reason, "high-hash");
714 BOOST_REQUIRE_EQUAL(debug, "proof of work failed");
715 }
716 }
717
718 // We can't make transactions until we have inputs
719 // Therefore, load 110 blocks :)
720 static_assert(std::size(BLOCKINFO) == 110, "Should have 110 blocks to import");
721 int baseheight = 0;
722 std::vector<CTransactionRef> txFirst;
723 for (const auto& bi : BLOCKINFO) {
724 const int current_height{mining->getTip()->height};
725
731 if (current_height % 2 == 0) {
732 block_template = mining->createNewBlock(options);
733 BOOST_REQUIRE(block_template);
734 }
735
736 CBlock block{block_template->getBlock()};
737 CMutableTransaction txCoinbase(*block.vtx[0]);
738 {
739 LOCK(cs_main);
740 block.nVersion = VERSIONBITS_TOP_BITS;
741 block.nTime = Assert(m_node.chainman)->ActiveChain().Tip()->GetMedianTimePast()+1;
742 txCoinbase.version = 1;
743 txCoinbase.vin[0].scriptSig = CScript{} << (current_height + 1) << bi.extranonce;
744 txCoinbase.vout.resize(1); // Ignore the (optional) segwit commitment added by CreateNewBlock (as the hardcoded nonces don't account for this)
745 txCoinbase.vout[0].scriptPubKey = CScript();
746 block.vtx[0] = MakeTransactionRef(txCoinbase);
747 if (txFirst.size() == 0)
748 baseheight = current_height;
749 if (txFirst.size() < 4)
750 txFirst.push_back(block.vtx[0]);
751 block.hashMerkleRoot = BlockMerkleRoot(block);
752 block.nNonce = bi.nonce;
753 }
754 std::shared_ptr<const CBlock> shared_pblock = std::make_shared<const CBlock>(block);
755 // Alternate calls between Chainman's ProcessNewBlock and submitSolution
756 // via the Mining interface. The former is used by net_processing as well
757 // as the submitblock RPC.
758 if (current_height % 2 == 0) {
759 BOOST_REQUIRE(Assert(m_node.chainman)->ProcessNewBlock(shared_pblock, /*force_processing=*/true, /*min_pow_checked=*/true, nullptr));
760 } else {
761 BOOST_REQUIRE(block_template->submitSolution(block.nVersion, block.nTime, block.nNonce, MakeTransactionRef(txCoinbase)));
762 }
763 {
764 LOCK(cs_main);
765 // The above calls don't guarantee the tip is actually updated, so
766 // we explicitly check this.
767 auto maybe_new_tip{Assert(m_node.chainman)->ActiveChain().Tip()};
768 BOOST_REQUIRE_EQUAL(maybe_new_tip->GetBlockHash(), block.GetHash());
769 }
770 if (current_height % 2 == 0) {
771 block_template = block_template->waitNext();
772 BOOST_REQUIRE(block_template);
773 } else {
774 // This just adds coverage
775 mining->waitTipChanged(block.hashPrevBlock);
776 }
777 }
778
779 LOCK(cs_main);
780
781 TestBasicMining(scriptPubKey, txFirst, baseheight);
782
783 m_node.chainman->ActiveChain().Tip()->nHeight--;
784 SetMockTime(0);
785
786 TestPackageSelection(scriptPubKey, txFirst);
787
788 m_node.chainman->ActiveChain().Tip()->nHeight--;
789 SetMockTime(0);
790
791 TestPrioritisedMining(scriptPubKey, txFirst);
792}
793
CScript GetScriptForDestination(const CTxDestination &dest)
Generate a Bitcoin scriptPubKey for the given CTxDestination.
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
AddToMempool(pool, CTxMemPoolEntry(tx, fee, 0, 1, 0, false, 4, lp))
node::NodeContext m_node
Definition: bitcoin-gui.cpp:42
int flags
Definition: bitcoin-tx.cpp:529
#define Assert(val)
Identity function.
Definition: check.h:106
Definition: block.h:69
The block chain is a tree shaped structure starting with the genesis block at the root,...
Definition: chain.h:141
CBlockIndex * pprev
pointer to the index of the predecessor of this block
Definition: chain.h:147
void BuildSkip()
Build the skiplist pointer for this entry.
Definition: chain.cpp:120
uint256 GetBlockHash() const
Definition: chain.h:243
int nHeight
height of the entry in the chain. The genesis block has height 0
Definition: chain.h:153
static constexpr int nMedianTimeSpan
Definition: chain.h:276
const uint256 * phashBlock
pointer to the hash of the block, if any. Memory is owned by this CBlockIndex
Definition: chain.h:144
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
CAmount GetFee(int32_t virtual_bytes) const
Return the fee in satoshis for the given vsize in vbytes.
Definition: feerate.cpp:20
Serialized script, used inside transaction inputs and outputs.
Definition: script.h:413
The basic transaction that is broadcasted on the network and contained in blocks.
Definition: transaction.h:296
static const uint32_t MAX_SEQUENCE_NONFINAL
This is the maximum sequence number that enables both nLockTime and OP_CHECKLOCKTIMEVERIFY (BIP 65).
Definition: transaction.h:87
static const uint32_t SEQUENCE_LOCKTIME_TYPE_FLAG
If CTxIn::nSequence encodes a relative lock-time and this flag is set, the relative lock-time has uni...
Definition: transaction.h:104
static const int SEQUENCE_LOCKTIME_GRANULARITY
In order to use the same number of bits to encode roughly the same wall-clock duration,...
Definition: transaction.h:119
CTxMemPool stores valid-according-to-the-current-best-chain transactions that may be included in the ...
Definition: txmempool.h:281
BOOST_CHECK_EXCEPTION predicates to check the specific validation error.
Definition: setup_common.h:304
Block template interface.
Definition: mining.h:32
Interface giving clients (RPC, Stratum v2 Template Provider in the future) ability to create block te...
Definition: mining.h:80
Generate a new block, without valid proof-of-work.
Definition: miner.h:151
256-bit opaque blob.
Definition: uint256.h:196
uint256 BlockMerkleRoot(const CBlock &block, bool *mutated)
Definition: merkle.cpp:66
static constexpr unsigned int LOCKTIME_VERIFY_SEQUENCE
Flags for nSequence and nLockTime locks.
Definition: consensus.h:28
RecursiveMutex cs_main
Mutex to guard access to validation specific variables, such as reading or changing the chainstate.
Definition: cs_main.cpp:8
BOOST_FIXTURE_TEST_SUITE(cuckoocache_tests, BasicTestingSetup)
Test Suite for CuckooCache.
BOOST_AUTO_TEST_SUITE_END()
unsigned int nHeight
bool spendsCoinbase
@ REPLACED
Removed for replacement.
BOOST_AUTO_TEST_CASE(CreateNewBlock_validity)
unsigned int extranonce
Definition: miner_tests.cpp:75
static std::unique_ptr< CBlockIndex > CreateBlockIndex(int nHeight, CBlockIndex *active_chain_tip) EXCLUSIVE_LOCKS_REQUIRED(cs_main)
Definition: miner_tests.cpp:97
static constexpr struct @14 BLOCKINFO[]
static CFeeRate blockMinFeeRate
Definition: miner_tests.cpp:72
unsigned int nonce
Definition: miner_tests.cpp:76
std::unique_ptr< Mining > MakeMining(node::NodeContext &node)
Return implementation of Mining interface.
Definition: interfaces.cpp:990
""_hex is a compile-time user-defined literal returning a std::array<std::byte>, equivalent to ParseH...
Definition: strencodings.h:384
#define BOOST_CHECK_EQUAL(v1, v2)
Definition: object.cpp:18
#define BOOST_CHECK(expr)
Definition: object.cpp:17
static constexpr unsigned int DEFAULT_BLOCK_MIN_TX_FEE
Default for -blockmintxfee, which sets the minimum feerate for a transaction in blocks created by min...
Definition: policy.h:32
bool CheckProofOfWork(uint256 hash, unsigned int nBits, const Consensus::Params &params)
Check whether a block hash satisfies the proof-of-work requirement specified by nBits.
Definition: pow.cpp:140
static constexpr TransactionSerParams TX_WITH_WITNESS
Definition: transaction.h:195
static CTransactionRef MakeTransactionRef(Tx &&txIn)
Definition: transaction.h:424
@ OP_2
Definition: script.h:85
@ OP_CHECKMULTISIG
Definition: script.h:192
@ OP_CHECKSIG
Definition: script.h:190
@ OP_NOP
Definition: script.h:102
@ OP_1
Definition: script.h:83
@ OP_DROP
Definition: script.h:124
@ OP_0
Definition: script.h:76
size_t GetSerializeSize(const T &t)
Definition: serialize.h:1094
static constexpr CAmount CENT
Definition: setup_common.h:47
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
Txid GetHash() const
Compute the hash of this CMutableTransaction.
Definition: transaction.cpp:69
std::vector< CTxIn > vin
Definition: transaction.h:379
Data structure storing a fee and size, ordered by increasing fee/size.
Definition: feefrac.h:40
Definition: txmempool.h:19
TestMemPoolEntryHelper & SigOpsCost(unsigned int _sigopsCost)
Definition: txmempool.h:38
TestMemPoolEntryHelper & Time(NodeSeconds tp)
Definition: txmempool.h:34
CAmount nFee
Definition: txmempool.h:21
CTxMemPoolEntry FromTx(const CMutableTransaction &tx) const
Definition: txmempool.cpp:33
TestMemPoolEntryHelper & SpendsCoinbase(bool _flag)
Definition: txmempool.h:37
unsigned int nHeight
Definition: txmempool.h:23
TestMemPoolEntryHelper & Fee(CAmount _fee)
Definition: txmempool.h:33
Testing setup that configures a complete environment.
Definition: setup_common.h:121
Bilingual messages:
Definition: translation.h:24
bool empty() const
Definition: translation.h:35
std::unique_ptr< Mining > MakeMining()
Definition: miner_tests.cpp:63
void TestPackageSelection(const CScript &scriptPubKey, const std::vector< CTransactionRef > &txFirst) EXCLUSIVE_LOCKS_REQUIRED(void TestBasicMining(const CScript &scriptPubKey, const std::vector< CTransactionRef > &txFirst, int baseheight) EXCLUSIVE_LOCKS_REQUIRED(void TestPrioritisedMining(const CScript &scriptPubKey, const std::vector< CTransactionRef > &txFirst) EXCLUSIVE_LOCKS_REQUIRED(bool TestSequenceLocks(const CTransaction &tx, CTxMemPool &tx_mempool) EXCLUSIVE_LOCKS_REQUIRED(
Definition: miner_tests.cpp:45
std::unique_ptr< CTxMemPool > mempool
Definition: context.h:68
std::unique_ptr< ChainstateManager > chainman
Definition: context.h:72
#define LOCK(cs)
Definition: sync.h:259
CTxMemPool::Options MemPoolOptionsForTest(const NodeContext &node)
Definition: txmempool.cpp:20
#define EXCLUSIVE_LOCKS_REQUIRED(...)
Definition: threadsafety.h:51
void BulkTransaction(CMutableTransaction &tx, int32_t target_weight)
bool SequenceLocks(const CTransaction &tx, int flags, std::vector< int > &prevHeights, const CBlockIndex &block)
Check if transaction is final per BIP 68 sequence numbers and can be included in a block.
Definition: tx_verify.cpp:107
bool IsFinalTx(const CTransaction &tx, int nBlockHeight, int64_t nBlockTime)
Check if transaction is final and can be included in a block with the specified height and time.
Definition: tx_verify.cpp:17
void SetMockTime(int64_t nMockTimeIn)
DEPRECATED Use SetMockTime with chrono type.
Definition: time.cpp:40
std::chrono::duration< double, std::chrono::milliseconds::period > MillisecondsDouble
Definition: time.h:88
bool CheckFinalTxAtTip(const CBlockIndex &active_chain_tip, const CTransaction &tx)
Definition: validation.cpp:148
bool CheckSequenceLocksAtTip(CBlockIndex *tip, const LockPoints &lock_points)
Check if transaction will be BIP68 final in the next block to be created on top of tip.
Definition: validation.cpp:247
bool CheckFinalTxAtTip(const CBlockIndex &active_chain_tip, const CTransaction &tx) EXCLUSIVE_LOCKS_REQUIRED(std::optional< LockPoints > CalculateLockPointsAtTip(CBlockIndex *tip, const CCoinsView &coins_view, const CTransaction &tx)
Check if transaction will be final in the next block to be created.
Definition: validation.h:312
static const int32_t VERSIONBITS_TOP_BITS
What bits to set in version for versionbits blocks.
Definition: versionbits.h:21