1// Copyright (c) 2009-2010 Satoshi Nakamoto
2// Copyright (c) 2009-present The Bitcoin Core developers
3// Distributed under the MIT software license, see the accompanying
4// file COPYING or http://www.opensource.org/licenses/mit-license.php.
5
6#include <node/miner.h>
7
8#include <chain.h>
9#include <chainparams.h>
10#include <common/args.h>
11#include <consensus/amount.h>
12#include <consensus/consensus.h>
13#include <consensus/merkle.h>
14#include <consensus/params.h>
15#include <consensus/tx_verify.h>
16#include <consensus/validation.h>
17#include <interfaces/types.h>
18#include <node/blockstorage.h>
19#include <node/kernel_notifications.h>
20#include <node/mining_args.h>
21#include <node/mining_types.h>
22#include <policy/feerate.h>
23#include <policy/policy.h>
24#include <pow.h>
25#include <primitives/block.h>
26#include <primitives/transaction.h>
27#include <script/script.h>
28#include <sync.h>
29#include <tinyformat.h>
30#include <txgraph.h>
31#include <txmempool.h>
32#include <uint256.h>
33#include <util/check.h>
34#include <util/feefrac.h>
35#include <util/log.h>
36#include <util/result.h>
37#include <util/signalinterrupt.h>
38#include <util/time.h>
39#include <util/translation.h>
40#include <validation.h>
41#include <validationinterface.h>
42#include <versionbits.h>
43
44#include <algorithm>
45#include <compare>
46#include <condition_variable>
47#include <cstddef>
48#include <functional>
49#include <numeric>
50#include <span>
51#include <stdexcept>
52#include <string>
53#include <utility>
54
55namespace node {
56
57int64_t GetMinimumTime(const CBlockIndex* pindexPrev, const int64_t difficulty_adjustment_interval)
58{
59    int64_t min_time{pindexPrev->GetMedianTimePast() + 1};
60    // Height of block to be mined.
61    const int height{pindexPrev->nHeight + 1};
62    // Account for BIP94 timewarp rule on all networks. This makes future
63    // activation safer.
64    if (height % difficulty_adjustment_interval == 0) {
65        min_time = std::max<int64_t>(min_time, pindexPrev->GetBlockTime() - MAX_TIMEWARP);
66    }
67    // Account for the BIP54 Murch-Zawy rule on all networks: the last block of
68    // a difficulty adjustment period may not be earlier than its first block.
69    if (height % difficulty_adjustment_interval == difficulty_adjustment_interval - 1) {
70        const int first_height{height - static_cast<int>(difficulty_adjustment_interval) + 1};
71        const CBlockIndex* first_block{Assert(pindexPrev->GetAncestor(first_height))};
72        min_time = std::max<int64_t>(min_time, first_block->GetBlockTime());
73    }
74    return min_time;
75}
76
77int64_t UpdateTime(CBlockHeader* pblock, const Consensus::Params& consensusParams, const CBlockIndex* pindexPrev)
78{
79    int64_t nOldTime = pblock->nTime;
80    int64_t nNewTime{std::max<int64_t>(GetMinimumTime(pindexPrev, consensusParams.DifficultyAdjustmentInterval()),
81                                       TicksSinceEpoch<std::chrono::seconds>(NodeClock::now()))};
82
83    if (nOldTime < nNewTime) {
84        pblock->nTime = nNewTime;
85    }
86
87    // Updating time can change work required on testnet:
88    if (consensusParams.fPowAllowMinDifficultyBlocks) {
89        pblock->nBits = GetNextWorkRequired(pindexPrev, pblock, consensusParams);
90    }
91
92    return nNewTime - nOldTime;
93}
94
95void RegenerateCommitments(CBlock& block, ChainstateManager& chainman)
96{
97    CMutableTransaction tx{*block.vtx.at(0)};
98    tx.vout.erase(tx.vout.begin() + GetWitnessCommitmentIndex(block));
99    block.vtx.at(0) = MakeTransactionRef(tx);
100
101    const CBlockIndex* prev_block = WITH_LOCK(::cs_main, return chainman.m_blockman.LookupBlockIndex(block.hashPrevBlock));
102    chainman.GenerateCoinbaseCommitment(block, prev_block);
103
104    block.hashMerkleRoot = BlockMerkleRoot(block);
105}
106
107BlockAssembler::BlockAssembler(Chainstate& chainstate,
108                               const CTxMemPool* mempool,
109                               BlockCreateOptions options)
110    : chainparams{chainstate.m_chainman.GetParams()},
111      m_mempool{options.use_mempool ? mempool : nullptr},
112      m_chainstate{chainstate},
113      m_options{[&] {
114          if (auto result{CheckMiningOptions(options, /*use_argnames=*/false)}; !result) {
115              throw std::runtime_error(util::ErrorString(result).original);
116          }
117          return FlattenMiningOptions(std::move(options));
118      }()}
119{
120}
121
122void BlockAssembler::resetBlock()
123{
124    // Reserve space for fixed-size block header, txs count, and coinbase tx.
125    nBlockWeight = *Assert(m_options.block_reserved_weight);
126    nBlockSigOpsCost = m_options.coinbase_output_max_additional_sigops;
127
128    // These counters do not include coinbase tx
129    nBlockTx = 0;
130    nFees = 0;
131}
132
133std::unique_ptr<CBlockTemplate> BlockAssembler::CreateNewBlock()
134{
135    const auto time_start{SteadyClock::now()};
136
137    resetBlock();
138
139    pblocktemplate.reset(new CBlockTemplate());
140    CBlock* const pblock = &pblocktemplate->block; // pointer for convenience
141
142    // Add dummy coinbase tx as first transaction. It is skipped by the
143    // getblocktemplate RPC and mining interface consumers must not use it.
144    pblock->vtx.emplace_back();
145
146    LOCK(::cs_main);
147    CBlockIndex* pindexPrev = m_chainstate.m_chain.Tip();
148    assert(pindexPrev != nullptr);
149    nHeight = pindexPrev->nHeight + 1;
150
151    pblock->nVersion = m_chainstate.m_chainman.m_versionbitscache.ComputeBlockVersion(pindexPrev, chainparams.GetConsensus());
152    // -regtest only: allow overriding block.nVersion with
153    // -blockversion=N to test forking scenarios
154    if (chainparams.MineBlocksOnDemand()) {
155        pblock->nVersion = gArgs.GetIntArg("-blockversion", pblock->nVersion);
156    }
157
158    pblock->nTime = TicksSinceEpoch<std::chrono::seconds>(NodeClock::now());
159    m_lock_time_cutoff = pindexPrev->GetMedianTimePast();
160
161    if (m_mempool) {
162        LOCK(m_mempool->cs);
163        m_mempool->StartBlockBuilding();
164        addChunks();
165        m_mempool->StopBlockBuilding();
166    }
167
168    const auto time_1{SteadyClock::now()};
169
170    m_last_block_num_txs = nBlockTx;
171    m_last_block_weight = nBlockWeight;
172
173    // Create coinbase transaction.
174    CMutableTransaction coinbaseTx;
175
176    // Construct coinbase transaction struct in parallel
177    CoinbaseTx& coinbase_tx{pblocktemplate->m_coinbase_tx};
178    coinbase_tx.version = coinbaseTx.version;
179
180    coinbaseTx.vin.resize(1);
181    coinbaseTx.vin[0].prevout.SetNull();
182    coinbaseTx.vin[0].nSequence = CTxIn::MAX_SEQUENCE_NONFINAL; // Make sure timelock is enforced.
183    coinbase_tx.sequence = coinbaseTx.vin[0].nSequence;
184
185    // Add an output that spends the full coinbase reward.
186    coinbaseTx.vout.resize(1);
187    coinbaseTx.vout[0].scriptPubKey = m_options.coinbase_output_script;
188    // Block subsidy + fees
189    const CAmount block_reward{nFees + GetBlockSubsidy(nHeight, chainparams.GetConsensus())};
190    coinbaseTx.vout[0].nValue = block_reward;
191    coinbase_tx.block_reward_remaining = block_reward;
192
193    // Start the coinbase scriptSig with the block height as required by BIP34.
194    // Mining clients are expected to append extra data to this prefix, so
195    // increasing its length would reduce the space they can use and may break
196    // existing clients.
197    coinbaseTx.vin[0].scriptSig = CScript() << nHeight;
198    // Set script_sig_prefix here, so IPC mining clients are not affected by
199    // the optional scriptSig padding below. They provide their own extraNonce,
200    // and in a typical setup a pool name or realistic extraNonce already makes
201    // the scriptSig long enough.
202    coinbase_tx.script_sig_prefix = coinbaseTx.vin[0].scriptSig;
203    if (nHeight <= 16) {
204        // For blocks at heights <= 16, the BIP34-encoded height alone is only
205        // one byte. Consensus requires coinbase scriptSigs to be at least two
206        // bytes long (bad-cb-length), so an OP_0 is always appended at those
207        // heights.
208        coinbaseTx.vin[0].scriptSig << OP_0;
209    }
210    Assert(nHeight > 0);
211    coinbaseTx.nLockTime = static_cast<uint32_t>(nHeight - 1);
212    coinbase_tx.lock_time = coinbaseTx.nLockTime;
213
214    pblock->vtx[0] = MakeTransactionRef(std::move(coinbaseTx));
215    m_chainstate.m_chainman.GenerateCoinbaseCommitment(*pblock, pindexPrev);
216
217    const CTransactionRef& final_coinbase{pblock->vtx[0]};
218    if (final_coinbase->HasWitness()) {
219        const auto& witness_stack{final_coinbase->vin[0].scriptWitness.stack};
220        // Consensus requires the coinbase witness stack to have exactly one
221        // element of 32 bytes.
222        Assert(witness_stack.size() == 1 && witness_stack[0].size() == 32);
223        coinbase_tx.witness = uint256(witness_stack[0]);
224    }
225    if (const int witness_index = GetWitnessCommitmentIndex(*pblock); witness_index != NO_WITNESS_COMMITMENT) {
226        Assert(witness_index >= 0 && static_cast<size_t>(witness_index) < final_coinbase->vout.size());
227        coinbase_tx.required_outputs.push_back(final_coinbase->vout[witness_index]);
228    }
229
230    LogDebug(BCLog::MINING, "CreateNewBlock(): block weight: %u txs: %u fees: %ld sigops %d\n", GetBlockWeight(*pblock), nBlockTx, nFees, nBlockSigOpsCost);
231
232    // Fill in header
233    pblock->hashPrevBlock  = pindexPrev->GetBlockHash();
234    UpdateTime(pblock, chainparams.GetConsensus(), pindexPrev);
235    pblock->nBits          = GetNextWorkRequired(pindexPrev, pblock, chainparams.GetConsensus());
236    pblock->nNonce         = 0;
237
238    if (m_options.test_block_validity) {
239        if (BlockValidationState state{TestBlockValidity(m_chainstate, *pblock, /*check_pow=*/false, /*check_merkle_root=*/false)}; !state.IsValid()) {
240            throw std::runtime_error(strprintf("TestBlockValidity failed: %s", state.ToString()));
241        }
242    }
243    const auto time_2{SteadyClock::now()};
244
245    LogDebug(BCLog::BENCH, "CreateNewBlock() chunks: %.2fms, validity: %.2fms (total %.2fms)\n",
246             Ticks<MillisecondsDouble>(time_1 - time_start),
247             Ticks<MillisecondsDouble>(time_2 - time_1),
248             Ticks<MillisecondsDouble>(time_2 - time_start));
249
250    return std::move(pblocktemplate);