Branch data Line data Source code
1 : : // Copyright (c) 2019-present 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 <test/util/mining.h>
6 : :
7 : : #include <addresstype.h>
8 : : #include <chain.h>
9 : : #include <chainparams.h>
10 : : #include <consensus/merkle.h>
11 : : #include <consensus/validation.h>
12 : : #include <interfaces/mining.h>
13 : : #include <key_io.h>
14 : : #include <node/context.h>
15 : : #include <pow.h>
16 : : #include <primitives/block.h>
17 : : #include <primitives/transaction.h>
18 : : #include <script/script.h>
19 : : #include <sync.h>
20 : : #include <test/util/script.h>
21 : : #include <uint256.h>
22 : : #include <util/check.h>
23 : : #include <validation.h>
24 : : #include <validationinterface.h>
25 : : #include <versionbits.h>
26 : :
27 : : #include <cstdint>
28 : : #include <memory>
29 : : #include <optional>
30 : : #include <utility>
31 : :
32 : : using node::NodeContext;
33 : :
34 : 0 : COutPoint generatetoaddress(const NodeContext& node, const std::string& address)
35 : : {
36 : 0 : const auto dest = DecodeDestination(address);
37 [ # # # # ]: 0 : assert(IsValidDestination(dest));
38 [ # # ]: 0 : return MineBlock(node, {
39 : : .coinbase_output_script = GetScriptForDestination(dest),
40 : 0 : });
41 [ # # ]: 0 : }
42 : :
43 : 2 : std::vector<std::shared_ptr<CBlock>> CreateBlockChain(size_t total_height, const CChainParams& params)
44 : : {
45 : 2 : std::vector<std::shared_ptr<CBlock>> ret{total_height};
46 : 2 : auto time{params.GenesisBlock().nTime};
47 : : // NOTE: here `height` does not correspond to the block height but the block height - 1.
48 [ + + ]: 402 : for (size_t height{0}; height < total_height; ++height) {
49 [ + - - + ]: 800 : CBlock& block{*(ret.at(height) = std::make_shared<CBlock>())};
50 : :
51 [ + - ]: 400 : CMutableTransaction coinbase_tx;
52 : 400 : coinbase_tx.nLockTime = static_cast<uint32_t>(height);
53 [ + - ]: 400 : coinbase_tx.vin.resize(1);
54 : 400 : coinbase_tx.vin[0].prevout.SetNull();
55 [ + - ]: 400 : coinbase_tx.vin[0].nSequence = CTxIn::MAX_SEQUENCE_NONFINAL; // Make sure timelock is enforced.
56 [ + - ]: 400 : coinbase_tx.vout.resize(1);
57 : 400 : coinbase_tx.vout[0].scriptPubKey = P2WSH_OP_TRUE;
58 [ + - + - ]: 400 : coinbase_tx.vout[0].nValue = GetBlockSubsidy(height + 1, params.GetConsensus());
59 : : // Always include OP_0 as a dummy extraNonce.
60 [ + - + - ]: 400 : coinbase_tx.vin[0].scriptSig = CScript() << (height + 1) << OP_0;
61 [ + + + - : 800 : block.vtx = {MakeTransactionRef(std::move(coinbase_tx))};
- - - - ]
62 : :
63 : 400 : block.nVersion = VERSIONBITS_LAST_OLD_BLOCK_VERSION;
64 [ + + + - : 400 : block.hashPrevBlock = (height >= 1 ? *ret.at(height - 1) : params.GenesisBlock()).GetHash();
+ - ]
65 [ + - ]: 400 : block.hashMerkleRoot = BlockMerkleRoot(block);
66 : 400 : block.nTime = ++time;
67 : 400 : block.nBits = params.GenesisBlock().nBits;
68 : 400 : block.nNonce = 0;
69 : :
70 [ + - + - : 762 : while (!CheckProofOfWork(block.GetHash(), block.nBits, params.GetConsensus())) {
+ + ]
71 : 362 : ++block.nNonce;
72 [ - + ]: 362 : assert(block.nNonce);
73 : : }
74 : 400 : }
75 : 2 : return ret;
76 [ + - + - ]: 800 : }
77 : :
78 : 0 : bool BuildChain(const NodeContext& node, const CBlockIndex* pindex,
79 : : const CScript& coinbase_script_pub_key,
80 : : size_t length,
81 : : std::vector<std::shared_ptr<CBlock>>& chain)
82 : : {
83 : 0 : auto mining{interfaces::MakeMining(node)};
84 [ # # # # ]: 0 : const Consensus::Params& consensus{Assert(node.chainman)->GetConsensus()};
85 : :
86 [ # # ]: 0 : chain.resize(length);
87 [ # # ]: 0 : for (auto& chain_block : chain) {
88 : 0 : auto block_template{mining->createNewBlock({
89 : : .use_mempool = false,
90 : : .coinbase_output_script = coinbase_script_pub_key,
91 : 0 : }, /*cooldown=*/false)};
92 [ # # # # ]: 0 : CBlock block{Assert(block_template)->getBlock()};
93 : :
94 : : // The template is built on the active tip, so repoint it at pindex and
95 : : // redo the fields that depend on the predecessor.
96 : 0 : block.hashPrevBlock = pindex->GetBlockHash();
97 : 0 : block.nTime = pindex->nTime + 1;
98 : 0 : {
99 [ # # # # ]: 0 : CMutableTransaction tx_coinbase{*block.vtx.at(0)};
100 : 0 : tx_coinbase.nLockTime = static_cast<uint32_t>(pindex->nHeight);
101 [ # # # # ]: 0 : tx_coinbase.vin.at(0).scriptSig = CScript{} << pindex->nHeight + 1;
102 [ # # # # : 0 : block.vtx.at(0) = MakeTransactionRef(std::move(tx_coinbase));
# # ]
103 [ # # ]: 0 : block.hashMerkleRoot = BlockMerkleRoot(block);
104 : 0 : }
105 : :
106 [ # # # # : 0 : while (!CheckProofOfWork(block.GetHash(), block.nBits, consensus)) ++block.nNonce;
# # ]
107 : :
108 [ # # # # ]: 0 : chain_block = std::make_shared<CBlock>(std::move(block));
109 : :
110 [ # # ]: 0 : BlockValidationState state;
111 [ # # # # : 0 : if (!Assert(node.chainman)->ProcessNewBlockHeaders({{*chain_block}}, true, state, &pindex)) {
# # ]
112 : 0 : return false;
113 : : }
114 : 0 : }
115 : :
116 : : return true;
117 [ # # ]: 0 : }
118 : :
119 : 247601 : COutPoint MineBlock(const NodeContext& node, const node::BlockCreateOptions& assembler_options)
120 : : {
121 : 247601 : auto block = PrepareBlock(node, assembler_options);
122 [ + - ]: 247601 : auto valid = MineBlock(node, block);
123 [ - + ]: 247601 : assert(!valid.IsNull());
124 [ + - ]: 247601 : return valid;
125 : 247601 : }
126 : :
127 : : struct BlockValidationStateCatcher : public CValidationInterface {
128 : : const uint256 m_hash;
129 : : std::optional<BlockValidationState> m_state;
130 : :
131 : 374293 : BlockValidationStateCatcher(const uint256& hash)
132 : 374293 : : m_hash{hash},
133 : 374293 : m_state{} {}
134 : :
135 : : protected:
136 : 374293 : void BlockChecked(const std::shared_ptr<const CBlock>& block, const BlockValidationState& state) override
137 : : {
138 [ + - ]: 374293 : if (block->GetHash() != m_hash) return;
139 : 374293 : m_state = state;
140 : : }
141 : : };
142 : :
143 : 373893 : COutPoint MineBlock(const NodeContext& node, std::shared_ptr<CBlock>& block)
144 : : {
145 [ + + ]: 702588 : while (!CheckProofOfWork(block->GetHash(), block->nBits, Params().GetConsensus())) {
146 [ - + ]: 328695 : ++block->nNonce;
147 [ - + ]: 328695 : assert(block->nNonce);
148 : : }
149 : :
150 : 373893 : return ProcessBlock(node, block);
151 : : }
152 : :
153 : 374293 : COutPoint ProcessBlock(const NodeContext& node, const std::shared_ptr<CBlock>& block)
154 : : {
155 [ - + ]: 374293 : auto& chainman{*Assert(node.chainman)};
156 [ + - + - ]: 1122879 : const auto old_height = WITH_LOCK(chainman.GetMutex(), return chainman.ActiveHeight());
157 : 374293 : bool new_block;
158 [ + - ]: 374293 : BlockValidationStateCatcher bvsc{block->GetHash()};
159 [ + - ]: 374293 : node.validation_signals->RegisterValidationInterface(&bvsc);
160 [ + - + - : 748586 : const bool processed{chainman.ProcessNewBlock(block, true, true, &new_block)};
+ - ]
161 [ + + - + ]: 374293 : const bool duplicate{!new_block && processed};
162 : 0 : assert(!duplicate);
163 [ + - ]: 374293 : node.validation_signals->UnregisterValidationInterface(&bvsc);
164 [ + - ]: 374293 : node.validation_signals->SyncWithValidationInterfaceQueue();
165 [ + - + + ]: 374293 : const bool was_valid{bvsc.m_state && bvsc.m_state->IsValid()};
166 [ + - - + : 1122879 : assert(old_height + was_valid == WITH_LOCK(chainman.GetMutex(), return chainman.ActiveHeight()));
+ - + - ]
167 : :
168 [ + + ]: 374293 : if (was_valid) return {block->vtx[0]->GetHash(), 0};
169 : 31860 : return {};
170 : 374293 : }
171 : :
172 : 376645 : std::shared_ptr<CBlock> PrepareBlock(const NodeContext& node,
173 : : const node::BlockCreateOptions& assembler_options)
174 : : {
175 : 376645 : auto mining = interfaces::MakeMining(node);
176 [ + - ]: 376645 : auto block_template = mining->createNewBlock(assembler_options, /*cooldown=*/false);
177 [ - + + - ]: 753290 : auto block = std::make_shared<CBlock>(Assert(block_template)->getBlock());
178 : :
179 [ + - ]: 376645 : LOCK(cs_main);
180 [ - + + - : 753290 : block->nTime = Assert(node.chainman)->ActiveChain().Tip()->GetMedianTimePast() + 1;
- + + - ]
181 [ + - ]: 376645 : block->hashMerkleRoot = BlockMerkleRoot(*block);
182 : :
183 [ + - ]: 753290 : return block;
184 : 376645 : }
|
