Line data Source code
1 : // Copyright (c) 2009-2010 Satoshi Nakamoto
2 : // Copyright (c) 2009-2021 The Bitcoin Core developers
3 : // Copyright (c) 2021 The PIVX Core developers
4 : // Distributed under the MIT software license, see the accompanying
5 : // file COPYING or https://www.opensource.org/licenses/mit-license.php.
6 :
7 : #include "blockassembler.h"
8 :
9 : #include "amount.h"
10 : #include "blocksignature.h"
11 : #include "chain.h"
12 : #include "chainparams.h"
13 : #include "consensus/consensus.h"
14 : #include "consensus/merkle.h"
15 : #include "consensus/upgrades.h"
16 : #include "consensus/validation.h"
17 : #include "llmq/quorums_blockprocessor.h"
18 : #include "masternode-payments.h"
19 : #include "policy/policy.h"
20 : #include "pow.h"
21 : #include "primitives/transaction.h"
22 : #include "spork.h"
23 : #include "timedata.h"
24 : #include "util/system.h"
25 : #include "util/validation.h"
26 : #include "validationinterface.h"
27 :
28 : #ifdef ENABLE_WALLET
29 : #include "wallet/wallet.h"
30 : #endif
31 :
32 : #include <algorithm>
33 : #include <boost/thread.hpp>
34 :
35 : // Unconfirmed transactions in the memory pool often depend on other
36 : // transactions in the memory pool. When we select transactions from the
37 : // pool, we select by highest priority or fee rate, so we might consider
38 : // transactions that depend on transactions that aren't yet in the block.
39 :
40 : uint64_t nLastBlockTx = 0;
41 : uint64_t nLastBlockSize = 0;
42 :
43 13117 : int64_t UpdateTime(CBlockHeader* pblock, const Consensus::Params& consensusParams, const CBlockIndex* pindexPrev)
44 : {
45 13117 : int64_t nOldTime = pblock->nTime;
46 13117 : int64_t nNewTime = std::max(pindexPrev->GetMedianTimePast()+1, GetAdjustedTime());
47 :
48 13117 : if (nOldTime < nNewTime)
49 13117 : pblock->nTime = nNewTime;
50 :
51 : // Updating time can change work required on testnet:
52 13117 : if (consensusParams.fPowAllowMinDifficultyBlocks)
53 13117 : pblock->nBits = GetNextWorkRequired(pindexPrev, pblock);
54 :
55 13117 : return nNewTime - nOldTime;
56 : }
57 :
58 15126 : static CMutableTransaction NewCoinbase(const int nHeight, const CScript* pScriptPubKey = nullptr)
59 : {
60 15126 : CMutableTransaction txCoinbase;
61 15126 : txCoinbase.vout.emplace_back();
62 15126 : txCoinbase.vout[0].SetEmpty();
63 15126 : if (pScriptPubKey) txCoinbase.vout[0].scriptPubKey = *pScriptPubKey;
64 15126 : txCoinbase.vin.emplace_back();
65 15126 : txCoinbase.vin[0].scriptSig = CScript() << nHeight << OP_0;
66 15126 : return txCoinbase;
67 : }
68 :
69 1917 : bool SolveProofOfStake(CBlock* pblock, CBlockIndex* pindexPrev, CWallet* pwallet,
70 : std::vector<CStakeableOutput>* availableCoins, bool stopPoSOnNewBlock)
71 : {
72 1917 : boost::this_thread::interruption_point();
73 :
74 1917 : assert(pindexPrev);
75 1917 : pblock->nBits = GetNextWorkRequired(pindexPrev, pblock);
76 :
77 : // Sync wallet before create coinstake
78 1917 : pwallet->BlockUntilSyncedToCurrentChain();
79 :
80 3834 : CMutableTransaction txCoinStake;
81 1917 : int64_t nTxNewTime = 0;
82 1917 : if (!pwallet->CreateCoinStake(pindexPrev,
83 : pblock->nBits,
84 : txCoinStake,
85 : nTxNewTime,
86 : availableCoins,
87 : stopPoSOnNewBlock
88 : )) {
89 19 : LogPrint(BCLog::STAKING, "%s : stake not found\n", __func__);
90 19 : return false;
91 : }
92 : // Stake found
93 :
94 : // Create coinbase tx and add masternode/budget payments
95 3796 : CMutableTransaction txCoinbase = NewCoinbase(pindexPrev->nHeight + 1);
96 1898 : FillBlockPayee(txCoinbase, txCoinStake, pindexPrev, true);
97 :
98 : // Sign coinstake
99 1898 : if (!pwallet->SignCoinStake(txCoinStake)) {
100 0 : const COutPoint& stakeIn = txCoinStake.vin[0].prevout;
101 0 : return error("Unable to sign coinstake with input %s-%d", stakeIn.hash.ToString(), stakeIn.n);
102 : }
103 :
104 1898 : pblock->vtx.emplace_back(MakeTransactionRef(txCoinbase));
105 1898 : pblock->vtx.emplace_back(MakeTransactionRef(txCoinStake));
106 1898 : pblock->nTime = nTxNewTime;
107 1898 : return true;
108 : }
109 :
110 13228 : CMutableTransaction CreateCoinbaseTx(const CScript& scriptPubKeyIn, CBlockIndex* pindexPrev)
111 : {
112 13228 : assert(pindexPrev);
113 13228 : const int nHeight = pindexPrev->nHeight + 1;
114 :
115 : // Create coinbase tx
116 13228 : CMutableTransaction txCoinbase = NewCoinbase(nHeight, &scriptPubKeyIn);
117 :
118 : //Masternode and general budget payments
119 13228 : CMutableTransaction txDummy; // POW blocks have no coinstake
120 13228 : FillBlockPayee(txCoinbase, txDummy, pindexPrev, false);
121 :
122 : // If no payee was detected, then the whole block value goes to the first output.
123 13228 : if (txCoinbase.vout.size() == 1) {
124 12392 : txCoinbase.vout[0].nValue = GetBlockValue(nHeight);
125 : }
126 :
127 13228 : return txCoinbase;
128 : }
129 :
130 13227 : bool CreateCoinbaseTx(CBlock* pblock, const CScript& scriptPubKeyIn, CBlockIndex* pindexPrev)
131 : {
132 26454 : pblock->vtx.emplace_back(MakeTransactionRef(CreateCoinbaseTx(scriptPubKeyIn, pindexPrev)));
133 13227 : return true;
134 : }
135 :
136 15034 : BlockAssembler::BlockAssembler(const CChainParams& _chainparams, const bool _defaultPrintPriority)
137 15034 : : chainparams(_chainparams), defaultPrintPriority(_defaultPrintPriority)
138 : {
139 : // Largest block you're willing to create:
140 15034 : nBlockMaxSize = gArgs.GetArg("-blockmaxsize", DEFAULT_BLOCK_MAX_SIZE);
141 : // Limit to between 1K and MAX_BLOCK_SIZE-1K for sanity:
142 27107 : nBlockMaxSize = std::max((unsigned int)1000, std::min((unsigned int)(MAX_BLOCK_SIZE_CURRENT - 1000), nBlockMaxSize));
143 15034 : }
144 :
145 15034 : void BlockAssembler::resetBlock()
146 : {
147 15034 : inBlock.clear();
148 :
149 : // Reserve space for coinbase tx
150 15034 : nBlockSize = 1000;
151 15034 : nBlockSigOps = 100;
152 :
153 : // These counters do not include coinbase tx
154 15034 : nBlockTx = 0;
155 15034 : nFees = 0;
156 15034 : }
157 :
158 15034 : std::unique_ptr<CBlockTemplate> BlockAssembler::CreateNewBlock(const CScript& scriptPubKeyIn,
159 : CWallet* pwallet,
160 : bool fProofOfStake,
161 : std::vector<CStakeableOutput>* availableCoins,
162 : bool fNoMempoolTx,
163 : bool fTestValidity,
164 : CBlockIndex* prevBlock,
165 : bool stopPoSOnNewBlock,
166 : bool fIncludeQfc)
167 : {
168 15034 : resetBlock();
169 :
170 30068 : pblocktemplate.reset(new CBlockTemplate());
171 :
172 15034 : if(!pblocktemplate) return nullptr;
173 15034 : pblock = &pblocktemplate->block; // pointer for convenience
174 :
175 15034 : pblocktemplate->vTxFees.push_back(-1); // updated at end
176 15034 : pblocktemplate->vTxSigOps.push_back(-1); // updated at end
177 :
178 45076 : CBlockIndex* pindexPrev = prevBlock ? prevBlock : WITH_LOCK(cs_main, return chainActive.Tip());
179 15034 : assert(pindexPrev);
180 15034 : nHeight = pindexPrev->nHeight + 1;
181 :
182 15034 : pblock->nVersion = ComputeBlockVersion(chainparams.GetConsensus(), nHeight);
183 : // -regtest only: allow overriding block.nVersion with
184 : // -blockversion=N to test forking scenarios
185 15034 : if (Params().IsRegTestNet()) {
186 15034 : pblock->nVersion = gArgs.GetArg("-blockversion", pblock->nVersion);
187 : }
188 :
189 : // Depending on the tip height, try to find a coinstake who solves the block or create a coinbase tx.
190 28151 : if (!(fProofOfStake ? SolveProofOfStake(pblock, pindexPrev, pwallet, availableCoins, stopPoSOnNewBlock)
191 13117 : : CreateCoinbaseTx(pblock, scriptPubKeyIn, pindexPrev))) {
192 19 : return nullptr;
193 : }
194 :
195 : // After v6 enforcement, add LLMQ commitments if needed
196 15015 : const Consensus::Params& consensus = Params().GetConsensus();
197 15015 : if (consensus.NetworkUpgradeActive(nHeight, Consensus::UPGRADE_V6_0) && fIncludeQfc) {
198 2654 : LOCK(cs_main);
199 2654 : for (const auto& p : Params().GetConsensus().llmqs) {
200 1327 : CTransactionRef qcTx;
201 1327 : if (llmq::quorumBlockProcessor->GetMinableCommitmentTx(p.first, nHeight, qcTx)) {
202 353 : pblock->vtx.emplace_back(qcTx);
203 353 : pblocktemplate->vTxFees.emplace_back(0);
204 353 : pblocktemplate->vTxSigOps.emplace_back(0);
205 353 : nBlockSize += qcTx->GetTotalSize();
206 353 : ++nBlockTx;
207 : }
208 : }
209 : }
210 :
211 15015 : if (!fNoMempoolTx) {
212 : // Add transactions from mempool
213 37623 : LOCK2(cs_main,mempool.cs);
214 12541 : addPackageTxs();
215 : }
216 :
217 15015 : if (!fProofOfStake) {
218 : // Coinbase can get the fees.
219 26234 : CMutableTransaction txCoinbase(*pblock->vtx[0]);
220 13117 : txCoinbase.vout[0].nValue += nFees;
221 26234 : pblock->vtx[0] = MakeTransactionRef(txCoinbase);
222 13117 : pblocktemplate->vTxFees[0] = -nFees;
223 : }
224 :
225 15015 : nLastBlockTx = nBlockTx;
226 15015 : nLastBlockSize = nBlockSize;
227 15015 : LogPrintf("CreateNewBlock(): total size %u txs: %u fees: %ld sigops %d\n", nBlockSize, nBlockTx, nFees, nBlockSigOps);
228 :
229 :
230 : // Fill in header
231 15015 : pblock->hashPrevBlock = pindexPrev->GetBlockHash();
232 15015 : if (!fProofOfStake) UpdateTime(pblock, consensus, pindexPrev);
233 15015 : pblock->nBits = GetNextWorkRequired(pindexPrev, pblock);
234 15015 : pblock->nNonce = 0;
235 15015 : pblocktemplate->vTxSigOps[0] = GetLegacySigOpCount(*(pblock->vtx[0]));
236 15015 : appendSaplingTreeRoot();
237 :
238 15015 : if (fProofOfStake) { // this is only for PoS because the IncrementExtraNonce does it for PoW
239 1898 : pblock->hashMerkleRoot = BlockMerkleRoot(*pblock);
240 1898 : LogPrintf("CPUMiner : proof-of-stake block found %s \n", pblock->GetHash().GetHex());
241 1898 : if (!SignBlock(*pblock, *pwallet)) {
242 0 : LogPrintf("%s: Signing new block with UTXO key failed \n", __func__);
243 0 : return nullptr;
244 : }
245 : }
246 :
247 15015 : {
248 15015 : LOCK(cs_main);
249 30017 : if (prevBlock == nullptr && chainActive.Tip() != pindexPrev) return nullptr; // new block came in, move on
250 :
251 29967 : CValidationState state;
252 29967 : if (fTestValidity &&
253 14952 : !TestBlockValidity(state, *pblock, pindexPrev, false, false, false)) {
254 5 : throw std::runtime_error(
255 14 : strprintf("%s: TestBlockValidity failed: %s", __func__, FormatStateMessage(state)));
256 : }
257 : }
258 :
259 15029 : return std::move(pblocktemplate);
260 : }
261 :
262 122016 : void BlockAssembler::onlyUnconfirmed(CTxMemPool::setEntries& testSet)
263 : {
264 122016 : for (CTxMemPool::setEntries::iterator iit = testSet.begin(); iit != testSet.end(); ) {
265 : // Only test txs not already in the block
266 54403 : if (inBlock.count(*iit)) {
267 36995 : testSet.erase(iit++);
268 : }
269 : else {
270 193827 : iit++;
271 : }
272 : }
273 122016 : }
274 :
275 158199 : bool BlockAssembler::TestPackage(uint64_t packageSize, unsigned int packageSigOps)
276 : {
277 158199 : if (nBlockSize + packageSize >= nBlockMaxSize)
278 : return false;
279 122016 : if (nBlockSigOps + packageSigOps >= MAX_BLOCK_SIGOPS_CURRENT)
280 0 : return false;
281 : return true;
282 : }
283 :
284 : // Block size and sigops have already been tested. Check that all transactions
285 : // are final.
286 122016 : bool BlockAssembler::TestPackageFinality(const CTxMemPool::setEntries& package)
287 : {
288 261438 : for (const CTxMemPool::txiter& it : package) {
289 278848 : if (!IsFinalTx(it->GetSharedTx(), nHeight))
290 2 : return false;
291 : }
292 122014 : return true;
293 : }
294 :
295 139039 : void BlockAssembler::AddToBlock(CTxMemPool::txiter iter)
296 : {
297 139039 : pblock->vtx.emplace_back(iter->GetSharedTx());
298 139039 : pblocktemplate->vTxFees.push_back(iter->GetFee());
299 139039 : pblocktemplate->vTxSigOps.push_back(iter->GetSigOpCount());
300 139039 : nBlockSize += iter->GetTxSize();
301 139039 : ++nBlockTx;
302 139039 : nBlockSigOps += iter->GetSigOpCount();
303 139039 : nFees += iter->GetFee();
304 139039 : inBlock.insert(iter);
305 :
306 139039 : bool fPrintPriority = gArgs.GetBoolArg("-printpriority", defaultPrintPriority);
307 139039 : if (fPrintPriority) {
308 0 : LogPrintf("feerate %s txid %s\n",
309 0 : CFeeRate(iter->GetModifiedFee(), iter->GetTxSize()).ToString(),
310 0 : iter->GetTx().GetHash().ToString());
311 : }
312 139039 : }
313 :
314 134555 : void BlockAssembler::UpdatePackagesForAdded(const CTxMemPool::setEntries& alreadyAdded,
315 : indexed_modified_transaction_set& mapModifiedTx)
316 : {
317 273977 : for (const CTxMemPool::txiter& it : alreadyAdded) {
318 278844 : CTxMemPool::setEntries descendants;
319 139422 : mempool.CalculateDescendants(it, descendants);
320 : // Insert all descendants (not yet in block) into the modified set
321 2879111 : for (CTxMemPool::txiter desc : descendants) {
322 2739685 : if (alreadyAdded.count(desc))
323 1743493 : continue;
324 996199 : modtxiter mit = mapModifiedTx.find(desc);
325 996199 : if (mit == mapModifiedTx.end()) {
326 27694 : CTxMemPoolModifiedEntry modEntry(desc);
327 27694 : modEntry.nSizeWithAncestors -= it->GetTxSize();
328 27694 : modEntry.nModFeesWithAncestors -= it->GetModifiedFee();
329 27694 : modEntry.nSigOpCountWithAncestors -= it->GetSigOpCount();
330 27694 : mapModifiedTx.insert(modEntry);
331 : } else {
332 968505 : mapModifiedTx.modify(mit, update_for_parent_inclusion(it));
333 : }
334 : }
335 : }
336 134555 : }
337 :
338 : // Skip entries in mapTx that are already in a block or are present
339 : // in mapModifiedTx (which implies that the mapTx ancestor state is
340 : // stale due to ancestor inclusion in the block)
341 : // Also skip transactions that we've already failed to add. This can happen if
342 : // we consider a transaction in mapModifiedTx and it fails: we can then
343 : // potentially consider it again while walking mapTx. It's currently
344 : // guaranteed to fail again, but as a belt-and-suspenders check we put it in
345 : // failedTx and avoid re-evaluation, since the re-evaluation would be using
346 : // cached size/sigops/fee values that are not actually correct.
347 197639 : bool BlockAssembler::SkipMapTxEntry(CTxMemPool::txiter it, indexed_modified_transaction_set &mapModifiedTx, CTxMemPool::setEntries &failedTx)
348 : {
349 197639 : assert (it != mempool.mapTx.end());
350 543040 : if (mapModifiedTx.count(it) || inBlock.count(it) || failedTx.count(it))
351 39849 : return true;
352 : return false;
353 : }
354 :
355 122014 : void BlockAssembler::SortForBlock(const CTxMemPool::setEntries& package, CTxMemPool::txiter entry, std::vector<CTxMemPool::txiter>& sortedEntries)
356 : {
357 : // Sort package by ancestor count
358 : // If a transaction A depends on transaction B, then A's ancestor count
359 : // must be greater than B's. So this is sufficient to validly order the
360 : // transactions for block inclusion.
361 122014 : sortedEntries.clear();
362 122014 : sortedEntries.insert(sortedEntries.begin(), package.begin(), package.end());
363 122014 : std::sort(sortedEntries.begin(), sortedEntries.end(), CompareTxIterByAncestorCount());
364 122014 : }
365 :
366 : // This transaction selection algorithm orders the mempool based
367 : // on feerate of a transaction including all unconfirmed ancestors.
368 : // Since we don't remove transactions from the mempool as we select them
369 : // for block inclusion, we need an alternate method of updating the feerate
370 : // of a transaction with its not-yet-selected ancestors as we go.
371 : // This is accomplished by walking the in-mempool descendants of selected
372 : // transactions and storing a temporary modified state in mapModifiedTxs.
373 : // Each time through the loop, we compare the best transaction in
374 : // mapModifiedTxs with the next transaction in the mempool to decide what
375 : // transaction package to work on next.
376 12541 : void BlockAssembler::addPackageTxs()
377 : {
378 : // mapModifiedTx will store sorted packages after they are modified
379 : // because some of their txs are already in the block
380 12541 : indexed_modified_transaction_set mapModifiedTx;
381 : // Keep track of entries that failed inclusion, to avoid duplicate work
382 25080 : CTxMemPool::setEntries failedTx;
383 :
384 : // Start by adding all descendants of previously added txs to mapModifiedTx
385 : // and modifying them for their already included ancestors
386 12541 : UpdatePackagesForAdded(inBlock, mapModifiedTx);
387 :
388 12541 : CTxMemPool::indexed_transaction_set::index<ancestor_score>::type::iterator mi = mempool.mapTx.get<ancestor_score>().begin();
389 12541 : CTxMemPool::txiter iter;
390 210589 : while (mi != mempool.mapTx.get<ancestor_score>().end() || !mapModifiedTx.empty())
391 : {
392 : // First try to find a new transaction in mapTx to evaluate.
393 395689 : if (mi != mempool.mapTx.get<ancestor_score>().end() &&
394 197639 : SkipMapTxEntry(mempool.mapTx.project<0>(mi), mapModifiedTx, failedTx)) {
395 39849 : ++mi;
396 76034 : continue;
397 : }
398 :
399 : // Now that mi is not stale, determine which transaction to evaluate:
400 : // the next entry from mapTx, or the best from mapModifiedTx?
401 158201 : bool fUsingModified = false;
402 :
403 158201 : modtxscoreiter modit = mapModifiedTx.get<ancestor_score>().begin();
404 158201 : if (mi == mempool.mapTx.get<ancestor_score>().end()) {
405 : // We're out of entries in mapTx; use the entry from mapModifiedTx
406 411 : iter = modit->iter;
407 411 : fUsingModified = true;
408 : } else {
409 : // Try to compare the mapTx entry to the mapModifiedTx entry
410 157790 : iter = mempool.mapTx.project<0>(mi);
411 157790 : if (modit != mapModifiedTx.get<ancestor_score>().end() &&
412 46817 : CompareModifiedEntry()(*modit, CTxMemPoolModifiedEntry(iter))) {
413 : // The best entry in mapModifiedTx has higher score
414 : // than the one from mapTx.
415 : // Switch which transaction (package) to consider
416 22248 : iter = modit->iter;
417 22248 : fUsingModified = true;
418 : } else {
419 : // Either no entry in mapModifiedTx, or it's worse than mapTx.
420 : // Increment mi for the next loop iteration.
421 135542 : ++mi;
422 : }
423 : }
424 :
425 : // We skip mapTx entries that are inBlock, and mapModifiedTx shouldn't
426 : // contain anything that is inBlock.
427 158201 : assert(!inBlock.count(iter));
428 :
429 158201 : uint64_t packageSize = iter->GetSizeWithAncestors();
430 158201 : CAmount packageFees = iter->GetModFeesWithAncestors();
431 158201 : unsigned int packageSigOps = iter->GetSigOpCountWithAncestors();
432 158201 : if (fUsingModified) {
433 22659 : packageSize = modit->nSizeWithAncestors;
434 22659 : packageFees = modit->nModFeesWithAncestors;
435 22659 : packageSigOps = modit->nSigOpCountWithAncestors;
436 : }
437 :
438 158201 : if (packageFees < ::minRelayTxFee.GetFee(packageSize)) {
439 : // Everything else we might consider has a lower fee rate
440 2 : return;
441 : }
442 :
443 158199 : if (!TestPackage(packageSize, packageSigOps)) {
444 36183 : if (fUsingModified) {
445 : // Since we always look at the best entry in mapModifiedTx,
446 : // we must erase failed entries so that we can consider the
447 : // next best entry on the next loop iteration
448 13114 : mapModifiedTx.get<ancestor_score>().erase(modit);
449 13114 : failedTx.insert(iter);
450 : }
451 36183 : continue;
452 : }
453 :
454 244030 : CTxMemPool::setEntries ancestors;
455 122016 : uint64_t nNoLimit = std::numeric_limits<uint64_t>::max();
456 244030 : std::string dummy;
457 122016 : mempool.CalculateMemPoolAncestors(*iter, ancestors, nNoLimit, nNoLimit, nNoLimit, nNoLimit, dummy, false);
458 :
459 122016 : onlyUnconfirmed(ancestors);
460 122016 : ancestors.insert(iter);
461 :
462 : // Test if all tx's are Final
463 122016 : if (!TestPackageFinality(ancestors)) {
464 2 : if (fUsingModified) {
465 0 : mapModifiedTx.get<ancestor_score>().erase(modit);
466 0 : failedTx.insert(iter);
467 : }
468 2 : continue;
469 : }
470 :
471 : // Package can be added. Sort the entries in a valid order.
472 244028 : std::vector<CTxMemPool::txiter> sortedEntries;
473 122014 : SortForBlock(ancestors, iter, sortedEntries);
474 :
475 261053 : for (size_t i = 0; i < sortedEntries.size(); ++i) {
476 139422 : CTxMemPool::txiter& iterSortedEntries = sortedEntries[i];
477 139422 : if (iterSortedEntries->IsShielded()) {
478 : // Don't add SHIELD transactions if in maintenance (SPORK_20)
479 1075 : if (sporkManager.IsSporkActive(SPORK_20_SAPLING_MAINTENANCE)) {
480 : break;
481 : }
482 : // Don't add SHIELD transactions if there's no reserved space left in the block
483 1075 : if (nSizeShielded + iterSortedEntries->GetTxSize() > MAX_BLOCK_SHIELDED_TXES_SIZE) {
484 : break;
485 : }
486 : // Update cumulative size of SHIELD transactions in this block
487 692 : nSizeShielded += iterSortedEntries->GetTxSize();
488 : }
489 139039 : AddToBlock(iterSortedEntries);
490 : // Erase from the modified set, if present
491 139039 : mapModifiedTx.erase(iterSortedEntries);
492 : }
493 :
494 : // Update transactions that depend on each of these
495 122014 : UpdatePackagesForAdded(ancestors, mapModifiedTx);
496 : }
497 : }
498 :
499 15015 : void BlockAssembler::appendSaplingTreeRoot()
500 : {
501 : // Update header
502 15015 : pblock->hashFinalSaplingRoot = CalculateSaplingTreeRoot(pblock, nHeight, chainparams);
503 15015 : }
504 :
505 17450 : uint256 CalculateSaplingTreeRoot(CBlock* pblock, int nHeight, const CChainParams& chainparams)
506 : {
507 17450 : if (NetworkUpgradeActive(nHeight, chainparams.GetConsensus(), Consensus::UPGRADE_V5_0)) {
508 10060 : SaplingMerkleTree sapling_tree;
509 5030 : assert(pcoinsTip->GetSaplingAnchorAt(pcoinsTip->GetBestAnchor(), sapling_tree));
510 :
511 : // Update the Sapling commitment tree.
512 12990 : for (const auto &tx : pblock->vtx) {
513 9188 : if (tx->IsShieldedTx()) {
514 1467 : for (const OutputDescription &odesc : tx->sapData->vShieldedOutput) {
515 772 : sapling_tree.append(odesc.cmu);
516 : }
517 : }
518 : }
519 5030 : return sapling_tree.root();
520 : }
521 12420 : return UINT256_ZERO;
522 : }
523 :
524 13018 : bool SolveBlock(std::shared_ptr<CBlock>& pblock, int nHeight)
525 : {
526 13018 : unsigned int extraNonce = 0;
527 13018 : IncrementExtraNonce(pblock, nHeight, extraNonce);
528 51764 : while (pblock->nNonce < std::numeric_limits<uint32_t>::max() &&
529 25882 : !CheckProofOfWork(pblock->GetHash(), pblock->nBits)) {
530 12864 : ++pblock->nNonce;
531 : }
532 13018 : return pblock->nNonce != std::numeric_limits<uint32_t>::max();
533 : }
534 :
535 13018 : void IncrementExtraNonce(std::shared_ptr<CBlock>& pblock, int nHeight, unsigned int& nExtraNonce)
536 : {
537 : // Update nExtraNonce
538 13147 : static uint256 hashPrevBlock;
539 13018 : if (hashPrevBlock != pblock->hashPrevBlock) {
540 12991 : nExtraNonce = 0;
541 12991 : hashPrevBlock = pblock->hashPrevBlock;
542 : }
543 13018 : ++nExtraNonce;
544 26036 : CMutableTransaction txCoinbase(*pblock->vtx[0]);
545 26036 : txCoinbase.vin[0].scriptSig = (CScript() << nHeight << CScriptNum(nExtraNonce)) + COINBASE_FLAGS;
546 13018 : assert(txCoinbase.vin[0].scriptSig.size() <= 100);
547 :
548 26036 : pblock->vtx[0] = MakeTransactionRef(txCoinbase);
549 13018 : pblock->hashMerkleRoot = BlockMerkleRoot(*pblock);
550 13018 : }
551 :
552 15034 : int32_t ComputeBlockVersion(const Consensus::Params& consensus, int nHeight)
553 : {
554 15034 : if (NetworkUpgradeActive(nHeight, consensus, Consensus::UPGRADE_V5_0)) {
555 : return CBlockHeader::CURRENT_VERSION; // v11 (since 5.2.99)
556 10394 : } else if (consensus.NetworkUpgradeActive(nHeight, Consensus::UPGRADE_V4_0)) {
557 : return 7;
558 2658 : } else if (consensus.NetworkUpgradeActive(nHeight, Consensus::UPGRADE_V3_4)) {
559 : return 6;
560 2658 : } else if (consensus.NetworkUpgradeActive(nHeight, Consensus::UPGRADE_BIP65)) {
561 : return 5;
562 0 : } else if (consensus.NetworkUpgradeActive(nHeight, Consensus::UPGRADE_ZC)) {
563 : return 4;
564 : } else {
565 0 : return 3;
566 : }
567 : }
568 :
|
