Bitcoin Core  27.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>
8 #include <consensus/consensus.h>
9 #include <consensus/merkle.h>
10 #include <consensus/tx_verify.h>
11 #include <node/miner.h>
12 #include <policy/policy.h>
13 #include <test/util/random.h>
14 #include <test/util/txmempool.h>
15 #include <txmempool.h>
16 #include <uint256.h>
17 #include <util/check.h>
18 #include <util/strencodings.h>
19 #include <util/time.h>
20 #include <util/translation.h>
21 #include <validation.h>
22 #include <versionbits.h>
23 
24 #include <test/util/setup_common.h>
25 
26 #include <memory>
27 
28 #include <boost/test/unit_test.hpp>
29 
32 
33 namespace miner_tests {
35  void TestPackageSelection(const CScript& scriptPubKey, const std::vector<CTransactionRef>& txFirst) EXCLUSIVE_LOCKS_REQUIRED(::cs_main);
36  void TestBasicMining(const CScript& scriptPubKey, const std::vector<CTransactionRef>& txFirst, int baseheight) EXCLUSIVE_LOCKS_REQUIRED(::cs_main);
37  void TestPrioritisedMining(const CScript& scriptPubKey, const std::vector<CTransactionRef>& txFirst) EXCLUSIVE_LOCKS_REQUIRED(::cs_main);
39  {
40  CCoinsViewMemPool view_mempool{&m_node.chainman->ActiveChainstate().CoinsTip(), tx_mempool};
41  CBlockIndex* tip{m_node.chainman->ActiveChain().Tip()};
42  const std::optional<LockPoints> lock_points{CalculateLockPointsAtTip(tip, view_mempool, tx)};
43  return lock_points.has_value() && CheckSequenceLocksAtTip(tip, *lock_points);
44  }
46  {
47  // Delete the previous mempool to ensure with valgrind that the old
48  // pointer is not accessed, when the new one should be accessed
49  // instead.
50  m_node.mempool.reset();
51  bilingual_str error;
52  m_node.mempool = std::make_unique<CTxMemPool>(MemPoolOptionsForTest(m_node), error);
53  Assert(error.empty());
54  return *m_node.mempool;
55  }
57 };
58 } // namespace miner_tests
59 
60 BOOST_FIXTURE_TEST_SUITE(miner_tests, MinerTestingSetup)
61 
63 
64 BlockAssembler MinerTestingSetup::AssemblerForTest(CTxMemPool& tx_mempool)
65 {
66  BlockAssembler::Options options;
67 
68  options.nBlockMaxWeight = MAX_BLOCK_WEIGHT;
69  options.blockMinFeeRate = blockMinFeeRate;
70  return BlockAssembler{m_node.chainman->ActiveChainstate(), &tx_mempool, options};
71 }
72 
73 constexpr static struct {
74  unsigned char extranonce;
75  unsigned int nonce;
76 } BLOCKINFO[]{{8, 582909131}, {0, 971462344}, {2, 1169481553}, {6, 66147495}, {7, 427785981}, {8, 80538907},
77  {8, 207348013}, {2, 1951240923}, {4, 215054351}, {1, 491520534}, {8, 1282281282}, {4, 639565734},
78  {3, 248274685}, {8, 1160085976}, {6, 396349768}, {5, 393780549}, {5, 1096899528}, {4, 965381630},
79  {0, 728758712}, {5, 318638310}, {3, 164591898}, {2, 274234550}, {2, 254411237}, {7, 561761812},
80  {2, 268342573}, {0, 402816691}, {1, 221006382}, {6, 538872455}, {7, 393315655}, {4, 814555937},
81  {7, 504879194}, {6, 467769648}, {3, 925972193}, {2, 200581872}, {3, 168915404}, {8, 430446262},
82  {5, 773507406}, {3, 1195366164}, {0, 433361157}, {3, 297051771}, {0, 558856551}, {2, 501614039},
83  {3, 528488272}, {2, 473587734}, {8, 230125274}, {2, 494084400}, {4, 357314010}, {8, 60361686},
84  {7, 640624687}, {3, 480441695}, {8, 1424447925}, {4, 752745419}, {1, 288532283}, {6, 669170574},
85  {5, 1900907591}, {3, 555326037}, {3, 1121014051}, {0, 545835650}, {8, 189196651}, {5, 252371575},
86  {0, 199163095}, {6, 558895874}, {6, 1656839784}, {6, 815175452}, {6, 718677851}, {5, 544000334},
87  {0, 340113484}, {6, 850744437}, {4, 496721063}, {8, 524715182}, {6, 574361898}, {6, 1642305743},
88  {6, 355110149}, {5, 1647379658}, {8, 1103005356}, {7, 556460625}, {3, 1139533992}, {5, 304736030},
89  {2, 361539446}, {2, 143720360}, {6, 201939025}, {7, 423141476}, {4, 574633709}, {3, 1412254823},
90  {4, 873254135}, {0, 341817335}, {6, 53501687}, {3, 179755410}, {5, 172209688}, {8, 516810279},
91  {4, 1228391489}, {8, 325372589}, {6, 550367589}, {0, 876291812}, {7, 412454120}, {7, 717202854},
92  {2, 222677843}, {6, 251778867}, {7, 842004420}, {7, 194762829}, {4, 96668841}, {1, 925485796},
93  {0, 792342903}, {6, 678455063}, {6, 773251385}, {5, 186617471}, {6, 883189502}, {7, 396077336},
94  {8, 254702874}, {0, 455592851}};
95 
96 static std::unique_ptr<CBlockIndex> CreateBlockIndex(int nHeight, CBlockIndex* active_chain_tip) EXCLUSIVE_LOCKS_REQUIRED(cs_main)
97 {
98  auto index{std::make_unique<CBlockIndex>()};
99  index->nHeight = nHeight;
100  index->pprev = active_chain_tip;
101  return index;
102 }
103 
104 // Test suite for ancestor feerate transaction selection.
105 // Implemented as an additional function, rather than a separate test case,
106 // to allow reusing the blockchain created in CreateNewBlock_validity.
107 void MinerTestingSetup::TestPackageSelection(const CScript& scriptPubKey, const std::vector<CTransactionRef>& txFirst)
108 {
109  CTxMemPool& tx_mempool{MakeMempool()};
110  LOCK(tx_mempool.cs);
111  // Test the ancestor feerate transaction selection.
113 
114  // Test that a medium fee transaction will be selected after a higher fee
115  // rate package with a low fee rate parent.
117  tx.vin.resize(1);
118  tx.vin[0].scriptSig = CScript() << OP_1;
119  tx.vin[0].prevout.hash = txFirst[0]->GetHash();
120  tx.vin[0].prevout.n = 0;
121  tx.vout.resize(1);
122  tx.vout[0].nValue = 5000000000LL - 1000;
123  // This tx has a low fee: 1000 satoshis
124  Txid hashParentTx = tx.GetHash(); // save this txid for later use
125  tx_mempool.addUnchecked(entry.Fee(1000).Time(Now<NodeSeconds>()).SpendsCoinbase(true).FromTx(tx));
126 
127  // This tx has a medium fee: 10000 satoshis
128  tx.vin[0].prevout.hash = txFirst[1]->GetHash();
129  tx.vout[0].nValue = 5000000000LL - 10000;
130  Txid hashMediumFeeTx = tx.GetHash();
131  tx_mempool.addUnchecked(entry.Fee(10000).Time(Now<NodeSeconds>()).SpendsCoinbase(true).FromTx(tx));
132 
133  // This tx has a high fee, but depends on the first transaction
134  tx.vin[0].prevout.hash = hashParentTx;
135  tx.vout[0].nValue = 5000000000LL - 1000 - 50000; // 50k satoshi fee
136  Txid hashHighFeeTx = tx.GetHash();
137  tx_mempool.addUnchecked(entry.Fee(50000).Time(Now<NodeSeconds>()).SpendsCoinbase(false).FromTx(tx));
138 
139  std::unique_ptr<CBlockTemplate> pblocktemplate = AssemblerForTest(tx_mempool).CreateNewBlock(scriptPubKey);
140  BOOST_REQUIRE_EQUAL(pblocktemplate->block.vtx.size(), 4U);
141  BOOST_CHECK(pblocktemplate->block.vtx[1]->GetHash() == hashParentTx);
142  BOOST_CHECK(pblocktemplate->block.vtx[2]->GetHash() == hashHighFeeTx);
143  BOOST_CHECK(pblocktemplate->block.vtx[3]->GetHash() == hashMediumFeeTx);
144 
145  // Test that a package below the block min tx fee doesn't get included
146  tx.vin[0].prevout.hash = hashHighFeeTx;
147  tx.vout[0].nValue = 5000000000LL - 1000 - 50000; // 0 fee
148  Txid hashFreeTx = tx.GetHash();
149  tx_mempool.addUnchecked(entry.Fee(0).FromTx(tx));
150  size_t freeTxSize = ::GetSerializeSize(TX_WITH_WITNESS(tx));
151 
152  // Calculate a fee on child transaction that will put the package just
153  // below the block min tx fee (assuming 1 child tx of the same size).
154  CAmount feeToUse = blockMinFeeRate.GetFee(2*freeTxSize) - 1;
155 
156  tx.vin[0].prevout.hash = hashFreeTx;
157  tx.vout[0].nValue = 5000000000LL - 1000 - 50000 - feeToUse;
158  Txid hashLowFeeTx = tx.GetHash();
159  tx_mempool.addUnchecked(entry.Fee(feeToUse).FromTx(tx));
160  pblocktemplate = AssemblerForTest(tx_mempool).CreateNewBlock(scriptPubKey);
161  // Verify that the free tx and the low fee tx didn't get selected
162  for (size_t i=0; i<pblocktemplate->block.vtx.size(); ++i) {
163  BOOST_CHECK(pblocktemplate->block.vtx[i]->GetHash() != hashFreeTx);
164  BOOST_CHECK(pblocktemplate->block.vtx[i]->GetHash() != hashLowFeeTx);
165  }
166 
167  // Test that packages above the min relay fee do get included, even if one
168  // of the transactions is below the min relay fee
169  // Remove the low fee transaction and replace with a higher fee transaction
170  tx_mempool.removeRecursive(CTransaction(tx), MemPoolRemovalReason::REPLACED);
171  tx.vout[0].nValue -= 2; // Now we should be just over the min relay fee
172  hashLowFeeTx = tx.GetHash();
173  tx_mempool.addUnchecked(entry.Fee(feeToUse + 2).FromTx(tx));
174  pblocktemplate = AssemblerForTest(tx_mempool).CreateNewBlock(scriptPubKey);
175  BOOST_REQUIRE_EQUAL(pblocktemplate->block.vtx.size(), 6U);
176  BOOST_CHECK(pblocktemplate->block.vtx[4]->GetHash() == hashFreeTx);
177  BOOST_CHECK(pblocktemplate->block.vtx[5]->GetHash() == hashLowFeeTx);
178 
179  // Test that transaction selection properly updates ancestor fee
180  // calculations as ancestor transactions get included in a block.
181  // Add a 0-fee transaction that has 2 outputs.
182  tx.vin[0].prevout.hash = txFirst[2]->GetHash();
183  tx.vout.resize(2);
184  tx.vout[0].nValue = 5000000000LL - 100000000;
185  tx.vout[1].nValue = 100000000; // 1BTC output
186  Txid hashFreeTx2 = tx.GetHash();
187  tx_mempool.addUnchecked(entry.Fee(0).SpendsCoinbase(true).FromTx(tx));
188 
189  // This tx can't be mined by itself
190  tx.vin[0].prevout.hash = hashFreeTx2;
191  tx.vout.resize(1);
192  feeToUse = blockMinFeeRate.GetFee(freeTxSize);
193  tx.vout[0].nValue = 5000000000LL - 100000000 - feeToUse;
194  Txid hashLowFeeTx2 = tx.GetHash();
195  tx_mempool.addUnchecked(entry.Fee(feeToUse).SpendsCoinbase(false).FromTx(tx));
196  pblocktemplate = AssemblerForTest(tx_mempool).CreateNewBlock(scriptPubKey);
197 
198  // Verify that this tx isn't selected.
199  for (size_t i=0; i<pblocktemplate->block.vtx.size(); ++i) {
200  BOOST_CHECK(pblocktemplate->block.vtx[i]->GetHash() != hashFreeTx2);
201  BOOST_CHECK(pblocktemplate->block.vtx[i]->GetHash() != hashLowFeeTx2);
202  }
203 
204  // This tx will be mineable, and should cause hashLowFeeTx2 to be selected
205  // as well.
206  tx.vin[0].prevout.n = 1;
207  tx.vout[0].nValue = 100000000 - 10000; // 10k satoshi fee
208  tx_mempool.addUnchecked(entry.Fee(10000).FromTx(tx));
209  pblocktemplate = AssemblerForTest(tx_mempool).CreateNewBlock(scriptPubKey);
210  BOOST_REQUIRE_EQUAL(pblocktemplate->block.vtx.size(), 9U);
211  BOOST_CHECK(pblocktemplate->block.vtx[8]->GetHash() == hashLowFeeTx2);
212 }
213 
214 void MinerTestingSetup::TestBasicMining(const CScript& scriptPubKey, const std::vector<CTransactionRef>& txFirst, int baseheight)
215 {
216  Txid hash;
219  entry.nFee = 11;
220  entry.nHeight = 11;
221 
222  const CAmount BLOCKSUBSIDY = 50 * COIN;
223  const CAmount LOWFEE = CENT;
224  const CAmount HIGHFEE = COIN;
225  const CAmount HIGHERFEE = 4 * COIN;
226 
227  {
228  CTxMemPool& tx_mempool{MakeMempool()};
229  LOCK(tx_mempool.cs);
230 
231  // Just to make sure we can still make simple blocks
232  auto pblocktemplate = AssemblerForTest(tx_mempool).CreateNewBlock(scriptPubKey);
233  BOOST_CHECK(pblocktemplate);
234 
235  // block sigops > limit: 1000 CHECKMULTISIG + 1
236  tx.vin.resize(1);
237  // NOTE: OP_NOP is used to force 20 SigOps for the CHECKMULTISIG
238  tx.vin[0].scriptSig = CScript() << OP_0 << OP_0 << OP_0 << OP_NOP << OP_CHECKMULTISIG << OP_1;
239  tx.vin[0].prevout.hash = txFirst[0]->GetHash();
240  tx.vin[0].prevout.n = 0;
241  tx.vout.resize(1);
242  tx.vout[0].nValue = BLOCKSUBSIDY;
243  for (unsigned int i = 0; i < 1001; ++i) {
244  tx.vout[0].nValue -= LOWFEE;
245  hash = tx.GetHash();
246  bool spendsCoinbase = i == 0; // only first tx spends coinbase
247  // If we don't set the # of sig ops in the CTxMemPoolEntry, template creation fails
248  tx_mempool.addUnchecked(entry.Fee(LOWFEE).Time(Now<NodeSeconds>()).SpendsCoinbase(spendsCoinbase).FromTx(tx));
249  tx.vin[0].prevout.hash = hash;
250  }
251 
252  BOOST_CHECK_EXCEPTION(AssemblerForTest(tx_mempool).CreateNewBlock(scriptPubKey), std::runtime_error, HasReason("bad-blk-sigops"));
253  }
254 
255  {
256  CTxMemPool& tx_mempool{MakeMempool()};
257  LOCK(tx_mempool.cs);
258 
259  tx.vin[0].prevout.hash = txFirst[0]->GetHash();
260  tx.vout[0].nValue = BLOCKSUBSIDY;
261  for (unsigned int i = 0; i < 1001; ++i) {
262  tx.vout[0].nValue -= LOWFEE;
263  hash = tx.GetHash();
264  bool spendsCoinbase = i == 0; // only first tx spends coinbase
265  // If we do set the # of sig ops in the CTxMemPoolEntry, template creation passes
266  tx_mempool.addUnchecked(entry.Fee(LOWFEE).Time(Now<NodeSeconds>()).SpendsCoinbase(spendsCoinbase).SigOpsCost(80).FromTx(tx));
267  tx.vin[0].prevout.hash = hash;
268  }
269  BOOST_CHECK(AssemblerForTest(tx_mempool).CreateNewBlock(scriptPubKey));
270  }
271 
272  {
273  CTxMemPool& tx_mempool{MakeMempool()};
274  LOCK(tx_mempool.cs);
275 
276  // block size > limit
277  tx.vin[0].scriptSig = CScript();
278  // 18 * (520char + DROP) + OP_1 = 9433 bytes
279  std::vector<unsigned char> vchData(520);
280  for (unsigned int i = 0; i < 18; ++i) {
281  tx.vin[0].scriptSig << vchData << OP_DROP;
282  }
283  tx.vin[0].scriptSig << OP_1;
284  tx.vin[0].prevout.hash = txFirst[0]->GetHash();
285  tx.vout[0].nValue = BLOCKSUBSIDY;
286  for (unsigned int i = 0; i < 128; ++i) {
287  tx.vout[0].nValue -= LOWFEE;
288  hash = tx.GetHash();
289  bool spendsCoinbase = i == 0; // only first tx spends coinbase
290  tx_mempool.addUnchecked(entry.Fee(LOWFEE).Time(Now<NodeSeconds>()).SpendsCoinbase(spendsCoinbase).FromTx(tx));
291  tx.vin[0].prevout.hash = hash;
292  }
293  BOOST_CHECK(AssemblerForTest(tx_mempool).CreateNewBlock(scriptPubKey));
294  }
295 
296  {
297  CTxMemPool& tx_mempool{MakeMempool()};
298  LOCK(tx_mempool.cs);
299 
300  // orphan in tx_mempool, template creation fails
301  hash = tx.GetHash();
302  tx_mempool.addUnchecked(entry.Fee(LOWFEE).Time(Now<NodeSeconds>()).FromTx(tx));
303  BOOST_CHECK_EXCEPTION(AssemblerForTest(tx_mempool).CreateNewBlock(scriptPubKey), std::runtime_error, HasReason("bad-txns-inputs-missingorspent"));
304  }
305 
306  {
307  CTxMemPool& tx_mempool{MakeMempool()};
308  LOCK(tx_mempool.cs);
309 
310  // child with higher feerate than parent
311  tx.vin[0].scriptSig = CScript() << OP_1;
312  tx.vin[0].prevout.hash = txFirst[1]->GetHash();
313  tx.vout[0].nValue = BLOCKSUBSIDY - HIGHFEE;
314  hash = tx.GetHash();
315  tx_mempool.addUnchecked(entry.Fee(HIGHFEE).Time(Now<NodeSeconds>()).SpendsCoinbase(true).FromTx(tx));
316  tx.vin[0].prevout.hash = hash;
317  tx.vin.resize(2);
318  tx.vin[1].scriptSig = CScript() << OP_1;
319  tx.vin[1].prevout.hash = txFirst[0]->GetHash();
320  tx.vin[1].prevout.n = 0;
321  tx.vout[0].nValue = tx.vout[0].nValue + BLOCKSUBSIDY - HIGHERFEE; // First txn output + fresh coinbase - new txn fee
322  hash = tx.GetHash();
323  tx_mempool.addUnchecked(entry.Fee(HIGHERFEE).Time(Now<NodeSeconds>()).SpendsCoinbase(true).FromTx(tx));
324  BOOST_CHECK(AssemblerForTest(tx_mempool).CreateNewBlock(scriptPubKey));
325  }
326 
327  {
328  CTxMemPool& tx_mempool{MakeMempool()};
329  LOCK(tx_mempool.cs);
330 
331  // coinbase in tx_mempool, template creation fails
332  tx.vin.resize(1);
333  tx.vin[0].prevout.SetNull();
334  tx.vin[0].scriptSig = CScript() << OP_0 << OP_1;
335  tx.vout[0].nValue = 0;
336  hash = tx.GetHash();
337  // give it a fee so it'll get mined
338  tx_mempool.addUnchecked(entry.Fee(LOWFEE).Time(Now<NodeSeconds>()).SpendsCoinbase(false).FromTx(tx));
339  // Should throw bad-cb-multiple
340  BOOST_CHECK_EXCEPTION(AssemblerForTest(tx_mempool).CreateNewBlock(scriptPubKey), std::runtime_error, HasReason("bad-cb-multiple"));
341  }
342 
343  {
344  CTxMemPool& tx_mempool{MakeMempool()};
345  LOCK(tx_mempool.cs);
346 
347  // double spend txn pair in tx_mempool, template creation fails
348  tx.vin[0].prevout.hash = txFirst[0]->GetHash();
349  tx.vin[0].scriptSig = CScript() << OP_1;
350  tx.vout[0].nValue = BLOCKSUBSIDY - HIGHFEE;
351  tx.vout[0].scriptPubKey = CScript() << OP_1;
352  hash = tx.GetHash();
353  tx_mempool.addUnchecked(entry.Fee(HIGHFEE).Time(Now<NodeSeconds>()).SpendsCoinbase(true).FromTx(tx));
354  tx.vout[0].scriptPubKey = CScript() << OP_2;
355  hash = tx.GetHash();
356  tx_mempool.addUnchecked(entry.Fee(HIGHFEE).Time(Now<NodeSeconds>()).SpendsCoinbase(true).FromTx(tx));
357  BOOST_CHECK_EXCEPTION(AssemblerForTest(tx_mempool).CreateNewBlock(scriptPubKey), std::runtime_error, HasReason("bad-txns-inputs-missingorspent"));
358  }
359 
360  {
361  CTxMemPool& tx_mempool{MakeMempool()};
362  LOCK(tx_mempool.cs);
363 
364  // subsidy changing
365  int nHeight = m_node.chainman->ActiveChain().Height();
366  // Create an actual 209999-long block chain (without valid blocks).
367  while (m_node.chainman->ActiveChain().Tip()->nHeight < 209999) {
368  CBlockIndex* prev = m_node.chainman->ActiveChain().Tip();
369  CBlockIndex* next = new CBlockIndex();
370  next->phashBlock = new uint256(InsecureRand256());
371  m_node.chainman->ActiveChainstate().CoinsTip().SetBestBlock(next->GetBlockHash());
372  next->pprev = prev;
373  next->nHeight = prev->nHeight + 1;
374  next->BuildSkip();
375  m_node.chainman->ActiveChain().SetTip(*next);
376  }
377  BOOST_CHECK(AssemblerForTest(tx_mempool).CreateNewBlock(scriptPubKey));
378  // Extend to a 210000-long block chain.
379  while (m_node.chainman->ActiveChain().Tip()->nHeight < 210000) {
380  CBlockIndex* prev = m_node.chainman->ActiveChain().Tip();
381  CBlockIndex* next = new CBlockIndex();
382  next->phashBlock = new uint256(InsecureRand256());
383  m_node.chainman->ActiveChainstate().CoinsTip().SetBestBlock(next->GetBlockHash());
384  next->pprev = prev;
385  next->nHeight = prev->nHeight + 1;
386  next->BuildSkip();
387  m_node.chainman->ActiveChain().SetTip(*next);
388  }
389  BOOST_CHECK(AssemblerForTest(tx_mempool).CreateNewBlock(scriptPubKey));
390 
391  // invalid p2sh txn in tx_mempool, template creation fails
392  tx.vin[0].prevout.hash = txFirst[0]->GetHash();
393  tx.vin[0].prevout.n = 0;
394  tx.vin[0].scriptSig = CScript() << OP_1;
395  tx.vout[0].nValue = BLOCKSUBSIDY - LOWFEE;
396  CScript script = CScript() << OP_0;
397  tx.vout[0].scriptPubKey = GetScriptForDestination(ScriptHash(script));
398  hash = tx.GetHash();
399  tx_mempool.addUnchecked(entry.Fee(LOWFEE).Time(Now<NodeSeconds>()).SpendsCoinbase(true).FromTx(tx));
400  tx.vin[0].prevout.hash = hash;
401  tx.vin[0].scriptSig = CScript() << std::vector<unsigned char>(script.begin(), script.end());
402  tx.vout[0].nValue -= LOWFEE;
403  hash = tx.GetHash();
404  tx_mempool.addUnchecked(entry.Fee(LOWFEE).Time(Now<NodeSeconds>()).SpendsCoinbase(false).FromTx(tx));
405  // Should throw block-validation-failed
406  BOOST_CHECK_EXCEPTION(AssemblerForTest(tx_mempool).CreateNewBlock(scriptPubKey), std::runtime_error, HasReason("block-validation-failed"));
407 
408  // Delete the dummy blocks again.
409  while (m_node.chainman->ActiveChain().Tip()->nHeight > nHeight) {
410  CBlockIndex* del = m_node.chainman->ActiveChain().Tip();
411  m_node.chainman->ActiveChain().SetTip(*Assert(del->pprev));
412  m_node.chainman->ActiveChainstate().CoinsTip().SetBestBlock(del->pprev->GetBlockHash());
413  delete del->phashBlock;
414  delete del;
415  }
416  }
417 
418  CTxMemPool& tx_mempool{MakeMempool()};
419  LOCK(tx_mempool.cs);
420 
421  // non-final txs in mempool
422  SetMockTime(m_node.chainman->ActiveChain().Tip()->GetMedianTimePast() + 1);
423  const int flags{LOCKTIME_VERIFY_SEQUENCE};
424  // height map
425  std::vector<int> prevheights;
426 
427  // relative height locked
428  tx.version = 2;
429  tx.vin.resize(1);
430  prevheights.resize(1);
431  tx.vin[0].prevout.hash = txFirst[0]->GetHash(); // only 1 transaction
432  tx.vin[0].prevout.n = 0;
433  tx.vin[0].scriptSig = CScript() << OP_1;
434  tx.vin[0].nSequence = m_node.chainman->ActiveChain().Tip()->nHeight + 1; // txFirst[0] is the 2nd block
435  prevheights[0] = baseheight + 1;
436  tx.vout.resize(1);
437  tx.vout[0].nValue = BLOCKSUBSIDY-HIGHFEE;
438  tx.vout[0].scriptPubKey = CScript() << OP_1;
439  tx.nLockTime = 0;
440  hash = tx.GetHash();
441  tx_mempool.addUnchecked(entry.Fee(HIGHFEE).Time(Now<NodeSeconds>()).SpendsCoinbase(true).FromTx(tx));
442  BOOST_CHECK(CheckFinalTxAtTip(*Assert(m_node.chainman->ActiveChain().Tip()), CTransaction{tx})); // Locktime passes
443  BOOST_CHECK(!TestSequenceLocks(CTransaction{tx}, tx_mempool)); // Sequence locks fail
444 
445  {
446  CBlockIndex* active_chain_tip = m_node.chainman->ActiveChain().Tip();
447  BOOST_CHECK(SequenceLocks(CTransaction(tx), flags, prevheights, *CreateBlockIndex(active_chain_tip->nHeight + 2, active_chain_tip))); // Sequence locks pass on 2nd block
448  }
449 
450  // relative time locked
451  tx.vin[0].prevout.hash = txFirst[1]->GetHash();
452  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
453  prevheights[0] = baseheight + 2;
454  hash = tx.GetHash();
455  tx_mempool.addUnchecked(entry.Time(Now<NodeSeconds>()).FromTx(tx));
456  BOOST_CHECK(CheckFinalTxAtTip(*Assert(m_node.chainman->ActiveChain().Tip()), CTransaction{tx})); // Locktime passes
457  BOOST_CHECK(!TestSequenceLocks(CTransaction{tx}, tx_mempool)); // Sequence locks fail
458 
459  const int SEQUENCE_LOCK_TIME = 512; // Sequence locks pass 512 seconds later
460  for (int i = 0; i < CBlockIndex::nMedianTimeSpan; ++i)
461  m_node.chainman->ActiveChain().Tip()->GetAncestor(m_node.chainman->ActiveChain().Tip()->nHeight - i)->nTime += SEQUENCE_LOCK_TIME; // Trick the MedianTimePast
462  {
463  CBlockIndex* active_chain_tip = m_node.chainman->ActiveChain().Tip();
464  BOOST_CHECK(SequenceLocks(CTransaction(tx), flags, prevheights, *CreateBlockIndex(active_chain_tip->nHeight + 1, active_chain_tip)));
465  }
466 
467  for (int i = 0; i < CBlockIndex::nMedianTimeSpan; ++i) {
468  CBlockIndex* ancestor{Assert(m_node.chainman->ActiveChain().Tip()->GetAncestor(m_node.chainman->ActiveChain().Tip()->nHeight - i))};
469  ancestor->nTime -= SEQUENCE_LOCK_TIME; // undo tricked MTP
470  }
471 
472  // absolute height locked
473  tx.vin[0].prevout.hash = txFirst[2]->GetHash();
474  tx.vin[0].nSequence = CTxIn::MAX_SEQUENCE_NONFINAL;
475  prevheights[0] = baseheight + 3;
476  tx.nLockTime = m_node.chainman->ActiveChain().Tip()->nHeight + 1;
477  hash = tx.GetHash();
478  tx_mempool.addUnchecked(entry.Time(Now<NodeSeconds>()).FromTx(tx));
479  BOOST_CHECK(!CheckFinalTxAtTip(*Assert(m_node.chainman->ActiveChain().Tip()), CTransaction{tx})); // Locktime fails
480  BOOST_CHECK(TestSequenceLocks(CTransaction{tx}, tx_mempool)); // Sequence locks pass
481  BOOST_CHECK(IsFinalTx(CTransaction(tx), m_node.chainman->ActiveChain().Tip()->nHeight + 2, m_node.chainman->ActiveChain().Tip()->GetMedianTimePast())); // Locktime passes on 2nd block
482 
483  // absolute time locked
484  tx.vin[0].prevout.hash = txFirst[3]->GetHash();
485  tx.nLockTime = m_node.chainman->ActiveChain().Tip()->GetMedianTimePast();
486  prevheights.resize(1);
487  prevheights[0] = baseheight + 4;
488  hash = tx.GetHash();
489  tx_mempool.addUnchecked(entry.Time(Now<NodeSeconds>()).FromTx(tx));
490  BOOST_CHECK(!CheckFinalTxAtTip(*Assert(m_node.chainman->ActiveChain().Tip()), CTransaction{tx})); // Locktime fails
491  BOOST_CHECK(TestSequenceLocks(CTransaction{tx}, tx_mempool)); // Sequence locks pass
492  BOOST_CHECK(IsFinalTx(CTransaction(tx), m_node.chainman->ActiveChain().Tip()->nHeight + 2, m_node.chainman->ActiveChain().Tip()->GetMedianTimePast() + 1)); // Locktime passes 1 second later
493 
494  // mempool-dependent transactions (not added)
495  tx.vin[0].prevout.hash = hash;
496  prevheights[0] = m_node.chainman->ActiveChain().Tip()->nHeight + 1;
497  tx.nLockTime = 0;
498  tx.vin[0].nSequence = 0;
499  BOOST_CHECK(CheckFinalTxAtTip(*Assert(m_node.chainman->ActiveChain().Tip()), CTransaction{tx})); // Locktime passes
500  BOOST_CHECK(TestSequenceLocks(CTransaction{tx}, tx_mempool)); // Sequence locks pass
501  tx.vin[0].nSequence = 1;
502  BOOST_CHECK(!TestSequenceLocks(CTransaction{tx}, tx_mempool)); // Sequence locks fail
503  tx.vin[0].nSequence = CTxIn::SEQUENCE_LOCKTIME_TYPE_FLAG;
504  BOOST_CHECK(TestSequenceLocks(CTransaction{tx}, tx_mempool)); // Sequence locks pass
505  tx.vin[0].nSequence = CTxIn::SEQUENCE_LOCKTIME_TYPE_FLAG | 1;
506  BOOST_CHECK(!TestSequenceLocks(CTransaction{tx}, tx_mempool)); // Sequence locks fail
507 
508  auto pblocktemplate = AssemblerForTest(tx_mempool).CreateNewBlock(scriptPubKey);
509  BOOST_CHECK(pblocktemplate);
510 
511  // None of the of the absolute height/time locked tx should have made
512  // it into the template because we still check IsFinalTx in CreateNewBlock,
513  // but relative locked txs will if inconsistently added to mempool.
514  // For now these will still generate a valid template until BIP68 soft fork
515  BOOST_CHECK_EQUAL(pblocktemplate->block.vtx.size(), 3U);
516  // However if we advance height by 1 and time by SEQUENCE_LOCK_TIME, all of them should be mined
517  for (int i = 0; i < CBlockIndex::nMedianTimeSpan; ++i) {
518  CBlockIndex* ancestor{Assert(m_node.chainman->ActiveChain().Tip()->GetAncestor(m_node.chainman->ActiveChain().Tip()->nHeight - i))};
519  ancestor->nTime += SEQUENCE_LOCK_TIME; // Trick the MedianTimePast
520  }
521  m_node.chainman->ActiveChain().Tip()->nHeight++;
522  SetMockTime(m_node.chainman->ActiveChain().Tip()->GetMedianTimePast() + 1);
523 
524  BOOST_CHECK(pblocktemplate = AssemblerForTest(tx_mempool).CreateNewBlock(scriptPubKey));
525  BOOST_CHECK_EQUAL(pblocktemplate->block.vtx.size(), 5U);
526 }
527 
528 void MinerTestingSetup::TestPrioritisedMining(const CScript& scriptPubKey, const std::vector<CTransactionRef>& txFirst)
529 {
530  CTxMemPool& tx_mempool{MakeMempool()};
531  LOCK(tx_mempool.cs);
532 
534 
535  // Test that a tx below min fee but prioritised is included
537  tx.vin.resize(1);
538  tx.vin[0].prevout.hash = txFirst[0]->GetHash();
539  tx.vin[0].prevout.n = 0;
540  tx.vin[0].scriptSig = CScript() << OP_1;
541  tx.vout.resize(1);
542  tx.vout[0].nValue = 5000000000LL; // 0 fee
543  uint256 hashFreePrioritisedTx = tx.GetHash();
544  tx_mempool.addUnchecked(entry.Fee(0).Time(Now<NodeSeconds>()).SpendsCoinbase(true).FromTx(tx));
545  tx_mempool.PrioritiseTransaction(hashFreePrioritisedTx, 5 * COIN);
546 
547  tx.vin[0].prevout.hash = txFirst[1]->GetHash();
548  tx.vin[0].prevout.n = 0;
549  tx.vout[0].nValue = 5000000000LL - 1000;
550  // This tx has a low fee: 1000 satoshis
551  Txid hashParentTx = tx.GetHash(); // save this txid for later use
552  tx_mempool.addUnchecked(entry.Fee(1000).Time(Now<NodeSeconds>()).SpendsCoinbase(true).FromTx(tx));
553 
554  // This tx has a medium fee: 10000 satoshis
555  tx.vin[0].prevout.hash = txFirst[2]->GetHash();
556  tx.vout[0].nValue = 5000000000LL - 10000;
557  Txid hashMediumFeeTx = tx.GetHash();
558  tx_mempool.addUnchecked(entry.Fee(10000).Time(Now<NodeSeconds>()).SpendsCoinbase(true).FromTx(tx));
559  tx_mempool.PrioritiseTransaction(hashMediumFeeTx, -5 * COIN);
560 
561  // This tx also has a low fee, but is prioritised
562  tx.vin[0].prevout.hash = hashParentTx;
563  tx.vout[0].nValue = 5000000000LL - 1000 - 1000; // 1000 satoshi fee
564  Txid hashPrioritsedChild = tx.GetHash();
565  tx_mempool.addUnchecked(entry.Fee(1000).Time(Now<NodeSeconds>()).SpendsCoinbase(false).FromTx(tx));
566  tx_mempool.PrioritiseTransaction(hashPrioritsedChild, 2 * COIN);
567 
568  // Test that transaction selection properly updates ancestor fee calculations as prioritised
569  // parents get included in a block. Create a transaction with two prioritised ancestors, each
570  // included by itself: FreeParent <- FreeChild <- FreeGrandchild.
571  // When FreeParent is added, a modified entry will be created for FreeChild + FreeGrandchild
572  // FreeParent's prioritisation should not be included in that entry.
573  // When FreeChild is included, FreeChild's prioritisation should also not be included.
574  tx.vin[0].prevout.hash = txFirst[3]->GetHash();
575  tx.vout[0].nValue = 5000000000LL; // 0 fee
576  Txid hashFreeParent = tx.GetHash();
577  tx_mempool.addUnchecked(entry.Fee(0).SpendsCoinbase(true).FromTx(tx));
578  tx_mempool.PrioritiseTransaction(hashFreeParent, 10 * COIN);
579 
580  tx.vin[0].prevout.hash = hashFreeParent;
581  tx.vout[0].nValue = 5000000000LL; // 0 fee
582  Txid hashFreeChild = tx.GetHash();
583  tx_mempool.addUnchecked(entry.Fee(0).SpendsCoinbase(false).FromTx(tx));
584  tx_mempool.PrioritiseTransaction(hashFreeChild, 1 * COIN);
585 
586  tx.vin[0].prevout.hash = hashFreeChild;
587  tx.vout[0].nValue = 5000000000LL; // 0 fee
588  Txid hashFreeGrandchild = tx.GetHash();
589  tx_mempool.addUnchecked(entry.Fee(0).SpendsCoinbase(false).FromTx(tx));
590 
591  auto pblocktemplate = AssemblerForTest(tx_mempool).CreateNewBlock(scriptPubKey);
592  BOOST_REQUIRE_EQUAL(pblocktemplate->block.vtx.size(), 6U);
593  BOOST_CHECK(pblocktemplate->block.vtx[1]->GetHash() == hashFreeParent);
594  BOOST_CHECK(pblocktemplate->block.vtx[2]->GetHash() == hashFreePrioritisedTx);
595  BOOST_CHECK(pblocktemplate->block.vtx[3]->GetHash() == hashParentTx);
596  BOOST_CHECK(pblocktemplate->block.vtx[4]->GetHash() == hashPrioritsedChild);
597  BOOST_CHECK(pblocktemplate->block.vtx[5]->GetHash() == hashFreeChild);
598  for (size_t i=0; i<pblocktemplate->block.vtx.size(); ++i) {
599  // The FreeParent and FreeChild's prioritisations should not impact the child.
600  BOOST_CHECK(pblocktemplate->block.vtx[i]->GetHash() != hashFreeGrandchild);
601  // De-prioritised transaction should not be included.
602  BOOST_CHECK(pblocktemplate->block.vtx[i]->GetHash() != hashMediumFeeTx);
603  }
604 }
605 
606 // NOTE: These tests rely on CreateNewBlock doing its own self-validation!
607 BOOST_AUTO_TEST_CASE(CreateNewBlock_validity)
608 {
609  // Note that by default, these tests run with size accounting enabled.
610  CScript scriptPubKey = CScript() << ParseHex("04678afdb0fe5548271967f1a67130b7105cd6a828e03909a67962e0ea1f61deb649f6bc3f4cef38c4f35504e51ec112de5c384df7ba0b8d578a4c702b6bf11d5f") << OP_CHECKSIG;
611  std::unique_ptr<CBlockTemplate> pblocktemplate;
612 
613  CTxMemPool& tx_mempool{*m_node.mempool};
614  // Simple block creation, nothing special yet:
615  BOOST_CHECK(pblocktemplate = AssemblerForTest(tx_mempool).CreateNewBlock(scriptPubKey));
616 
617  // We can't make transactions until we have inputs
618  // Therefore, load 110 blocks :)
619  static_assert(std::size(BLOCKINFO) == 110, "Should have 110 blocks to import");
620  int baseheight = 0;
621  std::vector<CTransactionRef> txFirst;
622  for (const auto& bi : BLOCKINFO) {
623  CBlock *pblock = &pblocktemplate->block; // pointer for convenience
624  {
625  LOCK(cs_main);
626  pblock->nVersion = VERSIONBITS_TOP_BITS;
627  pblock->nTime = m_node.chainman->ActiveChain().Tip()->GetMedianTimePast()+1;
628  CMutableTransaction txCoinbase(*pblock->vtx[0]);
629  txCoinbase.version = 1;
630  txCoinbase.vin[0].scriptSig = CScript{} << (m_node.chainman->ActiveChain().Height() + 1) << bi.extranonce;
631  txCoinbase.vout.resize(1); // Ignore the (optional) segwit commitment added by CreateNewBlock (as the hardcoded nonces don't account for this)
632  txCoinbase.vout[0].scriptPubKey = CScript();
633  pblock->vtx[0] = MakeTransactionRef(std::move(txCoinbase));
634  if (txFirst.size() == 0)
635  baseheight = m_node.chainman->ActiveChain().Height();
636  if (txFirst.size() < 4)
637  txFirst.push_back(pblock->vtx[0]);
638  pblock->hashMerkleRoot = BlockMerkleRoot(*pblock);
639  pblock->nNonce = bi.nonce;
640  }
641  std::shared_ptr<const CBlock> shared_pblock = std::make_shared<const CBlock>(*pblock);
642  BOOST_CHECK(Assert(m_node.chainman)->ProcessNewBlock(shared_pblock, true, true, nullptr));
643  pblock->hashPrevBlock = pblock->GetHash();
644  }
645 
646  LOCK(cs_main);
647 
648  TestBasicMining(scriptPubKey, txFirst, baseheight);
649 
650  m_node.chainman->ActiveChain().Tip()->nHeight--;
651  SetMockTime(0);
652 
653  TestPackageSelection(scriptPubKey, txFirst);
654 
655  m_node.chainman->ActiveChain().Tip()->nHeight--;
656  SetMockTime(0);
657 
658  TestPrioritisedMining(scriptPubKey, txFirst);
659 }
660 
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
node::NodeContext m_node
Definition: bitcoin-gui.cpp:37
int flags
Definition: bitcoin-tx.cpp:533
#define Assert(val)
Identity function.
Definition: check.h:77
uint32_t nNonce
Definition: block.h:30
uint32_t nTime
Definition: block.h:28
int32_t nVersion
Definition: block.h:25
uint256 hashPrevBlock
Definition: block.h:26
uint256 hashMerkleRoot
Definition: block.h:27
uint256 GetHash() const
Definition: block.cpp:11
Definition: block.h:69
std::vector< CTransactionRef > vtx
Definition: block.h:72
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:125
uint256 GetBlockHash() const
Definition: chain.h:244
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:277
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:836
Fee rate in satoshis per kilovirtualbyte: CAmount / kvB.
Definition: feerate.h:33
CAmount GetFee(uint32_t num_bytes) const
Return the fee in satoshis for the given vsize in vbytes.
Definition: feerate.cpp:23
Serialized script, used inside transaction inputs and outputs.
Definition: script.h:414
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:304
BOOST_CHECK_EXCEPTION predicates to check the specific validation error.
Definition: setup_common.h:246
Generate a new block, without valid proof-of-work.
Definition: miner.h:135
256-bit opaque blob.
Definition: uint256.h:106
static constexpr unsigned int LOCKTIME_VERIFY_SEQUENCE
Flags for nSequence and nLockTime locks.
Definition: consensus.h:28
static const unsigned int MAX_BLOCK_WEIGHT
The maximum allowed weight for a block, see BIP 141 (network rule)
Definition: consensus.h:15
RecursiveMutex cs_main
Mutex to guard access to validation specific variables, such as reading or changing the chainstate.
Definition: cs_main.cpp:8
BOOST_AUTO_TEST_SUITE_END()
unsigned int nHeight
bool spendsCoinbase
@ REPLACED
Removed for replacement.
uint256 BlockMerkleRoot(const CBlock &block, bool *mutated)
Definition: merkle.cpp:65
BOOST_AUTO_TEST_CASE(CreateNewBlock_validity)
static std::unique_ptr< CBlockIndex > CreateBlockIndex(int nHeight, CBlockIndex *active_chain_tip) EXCLUSIVE_LOCKS_REQUIRED(cs_main)
Definition: miner_tests.cpp:96
constexpr static struct @13 BLOCKINFO[]
static CFeeRate blockMinFeeRate
Definition: miner_tests.cpp:62
unsigned char extranonce
Definition: miner_tests.cpp:74
unsigned int nonce
Definition: miner_tests.cpp:75
#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:25
static constexpr TransactionSerParams TX_WITH_WITNESS
Definition: transaction.h:195
static CTransactionRef MakeTransactionRef(Tx &&txIn)
Definition: transaction.h:424
@ OP_2
Definition: script.h:84
@ OP_CHECKMULTISIG
Definition: script.h:191
@ OP_CHECKSIG
Definition: script.h:189
@ OP_NOP
Definition: script.h:101
@ OP_1
Definition: script.h:82
@ OP_DROP
Definition: script.h:123
@ OP_0
Definition: script.h:75
size_t GetSerializeSize(const T &t)
Definition: serialize.h:1101
static constexpr CAmount CENT
Definition: setup_common.h:49
std::vector< Byte > ParseHex(std::string_view hex_str)
Like TryParseHex, but returns an empty vector on invalid input.
Definition: strencodings.h:66
node::NodeContext m_node
Definition: setup_common.h:56
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
Definition: txmempool.h:19
TestMemPoolEntryHelper & SpendsCoinbase(bool _flag)
Definition: txmempool.h:37
CAmount nFee
Definition: txmempool.h:21
TestMemPoolEntryHelper & SigOpsCost(unsigned int _sigopsCost)
Definition: txmempool.h:38
CTxMemPoolEntry FromTx(const CMutableTransaction &tx) const
Definition: txmempool.cpp:33
unsigned int nHeight
Definition: txmempool.h:23
TestMemPoolEntryHelper & Time(NodeSeconds tp)
Definition: txmempool.h:34
TestMemPoolEntryHelper & Fee(CAmount _fee)
Definition: txmempool.h:33
Testing setup that configures a complete environment.
Definition: setup_common.h:85
Bilingual messages:
Definition: translation.h:18
bool empty() const
Definition: translation.h:29
BlockAssembler AssemblerForTest(CTxMemPool &tx_mempool)
Definition: miner_tests.cpp:64
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:38
std::unique_ptr< CTxMemPool > mempool
Definition: context.h:65
std::unique_ptr< ChainstateManager > chainman
Definition: context.h:69
#define LOCK(cs)
Definition: sync.h:257
static uint256 InsecureRand256()
Definition: random.h:35
CTxMemPool::Options MemPoolOptionsForTest(const NodeContext &node)
Definition: txmempool.cpp:20
#define EXCLUSIVE_LOCKS_REQUIRED(...)
Definition: threadsafety.h:49
void SetMockTime(int64_t nMockTimeIn)
DEPRECATED Use SetMockTime with chrono type.
Definition: time.cpp:32
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
bool CheckFinalTxAtTip(const CBlockIndex &active_chain_tip, const CTransaction &tx)
Definition: validation.cpp:141
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:244
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:314
static const int32_t VERSIONBITS_TOP_BITS
What bits to set in version for versionbits blocks.
Definition: versionbits.h:16