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 8754 : int64_t UpdateTime(CBlockHeader* pblock, const Consensus::Params& consensusParams, const CBlockIndex* pindexPrev)
44 : {
45 8754 : int64_t nOldTime = pblock->nTime;
46 8754 : int64_t nNewTime = std::max(pindexPrev->GetMedianTimePast()+1, GetAdjustedTime());
47 :
48 8754 : if (nOldTime < nNewTime)
49 8754 : pblock->nTime = nNewTime;
50 :
51 : // Updating time can change work required on testnet:
52 8754 : if (consensusParams.fPowAllowMinDifficultyBlocks)
53 8754 : pblock->nBits = GetNextWorkRequired(pindexPrev, pblock);
54 :
55 8754 : return nNewTime - nOldTime;
56 : }
57 :
58 10235 : static CMutableTransaction NewCoinbase(const int nHeight, const CScript* pScriptPubKey = nullptr)
59 : {
60 10235 : CMutableTransaction txCoinbase;
61 10235 : txCoinbase.vout.emplace_back();
62 10235 : txCoinbase.vout[0].SetEmpty();
63 10235 : if (pScriptPubKey) txCoinbase.vout[0].scriptPubKey = *pScriptPubKey;
64 10235 : txCoinbase.vin.emplace_back();
65 10235 : txCoinbase.vin[0].scriptSig = CScript() << nHeight << OP_0;
66 10235 : return txCoinbase;
67 : }
68 :
69 1386 : bool SolveProofOfStake(CBlock* pblock, CBlockIndex* pindexPrev, CWallet* pwallet,
70 : std::vector<CStakeableOutput>* availableCoins, bool stopPoSOnNewBlock)
71 : {
72 1386 : boost::this_thread::interruption_point();
73 :
74 1386 : assert(pindexPrev);
75 1386 : pblock->nBits = GetNextWorkRequired(pindexPrev, pblock);
76 :
77 : // Sync wallet before create coinstake
78 1386 : pwallet->BlockUntilSyncedToCurrentChain();
79 :
80 2772 : CMutableTransaction txCoinStake;
81 1386 : int64_t nTxNewTime = 0;
82 1386 : if (!pwallet->CreateCoinStake(pindexPrev,
83 : pblock->nBits,
84 : txCoinStake,
85 : nTxNewTime,
86 : availableCoins,
87 : stopPoSOnNewBlock
88 : )) {
89 16 : LogPrint(BCLog::STAKING, "%s : stake not found\n", __func__);
90 16 : return false;
91 : }
92 : // Stake found
93 :
94 : // Create coinbase tx and add masternode/budget payments
95 2740 : CMutableTransaction txCoinbase = NewCoinbase(pindexPrev->nHeight + 1);
96 1370 : FillBlockPayee(txCoinbase, txCoinStake, pindexPrev, true);
97 :
98 : // Sign coinstake
99 1370 : 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 1370 : pblock->vtx.emplace_back(MakeTransactionRef(txCoinbase));
105 1370 : pblock->vtx.emplace_back(MakeTransactionRef(txCoinStake));
106 1370 : pblock->nTime = nTxNewTime;
107 1370 : return true;
108 : }
109 :
110 8865 : CMutableTransaction CreateCoinbaseTx(const CScript& scriptPubKeyIn, CBlockIndex* pindexPrev)
111 : {
112 8865 : assert(pindexPrev);
113 8865 : const int nHeight = pindexPrev->nHeight + 1;
114 :
115 : // Create coinbase tx
116 8865 : CMutableTransaction txCoinbase = NewCoinbase(nHeight, &scriptPubKeyIn);
117 :
118 : //Masternode and general budget payments
119 8865 : CMutableTransaction txDummy; // POW blocks have no coinstake
120 8865 : FillBlockPayee(txCoinbase, txDummy, pindexPrev, false);
121 :
122 : // If no payee was detected, then the whole block value goes to the first output.
123 8865 : if (txCoinbase.vout.size() == 1) {
124 8506 : txCoinbase.vout[0].nValue = GetBlockValue(nHeight);
125 : }
126 :
127 8865 : return txCoinbase;
128 : }
129 :
130 8864 : bool CreateCoinbaseTx(CBlock* pblock, const CScript& scriptPubKeyIn, CBlockIndex* pindexPrev)
131 : {
132 17728 : pblock->vtx.emplace_back(MakeTransactionRef(CreateCoinbaseTx(scriptPubKeyIn, pindexPrev)));
133 8864 : return true;
134 : }
135 :
136 10140 : BlockAssembler::BlockAssembler(const CChainParams& _chainparams, const bool _defaultPrintPriority)
137 10140 : : chainparams(_chainparams), defaultPrintPriority(_defaultPrintPriority)
138 : {
139 : // Largest block you're willing to create:
140 10140 : nBlockMaxSize = gArgs.GetArg("-blockmaxsize", DEFAULT_BLOCK_MAX_SIZE);
141 : // Limit to between 1K and MAX_BLOCK_SIZE-1K for sanity:
142 19978 : nBlockMaxSize = std::max((unsigned int)1000, std::min((unsigned int)(MAX_BLOCK_SIZE_CURRENT - 1000), nBlockMaxSize));
143 10140 : }
144 :
145 10140 : void BlockAssembler::resetBlock()
146 : {
147 10140 : inBlock.clear();
148 :
149 : // Reserve space for coinbase tx
150 10140 : nBlockSize = 1000;
151 10140 : nBlockSigOps = 100;
152 :
153 : // These counters do not include coinbase tx
154 10140 : nBlockTx = 0;
155 10140 : nFees = 0;
156 10140 : }
157 :
158 10140 : 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 10140 : resetBlock();
169 :
170 20280 : pblocktemplate.reset(new CBlockTemplate());
171 :
172 10140 : if(!pblocktemplate) return nullptr;
173 10140 : pblock = &pblocktemplate->block; // pointer for convenience
174 :
175 10140 : pblocktemplate->vTxFees.push_back(-1); // updated at end
176 10140 : pblocktemplate->vTxSigOps.push_back(-1); // updated at end
177 :
178 30394 : CBlockIndex* pindexPrev = prevBlock ? prevBlock : WITH_LOCK(cs_main, return chainActive.Tip());
179 10140 : assert(pindexPrev);
180 10140 : nHeight = pindexPrev->nHeight + 1;
181 :
182 10140 : pblock->nVersion = ComputeBlockVersion(chainparams.GetConsensus(), nHeight);
183 : // -regtest only: allow overriding block.nVersion with
184 : // -blockversion=N to test forking scenarios
185 10140 : if (Params().IsRegTestNet()) {
186 10140 : 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 18894 : if (!(fProofOfStake ? SolveProofOfStake(pblock, pindexPrev, pwallet, availableCoins, stopPoSOnNewBlock)
191 8754 : : CreateCoinbaseTx(pblock, scriptPubKeyIn, pindexPrev))) {
192 16 : return nullptr;
193 : }
194 :
195 : // After v6 enforcement, add LLMQ commitments if needed
196 10124 : const Consensus::Params& consensus = Params().GetConsensus();
197 10124 : if (consensus.NetworkUpgradeActive(nHeight, Consensus::UPGRADE_V6_0) && fIncludeQfc) {
198 612 : LOCK(cs_main);
199 612 : for (const auto& p : Params().GetConsensus().llmqs) {
200 306 : CTransactionRef qcTx;
201 306 : if (llmq::quorumBlockProcessor->GetMinableCommitmentTx(p.first, nHeight, qcTx)) {
202 83 : pblock->vtx.emplace_back(qcTx);
203 83 : pblocktemplate->vTxFees.emplace_back(0);
204 83 : pblocktemplate->vTxSigOps.emplace_back(0);
205 83 : nBlockSize += qcTx->GetTotalSize();
206 83 : ++nBlockTx;
207 : }
208 : }
209 : }
210 :
211 10124 : if (!fNoMempoolTx) {
212 : // Add transactions from mempool
213 22950 : LOCK2(cs_main,mempool.cs);
214 7650 : addPackageTxs();
215 : }
216 :
217 10124 : if (!fProofOfStake) {
218 : // Coinbase can get the fees.
219 17508 : CMutableTransaction txCoinbase(*pblock->vtx[0]);
220 8754 : txCoinbase.vout[0].nValue += nFees;
221 17508 : pblock->vtx[0] = MakeTransactionRef(txCoinbase);
222 8754 : pblocktemplate->vTxFees[0] = -nFees;
223 : }
224 :
225 10124 : nLastBlockTx = nBlockTx;
226 10124 : nLastBlockSize = nBlockSize;
227 10124 : LogPrintf("CreateNewBlock(): total size %u txs: %u fees: %ld sigops %d\n", nBlockSize, nBlockTx, nFees, nBlockSigOps);
228 :
229 :
230 : // Fill in header
231 10124 : pblock->hashPrevBlock = pindexPrev->GetBlockHash();
232 10124 : if (!fProofOfStake) UpdateTime(pblock, consensus, pindexPrev);
233 10124 : pblock->nBits = GetNextWorkRequired(pindexPrev, pblock);
234 10124 : pblock->nNonce = 0;
235 10124 : pblocktemplate->vTxSigOps[0] = GetLegacySigOpCount(*(pblock->vtx[0]));
236 10124 : appendSaplingTreeRoot();
237 :
238 10124 : if (fProofOfStake) { // this is only for PoS because the IncrementExtraNonce does it for PoW
239 1370 : pblock->hashMerkleRoot = BlockMerkleRoot(*pblock);
240 1370 : LogPrintf("CPUMiner : proof-of-stake block found %s \n", pblock->GetHash().GetHex());
241 1370 : 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 10124 : {
248 10124 : LOCK(cs_main);
249 20235 : if (prevBlock == nullptr && chainActive.Tip() != pindexPrev) return nullptr; // new block came in, move on
250 :
251 20185 : CValidationState state;
252 20185 : if (fTestValidity &&
253 10061 : !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 10135 : return std::move(pblocktemplate);
260 : }
261 :
262 6589 : void BlockAssembler::onlyUnconfirmed(CTxMemPool::setEntries& testSet)
263 : {
264 6589 : for (CTxMemPool::setEntries::iterator iit = testSet.begin(); iit != testSet.end(); ) {
265 : // Only test txs not already in the block
266 18661 : if (inBlock.count(*iit)) {
267 15519 : testSet.erase(iit++);
268 : }
269 : else {
270 28392 : iit++;
271 : }
272 : }
273 6589 : }
274 :
275 22202 : bool BlockAssembler::TestPackage(uint64_t packageSize, unsigned int packageSigOps)
276 : {
277 22202 : if (nBlockSize + packageSize >= nBlockMaxSize)
278 : return false;
279 6589 : 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 6589 : bool BlockAssembler::TestPackageFinality(const CTxMemPool::setEntries& package)
287 : {
288 16318 : for (const CTxMemPool::txiter& it : package) {
289 19462 : if (!IsFinalTx(it->GetSharedTx(), nHeight))
290 2 : return false;
291 : }
292 6587 : return true;
293 : }
294 :
295 9729 : void BlockAssembler::AddToBlock(CTxMemPool::txiter iter)
296 : {
297 9729 : pblock->vtx.emplace_back(iter->GetSharedTx());
298 9729 : pblocktemplate->vTxFees.push_back(iter->GetFee());
299 9729 : pblocktemplate->vTxSigOps.push_back(iter->GetSigOpCount());
300 9729 : nBlockSize += iter->GetTxSize();
301 9729 : ++nBlockTx;
302 9729 : nBlockSigOps += iter->GetSigOpCount();
303 9729 : nFees += iter->GetFee();
304 9729 : inBlock.insert(iter);
305 :
306 9729 : bool fPrintPriority = gArgs.GetBoolArg("-printpriority", defaultPrintPriority);
307 9729 : 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 9729 : }
313 :
314 14237 : void BlockAssembler::UpdatePackagesForAdded(const CTxMemPool::setEntries& alreadyAdded,
315 : indexed_modified_transaction_set& mapModifiedTx)
316 : {
317 23966 : for (const CTxMemPool::txiter& it : alreadyAdded) {
318 19458 : CTxMemPool::setEntries descendants;
319 9729 : mempool.CalculateDescendants(it, descendants);
320 : // Insert all descendants (not yet in block) into the modified set
321 2535369 : for (CTxMemPool::txiter desc : descendants) {
322 2525636 : if (alreadyAdded.count(desc))
323 1590895 : continue;
324 934748 : modtxiter mit = mapModifiedTx.find(desc);
325 934748 : if (mit == mapModifiedTx.end()) {
326 1557 : CTxMemPoolModifiedEntry modEntry(desc);
327 1557 : modEntry.nSizeWithAncestors -= it->GetTxSize();
328 1557 : modEntry.nModFeesWithAncestors -= it->GetModifiedFee();
329 1557 : modEntry.nSigOpCountWithAncestors -= it->GetSigOpCount();
330 1557 : mapModifiedTx.insert(modEntry);
331 : } else {
332 933191 : mapModifiedTx.modify(mit, update_for_parent_inclusion(it));
333 : }
334 : }
335 : }
336 14237 : }
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 25132 : bool BlockAssembler::SkipMapTxEntry(CTxMemPool::txiter it, indexed_modified_transaction_set &mapModifiedTx, CTxMemPool::setEntries &failedTx)
348 : {
349 25132 : assert (it != mempool.mapTx.end());
350 70724 : if (mapModifiedTx.count(it) || inBlock.count(it) || failedTx.count(it))
351 3333 : return true;
352 : return false;
353 : }
354 :
355 6587 : 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 6587 : sortedEntries.clear();
362 6587 : sortedEntries.insert(sortedEntries.begin(), package.begin(), package.end());
363 6587 : std::sort(sortedEntries.begin(), sortedEntries.end(), CompareTxIterByAncestorCount());
364 6587 : }
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 7650 : 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 7650 : indexed_modified_transaction_set mapModifiedTx;
381 : // Keep track of entries that failed inclusion, to avoid duplicate work
382 15298 : 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 7650 : UpdatePackagesForAdded(inBlock, mapModifiedTx);
387 :
388 7650 : CTxMemPool::indexed_transaction_set::index<ancestor_score>::type::iterator mi = mempool.mapTx.get<ancestor_score>().begin();
389 7650 : CTxMemPool::txiter iter;
390 33185 : while (mi != mempool.mapTx.get<ancestor_score>().end() || !mapModifiedTx.empty())
391 : {
392 : // First try to find a new transaction in mapTx to evaluate.
393 50669 : if (mi != mempool.mapTx.get<ancestor_score>().end() &&
394 25132 : SkipMapTxEntry(mempool.mapTx.project<0>(mi), mapModifiedTx, failedTx)) {
395 3333 : ++mi;
396 18948 : 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 22204 : bool fUsingModified = false;
402 :
403 22204 : modtxscoreiter modit = mapModifiedTx.get<ancestor_score>().begin();
404 22204 : if (mi == mempool.mapTx.get<ancestor_score>().end()) {
405 : // We're out of entries in mapTx; use the entry from mapModifiedTx
406 405 : iter = modit->iter;
407 405 : fUsingModified = true;
408 : } else {
409 : // Try to compare the mapTx entry to the mapModifiedTx entry
410 21799 : iter = mempool.mapTx.project<0>(mi);
411 21799 : if (modit != mapModifiedTx.get<ancestor_score>().end() &&
412 13 : 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 3 : iter = modit->iter;
417 3 : 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 21796 : ++mi;
422 : }
423 : }
424 :
425 : // We skip mapTx entries that are inBlock, and mapModifiedTx shouldn't
426 : // contain anything that is inBlock.
427 22204 : assert(!inBlock.count(iter));
428 :
429 22204 : uint64_t packageSize = iter->GetSizeWithAncestors();
430 22204 : CAmount packageFees = iter->GetModFeesWithAncestors();
431 22204 : unsigned int packageSigOps = iter->GetSigOpCountWithAncestors();
432 22204 : if (fUsingModified) {
433 408 : packageSize = modit->nSizeWithAncestors;
434 408 : packageFees = modit->nModFeesWithAncestors;
435 408 : packageSigOps = modit->nSigOpCountWithAncestors;
436 : }
437 :
438 22204 : if (packageFees < ::minRelayTxFee.GetFee(packageSize)) {
439 : // Everything else we might consider has a lower fee rate
440 2 : return;
441 : }
442 :
443 22202 : if (!TestPackage(packageSize, packageSigOps)) {
444 15613 : 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 351 : mapModifiedTx.get<ancestor_score>().erase(modit);
449 351 : failedTx.insert(iter);
450 : }
451 15613 : continue;
452 : }
453 :
454 13176 : CTxMemPool::setEntries ancestors;
455 6589 : uint64_t nNoLimit = std::numeric_limits<uint64_t>::max();
456 13176 : std::string dummy;
457 6589 : mempool.CalculateMemPoolAncestors(*iter, ancestors, nNoLimit, nNoLimit, nNoLimit, nNoLimit, dummy, false);
458 :
459 6589 : onlyUnconfirmed(ancestors);
460 6589 : ancestors.insert(iter);
461 :
462 : // Test if all tx's are Final
463 6589 : 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 13174 : std::vector<CTxMemPool::txiter> sortedEntries;
473 6587 : SortForBlock(ancestors, iter, sortedEntries);
474 :
475 16316 : for (size_t i = 0; i < sortedEntries.size(); ++i) {
476 9729 : CTxMemPool::txiter& iterSortedEntries = sortedEntries[i];
477 9729 : if (iterSortedEntries->IsShielded()) {
478 : // Don't add SHIELD transactions if in maintenance (SPORK_20)
479 78 : 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 78 : if (nSizeShielded + iterSortedEntries->GetTxSize() > MAX_BLOCK_SHIELDED_TXES_SIZE) {
484 : break;
485 : }
486 : // Update cumulative size of SHIELD transactions in this block
487 78 : nSizeShielded += iterSortedEntries->GetTxSize();
488 : }
489 9729 : AddToBlock(iterSortedEntries);
490 : // Erase from the modified set, if present
491 9729 : mapModifiedTx.erase(iterSortedEntries);
492 : }
493 :
494 : // Update transactions that depend on each of these
495 6587 : UpdatePackagesForAdded(ancestors, mapModifiedTx);
496 : }
497 : }
498 :
499 10124 : void BlockAssembler::appendSaplingTreeRoot()
500 : {
501 : // Update header
502 10124 : pblock->hashFinalSaplingRoot = CalculateSaplingTreeRoot(pblock, nHeight, chainparams);
503 10124 : }
504 :
505 12559 : uint256 CalculateSaplingTreeRoot(CBlock* pblock, int nHeight, const CChainParams& chainparams)
506 : {
507 12559 : if (NetworkUpgradeActive(nHeight, chainparams.GetConsensus(), Consensus::UPGRADE_V5_0)) {
508 6562 : SaplingMerkleTree sapling_tree;
509 3281 : assert(pcoinsTip->GetSaplingAnchorAt(pcoinsTip->GetBestAnchor(), sapling_tree));
510 :
511 : // Update the Sapling commitment tree.
512 7952 : for (const auto &tx : pblock->vtx) {
513 4969 : if (tx->IsShieldedTx()) {
514 239 : for (const OutputDescription &odesc : tx->sapData->vShieldedOutput) {
515 158 : sapling_tree.append(odesc.cmu);
516 : }
517 : }
518 : }
519 3281 : return sapling_tree.root();
520 : }
521 9278 : return UINT256_ZERO;
522 : }
523 :
524 8644 : bool SolveBlock(std::shared_ptr<CBlock>& pblock, int nHeight)
525 : {
526 8644 : unsigned int extraNonce = 0;
527 8644 : IncrementExtraNonce(pblock, nHeight, extraNonce);
528 34262 : while (pblock->nNonce < std::numeric_limits<uint32_t>::max() &&
529 17131 : !CheckProofOfWork(pblock->GetHash(), pblock->nBits)) {
530 8487 : ++pblock->nNonce;
531 : }
532 8644 : return pblock->nNonce != std::numeric_limits<uint32_t>::max();
533 : }
534 :
535 8644 : void IncrementExtraNonce(std::shared_ptr<CBlock>& pblock, int nHeight, unsigned int& nExtraNonce)
536 : {
537 : // Update nExtraNonce
538 8763 : static uint256 hashPrevBlock;
539 8644 : if (hashPrevBlock != pblock->hashPrevBlock) {
540 8617 : nExtraNonce = 0;
541 8617 : hashPrevBlock = pblock->hashPrevBlock;
542 : }
543 8644 : ++nExtraNonce;
544 17288 : CMutableTransaction txCoinbase(*pblock->vtx[0]);
545 17288 : txCoinbase.vin[0].scriptSig = (CScript() << nHeight << CScriptNum(nExtraNonce)) + COINBASE_FLAGS;
546 8644 : assert(txCoinbase.vin[0].scriptSig.size() <= 100);
547 :
548 17288 : pblock->vtx[0] = MakeTransactionRef(txCoinbase);
549 8644 : pblock->hashMerkleRoot = BlockMerkleRoot(*pblock);
550 8644 : }
551 :
552 10140 : int32_t ComputeBlockVersion(const Consensus::Params& consensus, int nHeight)
553 : {
554 10140 : if (NetworkUpgradeActive(nHeight, consensus, Consensus::UPGRADE_V5_0)) {
555 : return CBlockHeader::CURRENT_VERSION; // v11 (since 5.2.99)
556 7255 : } else if (consensus.NetworkUpgradeActive(nHeight, Consensus::UPGRADE_V4_0)) {
557 : return 7;
558 0 : } else if (consensus.NetworkUpgradeActive(nHeight, Consensus::UPGRADE_V3_4)) {
559 : return 6;
560 0 : } 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 :
|
