Bitcoin Core  22.99.0
P2P Digital Currency
validation_block_tests.cpp
Go to the documentation of this file.
1 // Copyright (c) 2018-2021 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 <boost/test/unit_test.hpp>
6 
7 #include <chainparams.h>
8 #include <consensus/merkle.h>
9 #include <consensus/validation.h>
10 #include <node/miner.h>
11 #include <pow.h>
12 #include <random.h>
13 #include <script/standard.h>
14 #include <test/util/script.h>
15 #include <test/util/setup_common.h>
16 #include <util/time.h>
17 #include <validation.h>
18 #include <validationinterface.h>
19 
20 #include <thread>
21 
23 
26  std::shared_ptr<CBlock> Block(const uint256& prev_hash);
27  std::shared_ptr<const CBlock> GoodBlock(const uint256& prev_hash);
28  std::shared_ptr<const CBlock> BadBlock(const uint256& prev_hash);
29  std::shared_ptr<CBlock> FinalizeBlock(std::shared_ptr<CBlock> pblock);
30  void BuildChain(const uint256& root, int height, const unsigned int invalid_rate, const unsigned int branch_rate, const unsigned int max_size, std::vector<std::shared_ptr<const CBlock>>& blocks);
31 };
32 } // namespace validation_block_tests
33 
35 
36 struct TestSubscriber final : public CValidationInterface {
38 
39  explicit TestSubscriber(uint256 tip) : m_expected_tip(tip) {}
40 
41  void UpdatedBlockTip(const CBlockIndex* pindexNew, const CBlockIndex* pindexFork, bool fInitialDownload) override
42  {
43  BOOST_CHECK_EQUAL(m_expected_tip, pindexNew->GetBlockHash());
44  }
45 
46  void BlockConnected(const std::shared_ptr<const CBlock>& block, const CBlockIndex* pindex) override
47  {
48  BOOST_CHECK_EQUAL(m_expected_tip, block->hashPrevBlock);
49  BOOST_CHECK_EQUAL(m_expected_tip, pindex->pprev->GetBlockHash());
50 
51  m_expected_tip = block->GetHash();
52  }
53 
54  void BlockDisconnected(const std::shared_ptr<const CBlock>& block, const CBlockIndex* pindex) override
55  {
56  BOOST_CHECK_EQUAL(m_expected_tip, block->GetHash());
57  BOOST_CHECK_EQUAL(m_expected_tip, pindex->GetBlockHash());
58 
59  m_expected_tip = block->hashPrevBlock;
60  }
61 };
62 
63 std::shared_ptr<CBlock> MinerTestingSetup::Block(const uint256& prev_hash)
64 {
65  static int i = 0;
66  static uint64_t time = Params().GenesisBlock().nTime;
67 
68  auto ptemplate = BlockAssembler(m_node.chainman->ActiveChainstate(), *m_node.mempool, Params()).CreateNewBlock(CScript{} << i++ << OP_TRUE);
69  auto pblock = std::make_shared<CBlock>(ptemplate->block);
70  pblock->hashPrevBlock = prev_hash;
71  pblock->nTime = ++time;
72 
73  // Make the coinbase transaction with two outputs:
74  // One zero-value one that has a unique pubkey to make sure that blocks at the same height can have a different hash
75  // Another one that has the coinbase reward in a P2WSH with OP_TRUE as witness program to make it easy to spend
76  CMutableTransaction txCoinbase(*pblock->vtx[0]);
77  txCoinbase.vout.resize(2);
78  txCoinbase.vout[1].scriptPubKey = P2WSH_OP_TRUE;
79  txCoinbase.vout[1].nValue = txCoinbase.vout[0].nValue;
80  txCoinbase.vout[0].nValue = 0;
81  txCoinbase.vin[0].scriptWitness.SetNull();
82  // Always pad with OP_0 at the end to avoid bad-cb-length error
83  txCoinbase.vin[0].scriptSig = CScript{} << WITH_LOCK(::cs_main, return m_node.chainman->m_blockman.LookupBlockIndex(prev_hash)->nHeight + 1) << OP_0;
84  pblock->vtx[0] = MakeTransactionRef(std::move(txCoinbase));
85 
86  return pblock;
87 }
88 
89 std::shared_ptr<CBlock> MinerTestingSetup::FinalizeBlock(std::shared_ptr<CBlock> pblock)
90 {
91  const CBlockIndex* prev_block{WITH_LOCK(::cs_main, return m_node.chainman->m_blockman.LookupBlockIndex(pblock->hashPrevBlock))};
92  GenerateCoinbaseCommitment(*pblock, prev_block, Params().GetConsensus());
93 
94  pblock->hashMerkleRoot = BlockMerkleRoot(*pblock);
95 
96  while (!CheckProofOfWork(pblock->GetHash(), pblock->nBits, Params().GetConsensus())) {
97  ++(pblock->nNonce);
98  }
99 
100  // submit block header, so that miner can get the block height from the
101  // global state and the node has the topology of the chain
102  BlockValidationState ignored;
103  BOOST_CHECK(Assert(m_node.chainman)->ProcessNewBlockHeaders({pblock->GetBlockHeader()}, ignored, Params()));
104 
105  return pblock;
106 }
107 
108 // construct a valid block
109 std::shared_ptr<const CBlock> MinerTestingSetup::GoodBlock(const uint256& prev_hash)
110 {
111  return FinalizeBlock(Block(prev_hash));
112 }
113 
114 // construct an invalid block (but with a valid header)
115 std::shared_ptr<const CBlock> MinerTestingSetup::BadBlock(const uint256& prev_hash)
116 {
117  auto pblock = Block(prev_hash);
118 
119  CMutableTransaction coinbase_spend;
120  coinbase_spend.vin.push_back(CTxIn(COutPoint(pblock->vtx[0]->GetHash(), 0), CScript(), 0));
121  coinbase_spend.vout.push_back(pblock->vtx[0]->vout[0]);
122 
123  CTransactionRef tx = MakeTransactionRef(coinbase_spend);
124  pblock->vtx.push_back(tx);
125 
126  auto ret = FinalizeBlock(pblock);
127  return ret;
128 }
129 
130 void MinerTestingSetup::BuildChain(const uint256& root, int height, const unsigned int invalid_rate, const unsigned int branch_rate, const unsigned int max_size, std::vector<std::shared_ptr<const CBlock>>& blocks)
131 {
132  if (height <= 0 || blocks.size() >= max_size) return;
133 
134  bool gen_invalid = InsecureRandRange(100) < invalid_rate;
135  bool gen_fork = InsecureRandRange(100) < branch_rate;
136 
137  const std::shared_ptr<const CBlock> pblock = gen_invalid ? BadBlock(root) : GoodBlock(root);
138  blocks.push_back(pblock);
139  if (!gen_invalid) {
140  BuildChain(pblock->GetHash(), height - 1, invalid_rate, branch_rate, max_size, blocks);
141  }
142 
143  if (gen_fork) {
144  blocks.push_back(GoodBlock(root));
145  BuildChain(blocks.back()->GetHash(), height - 1, invalid_rate, branch_rate, max_size, blocks);
146  }
147 }
148 
149 BOOST_AUTO_TEST_CASE(processnewblock_signals_ordering)
150 {
151  // build a large-ish chain that's likely to have some forks
152  std::vector<std::shared_ptr<const CBlock>> blocks;
153  while (blocks.size() < 50) {
154  blocks.clear();
155  BuildChain(Params().GenesisBlock().GetHash(), 100, 15, 10, 500, blocks);
156  }
157 
158  bool ignored;
159  // Connect the genesis block and drain any outstanding events
160  BOOST_CHECK(Assert(m_node.chainman)->ProcessNewBlock(Params(), std::make_shared<CBlock>(Params().GenesisBlock()), true, &ignored));
162 
163  // subscribe to events (this subscriber will validate event ordering)
164  const CBlockIndex* initial_tip = nullptr;
165  {
166  LOCK(cs_main);
167  initial_tip = m_node.chainman->ActiveChain().Tip();
168  }
169  auto sub = std::make_shared<TestSubscriber>(initial_tip->GetBlockHash());
171 
172  // create a bunch of threads that repeatedly process a block generated above at random
173  // this will create parallelism and randomness inside validation - the ValidationInterface
174  // will subscribe to events generated during block validation and assert on ordering invariance
175  std::vector<std::thread> threads;
176  for (int i = 0; i < 10; i++) {
177  threads.emplace_back([&]() {
178  bool ignored;
179  FastRandomContext insecure;
180  for (int i = 0; i < 1000; i++) {
181  auto block = blocks[insecure.randrange(blocks.size() - 1)];
182  Assert(m_node.chainman)->ProcessNewBlock(Params(), block, true, &ignored);
183  }
184 
185  // to make sure that eventually we process the full chain - do it here
186  for (auto block : blocks) {
187  if (block->vtx.size() == 1) {
188  bool processed = Assert(m_node.chainman)->ProcessNewBlock(Params(), block, true, &ignored);
189  assert(processed);
190  }
191  }
192  });
193  }
194 
195  for (auto& t : threads) {
196  t.join();
197  }
199 
201 
202  LOCK(cs_main);
203  BOOST_CHECK_EQUAL(sub->m_expected_tip, m_node.chainman->ActiveChain().Tip()->GetBlockHash());
204 }
205 
223 BOOST_AUTO_TEST_CASE(mempool_locks_reorg)
224 {
225  bool ignored;
226  auto ProcessBlock = [&](std::shared_ptr<const CBlock> block) -> bool {
227  return Assert(m_node.chainman)->ProcessNewBlock(Params(), block, /*force_processing=*/true, /*new_block=*/&ignored);
228  };
229 
230  // Process all mined blocks
231  BOOST_REQUIRE(ProcessBlock(std::make_shared<CBlock>(Params().GenesisBlock())));
232  auto last_mined = GoodBlock(Params().GenesisBlock().GetHash());
233  BOOST_REQUIRE(ProcessBlock(last_mined));
234 
235  // Run the test multiple times
236  for (int test_runs = 3; test_runs > 0; --test_runs) {
237  BOOST_CHECK_EQUAL(last_mined->GetHash(), m_node.chainman->ActiveChain().Tip()->GetBlockHash());
238 
239  // Later on split from here
240  const uint256 split_hash{last_mined->hashPrevBlock};
241 
242  // Create a bunch of transactions to spend the miner rewards of the
243  // most recent blocks
244  std::vector<CTransactionRef> txs;
245  for (int num_txs = 22; num_txs > 0; --num_txs) {
247  mtx.vin.push_back(CTxIn{COutPoint{last_mined->vtx[0]->GetHash(), 1}, CScript{}});
248  mtx.vin[0].scriptWitness.stack.push_back(WITNESS_STACK_ELEM_OP_TRUE);
249  mtx.vout.push_back(last_mined->vtx[0]->vout[1]);
250  mtx.vout[0].nValue -= 1000;
251  txs.push_back(MakeTransactionRef(mtx));
252 
253  last_mined = GoodBlock(last_mined->GetHash());
254  BOOST_REQUIRE(ProcessBlock(last_mined));
255  }
256 
257  // Mature the inputs of the txs
258  for (int j = COINBASE_MATURITY; j > 0; --j) {
259  last_mined = GoodBlock(last_mined->GetHash());
260  BOOST_REQUIRE(ProcessBlock(last_mined));
261  }
262 
263  // Mine a reorg (and hold it back) before adding the txs to the mempool
264  const uint256 tip_init{last_mined->GetHash()};
265 
266  std::vector<std::shared_ptr<const CBlock>> reorg;
267  last_mined = GoodBlock(split_hash);
268  reorg.push_back(last_mined);
269  for (size_t j = COINBASE_MATURITY + txs.size() + 1; j > 0; --j) {
270  last_mined = GoodBlock(last_mined->GetHash());
271  reorg.push_back(last_mined);
272  }
273 
274  // Add the txs to the tx pool
275  {
276  LOCK(cs_main);
277  for (const auto& tx : txs) {
278  const MempoolAcceptResult result = m_node.chainman->ProcessTransaction(tx);
279  BOOST_REQUIRE(result.m_result_type == MempoolAcceptResult::ResultType::VALID);
280  }
281  }
282 
283  // Check that all txs are in the pool
284  {
285  LOCK(m_node.mempool->cs);
286  BOOST_CHECK_EQUAL(m_node.mempool->mapTx.size(), txs.size());
287  }
288 
289  // Run a thread that simulates an RPC caller that is polling while
290  // validation is doing a reorg
291  std::thread rpc_thread{[&]() {
292  // This thread is checking that the mempool either contains all of
293  // the transactions invalidated by the reorg, or none of them, and
294  // not some intermediate amount.
295  while (true) {
296  LOCK(m_node.mempool->cs);
297  if (m_node.mempool->mapTx.size() == 0) {
298  // We are done with the reorg
299  break;
300  }
301  // Internally, we might be in the middle of the reorg, but
302  // externally the reorg to the most-proof-of-work chain should
303  // be atomic. So the caller assumes that the returned mempool
304  // is consistent. That is, it has all txs that were there
305  // before the reorg.
306  assert(m_node.mempool->mapTx.size() == txs.size());
307  continue;
308  }
309  LOCK(cs_main);
310  // We are done with the reorg, so the tip must have changed
311  assert(tip_init != m_node.chainman->ActiveChain().Tip()->GetBlockHash());
312  }};
313 
314  // Submit the reorg in this thread to invalidate and remove the txs from the tx pool
315  for (const auto& b : reorg) {
316  ProcessBlock(b);
317  }
318  // Check that the reorg was eventually successful
319  BOOST_CHECK_EQUAL(last_mined->GetHash(), m_node.chainman->ActiveChain().Tip()->GetBlockHash());
320 
321  // We can join the other thread, which returns when the reorg was successful
322  rpc_thread.join();
323  }
324 }
325 
326 BOOST_AUTO_TEST_CASE(witness_commitment_index)
327 {
328  CScript pubKey;
329  pubKey << 1 << OP_TRUE;
330  auto ptemplate = BlockAssembler(m_node.chainman->ActiveChainstate(), *m_node.mempool, Params()).CreateNewBlock(pubKey);
331  CBlock pblock = ptemplate->block;
332 
333  CTxOut witness;
335  witness.scriptPubKey[0] = OP_RETURN;
336  witness.scriptPubKey[1] = 0x24;
337  witness.scriptPubKey[2] = 0xaa;
338  witness.scriptPubKey[3] = 0x21;
339  witness.scriptPubKey[4] = 0xa9;
340  witness.scriptPubKey[5] = 0xed;
341 
342  // A witness larger than the minimum size is still valid
343  CTxOut min_plus_one = witness;
345 
346  CTxOut invalid = witness;
347  invalid.scriptPubKey[0] = OP_VERIFY;
348 
349  CMutableTransaction txCoinbase(*pblock.vtx[0]);
350  txCoinbase.vout.resize(4);
351  txCoinbase.vout[0] = witness;
352  txCoinbase.vout[1] = witness;
353  txCoinbase.vout[2] = min_plus_one;
354  txCoinbase.vout[3] = invalid;
355  pblock.vtx[0] = MakeTransactionRef(std::move(txCoinbase));
356 
358 }
CValidationInterface
Implement this to subscribe to events generated in validation.
Definition: validationinterface.h:78
CTxIn
An input of a transaction.
Definition: transaction.h:65
CMutableTransaction::vin
std::vector< CTxIn > vin
Definition: transaction.h:366
validation_block_tests::MinerTestingSetup
Definition: validation_block_tests.cpp:25
RegTestingSetup
Identical to TestingSetup, but chain set to regtest.
Definition: setup_common.h:112
TestSubscriber::m_expected_tip
uint256 m_expected_tip
Definition: validation_block_tests.cpp:37
RegisterSharedValidationInterface
void RegisterSharedValidationInterface(std::shared_ptr< CValidationInterface > callbacks)
Register subscriber.
Definition: validationinterface.cpp:121
assert
assert(!tx.IsCoinBase())
validation_block_tests
Definition: validation_block_tests.cpp:24
pow.h
COINBASE_MATURITY
static const int COINBASE_MATURITY
Coinbase transaction outputs can only be spent after this number of new blocks (network rule)
Definition: consensus.h:19
BlockValidationState
Definition: validation.h:141
setup_common.h
TestSubscriber::BlockConnected
void BlockConnected(const std::shared_ptr< const CBlock > &block, const CBlockIndex *pindex) override
Notifies listeners of a block being connected.
Definition: validation_block_tests.cpp:46
MempoolAcceptResult::m_result_type
const ResultType m_result_type
Result type.
Definition: validation.h:169
CBlockIndex::pprev
CBlockIndex * pprev
pointer to the index of the predecessor of this block
Definition: chain.h:158
InsecureRandRange
static uint64_t InsecureRandRange(uint64_t range)
Definition: setup_common.h:75
m_node
node::NodeContext m_node
Definition: bitcoin-gui.cpp:36
validationinterface.h
validation.h
WITH_LOCK
#define WITH_LOCK(cs, code)
Run code while locking a mutex.
Definition: sync.h:270
validation_block_tests::MinerTestingSetup::GoodBlock
std::shared_ptr< const CBlock > GoodBlock(const uint256 &prev_hash)
Definition: validation_block_tests.cpp:109
MakeTransactionRef
static CTransactionRef MakeTransactionRef(Tx &&txIn)
Definition: transaction.h:407
CheckProofOfWork
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:74
chainparams.h
CTransactionRef
std::shared_ptr< const CTransaction > CTransactionRef
Definition: transaction.h:406
BOOST_FIXTURE_TEST_SUITE
#define BOOST_FIXTURE_TEST_SUITE(a, b)
Definition: object.cpp:14
node::NodeContext::mempool
std::unique_ptr< CTxMemPool > mempool
Definition: context.h:45
TestSubscriber::UpdatedBlockTip
void UpdatedBlockTip(const CBlockIndex *pindexNew, const CBlockIndex *pindexFork, bool fInitialDownload) override
Notifies listeners when the block chain tip advances.
Definition: validation_block_tests.cpp:41
BOOST_AUTO_TEST_SUITE_END
BOOST_AUTO_TEST_SUITE_END()
Assert
#define Assert(val)
Identity function.
Definition: check.h:57
OP_VERIFY
@ OP_VERIFY
Definition: script.h:103
WITNESS_STACK_ELEM_OP_TRUE
static const std::vector< uint8_t > WITNESS_STACK_ELEM_OP_TRUE
Definition: script.h:11
SyncWithValidationInterfaceQueue
void SyncWithValidationInterfaceQueue()
This is a synonym for the following, which asserts certain locks are not held: std::promise<void> pro...
Definition: validationinterface.cpp:160
script.h
OP_0
@ OP_0
Definition: script.h:69
OP_RETURN
@ OP_RETURN
Definition: script.h:104
random.h
BOOST_AUTO_TEST_CASE
BOOST_AUTO_TEST_CASE(processnewblock_signals_ordering)
Definition: validation_block_tests.cpp:149
TestSubscriber::BlockDisconnected
void BlockDisconnected(const std::shared_ptr< const CBlock > &block, const CBlockIndex *pindex) override
Notifies listeners of a block being disconnected.
Definition: validation_block_tests.cpp:54
CTxOut
An output of a transaction.
Definition: transaction.h:148
CTxOut::scriptPubKey
CScript scriptPubKey
Definition: transaction.h:152
validation_block_tests::MinerTestingSetup::FinalizeBlock
std::shared_ptr< CBlock > FinalizeBlock(std::shared_ptr< CBlock > pblock)
Definition: validation_block_tests.cpp:89
miner.h
GenerateCoinbaseCommitment
std::vector< unsigned char > GenerateCoinbaseCommitment(CBlock &block, const CBlockIndex *pindexPrev, const Consensus::Params &consensusParams)
Produce the necessary coinbase commitment for a block (modifies the hash, don't call for mined blocks...
Definition: validation.cpp:3326
time.h
UnregisterSharedValidationInterface
void UnregisterSharedValidationInterface(std::shared_ptr< CValidationInterface > callbacks)
Unregister subscriber.
Definition: validationinterface.cpp:135
standard.h
node::BlockAssembler::CreateNewBlock
std::unique_ptr< CBlockTemplate > CreateNewBlock(const CScript &scriptPubKeyIn)
Construct a new block template with coinbase to scriptPubKeyIn.
Definition: miner.cpp:107
CBlockHeader::nTime
uint32_t nTime
Definition: block.h:27
MINIMUM_WITNESS_COMMITMENT
static constexpr size_t MINIMUM_WITNESS_COMMITMENT
Minimum size of a witness commitment structure.
Definition: validation.h:19
validation_block_tests::MinerTestingSetup::BadBlock
std::shared_ptr< const CBlock > BadBlock(const uint256 &prev_hash)
Definition: validation_block_tests.cpp:115
CChainParams::GenesisBlock
const CBlock & GenesisBlock() const
Definition: chainparams.h:95
uint256
256-bit opaque blob.
Definition: uint256.h:126
node::BlockAssembler
Generate a new block, without valid proof-of-work.
Definition: miner.h:128
GetWitnessCommitmentIndex
int GetWitnessCommitmentIndex(const CBlock &block)
Compute at which vout of the block's coinbase transaction the witness commitment occurs,...
Definition: validation.h:162
CScript
Serialized script, used inside transaction inputs and outputs.
Definition: script.h:405
CBlockIndex::GetBlockHash
uint256 GetBlockHash() const
Definition: chain.h:264
OP_TRUE
@ OP_TRUE
Definition: script.h:77
merkle.h
prevector::resize
void resize(size_type new_size)
Definition: prevector.h:316
validation_block_tests::MinerTestingSetup::Block
std::shared_ptr< CBlock > Block(const uint256 &prev_hash)
Definition: validation_block_tests.cpp:63
MempoolAcceptResult::ResultType::VALID
@ VALID
CBlock
Definition: block.h:62
CMutableTransaction::vout
std::vector< CTxOut > vout
Definition: transaction.h:367
CBlock::vtx
std::vector< CTransactionRef > vtx
Definition: block.h:66
LOCK
#define LOCK(cs)
Definition: sync.h:226
validation_block_tests::MinerTestingSetup::BuildChain
void BuildChain(const uint256 &root, int height, const unsigned int invalid_rate, const unsigned int branch_rate, const unsigned int max_size, std::vector< std::shared_ptr< const CBlock >> &blocks)
Definition: validation_block_tests.cpp:130
TestSubscriber::TestSubscriber
TestSubscriber(uint256 tip)
Definition: validation_block_tests.cpp:39
MempoolAcceptResult
Validation result for a single transaction mempool acceptance.
Definition: validation.h:160
Params
const CChainParams & Params()
Return the currently selected parameters.
Definition: chainparams.cpp:561
node::NodeContext::chainman
std::unique_ptr< ChainstateManager > chainman
Definition: context.h:48
FastRandomContext::randrange
uint64_t randrange(uint64_t range) noexcept
Generate a random integer in the range [0..range).
Definition: random.h:202
TestSubscriber
Definition: validation_block_tests.cpp:36
COutPoint
An outpoint - a combination of a transaction hash and an index n into its vout.
Definition: transaction.h:26
CMutableTransaction
A mutable version of CTransaction.
Definition: transaction.h:364
cs_main
RecursiveMutex cs_main
Mutex to guard access to validation specific variables, such as reading or changing the chainstate.
Definition: validation.cpp:138
CBlockIndex
The block chain is a tree shaped structure starting with the genesis block at the root,...
Definition: chain.h:151
FastRandomContext
Fast randomness source.
Definition: random.h:131
BOOST_CHECK
#define BOOST_CHECK(expr)
Definition: object.cpp:17
BOOST_CHECK_EQUAL
#define BOOST_CHECK_EQUAL(v1, v2)
Definition: object.cpp:18
ByteUnit::t
@ t
BlockMerkleRoot
uint256 BlockMerkleRoot(const CBlock &block, bool *mutated)
Definition: merkle.cpp:65
P2WSH_OP_TRUE
static const CScript P2WSH_OP_TRUE
Definition: script.h:12