Bitcoin Core  0.20.99
P2P Digital Currency
miner.cpp
Go to the documentation of this file.
1 // Copyright (c) 2009-2010 Satoshi Nakamoto
2 // Copyright (c) 2009-2020 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 <miner.h>
7 
8 #include <amount.h>
9 #include <chain.h>
10 #include <chainparams.h>
11 #include <coins.h>
12 #include <consensus/consensus.h>
13 #include <consensus/merkle.h>
14 #include <consensus/tx_verify.h>
15 #include <consensus/validation.h>
16 #include <policy/feerate.h>
17 #include <policy/policy.h>
18 #include <pow.h>
19 #include <primitives/transaction.h>
20 #include <timedata.h>
21 #include <util/moneystr.h>
22 #include <util/system.h>
23 
24 #include <algorithm>
25 #include <utility>
26 
27 int64_t UpdateTime(CBlockHeader* pblock, const Consensus::Params& consensusParams, const CBlockIndex* pindexPrev)
28 {
29  int64_t nOldTime = pblock->nTime;
30  int64_t nNewTime = std::max(pindexPrev->GetMedianTimePast()+1, GetAdjustedTime());
31 
32  if (nOldTime < nNewTime)
33  pblock->nTime = nNewTime;
34 
35  // Updating time can change work required on testnet:
36  if (consensusParams.fPowAllowMinDifficultyBlocks)
37  pblock->nBits = GetNextWorkRequired(pindexPrev, pblock, consensusParams);
38 
39  return nNewTime - nOldTime;
40 }
41 
43 {
44  CMutableTransaction tx{*block.vtx.at(0)};
45  tx.vout.erase(tx.vout.begin() + GetWitnessCommitmentIndex(block));
46  block.vtx.at(0) = MakeTransactionRef(tx);
47 
48  GenerateCoinbaseCommitment(block, WITH_LOCK(cs_main, return LookupBlockIndex(block.hashPrevBlock)), Params().GetConsensus());
49 
50  block.hashMerkleRoot = BlockMerkleRoot(block);
51 }
52 
56 }
57 
58 BlockAssembler::BlockAssembler(const CTxMemPool& mempool, const CChainParams& params, const Options& options)
59  : chainparams(params),
60  m_mempool(mempool)
61 {
63  // Limit weight to between 4K and MAX_BLOCK_WEIGHT-4K for sanity:
64  nBlockMaxWeight = std::max<size_t>(4000, std::min<size_t>(MAX_BLOCK_WEIGHT - 4000, options.nBlockMaxWeight));
65 }
66 
68 {
69  // Block resource limits
70  // If -blockmaxweight is not given, limit to DEFAULT_BLOCK_MAX_WEIGHT
72  options.nBlockMaxWeight = gArgs.GetArg("-blockmaxweight", DEFAULT_BLOCK_MAX_WEIGHT);
73  CAmount n = 0;
74  if (gArgs.IsArgSet("-blockmintxfee") && ParseMoney(gArgs.GetArg("-blockmintxfee", ""), n)) {
75  options.blockMinFeeRate = CFeeRate(n);
76  } else {
78  }
79  return options;
80 }
81 
83  : BlockAssembler(mempool, params, DefaultOptions()) {}
84 
86 {
87  inBlock.clear();
88 
89  // Reserve space for coinbase tx
90  nBlockWeight = 4000;
91  nBlockSigOpsCost = 400;
92  fIncludeWitness = false;
93 
94  // These counters do not include coinbase tx
95  nBlockTx = 0;
96  nFees = 0;
97 }
98 
101 
102 std::unique_ptr<CBlockTemplate> BlockAssembler::CreateNewBlock(const CScript& scriptPubKeyIn)
103 {
104  int64_t nTimeStart = GetTimeMicros();
105 
106  resetBlock();
107 
108  pblocktemplate.reset(new CBlockTemplate());
109 
110  if(!pblocktemplate.get())
111  return nullptr;
112  CBlock* const pblock = &pblocktemplate->block; // pointer for convenience
113 
114  // Add dummy coinbase tx as first transaction
115  pblock->vtx.emplace_back();
116  pblocktemplate->vTxFees.push_back(-1); // updated at end
117  pblocktemplate->vTxSigOpsCost.push_back(-1); // updated at end
118 
120  CBlockIndex* pindexPrev = ::ChainActive().Tip();
121  assert(pindexPrev != nullptr);
122  nHeight = pindexPrev->nHeight + 1;
123 
124  pblock->nVersion = ComputeBlockVersion(pindexPrev, chainparams.GetConsensus());
125  // -regtest only: allow overriding block.nVersion with
126  // -blockversion=N to test forking scenarios
128  pblock->nVersion = gArgs.GetArg("-blockversion", pblock->nVersion);
129 
130  pblock->nTime = GetAdjustedTime();
131  const int64_t nMedianTimePast = pindexPrev->GetMedianTimePast();
132 
134  ? nMedianTimePast
135  : pblock->GetBlockTime();
136 
137  // Decide whether to include witness transactions
138  // This is only needed in case the witness softfork activation is reverted
139  // (which would require a very deep reorganization).
140  // Note that the mempool would accept transactions with witness data before
141  // IsWitnessEnabled, but we would only ever mine blocks after IsWitnessEnabled
142  // unless there is a massive block reorganization with the witness softfork
143  // not activated.
144  // TODO: replace this with a call to main to assess validity of a mempool
145  // transaction (which in most cases can be a no-op).
147 
148  int nPackagesSelected = 0;
149  int nDescendantsUpdated = 0;
150  addPackageTxs(nPackagesSelected, nDescendantsUpdated);
151 
152  int64_t nTime1 = GetTimeMicros();
153 
156 
157  // Create coinbase transaction.
158  CMutableTransaction coinbaseTx;
159  coinbaseTx.vin.resize(1);
160  coinbaseTx.vin[0].prevout.SetNull();
161  coinbaseTx.vout.resize(1);
162  coinbaseTx.vout[0].scriptPubKey = scriptPubKeyIn;
163  coinbaseTx.vout[0].nValue = nFees + GetBlockSubsidy(nHeight, chainparams.GetConsensus());
164  coinbaseTx.vin[0].scriptSig = CScript() << nHeight << OP_0;
165  pblock->vtx[0] = MakeTransactionRef(std::move(coinbaseTx));
166  pblocktemplate->vchCoinbaseCommitment = GenerateCoinbaseCommitment(*pblock, pindexPrev, chainparams.GetConsensus());
167  pblocktemplate->vTxFees[0] = -nFees;
168 
169  LogPrintf("CreateNewBlock(): block weight: %u txs: %u fees: %ld sigops %d\n", GetBlockWeight(*pblock), nBlockTx, nFees, nBlockSigOpsCost);
170 
171  // Fill in header
172  pblock->hashPrevBlock = pindexPrev->GetBlockHash();
173  UpdateTime(pblock, chainparams.GetConsensus(), pindexPrev);
174  pblock->nBits = GetNextWorkRequired(pindexPrev, pblock, chainparams.GetConsensus());
175  pblock->nNonce = 0;
176  pblocktemplate->vTxSigOpsCost[0] = WITNESS_SCALE_FACTOR * GetLegacySigOpCount(*pblock->vtx[0]);
177 
178  BlockValidationState state;
179  if (!TestBlockValidity(state, chainparams, *pblock, pindexPrev, false, false)) {
180  throw std::runtime_error(strprintf("%s: TestBlockValidity failed: %s", __func__, state.ToString()));
181  }
182  int64_t nTime2 = GetTimeMicros();
183 
184  LogPrint(BCLog::BENCH, "CreateNewBlock() packages: %.2fms (%d packages, %d updated descendants), validity: %.2fms (total %.2fms)\n", 0.001 * (nTime1 - nTimeStart), nPackagesSelected, nDescendantsUpdated, 0.001 * (nTime2 - nTime1), 0.001 * (nTime2 - nTimeStart));
185 
186  return std::move(pblocktemplate);
187 }
188 
190 {
191  for (CTxMemPool::setEntries::iterator iit = testSet.begin(); iit != testSet.end(); ) {
192  // Only test txs not already in the block
193  if (inBlock.count(*iit)) {
194  testSet.erase(iit++);
195  }
196  else {
197  iit++;
198  }
199  }
200 }
201 
202 bool BlockAssembler::TestPackage(uint64_t packageSize, int64_t packageSigOpsCost) const
203 {
204  // TODO: switch to weight-based accounting for packages instead of vsize-based accounting.
205  if (nBlockWeight + WITNESS_SCALE_FACTOR * packageSize >= nBlockMaxWeight)
206  return false;
207  if (nBlockSigOpsCost + packageSigOpsCost >= MAX_BLOCK_SIGOPS_COST)
208  return false;
209  return true;
210 }
211 
212 // Perform transaction-level checks before adding to block:
213 // - transaction finality (locktime)
214 // - premature witness (in case segwit transactions are added to mempool before
215 // segwit activation)
217 {
218  for (CTxMemPool::txiter it : package) {
219  if (!IsFinalTx(it->GetTx(), nHeight, nLockTimeCutoff))
220  return false;
221  if (!fIncludeWitness && it->GetTx().HasWitness())
222  return false;
223  }
224  return true;
225 }
226 
228 {
229  pblocktemplate->block.vtx.emplace_back(iter->GetSharedTx());
230  pblocktemplate->vTxFees.push_back(iter->GetFee());
231  pblocktemplate->vTxSigOpsCost.push_back(iter->GetSigOpCost());
232  nBlockWeight += iter->GetTxWeight();
233  ++nBlockTx;
234  nBlockSigOpsCost += iter->GetSigOpCost();
235  nFees += iter->GetFee();
236  inBlock.insert(iter);
237 
238  bool fPrintPriority = gArgs.GetBoolArg("-printpriority", DEFAULT_PRINTPRIORITY);
239  if (fPrintPriority) {
240  LogPrintf("fee %s txid %s\n",
241  CFeeRate(iter->GetModifiedFee(), iter->GetTxSize()).ToString(),
242  iter->GetTx().GetHash().ToString());
243  }
244 }
245 
247  indexed_modified_transaction_set &mapModifiedTx)
248 {
249  int nDescendantsUpdated = 0;
250  for (CTxMemPool::txiter it : alreadyAdded) {
251  CTxMemPool::setEntries descendants;
252  m_mempool.CalculateDescendants(it, descendants);
253  // Insert all descendants (not yet in block) into the modified set
254  for (CTxMemPool::txiter desc : descendants) {
255  if (alreadyAdded.count(desc))
256  continue;
257  ++nDescendantsUpdated;
258  modtxiter mit = mapModifiedTx.find(desc);
259  if (mit == mapModifiedTx.end()) {
260  CTxMemPoolModifiedEntry modEntry(desc);
261  modEntry.nSizeWithAncestors -= it->GetTxSize();
262  modEntry.nModFeesWithAncestors -= it->GetModifiedFee();
263  modEntry.nSigOpCostWithAncestors -= it->GetSigOpCost();
264  mapModifiedTx.insert(modEntry);
265  } else {
266  mapModifiedTx.modify(mit, update_for_parent_inclusion(it));
267  }
268  }
269  }
270  return nDescendantsUpdated;
271 }
272 
273 // Skip entries in mapTx that are already in a block or are present
274 // in mapModifiedTx (which implies that the mapTx ancestor state is
275 // stale due to ancestor inclusion in the block)
276 // Also skip transactions that we've already failed to add. This can happen if
277 // we consider a transaction in mapModifiedTx and it fails: we can then
278 // potentially consider it again while walking mapTx. It's currently
279 // guaranteed to fail again, but as a belt-and-suspenders check we put it in
280 // failedTx and avoid re-evaluation, since the re-evaluation would be using
281 // cached size/sigops/fee values that are not actually correct.
283 {
284  assert(it != m_mempool.mapTx.end());
285  return mapModifiedTx.count(it) || inBlock.count(it) || failedTx.count(it);
286 }
287 
288 void BlockAssembler::SortForBlock(const CTxMemPool::setEntries& package, std::vector<CTxMemPool::txiter>& sortedEntries)
289 {
290  // Sort package by ancestor count
291  // If a transaction A depends on transaction B, then A's ancestor count
292  // must be greater than B's. So this is sufficient to validly order the
293  // transactions for block inclusion.
294  sortedEntries.clear();
295  sortedEntries.insert(sortedEntries.begin(), package.begin(), package.end());
296  std::sort(sortedEntries.begin(), sortedEntries.end(), CompareTxIterByAncestorCount());
297 }
298 
299 // This transaction selection algorithm orders the mempool based
300 // on feerate of a transaction including all unconfirmed ancestors.
301 // Since we don't remove transactions from the mempool as we select them
302 // for block inclusion, we need an alternate method of updating the feerate
303 // of a transaction with its not-yet-selected ancestors as we go.
304 // This is accomplished by walking the in-mempool descendants of selected
305 // transactions and storing a temporary modified state in mapModifiedTxs.
306 // Each time through the loop, we compare the best transaction in
307 // mapModifiedTxs with the next transaction in the mempool to decide what
308 // transaction package to work on next.
309 void BlockAssembler::addPackageTxs(int &nPackagesSelected, int &nDescendantsUpdated)
310 {
311  // mapModifiedTx will store sorted packages after they are modified
312  // because some of their txs are already in the block
313  indexed_modified_transaction_set mapModifiedTx;
314  // Keep track of entries that failed inclusion, to avoid duplicate work
315  CTxMemPool::setEntries failedTx;
316 
317  // Start by adding all descendants of previously added txs to mapModifiedTx
318  // and modifying them for their already included ancestors
319  UpdatePackagesForAdded(inBlock, mapModifiedTx);
320 
321  CTxMemPool::indexed_transaction_set::index<ancestor_score>::type::iterator mi = m_mempool.mapTx.get<ancestor_score>().begin();
322  CTxMemPool::txiter iter;
323 
324  // Limit the number of attempts to add transactions to the block when it is
325  // close to full; this is just a simple heuristic to finish quickly if the
326  // mempool has a lot of entries.
327  const int64_t MAX_CONSECUTIVE_FAILURES = 1000;
328  int64_t nConsecutiveFailed = 0;
329 
330  while (mi != m_mempool.mapTx.get<ancestor_score>().end() || !mapModifiedTx.empty()) {
331  // First try to find a new transaction in mapTx to evaluate.
332  if (mi != m_mempool.mapTx.get<ancestor_score>().end() &&
333  SkipMapTxEntry(m_mempool.mapTx.project<0>(mi), mapModifiedTx, failedTx)) {
334  ++mi;
335  continue;
336  }
337 
338  // Now that mi is not stale, determine which transaction to evaluate:
339  // the next entry from mapTx, or the best from mapModifiedTx?
340  bool fUsingModified = false;
341 
342  modtxscoreiter modit = mapModifiedTx.get<ancestor_score>().begin();
343  if (mi == m_mempool.mapTx.get<ancestor_score>().end()) {
344  // We're out of entries in mapTx; use the entry from mapModifiedTx
345  iter = modit->iter;
346  fUsingModified = true;
347  } else {
348  // Try to compare the mapTx entry to the mapModifiedTx entry
349  iter = m_mempool.mapTx.project<0>(mi);
350  if (modit != mapModifiedTx.get<ancestor_score>().end() &&
352  // The best entry in mapModifiedTx has higher score
353  // than the one from mapTx.
354  // Switch which transaction (package) to consider
355  iter = modit->iter;
356  fUsingModified = true;
357  } else {
358  // Either no entry in mapModifiedTx, or it's worse than mapTx.
359  // Increment mi for the next loop iteration.
360  ++mi;
361  }
362  }
363 
364  // We skip mapTx entries that are inBlock, and mapModifiedTx shouldn't
365  // contain anything that is inBlock.
366  assert(!inBlock.count(iter));
367 
368  uint64_t packageSize = iter->GetSizeWithAncestors();
369  CAmount packageFees = iter->GetModFeesWithAncestors();
370  int64_t packageSigOpsCost = iter->GetSigOpCostWithAncestors();
371  if (fUsingModified) {
372  packageSize = modit->nSizeWithAncestors;
373  packageFees = modit->nModFeesWithAncestors;
374  packageSigOpsCost = modit->nSigOpCostWithAncestors;
375  }
376 
377  if (packageFees < blockMinFeeRate.GetFee(packageSize)) {
378  // Everything else we might consider has a lower fee rate
379  return;
380  }
381 
382  if (!TestPackage(packageSize, packageSigOpsCost)) {
383  if (fUsingModified) {
384  // Since we always look at the best entry in mapModifiedTx,
385  // we must erase failed entries so that we can consider the
386  // next best entry on the next loop iteration
387  mapModifiedTx.get<ancestor_score>().erase(modit);
388  failedTx.insert(iter);
389  }
390 
391  ++nConsecutiveFailed;
392 
393  if (nConsecutiveFailed > MAX_CONSECUTIVE_FAILURES && nBlockWeight >
394  nBlockMaxWeight - 4000) {
395  // Give up if we're close to full and haven't succeeded in a while
396  break;
397  }
398  continue;
399  }
400 
401  CTxMemPool::setEntries ancestors;
402  uint64_t nNoLimit = std::numeric_limits<uint64_t>::max();
403  std::string dummy;
404  m_mempool.CalculateMemPoolAncestors(*iter, ancestors, nNoLimit, nNoLimit, nNoLimit, nNoLimit, dummy, false);
405 
406  onlyUnconfirmed(ancestors);
407  ancestors.insert(iter);
408 
409  // Test if all tx's are Final
410  if (!TestPackageTransactions(ancestors)) {
411  if (fUsingModified) {
412  mapModifiedTx.get<ancestor_score>().erase(modit);
413  failedTx.insert(iter);
414  }
415  continue;
416  }
417 
418  // This transaction will make it in; reset the failed counter.
419  nConsecutiveFailed = 0;
420 
421  // Package can be added. Sort the entries in a valid order.
422  std::vector<CTxMemPool::txiter> sortedEntries;
423  SortForBlock(ancestors, sortedEntries);
424 
425  for (size_t i=0; i<sortedEntries.size(); ++i) {
426  AddToBlock(sortedEntries[i]);
427  // Erase from the modified set, if present
428  mapModifiedTx.erase(sortedEntries[i]);
429  }
430 
431  ++nPackagesSelected;
432 
433  // Update transactions that depend on each of these
434  nDescendantsUpdated += UpdatePackagesForAdded(ancestors, mapModifiedTx);
435  }
436 }
437 
438 void IncrementExtraNonce(CBlock* pblock, const CBlockIndex* pindexPrev, unsigned int& nExtraNonce)
439 {
440  // Update nExtraNonce
441  static uint256 hashPrevBlock;
442  if (hashPrevBlock != pblock->hashPrevBlock)
443  {
444  nExtraNonce = 0;
445  hashPrevBlock = pblock->hashPrevBlock;
446  }
447  ++nExtraNonce;
448  unsigned int nHeight = pindexPrev->nHeight+1; // Height first in coinbase required for block.version=2
449  CMutableTransaction txCoinbase(*pblock->vtx[0]);
450  txCoinbase.vin[0].scriptSig = (CScript() << nHeight << CScriptNum(nExtraNonce));
451  assert(txCoinbase.vin[0].scriptSig.size() <= 100);
452 
453  pblock->vtx[0] = MakeTransactionRef(std::move(txCoinbase));
454  pblock->hashMerkleRoot = BlockMerkleRoot(*pblock);
455 }
uint32_t nNonce
Definition: block.h:29
indexed_modified_transaction_set::nth_index< 0 >::type::iterator modtxiter
Definition: miner.h:108
peer m_getdata_requests erase(peer.m_getdata_requests.begin(), it)
bool TestPackageTransactions(const CTxMemPool::setEntries &package)
Perform checks on each transaction in a package: locktime, premature-witness, serialized size (if nec...
Definition: miner.cpp:216
bool TestBlockValidity(BlockValidationState &state, const CChainParams &chainparams, const CBlock &block, CBlockIndex *pindexPrev, bool fCheckPOW, bool fCheckMerkleRoot)
Check a block is completely valid from start to finish (only works on top of our current best block) ...
bool IsArgSet(const std::string &strArg) const
Return true if the given argument has been manually set.
Definition: system.cpp:370
CFeeRate blockMinFeeRate
Definition: miner.h:154
static Optional< int64_t > m_last_block_num_txs
Definition: miner.h:163
Definition: miner.h:38
std::deque< CInv >::iterator it
unsigned int nBlockMaxWeight
Definition: miner.h:134
CAmount GetBlockSubsidy(int nHeight, const Consensus::Params &consensusParams)
static const int WITNESS_SCALE_FACTOR
Definition: consensus.h:21
#define LogPrint(category,...)
Definition: logging.h:182
indexed_transaction_set::nth_index< 0 >::type::const_iterator txiter
Definition: txmempool.h:579
void AddToBlock(CTxMemPool::txiter iter)
Add a tx to the block.
Definition: miner.cpp:227
int UpdatePackagesForAdded(const CTxMemPool::setEntries &alreadyAdded, indexed_modified_transaction_set &mapModifiedTx) EXCLUSIVE_LOCKS_REQUIRED(m_mempool.cs)
Add descendants of given transactions to mapModifiedTx with ancestor state updated assuming given tra...
Definition: miner.cpp:246
int64_t UpdateTime(CBlockHeader *pblock, const Consensus::Params &consensusParams, const CBlockIndex *pindexPrev)
Definition: miner.cpp:27
Definition: block.h:62
CChain & ChainActive()
Please prefer the identical ChainstateManager::ActiveChain.
Definition: validation.cpp:113
uint64_t nBlockTx
Definition: miner.h:139
#define strprintf
Format arguments and return the string or write to given std::ostream (see tinyformat::format doc for...
Definition: tinyformat.h:1164
void CalculateDescendants(txiter it, setEntries &setDescendants) const EXCLUSIVE_LOCKS_REQUIRED(cs)
Populate setDescendants with all in-mempool descendants of hash.
Definition: txmempool.cpp:453
std::vector< CTxIn > vin
Definition: transaction.h:355
void onlyUnconfirmed(CTxMemPool::setEntries &testSet)
Remove confirmed (inBlock) entries from given set.
Definition: miner.cpp:189
int64_t nLockTimeCutoff
Definition: miner.h:146
static CTransactionRef MakeTransactionRef()
Definition: transaction.h:396
CTxMemPool::setEntries inBlock
Definition: miner.h:142
std::unique_ptr< CBlockTemplate > pblocktemplate
Definition: miner.h:130
bool fPowAllowMinDifficultyBlocks
Definition: params.h:77
static void LogPrintf(const char *fmt, const Args &... args)
Definition: logging.h:166
std::set< txiter, CompareIteratorByHash > setEntries
Definition: txmempool.h:582
static auto & nullopt
Substitute for C++17 std::nullopt.
Definition: optional.h:24
CChainParams defines various tweakable parameters of a given instance of the Bitcoin system...
Definition: chainparams.h:52
bool GetBoolArg(const std::string &strArg, bool fDefault) const
Return boolean argument or default value.
Definition: system.cpp:478
bool ParseMoney(const std::string &money_string, CAmount &nRet)
Parse an amount denoted in full coins.
Definition: moneystr.cpp:34
int32_t ComputeBlockVersion(const CBlockIndex *pindexPrev, const Consensus::Params &params)
Determine what nVersion a new block should use.
static const int64_t MAX_BLOCK_SIGOPS_COST
The maximum allowed number of signature check operations in a block (network rule) ...
Definition: consensus.h:17
uint32_t nTime
Definition: block.h:27
indexed_modified_transaction_set::index< ancestor_score >::type::iterator modtxscoreiter
Definition: miner.h:109
static const unsigned int MAX_BLOCK_WEIGHT
The maximum allowed weight for a block, see BIP 141 (network rule)
Definition: consensus.h:15
BlockAssembler(const CTxMemPool &mempool, const CChainParams &params)
Definition: miner.cpp:82
int64_t CAmount
Amount in satoshis (Can be negative)
Definition: amount.h:12
static BlockAssembler::Options DefaultOptions()
Definition: miner.cpp:67
uint256 GetBlockHash() const
Definition: chain.h:233
std::string ToString(const T &t)
Locale-independent version of std::to_string.
Definition: string.h:71
#define LOCK2(cs1, cs2)
Definition: sync.h:231
bool MineBlocksOnDemand() const
Whether it is possible to mine blocks on demand (no retargeting)
Definition: chainparams.h:84
Definition: txmempool.h:320
uint256 hashMerkleRoot
Definition: block.h:26
const CChainParams & chainparams
Definition: miner.h:147
static constexpr unsigned int LOCKTIME_MEDIAN_TIME_PAST
Use GetMedianTimePast() instead of nTime for end point timestamp.
Definition: consensus.h:30
unsigned int GetNextWorkRequired(const CBlockIndex *pindexLast, const CBlockHeader *pblock, const Consensus::Params &params)
Definition: pow.cpp:13
std::string ToString() const
Definition: validation.h:125
static const 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:22
boost::multi_index_container< CTxMemPoolModifiedEntry, boost::multi_index::indexed_by< boost::multi_index::ordered_unique< modifiedentry_iter, CompareCTxMemPoolIter >, boost::multi_index::ordered_non_unique< boost::multi_index::tag< ancestor_score >, boost::multi_index::identity< CTxMemPoolModifiedEntry >, CompareTxMemPoolEntryByAncestorFee > >> indexed_modified_transaction_set
Definition: miner.h:106
CAmount nFees
Definition: miner.h:141
uint256 hashPrevBlock
Definition: block.h:25
RecursiveMutex cs_main
Mutex to guard access to validation specific variables, such as reading or changing the chainstate...
Definition: validation.cpp:129
size_t nBlockMaxWeight
Definition: miner.h:153
Generate a new block, without valid proof-of-work.
Definition: miner.h:126
uint256 BlockMerkleRoot(const CBlock &block, bool *mutated)
Definition: merkle.cpp:65
bool SkipMapTxEntry(CTxMemPool::txiter it, indexed_modified_transaction_set &mapModifiedTx, CTxMemPool::setEntries &failedTx) EXCLUSIVE_LOCKS_REQUIRED(m_mempool.cs)
Return true if given transaction from mapTx has already been evaluated, or if the transaction&#39;s cache...
Definition: miner.cpp:282
void SortForBlock(const CTxMemPool::setEntries &package, std::vector< CTxMemPool::txiter > &sortedEntries)
Sort the package in an order that is valid to appear in a block.
Definition: miner.cpp:288
std::unique_ptr< CBlockTemplate > CreateNewBlock(const CScript &scriptPubKeyIn)
Construct a new block template with coinbase to scriptPubKeyIn.
Definition: miner.cpp:102
Parameters that influence chain consensus.
Definition: params.h:46
bool CalculateMemPoolAncestors(const CTxMemPoolEntry &entry, setEntries &setAncestors, uint64_t limitAncestorCount, uint64_t limitAncestorSize, uint64_t limitDescendantCount, uint64_t limitDescendantSize, std::string &errString, bool fSearchForParents=true) const EXCLUSIVE_LOCKS_REQUIRED(cs)
Try to calculate all in-mempool ancestors of entry.
Definition: txmempool.cpp:152
int64_t GetBlockTime() const
Definition: block.h:55
static Optional< int64_t > m_last_block_weight
Definition: miner.h:164
std::vector< CTxOut > vout
Definition: transaction.h:356
#define WITH_LOCK(cs, code)
Run code while locking a mutex.
Definition: sync.h:257
int64_t GetMedianTimePast() const
Definition: chain.h:259
const CTxMemPool & m_mempool
Definition: miner.h:148
uint64_t nSizeWithAncestors
Definition: miner.h:54
int64_t GetTimeMicros()
Returns the system time (not mockable)
Definition: time.cpp:65
void IncrementExtraNonce(CBlock *pblock, const CBlockIndex *pindexPrev, unsigned int &nExtraNonce)
Modify the extranonce in a block.
Definition: miner.cpp:438
CBlockIndex * LookupBlockIndex(const uint256 &hash)
Definition: validation.cpp:173
uint64_t nBlockSigOpsCost
Definition: miner.h:140
256-bit opaque blob.
Definition: uint256.h:124
CAmount nModFeesWithAncestors
Definition: miner.h:55
void RegenerateCommitments(CBlock &block)
Update an old GenerateCoinbaseCommitment from CreateNewBlock after the block txs have changed...
Definition: miner.cpp:42
std::vector< CTransactionRef > vtx
Definition: block.h:66
void addPackageTxs(int &nPackagesSelected, int &nDescendantsUpdated) EXCLUSIVE_LOCKS_REQUIRED(m_mempool.cs)
Add transactions based on feerate including unconfirmed ancestors Increments nPackagesSelected / nDes...
Definition: miner.cpp:309
CTxMemPool stores valid-according-to-the-current-best-chain transactions that may be included in the ...
Definition: txmempool.h:488
unsigned int GetLegacySigOpCount(const CTransaction &tx)
Auxiliary functions for transaction validation (ideally should not be exposed)
Definition: tx_verify.cpp:107
CFeeRate blockMinFeeRate
Definition: miner.h:135
The block chain is a tree shaped structure starting with the genesis block at the root...
Definition: chain.h:137
const CChainParams & Params()
Return the currently selected parameters.
Serialized script, used inside transaction inputs and outputs.
Definition: script.h:404
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&#39;t call for mined blocks...
int nHeight
Definition: miner.h:145
std::string GetArg(const std::string &strArg, const std::string &strDefault) const
Return string argument or default value.
Definition: system.cpp:466
int64_t GetAdjustedTime()
Definition: timedata.cpp:34
int64_t nSigOpCostWithAncestors
Definition: miner.h:56
CBlockIndex * Tip() const
Returns the index entry for the tip of this chain, or nullptr if none.
Definition: chain.h:390
uint64_t nBlockWeight
Definition: miner.h:138
ArgsManager gArgs
Definition: system.cpp:76
Fee rate in satoshis per kilobyte: CAmount / kB.
Definition: feerate.h:29
bool fIncludeWitness
Definition: miner.h:133
bool IsWitnessEnabled(const CBlockIndex *pindexPrev, const Consensus::Params &params)
Check whether witness commitments are required for a block, and whether to enforce NULLDUMMY (BIP 147...
void resetBlock()
Clear the block&#39;s state and prepare for assembling a new block.
Definition: miner.cpp:85
A mutable version of CTransaction.
Definition: transaction.h:353
CTransactionRef get(const uint256 &hash) const
Definition: txmempool.cpp:814
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
int nHeight
height of the entry in the chain. The genesis block has height 0
Definition: chain.h:150
boost::optional< T > Optional
Substitute for C++17 std::optional.
Definition: optional.h:14
const Consensus::Params & GetConsensus() const
Definition: chainparams.h:65
static const bool DEFAULT_PRINTPRIORITY
Definition: miner.h:26
int GetWitnessCommitmentIndex(const CBlock &block)
Compute at which vout of the block&#39;s coinbase transaction the witness commitment occurs, or -1 if not found.
Definition: validation.h:161
static const unsigned int DEFAULT_BLOCK_MAX_WEIGHT
Default for -blockmaxweight, which controls the range of block weights the mining code will create...
Definition: policy.h:20
static int64_t GetBlockWeight(const CBlock &block)
Definition: validation.h:150
static constexpr unsigned int STANDARD_LOCKTIME_VERIFY_FLAGS
Used as the flags parameter to sequence and nLocktime checks in non-consensus code.
Definition: policy.h:83
Definition: script.h:68
bool TestPackage(uint64_t packageSize, int64_t packageSigOpsCost) const
Test if a new package would "fit" in the block.
Definition: miner.cpp:202
int32_t nVersion
Definition: block.h:24
Nodes collect new transactions into a block, hash them into a hash tree, and scan through nonce value...
Definition: block.h:20
RecursiveMutex cs
This mutex needs to be locked when accessing mapTx or other members that are guarded by it...
Definition: txmempool.h:576
uint32_t nBits
Definition: block.h:28
CAmount GetFee(size_t nBytes) const
Return the fee in satoshis for the given size in bytes.
Definition: feerate.cpp:21