mining.cpp raw
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 COutPoint generatetoaddress(const NodeContext& node, const std::string& address)
35 {
36 const auto dest = DecodeDestination(address);
37 assert(IsValidDestination(dest));
38 return MineBlock(node, {
39 .coinbase_output_script = GetScriptForDestination(dest),
40 });
41 }
42
43 std::vector<std::shared_ptr<CBlock>> CreateBlockChain(size_t total_height, const CChainParams& params)
44 {
45 std::vector<std::shared_ptr<CBlock>> ret{total_height};
46 auto time{params.GenesisBlock().nTime};
47 // NOTE: here `height` does not correspond to the block height but the block height - 1.
48 for (size_t height{0}; height < total_height; ++height) {
49 CBlock& block{*(ret.at(height) = std::make_shared<CBlock>())};
50
51 CMutableTransaction coinbase_tx;
52 coinbase_tx.nLockTime = static_cast<uint32_t>(height);
53 coinbase_tx.vin.resize(1);
54 coinbase_tx.vin[0].prevout.SetNull();
55 coinbase_tx.vin[0].nSequence = CTxIn::MAX_SEQUENCE_NONFINAL; // Make sure timelock is enforced.
56 coinbase_tx.vout.resize(1);
57 coinbase_tx.vout[0].scriptPubKey = P2WSH_OP_TRUE;
58 coinbase_tx.vout[0].nValue = GetBlockSubsidy(height + 1, params.GetConsensus());
59 // Always include OP_0 as a dummy extraNonce.
60 coinbase_tx.vin[0].scriptSig = CScript() << (height + 1) << OP_0;
61 block.vtx = {MakeTransactionRef(std::move(coinbase_tx))};
62
63 block.nVersion = VERSIONBITS_LAST_OLD_BLOCK_VERSION;
64 block.hashPrevBlock = (height >= 1 ? *ret.at(height - 1) : params.GenesisBlock()).GetHash();
65 block.hashMerkleRoot = BlockMerkleRoot(block);
66 block.nTime = ++time;
67 block.nBits = params.GenesisBlock().nBits;
68 block.nNonce = 0;
69
70 while (!CheckProofOfWork(block.GetHash(), block.nBits, params.GetConsensus())) {
71 ++block.nNonce;
72 assert(block.nNonce);
73 }
74 }
75 return ret;
76 }
77
78 COutPoint MineBlock(const NodeContext& node, const node::BlockCreateOptions& assembler_options)
79 {
80 auto block = PrepareBlock(node, assembler_options);
81 auto valid = MineBlock(node, block);
82 assert(!valid.IsNull());
83 return valid;
84 }
85
86 struct BlockValidationStateCatcher : public CValidationInterface {
87 const uint256 m_hash;
88 std::optional<BlockValidationState> m_state;
89
90 BlockValidationStateCatcher(const uint256& hash)
91 : m_hash{hash},
92 m_state{} {}
93
94 protected:
95 void BlockChecked(const std::shared_ptr<const CBlock>& block, const BlockValidationState& state) override
96 {
97 if (block->GetHash() != m_hash) return;
98 m_state = state;
99 }
100 };
101
102 COutPoint MineBlock(const NodeContext& node, std::shared_ptr<CBlock>& block)
103 {
104 while (!CheckProofOfWork(block->GetHash(), block->nBits, Params().GetConsensus())) {
105 ++block->nNonce;
106 assert(block->nNonce);
107 }
108
109 return ProcessBlock(node, block);
110 }
111
112 COutPoint ProcessBlock(const NodeContext& node, const std::shared_ptr<CBlock>& block)
113 {
114 auto& chainman{*Assert(node.chainman)};
115 const auto old_height = WITH_LOCK(chainman.GetMutex(), return chainman.ActiveHeight());
116 bool new_block;
117 BlockValidationStateCatcher bvsc{block->GetHash()};
118 node.validation_signals->RegisterValidationInterface(&bvsc);
119 const bool processed{chainman.ProcessNewBlock(block, true, true, &new_block)};
120 const bool duplicate{!new_block && processed};
121 assert(!duplicate);
122 node.validation_signals->UnregisterValidationInterface(&bvsc);
123 node.validation_signals->SyncWithValidationInterfaceQueue();
124 const bool was_valid{bvsc.m_state && bvsc.m_state->IsValid()};
125 assert(old_height + was_valid == WITH_LOCK(chainman.GetMutex(), return chainman.ActiveHeight()));
126
127 if (was_valid) return {block->vtx[0]->GetHash(), 0};
128 return {};
129 }
130
131 std::shared_ptr<CBlock> PrepareBlock(const NodeContext& node,
132 const node::BlockCreateOptions& assembler_options)
133 {
134 auto mining = interfaces::MakeMining(node);
135 auto block_template = mining->createNewBlock(assembler_options, /*cooldown=*/false);
136 auto block = std::make_shared<CBlock>(Assert(block_template)->getBlock());
137
138 LOCK(cs_main);
139 block->nTime = Assert(node.chainman)->ActiveChain().Tip()->GetMedianTimePast() + 1;
140 block->hashMerkleRoot = BlockMerkleRoot(*block);
141
142 return block;
143 }
144