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