Use the variable name _ for unused return values
[bitcoinplatinum.git] / src / validation.cpp
blob3b9636839d27b308be3475f8f73791bd79e5f1a1
1 // Copyright (c) 2009-2010 Satoshi Nakamoto
2 // Copyright (c) 2009-2016 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.
6 #include "validation.h"
8 #include "arith_uint256.h"
9 #include "chain.h"
10 #include "chainparams.h"
11 #include "checkpoints.h"
12 #include "checkqueue.h"
13 #include "consensus/consensus.h"
14 #include "consensus/merkle.h"
15 #include "consensus/tx_verify.h"
16 #include "consensus/validation.h"
17 #include "cuckoocache.h"
18 #include "fs.h"
19 #include "hash.h"
20 #include "init.h"
21 #include "policy/fees.h"
22 #include "policy/policy.h"
23 #include "policy/rbf.h"
24 #include "pow.h"
25 #include "primitives/block.h"
26 #include "primitives/transaction.h"
27 #include "random.h"
28 #include "reverse_iterator.h"
29 #include "script/script.h"
30 #include "script/sigcache.h"
31 #include "script/standard.h"
32 #include "timedata.h"
33 #include "tinyformat.h"
34 #include "txdb.h"
35 #include "txmempool.h"
36 #include "ui_interface.h"
37 #include "undo.h"
38 #include "util.h"
39 #include "utilmoneystr.h"
40 #include "utilstrencodings.h"
41 #include "validationinterface.h"
42 #include "versionbits.h"
43 #include "warnings.h"
45 #include <atomic>
46 #include <sstream>
48 #include <boost/algorithm/string/replace.hpp>
49 #include <boost/algorithm/string/join.hpp>
50 #include <boost/thread.hpp>
52 #if defined(NDEBUG)
53 # error "Bitcoin cannot be compiled without assertions."
54 #endif
56 #define MICRO 0.000001
57 #define MILLI 0.001
59 /**
60 * Global state
63 CCriticalSection cs_main;
65 BlockMap mapBlockIndex;
66 CChain chainActive;
67 CBlockIndex *pindexBestHeader = nullptr;
68 CWaitableCriticalSection csBestBlock;
69 CConditionVariable cvBlockChange;
70 int nScriptCheckThreads = 0;
71 std::atomic_bool fImporting(false);
72 bool fReindex = false;
73 bool fTxIndex = false;
74 bool fHavePruned = false;
75 bool fPruneMode = false;
76 bool fIsBareMultisigStd = DEFAULT_PERMIT_BAREMULTISIG;
77 bool fRequireStandard = true;
78 bool fCheckBlockIndex = false;
79 bool fCheckpointsEnabled = DEFAULT_CHECKPOINTS_ENABLED;
80 size_t nCoinCacheUsage = 5000 * 300;
81 uint64_t nPruneTarget = 0;
82 int64_t nMaxTipAge = DEFAULT_MAX_TIP_AGE;
83 bool fEnableReplacement = DEFAULT_ENABLE_REPLACEMENT;
85 uint256 hashAssumeValid;
87 CFeeRate minRelayTxFee = CFeeRate(DEFAULT_MIN_RELAY_TX_FEE);
88 CAmount maxTxFee = DEFAULT_TRANSACTION_MAXFEE;
90 CBlockPolicyEstimator feeEstimator;
91 CTxMemPool mempool(&feeEstimator);
93 static void CheckBlockIndex(const Consensus::Params& consensusParams);
95 /** Constant stuff for coinbase transactions we create: */
96 CScript COINBASE_FLAGS;
98 const std::string strMessageMagic = "Bitcoin Signed Message:\n";
100 // Internal stuff
101 namespace {
103 struct CBlockIndexWorkComparator
105 bool operator()(const CBlockIndex *pa, const CBlockIndex *pb) const {
106 // First sort by most total work, ...
107 if (pa->nChainWork > pb->nChainWork) return false;
108 if (pa->nChainWork < pb->nChainWork) return true;
110 // ... then by earliest time received, ...
111 if (pa->nSequenceId < pb->nSequenceId) return false;
112 if (pa->nSequenceId > pb->nSequenceId) return true;
114 // Use pointer address as tie breaker (should only happen with blocks
115 // loaded from disk, as those all have id 0).
116 if (pa < pb) return false;
117 if (pa > pb) return true;
119 // Identical blocks.
120 return false;
124 CBlockIndex *pindexBestInvalid;
127 * The set of all CBlockIndex entries with BLOCK_VALID_TRANSACTIONS (for itself and all ancestors) and
128 * as good as our current tip or better. Entries may be failed, though, and pruning nodes may be
129 * missing the data for the block.
131 std::set<CBlockIndex*, CBlockIndexWorkComparator> setBlockIndexCandidates;
132 /** All pairs A->B, where A (or one of its ancestors) misses transactions, but B has transactions.
133 * Pruned nodes may have entries where B is missing data.
135 std::multimap<CBlockIndex*, CBlockIndex*> mapBlocksUnlinked;
137 CCriticalSection cs_LastBlockFile;
138 std::vector<CBlockFileInfo> vinfoBlockFile;
139 int nLastBlockFile = 0;
140 /** Global flag to indicate we should check to see if there are
141 * block/undo files that should be deleted. Set on startup
142 * or if we allocate more file space when we're in prune mode
144 bool fCheckForPruning = false;
147 * Every received block is assigned a unique and increasing identifier, so we
148 * know which one to give priority in case of a fork.
150 CCriticalSection cs_nBlockSequenceId;
151 /** Blocks loaded from disk are assigned id 0, so start the counter at 1. */
152 int32_t nBlockSequenceId = 1;
153 /** Decreasing counter (used by subsequent preciousblock calls). */
154 int32_t nBlockReverseSequenceId = -1;
155 /** chainwork for the last block that preciousblock has been applied to. */
156 arith_uint256 nLastPreciousChainwork = 0;
158 /** Dirty block index entries. */
159 std::set<CBlockIndex*> setDirtyBlockIndex;
161 /** Dirty block file entries. */
162 std::set<int> setDirtyFileInfo;
163 } // anon namespace
165 CBlockIndex* FindForkInGlobalIndex(const CChain& chain, const CBlockLocator& locator)
167 // Find the first block the caller has in the main chain
168 for (const uint256& hash : locator.vHave) {
169 BlockMap::iterator mi = mapBlockIndex.find(hash);
170 if (mi != mapBlockIndex.end())
172 CBlockIndex* pindex = (*mi).second;
173 if (chain.Contains(pindex))
174 return pindex;
175 if (pindex->GetAncestor(chain.Height()) == chain.Tip()) {
176 return chain.Tip();
180 return chain.Genesis();
183 CCoinsViewDB *pcoinsdbview = nullptr;
184 CCoinsViewCache *pcoinsTip = nullptr;
185 CBlockTreeDB *pblocktree = nullptr;
187 enum FlushStateMode {
188 FLUSH_STATE_NONE,
189 FLUSH_STATE_IF_NEEDED,
190 FLUSH_STATE_PERIODIC,
191 FLUSH_STATE_ALWAYS
194 // See definition for documentation
195 static bool FlushStateToDisk(const CChainParams& chainParams, CValidationState &state, FlushStateMode mode, int nManualPruneHeight=0);
196 static void FindFilesToPruneManual(std::set<int>& setFilesToPrune, int nManualPruneHeight);
197 static void FindFilesToPrune(std::set<int>& setFilesToPrune, uint64_t nPruneAfterHeight);
198 bool CheckInputs(const CTransaction& tx, CValidationState &state, const CCoinsViewCache &inputs, bool fScriptChecks, unsigned int flags, bool cacheSigStore, bool cacheFullScriptStore, PrecomputedTransactionData& txdata, std::vector<CScriptCheck> *pvChecks = nullptr);
199 static FILE* OpenUndoFile(const CDiskBlockPos &pos, bool fReadOnly = false);
201 bool CheckFinalTx(const CTransaction &tx, int flags)
203 AssertLockHeld(cs_main);
205 // By convention a negative value for flags indicates that the
206 // current network-enforced consensus rules should be used. In
207 // a future soft-fork scenario that would mean checking which
208 // rules would be enforced for the next block and setting the
209 // appropriate flags. At the present time no soft-forks are
210 // scheduled, so no flags are set.
211 flags = std::max(flags, 0);
213 // CheckFinalTx() uses chainActive.Height()+1 to evaluate
214 // nLockTime because when IsFinalTx() is called within
215 // CBlock::AcceptBlock(), the height of the block *being*
216 // evaluated is what is used. Thus if we want to know if a
217 // transaction can be part of the *next* block, we need to call
218 // IsFinalTx() with one more than chainActive.Height().
219 const int nBlockHeight = chainActive.Height() + 1;
221 // BIP113 will require that time-locked transactions have nLockTime set to
222 // less than the median time of the previous block they're contained in.
223 // When the next block is created its previous block will be the current
224 // chain tip, so we use that to calculate the median time passed to
225 // IsFinalTx() if LOCKTIME_MEDIAN_TIME_PAST is set.
226 const int64_t nBlockTime = (flags & LOCKTIME_MEDIAN_TIME_PAST)
227 ? chainActive.Tip()->GetMedianTimePast()
228 : GetAdjustedTime();
230 return IsFinalTx(tx, nBlockHeight, nBlockTime);
233 bool TestLockPointValidity(const LockPoints* lp)
235 AssertLockHeld(cs_main);
236 assert(lp);
237 // If there are relative lock times then the maxInputBlock will be set
238 // If there are no relative lock times, the LockPoints don't depend on the chain
239 if (lp->maxInputBlock) {
240 // Check whether chainActive is an extension of the block at which the LockPoints
241 // calculation was valid. If not LockPoints are no longer valid
242 if (!chainActive.Contains(lp->maxInputBlock)) {
243 return false;
247 // LockPoints still valid
248 return true;
251 bool CheckSequenceLocks(const CTransaction &tx, int flags, LockPoints* lp, bool useExistingLockPoints)
253 AssertLockHeld(cs_main);
254 AssertLockHeld(mempool.cs);
256 CBlockIndex* tip = chainActive.Tip();
257 CBlockIndex index;
258 index.pprev = tip;
259 // CheckSequenceLocks() uses chainActive.Height()+1 to evaluate
260 // height based locks because when SequenceLocks() is called within
261 // ConnectBlock(), the height of the block *being*
262 // evaluated is what is used.
263 // Thus if we want to know if a transaction can be part of the
264 // *next* block, we need to use one more than chainActive.Height()
265 index.nHeight = tip->nHeight + 1;
267 std::pair<int, int64_t> lockPair;
268 if (useExistingLockPoints) {
269 assert(lp);
270 lockPair.first = lp->height;
271 lockPair.second = lp->time;
273 else {
274 // pcoinsTip contains the UTXO set for chainActive.Tip()
275 CCoinsViewMemPool viewMemPool(pcoinsTip, mempool);
276 std::vector<int> prevheights;
277 prevheights.resize(tx.vin.size());
278 for (size_t txinIndex = 0; txinIndex < tx.vin.size(); txinIndex++) {
279 const CTxIn& txin = tx.vin[txinIndex];
280 Coin coin;
281 if (!viewMemPool.GetCoin(txin.prevout, coin)) {
282 return error("%s: Missing input", __func__);
284 if (coin.nHeight == MEMPOOL_HEIGHT) {
285 // Assume all mempool transaction confirm in the next block
286 prevheights[txinIndex] = tip->nHeight + 1;
287 } else {
288 prevheights[txinIndex] = coin.nHeight;
291 lockPair = CalculateSequenceLocks(tx, flags, &prevheights, index);
292 if (lp) {
293 lp->height = lockPair.first;
294 lp->time = lockPair.second;
295 // Also store the hash of the block with the highest height of
296 // all the blocks which have sequence locked prevouts.
297 // This hash needs to still be on the chain
298 // for these LockPoint calculations to be valid
299 // Note: It is impossible to correctly calculate a maxInputBlock
300 // if any of the sequence locked inputs depend on unconfirmed txs,
301 // except in the special case where the relative lock time/height
302 // is 0, which is equivalent to no sequence lock. Since we assume
303 // input height of tip+1 for mempool txs and test the resulting
304 // lockPair from CalculateSequenceLocks against tip+1. We know
305 // EvaluateSequenceLocks will fail if there was a non-zero sequence
306 // lock on a mempool input, so we can use the return value of
307 // CheckSequenceLocks to indicate the LockPoints validity
308 int maxInputHeight = 0;
309 for (int height : prevheights) {
310 // Can ignore mempool inputs since we'll fail if they had non-zero locks
311 if (height != tip->nHeight+1) {
312 maxInputHeight = std::max(maxInputHeight, height);
315 lp->maxInputBlock = tip->GetAncestor(maxInputHeight);
318 return EvaluateSequenceLocks(index, lockPair);
321 // Returns the script flags which should be checked for a given block
322 static unsigned int GetBlockScriptFlags(const CBlockIndex* pindex, const Consensus::Params& chainparams);
324 static void LimitMempoolSize(CTxMemPool& pool, size_t limit, unsigned long age) {
325 int expired = pool.Expire(GetTime() - age);
326 if (expired != 0) {
327 LogPrint(BCLog::MEMPOOL, "Expired %i transactions from the memory pool\n", expired);
330 std::vector<COutPoint> vNoSpendsRemaining;
331 pool.TrimToSize(limit, &vNoSpendsRemaining);
332 for (const COutPoint& removed : vNoSpendsRemaining)
333 pcoinsTip->Uncache(removed);
336 /** Convert CValidationState to a human-readable message for logging */
337 std::string FormatStateMessage(const CValidationState &state)
339 return strprintf("%s%s (code %i)",
340 state.GetRejectReason(),
341 state.GetDebugMessage().empty() ? "" : ", "+state.GetDebugMessage(),
342 state.GetRejectCode());
345 static bool IsCurrentForFeeEstimation()
347 AssertLockHeld(cs_main);
348 if (IsInitialBlockDownload())
349 return false;
350 if (chainActive.Tip()->GetBlockTime() < (GetTime() - MAX_FEE_ESTIMATION_TIP_AGE))
351 return false;
352 if (chainActive.Height() < pindexBestHeader->nHeight - 1)
353 return false;
354 return true;
357 /* Make mempool consistent after a reorg, by re-adding or recursively erasing
358 * disconnected block transactions from the mempool, and also removing any
359 * other transactions from the mempool that are no longer valid given the new
360 * tip/height.
362 * Note: we assume that disconnectpool only contains transactions that are NOT
363 * confirmed in the current chain nor already in the mempool (otherwise,
364 * in-mempool descendants of such transactions would be removed).
366 * Passing fAddToMempool=false will skip trying to add the transactions back,
367 * and instead just erase from the mempool as needed.
370 void UpdateMempoolForReorg(DisconnectedBlockTransactions &disconnectpool, bool fAddToMempool)
372 AssertLockHeld(cs_main);
373 std::vector<uint256> vHashUpdate;
374 // disconnectpool's insertion_order index sorts the entries from
375 // oldest to newest, but the oldest entry will be the last tx from the
376 // latest mined block that was disconnected.
377 // Iterate disconnectpool in reverse, so that we add transactions
378 // back to the mempool starting with the earliest transaction that had
379 // been previously seen in a block.
380 auto it = disconnectpool.queuedTx.get<insertion_order>().rbegin();
381 while (it != disconnectpool.queuedTx.get<insertion_order>().rend()) {
382 // ignore validation errors in resurrected transactions
383 CValidationState stateDummy;
384 if (!fAddToMempool || (*it)->IsCoinBase() || !AcceptToMemoryPool(mempool, stateDummy, *it, false, nullptr, nullptr, true)) {
385 // If the transaction doesn't make it in to the mempool, remove any
386 // transactions that depend on it (which would now be orphans).
387 mempool.removeRecursive(**it, MemPoolRemovalReason::REORG);
388 } else if (mempool.exists((*it)->GetHash())) {
389 vHashUpdate.push_back((*it)->GetHash());
391 ++it;
393 disconnectpool.queuedTx.clear();
394 // AcceptToMemoryPool/addUnchecked all assume that new mempool entries have
395 // no in-mempool children, which is generally not true when adding
396 // previously-confirmed transactions back to the mempool.
397 // UpdateTransactionsFromBlock finds descendants of any transactions in
398 // the disconnectpool that were added back and cleans up the mempool state.
399 mempool.UpdateTransactionsFromBlock(vHashUpdate);
401 // We also need to remove any now-immature transactions
402 mempool.removeForReorg(pcoinsTip, chainActive.Tip()->nHeight + 1, STANDARD_LOCKTIME_VERIFY_FLAGS);
403 // Re-limit mempool size, in case we added any transactions
404 LimitMempoolSize(mempool, gArgs.GetArg("-maxmempool", DEFAULT_MAX_MEMPOOL_SIZE) * 1000000, gArgs.GetArg("-mempoolexpiry", DEFAULT_MEMPOOL_EXPIRY) * 60 * 60);
407 // Used to avoid mempool polluting consensus critical paths if CCoinsViewMempool
408 // were somehow broken and returning the wrong scriptPubKeys
409 static bool CheckInputsFromMempoolAndCache(const CTransaction& tx, CValidationState &state, const CCoinsViewCache &view, CTxMemPool& pool,
410 unsigned int flags, bool cacheSigStore, PrecomputedTransactionData& txdata) {
411 AssertLockHeld(cs_main);
413 // pool.cs should be locked already, but go ahead and re-take the lock here
414 // to enforce that mempool doesn't change between when we check the view
415 // and when we actually call through to CheckInputs
416 LOCK(pool.cs);
418 assert(!tx.IsCoinBase());
419 for (const CTxIn& txin : tx.vin) {
420 const Coin& coin = view.AccessCoin(txin.prevout);
422 // At this point we haven't actually checked if the coins are all
423 // available (or shouldn't assume we have, since CheckInputs does).
424 // So we just return failure if the inputs are not available here,
425 // and then only have to check equivalence for available inputs.
426 if (coin.IsSpent()) return false;
428 const CTransactionRef& txFrom = pool.get(txin.prevout.hash);
429 if (txFrom) {
430 assert(txFrom->GetHash() == txin.prevout.hash);
431 assert(txFrom->vout.size() > txin.prevout.n);
432 assert(txFrom->vout[txin.prevout.n] == coin.out);
433 } else {
434 const Coin& coinFromDisk = pcoinsTip->AccessCoin(txin.prevout);
435 assert(!coinFromDisk.IsSpent());
436 assert(coinFromDisk.out == coin.out);
440 return CheckInputs(tx, state, view, true, flags, cacheSigStore, true, txdata);
443 static bool AcceptToMemoryPoolWorker(const CChainParams& chainparams, CTxMemPool& pool, CValidationState& state, const CTransactionRef& ptx, bool fLimitFree,
444 bool* pfMissingInputs, int64_t nAcceptTime, std::list<CTransactionRef>* plTxnReplaced,
445 bool fOverrideMempoolLimit, const CAmount& nAbsurdFee, std::vector<COutPoint>& coins_to_uncache)
447 const CTransaction& tx = *ptx;
448 const uint256 hash = tx.GetHash();
449 AssertLockHeld(cs_main);
450 if (pfMissingInputs)
451 *pfMissingInputs = false;
453 if (!CheckTransaction(tx, state))
454 return false; // state filled in by CheckTransaction
456 // Coinbase is only valid in a block, not as a loose transaction
457 if (tx.IsCoinBase())
458 return state.DoS(100, false, REJECT_INVALID, "coinbase");
460 // Reject transactions with witness before segregated witness activates (override with -prematurewitness)
461 bool witnessEnabled = IsWitnessEnabled(chainActive.Tip(), chainparams.GetConsensus());
462 if (!gArgs.GetBoolArg("-prematurewitness", false) && tx.HasWitness() && !witnessEnabled) {
463 return state.DoS(0, false, REJECT_NONSTANDARD, "no-witness-yet", true);
466 // Rather not work on nonstandard transactions (unless -testnet/-regtest)
467 std::string reason;
468 if (fRequireStandard && !IsStandardTx(tx, reason, witnessEnabled))
469 return state.DoS(0, false, REJECT_NONSTANDARD, reason);
471 // Only accept nLockTime-using transactions that can be mined in the next
472 // block; we don't want our mempool filled up with transactions that can't
473 // be mined yet.
474 if (!CheckFinalTx(tx, STANDARD_LOCKTIME_VERIFY_FLAGS))
475 return state.DoS(0, false, REJECT_NONSTANDARD, "non-final");
477 // is it already in the memory pool?
478 if (pool.exists(hash)) {
479 return state.Invalid(false, REJECT_DUPLICATE, "txn-already-in-mempool");
482 // Check for conflicts with in-memory transactions
483 std::set<uint256> setConflicts;
485 LOCK(pool.cs); // protect pool.mapNextTx
486 for (const CTxIn &txin : tx.vin)
488 auto itConflicting = pool.mapNextTx.find(txin.prevout);
489 if (itConflicting != pool.mapNextTx.end())
491 const CTransaction *ptxConflicting = itConflicting->second;
492 if (!setConflicts.count(ptxConflicting->GetHash()))
494 // Allow opt-out of transaction replacement by setting
495 // nSequence > MAX_BIP125_RBF_SEQUENCE (SEQUENCE_FINAL-2) on all inputs.
497 // SEQUENCE_FINAL-1 is picked to still allow use of nLockTime by
498 // non-replaceable transactions. All inputs rather than just one
499 // is for the sake of multi-party protocols, where we don't
500 // want a single party to be able to disable replacement.
502 // The opt-out ignores descendants as anyone relying on
503 // first-seen mempool behavior should be checking all
504 // unconfirmed ancestors anyway; doing otherwise is hopelessly
505 // insecure.
506 bool fReplacementOptOut = true;
507 if (fEnableReplacement)
509 for (const CTxIn &_txin : ptxConflicting->vin)
511 if (_txin.nSequence <= MAX_BIP125_RBF_SEQUENCE)
513 fReplacementOptOut = false;
514 break;
518 if (fReplacementOptOut) {
519 return state.Invalid(false, REJECT_DUPLICATE, "txn-mempool-conflict");
522 setConflicts.insert(ptxConflicting->GetHash());
529 CCoinsView dummy;
530 CCoinsViewCache view(&dummy);
532 CAmount nValueIn = 0;
533 LockPoints lp;
535 LOCK(pool.cs);
536 CCoinsViewMemPool viewMemPool(pcoinsTip, pool);
537 view.SetBackend(viewMemPool);
539 // do all inputs exist?
540 for (const CTxIn txin : tx.vin) {
541 if (!pcoinsTip->HaveCoinInCache(txin.prevout)) {
542 coins_to_uncache.push_back(txin.prevout);
544 if (!view.HaveCoin(txin.prevout)) {
545 // Are inputs missing because we already have the tx?
546 for (size_t out = 0; out < tx.vout.size(); out++) {
547 // Optimistically just do efficient check of cache for outputs
548 if (pcoinsTip->HaveCoinInCache(COutPoint(hash, out))) {
549 return state.Invalid(false, REJECT_DUPLICATE, "txn-already-known");
552 // Otherwise assume this might be an orphan tx for which we just haven't seen parents yet
553 if (pfMissingInputs) {
554 *pfMissingInputs = true;
556 return false; // fMissingInputs and !state.IsInvalid() is used to detect this condition, don't set state.Invalid()
560 // Bring the best block into scope
561 view.GetBestBlock();
563 nValueIn = view.GetValueIn(tx);
565 // we have all inputs cached now, so switch back to dummy, so we don't need to keep lock on mempool
566 view.SetBackend(dummy);
568 // Only accept BIP68 sequence locked transactions that can be mined in the next
569 // block; we don't want our mempool filled up with transactions that can't
570 // be mined yet.
571 // Must keep pool.cs for this unless we change CheckSequenceLocks to take a
572 // CoinsViewCache instead of create its own
573 if (!CheckSequenceLocks(tx, STANDARD_LOCKTIME_VERIFY_FLAGS, &lp))
574 return state.DoS(0, false, REJECT_NONSTANDARD, "non-BIP68-final");
577 // Check for non-standard pay-to-script-hash in inputs
578 if (fRequireStandard && !AreInputsStandard(tx, view))
579 return state.Invalid(false, REJECT_NONSTANDARD, "bad-txns-nonstandard-inputs");
581 // Check for non-standard witness in P2WSH
582 if (tx.HasWitness() && fRequireStandard && !IsWitnessStandard(tx, view))
583 return state.DoS(0, false, REJECT_NONSTANDARD, "bad-witness-nonstandard", true);
585 int64_t nSigOpsCost = GetTransactionSigOpCost(tx, view, STANDARD_SCRIPT_VERIFY_FLAGS);
587 CAmount nValueOut = tx.GetValueOut();
588 CAmount nFees = nValueIn-nValueOut;
589 // nModifiedFees includes any fee deltas from PrioritiseTransaction
590 CAmount nModifiedFees = nFees;
591 pool.ApplyDelta(hash, nModifiedFees);
593 // Keep track of transactions that spend a coinbase, which we re-scan
594 // during reorgs to ensure COINBASE_MATURITY is still met.
595 bool fSpendsCoinbase = false;
596 for (const CTxIn &txin : tx.vin) {
597 const Coin &coin = view.AccessCoin(txin.prevout);
598 if (coin.IsCoinBase()) {
599 fSpendsCoinbase = true;
600 break;
604 CTxMemPoolEntry entry(ptx, nFees, nAcceptTime, chainActive.Height(),
605 fSpendsCoinbase, nSigOpsCost, lp);
606 unsigned int nSize = entry.GetTxSize();
608 // Check that the transaction doesn't have an excessive number of
609 // sigops, making it impossible to mine. Since the coinbase transaction
610 // itself can contain sigops MAX_STANDARD_TX_SIGOPS is less than
611 // MAX_BLOCK_SIGOPS; we still consider this an invalid rather than
612 // merely non-standard transaction.
613 if (nSigOpsCost > MAX_STANDARD_TX_SIGOPS_COST)
614 return state.DoS(0, false, REJECT_NONSTANDARD, "bad-txns-too-many-sigops", false,
615 strprintf("%d", nSigOpsCost));
617 CAmount mempoolRejectFee = pool.GetMinFee(gArgs.GetArg("-maxmempool", DEFAULT_MAX_MEMPOOL_SIZE) * 1000000).GetFee(nSize);
618 if (mempoolRejectFee > 0 && nModifiedFees < mempoolRejectFee) {
619 return state.DoS(0, false, REJECT_INSUFFICIENTFEE, "mempool min fee not met", false, strprintf("%d < %d", nFees, mempoolRejectFee));
622 // No transactions are allowed below minRelayTxFee except from disconnected blocks
623 if (fLimitFree && nModifiedFees < ::minRelayTxFee.GetFee(nSize)) {
624 return state.DoS(0, false, REJECT_INSUFFICIENTFEE, "min relay fee not met");
627 if (nAbsurdFee && nFees > nAbsurdFee)
628 return state.Invalid(false,
629 REJECT_HIGHFEE, "absurdly-high-fee",
630 strprintf("%d > %d", nFees, nAbsurdFee));
632 // Calculate in-mempool ancestors, up to a limit.
633 CTxMemPool::setEntries setAncestors;
634 size_t nLimitAncestors = gArgs.GetArg("-limitancestorcount", DEFAULT_ANCESTOR_LIMIT);
635 size_t nLimitAncestorSize = gArgs.GetArg("-limitancestorsize", DEFAULT_ANCESTOR_SIZE_LIMIT)*1000;
636 size_t nLimitDescendants = gArgs.GetArg("-limitdescendantcount", DEFAULT_DESCENDANT_LIMIT);
637 size_t nLimitDescendantSize = gArgs.GetArg("-limitdescendantsize", DEFAULT_DESCENDANT_SIZE_LIMIT)*1000;
638 std::string errString;
639 if (!pool.CalculateMemPoolAncestors(entry, setAncestors, nLimitAncestors, nLimitAncestorSize, nLimitDescendants, nLimitDescendantSize, errString)) {
640 return state.DoS(0, false, REJECT_NONSTANDARD, "too-long-mempool-chain", false, errString);
643 // A transaction that spends outputs that would be replaced by it is invalid. Now
644 // that we have the set of all ancestors we can detect this
645 // pathological case by making sure setConflicts and setAncestors don't
646 // intersect.
647 for (CTxMemPool::txiter ancestorIt : setAncestors)
649 const uint256 &hashAncestor = ancestorIt->GetTx().GetHash();
650 if (setConflicts.count(hashAncestor))
652 return state.DoS(10, false,
653 REJECT_INVALID, "bad-txns-spends-conflicting-tx", false,
654 strprintf("%s spends conflicting transaction %s",
655 hash.ToString(),
656 hashAncestor.ToString()));
660 // Check if it's economically rational to mine this transaction rather
661 // than the ones it replaces.
662 CAmount nConflictingFees = 0;
663 size_t nConflictingSize = 0;
664 uint64_t nConflictingCount = 0;
665 CTxMemPool::setEntries allConflicting;
667 // If we don't hold the lock allConflicting might be incomplete; the
668 // subsequent RemoveStaged() and addUnchecked() calls don't guarantee
669 // mempool consistency for us.
670 LOCK(pool.cs);
671 const bool fReplacementTransaction = setConflicts.size();
672 if (fReplacementTransaction)
674 CFeeRate newFeeRate(nModifiedFees, nSize);
675 std::set<uint256> setConflictsParents;
676 const int maxDescendantsToVisit = 100;
677 CTxMemPool::setEntries setIterConflicting;
678 for (const uint256 &hashConflicting : setConflicts)
680 CTxMemPool::txiter mi = pool.mapTx.find(hashConflicting);
681 if (mi == pool.mapTx.end())
682 continue;
684 // Save these to avoid repeated lookups
685 setIterConflicting.insert(mi);
687 // Don't allow the replacement to reduce the feerate of the
688 // mempool.
690 // We usually don't want to accept replacements with lower
691 // feerates than what they replaced as that would lower the
692 // feerate of the next block. Requiring that the feerate always
693 // be increased is also an easy-to-reason about way to prevent
694 // DoS attacks via replacements.
696 // The mining code doesn't (currently) take children into
697 // account (CPFP) so we only consider the feerates of
698 // transactions being directly replaced, not their indirect
699 // descendants. While that does mean high feerate children are
700 // ignored when deciding whether or not to replace, we do
701 // require the replacement to pay more overall fees too,
702 // mitigating most cases.
703 CFeeRate oldFeeRate(mi->GetModifiedFee(), mi->GetTxSize());
704 if (newFeeRate <= oldFeeRate)
706 return state.DoS(0, false,
707 REJECT_INSUFFICIENTFEE, "insufficient fee", false,
708 strprintf("rejecting replacement %s; new feerate %s <= old feerate %s",
709 hash.ToString(),
710 newFeeRate.ToString(),
711 oldFeeRate.ToString()));
714 for (const CTxIn &txin : mi->GetTx().vin)
716 setConflictsParents.insert(txin.prevout.hash);
719 nConflictingCount += mi->GetCountWithDescendants();
721 // This potentially overestimates the number of actual descendants
722 // but we just want to be conservative to avoid doing too much
723 // work.
724 if (nConflictingCount <= maxDescendantsToVisit) {
725 // If not too many to replace, then calculate the set of
726 // transactions that would have to be evicted
727 for (CTxMemPool::txiter it : setIterConflicting) {
728 pool.CalculateDescendants(it, allConflicting);
730 for (CTxMemPool::txiter it : allConflicting) {
731 nConflictingFees += it->GetModifiedFee();
732 nConflictingSize += it->GetTxSize();
734 } else {
735 return state.DoS(0, false,
736 REJECT_NONSTANDARD, "too many potential replacements", false,
737 strprintf("rejecting replacement %s; too many potential replacements (%d > %d)\n",
738 hash.ToString(),
739 nConflictingCount,
740 maxDescendantsToVisit));
743 for (unsigned int j = 0; j < tx.vin.size(); j++)
745 // We don't want to accept replacements that require low
746 // feerate junk to be mined first. Ideally we'd keep track of
747 // the ancestor feerates and make the decision based on that,
748 // but for now requiring all new inputs to be confirmed works.
749 if (!setConflictsParents.count(tx.vin[j].prevout.hash))
751 // Rather than check the UTXO set - potentially expensive -
752 // it's cheaper to just check if the new input refers to a
753 // tx that's in the mempool.
754 if (pool.mapTx.find(tx.vin[j].prevout.hash) != pool.mapTx.end())
755 return state.DoS(0, false,
756 REJECT_NONSTANDARD, "replacement-adds-unconfirmed", false,
757 strprintf("replacement %s adds unconfirmed input, idx %d",
758 hash.ToString(), j));
762 // The replacement must pay greater fees than the transactions it
763 // replaces - if we did the bandwidth used by those conflicting
764 // transactions would not be paid for.
765 if (nModifiedFees < nConflictingFees)
767 return state.DoS(0, false,
768 REJECT_INSUFFICIENTFEE, "insufficient fee", false,
769 strprintf("rejecting replacement %s, less fees than conflicting txs; %s < %s",
770 hash.ToString(), FormatMoney(nModifiedFees), FormatMoney(nConflictingFees)));
773 // Finally in addition to paying more fees than the conflicts the
774 // new transaction must pay for its own bandwidth.
775 CAmount nDeltaFees = nModifiedFees - nConflictingFees;
776 if (nDeltaFees < ::incrementalRelayFee.GetFee(nSize))
778 return state.DoS(0, false,
779 REJECT_INSUFFICIENTFEE, "insufficient fee", false,
780 strprintf("rejecting replacement %s, not enough additional fees to relay; %s < %s",
781 hash.ToString(),
782 FormatMoney(nDeltaFees),
783 FormatMoney(::incrementalRelayFee.GetFee(nSize))));
787 unsigned int scriptVerifyFlags = STANDARD_SCRIPT_VERIFY_FLAGS;
788 if (!chainparams.RequireStandard()) {
789 scriptVerifyFlags = gArgs.GetArg("-promiscuousmempoolflags", scriptVerifyFlags);
792 // Check against previous transactions
793 // This is done last to help prevent CPU exhaustion denial-of-service attacks.
794 PrecomputedTransactionData txdata(tx);
795 if (!CheckInputs(tx, state, view, true, scriptVerifyFlags, true, false, txdata)) {
796 // SCRIPT_VERIFY_CLEANSTACK requires SCRIPT_VERIFY_WITNESS, so we
797 // need to turn both off, and compare against just turning off CLEANSTACK
798 // to see if the failure is specifically due to witness validation.
799 CValidationState stateDummy; // Want reported failures to be from first CheckInputs
800 if (!tx.HasWitness() && CheckInputs(tx, stateDummy, view, true, scriptVerifyFlags & ~(SCRIPT_VERIFY_WITNESS | SCRIPT_VERIFY_CLEANSTACK), true, false, txdata) &&
801 !CheckInputs(tx, stateDummy, view, true, scriptVerifyFlags & ~SCRIPT_VERIFY_CLEANSTACK, true, false, txdata)) {
802 // Only the witness is missing, so the transaction itself may be fine.
803 state.SetCorruptionPossible();
805 return false; // state filled in by CheckInputs
808 // Check again against the current block tip's script verification
809 // flags to cache our script execution flags. This is, of course,
810 // useless if the next block has different script flags from the
811 // previous one, but because the cache tracks script flags for us it
812 // will auto-invalidate and we'll just have a few blocks of extra
813 // misses on soft-fork activation.
815 // This is also useful in case of bugs in the standard flags that cause
816 // transactions to pass as valid when they're actually invalid. For
817 // instance the STRICTENC flag was incorrectly allowing certain
818 // CHECKSIG NOT scripts to pass, even though they were invalid.
820 // There is a similar check in CreateNewBlock() to prevent creating
821 // invalid blocks (using TestBlockValidity), however allowing such
822 // transactions into the mempool can be exploited as a DoS attack.
823 unsigned int currentBlockScriptVerifyFlags = GetBlockScriptFlags(chainActive.Tip(), Params().GetConsensus());
824 if (!CheckInputsFromMempoolAndCache(tx, state, view, pool, currentBlockScriptVerifyFlags, true, txdata))
826 // If we're using promiscuousmempoolflags, we may hit this normally
827 // Check if current block has some flags that scriptVerifyFlags
828 // does not before printing an ominous warning
829 if (!(~scriptVerifyFlags & currentBlockScriptVerifyFlags)) {
830 return error("%s: BUG! PLEASE REPORT THIS! ConnectInputs failed against latest-block but not STANDARD flags %s, %s",
831 __func__, hash.ToString(), FormatStateMessage(state));
832 } else {
833 if (!CheckInputs(tx, state, view, true, MANDATORY_SCRIPT_VERIFY_FLAGS, true, false, txdata)) {
834 return error("%s: ConnectInputs failed against MANDATORY but not STANDARD flags due to promiscuous mempool %s, %s",
835 __func__, hash.ToString(), FormatStateMessage(state));
836 } else {
837 LogPrintf("Warning: -promiscuousmempool flags set to not include currently enforced soft forks, this may break mining or otherwise cause instability!\n");
842 // Remove conflicting transactions from the mempool
843 for (const CTxMemPool::txiter it : allConflicting)
845 LogPrint(BCLog::MEMPOOL, "replacing tx %s with %s for %s BTC additional fees, %d delta bytes\n",
846 it->GetTx().GetHash().ToString(),
847 hash.ToString(),
848 FormatMoney(nModifiedFees - nConflictingFees),
849 (int)nSize - (int)nConflictingSize);
850 if (plTxnReplaced)
851 plTxnReplaced->push_back(it->GetSharedTx());
853 pool.RemoveStaged(allConflicting, false, MemPoolRemovalReason::REPLACED);
855 // This transaction should only count for fee estimation if it isn't a
856 // BIP 125 replacement transaction (may not be widely supported), the
857 // node is not behind, and the transaction is not dependent on any other
858 // transactions in the mempool.
859 bool validForFeeEstimation = !fReplacementTransaction && IsCurrentForFeeEstimation() && pool.HasNoInputsOf(tx);
861 // Store transaction in memory
862 pool.addUnchecked(hash, entry, setAncestors, validForFeeEstimation);
864 // trim mempool and check if tx was trimmed
865 if (!fOverrideMempoolLimit) {
866 LimitMempoolSize(pool, gArgs.GetArg("-maxmempool", DEFAULT_MAX_MEMPOOL_SIZE) * 1000000, gArgs.GetArg("-mempoolexpiry", DEFAULT_MEMPOOL_EXPIRY) * 60 * 60);
867 if (!pool.exists(hash))
868 return state.DoS(0, false, REJECT_INSUFFICIENTFEE, "mempool full");
872 GetMainSignals().TransactionAddedToMempool(ptx);
874 return true;
877 /** (try to) add transaction to memory pool with a specified acceptance time **/
878 static bool AcceptToMemoryPoolWithTime(const CChainParams& chainparams, CTxMemPool& pool, CValidationState &state, const CTransactionRef &tx, bool fLimitFree,
879 bool* pfMissingInputs, int64_t nAcceptTime, std::list<CTransactionRef>* plTxnReplaced,
880 bool fOverrideMempoolLimit, const CAmount nAbsurdFee)
882 std::vector<COutPoint> coins_to_uncache;
883 bool res = AcceptToMemoryPoolWorker(chainparams, pool, state, tx, fLimitFree, pfMissingInputs, nAcceptTime, plTxnReplaced, fOverrideMempoolLimit, nAbsurdFee, coins_to_uncache);
884 if (!res) {
885 for (const COutPoint& hashTx : coins_to_uncache)
886 pcoinsTip->Uncache(hashTx);
888 // After we've (potentially) uncached entries, ensure our coins cache is still within its size limits
889 CValidationState stateDummy;
890 FlushStateToDisk(chainparams, stateDummy, FLUSH_STATE_PERIODIC);
891 return res;
894 bool AcceptToMemoryPool(CTxMemPool& pool, CValidationState &state, const CTransactionRef &tx, bool fLimitFree,
895 bool* pfMissingInputs, std::list<CTransactionRef>* plTxnReplaced,
896 bool fOverrideMempoolLimit, const CAmount nAbsurdFee)
898 const CChainParams& chainparams = Params();
899 return AcceptToMemoryPoolWithTime(chainparams, pool, state, tx, fLimitFree, pfMissingInputs, GetTime(), plTxnReplaced, fOverrideMempoolLimit, nAbsurdFee);
902 /** Return transaction in txOut, and if it was found inside a block, its hash is placed in hashBlock */
903 bool GetTransaction(const uint256 &hash, CTransactionRef &txOut, const Consensus::Params& consensusParams, uint256 &hashBlock, bool fAllowSlow)
905 CBlockIndex *pindexSlow = nullptr;
907 LOCK(cs_main);
909 CTransactionRef ptx = mempool.get(hash);
910 if (ptx)
912 txOut = ptx;
913 return true;
916 if (fTxIndex) {
917 CDiskTxPos postx;
918 if (pblocktree->ReadTxIndex(hash, postx)) {
919 CAutoFile file(OpenBlockFile(postx, true), SER_DISK, CLIENT_VERSION);
920 if (file.IsNull())
921 return error("%s: OpenBlockFile failed", __func__);
922 CBlockHeader header;
923 try {
924 file >> header;
925 fseek(file.Get(), postx.nTxOffset, SEEK_CUR);
926 file >> txOut;
927 } catch (const std::exception& e) {
928 return error("%s: Deserialize or I/O error - %s", __func__, e.what());
930 hashBlock = header.GetHash();
931 if (txOut->GetHash() != hash)
932 return error("%s: txid mismatch", __func__);
933 return true;
937 if (fAllowSlow) { // use coin database to locate block that contains transaction, and scan it
938 const Coin& coin = AccessByTxid(*pcoinsTip, hash);
939 if (!coin.IsSpent()) pindexSlow = chainActive[coin.nHeight];
942 if (pindexSlow) {
943 CBlock block;
944 if (ReadBlockFromDisk(block, pindexSlow, consensusParams)) {
945 for (const auto& tx : block.vtx) {
946 if (tx->GetHash() == hash) {
947 txOut = tx;
948 hashBlock = pindexSlow->GetBlockHash();
949 return true;
955 return false;
963 //////////////////////////////////////////////////////////////////////////////
965 // CBlock and CBlockIndex
968 static bool WriteBlockToDisk(const CBlock& block, CDiskBlockPos& pos, const CMessageHeader::MessageStartChars& messageStart)
970 // Open history file to append
971 CAutoFile fileout(OpenBlockFile(pos), SER_DISK, CLIENT_VERSION);
972 if (fileout.IsNull())
973 return error("WriteBlockToDisk: OpenBlockFile failed");
975 // Write index header
976 unsigned int nSize = GetSerializeSize(fileout, block);
977 fileout << FLATDATA(messageStart) << nSize;
979 // Write block
980 long fileOutPos = ftell(fileout.Get());
981 if (fileOutPos < 0)
982 return error("WriteBlockToDisk: ftell failed");
983 pos.nPos = (unsigned int)fileOutPos;
984 fileout << block;
986 return true;
989 bool ReadBlockFromDisk(CBlock& block, const CDiskBlockPos& pos, const Consensus::Params& consensusParams)
991 block.SetNull();
993 // Open history file to read
994 CAutoFile filein(OpenBlockFile(pos, true), SER_DISK, CLIENT_VERSION);
995 if (filein.IsNull())
996 return error("ReadBlockFromDisk: OpenBlockFile failed for %s", pos.ToString());
998 // Read block
999 try {
1000 filein >> block;
1002 catch (const std::exception& e) {
1003 return error("%s: Deserialize or I/O error - %s at %s", __func__, e.what(), pos.ToString());
1006 // Check the header
1007 if (!CheckProofOfWork(block.GetHash(), block.nBits, consensusParams))
1008 return error("ReadBlockFromDisk: Errors in block header at %s", pos.ToString());
1010 return true;
1013 bool ReadBlockFromDisk(CBlock& block, const CBlockIndex* pindex, const Consensus::Params& consensusParams)
1015 if (!ReadBlockFromDisk(block, pindex->GetBlockPos(), consensusParams))
1016 return false;
1017 if (block.GetHash() != pindex->GetBlockHash())
1018 return error("ReadBlockFromDisk(CBlock&, CBlockIndex*): GetHash() doesn't match index for %s at %s",
1019 pindex->ToString(), pindex->GetBlockPos().ToString());
1020 return true;
1023 CAmount GetBlockSubsidy(int nHeight, const Consensus::Params& consensusParams)
1025 int halvings = nHeight / consensusParams.nSubsidyHalvingInterval;
1026 // Force block reward to zero when right shift is undefined.
1027 if (halvings >= 64)
1028 return 0;
1030 CAmount nSubsidy = 50 * COIN;
1031 // Subsidy is cut in half every 210,000 blocks which will occur approximately every 4 years.
1032 nSubsidy >>= halvings;
1033 return nSubsidy;
1036 bool IsInitialBlockDownload()
1038 const CChainParams& chainParams = Params();
1040 // Once this function has returned false, it must remain false.
1041 static std::atomic<bool> latchToFalse{false};
1042 // Optimization: pre-test latch before taking the lock.
1043 if (latchToFalse.load(std::memory_order_relaxed))
1044 return false;
1046 LOCK(cs_main);
1047 if (latchToFalse.load(std::memory_order_relaxed))
1048 return false;
1049 if (fImporting || fReindex)
1050 return true;
1051 if (chainActive.Tip() == nullptr)
1052 return true;
1053 if (chainActive.Tip()->nChainWork < UintToArith256(chainParams.GetConsensus().nMinimumChainWork))
1054 return true;
1055 if (chainActive.Tip()->GetBlockTime() < (GetTime() - nMaxTipAge))
1056 return true;
1057 LogPrintf("Leaving InitialBlockDownload (latching to false)\n");
1058 latchToFalse.store(true, std::memory_order_relaxed);
1059 return false;
1062 CBlockIndex *pindexBestForkTip = nullptr, *pindexBestForkBase = nullptr;
1064 static void AlertNotify(const std::string& strMessage)
1066 uiInterface.NotifyAlertChanged();
1067 std::string strCmd = gArgs.GetArg("-alertnotify", "");
1068 if (strCmd.empty()) return;
1070 // Alert text should be plain ascii coming from a trusted source, but to
1071 // be safe we first strip anything not in safeChars, then add single quotes around
1072 // the whole string before passing it to the shell:
1073 std::string singleQuote("'");
1074 std::string safeStatus = SanitizeString(strMessage);
1075 safeStatus = singleQuote+safeStatus+singleQuote;
1076 boost::replace_all(strCmd, "%s", safeStatus);
1078 boost::thread t(runCommand, strCmd); // thread runs free
1081 static void CheckForkWarningConditions()
1083 AssertLockHeld(cs_main);
1084 // Before we get past initial download, we cannot reliably alert about forks
1085 // (we assume we don't get stuck on a fork before finishing our initial sync)
1086 if (IsInitialBlockDownload())
1087 return;
1089 // If our best fork is no longer within 72 blocks (+/- 12 hours if no one mines it)
1090 // of our head, drop it
1091 if (pindexBestForkTip && chainActive.Height() - pindexBestForkTip->nHeight >= 72)
1092 pindexBestForkTip = nullptr;
1094 if (pindexBestForkTip || (pindexBestInvalid && pindexBestInvalid->nChainWork > chainActive.Tip()->nChainWork + (GetBlockProof(*chainActive.Tip()) * 6)))
1096 if (!GetfLargeWorkForkFound() && pindexBestForkBase)
1098 std::string warning = std::string("'Warning: Large-work fork detected, forking after block ") +
1099 pindexBestForkBase->phashBlock->ToString() + std::string("'");
1100 AlertNotify(warning);
1102 if (pindexBestForkTip && pindexBestForkBase)
1104 LogPrintf("%s: Warning: Large valid fork found\n forking the chain at height %d (%s)\n lasting to height %d (%s).\nChain state database corruption likely.\n", __func__,
1105 pindexBestForkBase->nHeight, pindexBestForkBase->phashBlock->ToString(),
1106 pindexBestForkTip->nHeight, pindexBestForkTip->phashBlock->ToString());
1107 SetfLargeWorkForkFound(true);
1109 else
1111 LogPrintf("%s: Warning: Found invalid chain at least ~6 blocks longer than our best chain.\nChain state database corruption likely.\n", __func__);
1112 SetfLargeWorkInvalidChainFound(true);
1115 else
1117 SetfLargeWorkForkFound(false);
1118 SetfLargeWorkInvalidChainFound(false);
1122 static void CheckForkWarningConditionsOnNewFork(CBlockIndex* pindexNewForkTip)
1124 AssertLockHeld(cs_main);
1125 // If we are on a fork that is sufficiently large, set a warning flag
1126 CBlockIndex* pfork = pindexNewForkTip;
1127 CBlockIndex* plonger = chainActive.Tip();
1128 while (pfork && pfork != plonger)
1130 while (plonger && plonger->nHeight > pfork->nHeight)
1131 plonger = plonger->pprev;
1132 if (pfork == plonger)
1133 break;
1134 pfork = pfork->pprev;
1137 // We define a condition where we should warn the user about as a fork of at least 7 blocks
1138 // with a tip within 72 blocks (+/- 12 hours if no one mines it) of ours
1139 // We use 7 blocks rather arbitrarily as it represents just under 10% of sustained network
1140 // hash rate operating on the fork.
1141 // or a chain that is entirely longer than ours and invalid (note that this should be detected by both)
1142 // We define it this way because it allows us to only store the highest fork tip (+ base) which meets
1143 // the 7-block condition and from this always have the most-likely-to-cause-warning fork
1144 if (pfork && (!pindexBestForkTip || pindexNewForkTip->nHeight > pindexBestForkTip->nHeight) &&
1145 pindexNewForkTip->nChainWork - pfork->nChainWork > (GetBlockProof(*pfork) * 7) &&
1146 chainActive.Height() - pindexNewForkTip->nHeight < 72)
1148 pindexBestForkTip = pindexNewForkTip;
1149 pindexBestForkBase = pfork;
1152 CheckForkWarningConditions();
1155 void static InvalidChainFound(CBlockIndex* pindexNew)
1157 if (!pindexBestInvalid || pindexNew->nChainWork > pindexBestInvalid->nChainWork)
1158 pindexBestInvalid = pindexNew;
1160 LogPrintf("%s: invalid block=%s height=%d log2_work=%.8g date=%s\n", __func__,
1161 pindexNew->GetBlockHash().ToString(), pindexNew->nHeight,
1162 log(pindexNew->nChainWork.getdouble())/log(2.0), DateTimeStrFormat("%Y-%m-%d %H:%M:%S",
1163 pindexNew->GetBlockTime()));
1164 CBlockIndex *tip = chainActive.Tip();
1165 assert (tip);
1166 LogPrintf("%s: current best=%s height=%d log2_work=%.8g date=%s\n", __func__,
1167 tip->GetBlockHash().ToString(), chainActive.Height(), log(tip->nChainWork.getdouble())/log(2.0),
1168 DateTimeStrFormat("%Y-%m-%d %H:%M:%S", tip->GetBlockTime()));
1169 CheckForkWarningConditions();
1172 void static InvalidBlockFound(CBlockIndex *pindex, const CValidationState &state) {
1173 if (!state.CorruptionPossible()) {
1174 pindex->nStatus |= BLOCK_FAILED_VALID;
1175 setDirtyBlockIndex.insert(pindex);
1176 setBlockIndexCandidates.erase(pindex);
1177 InvalidChainFound(pindex);
1181 void UpdateCoins(const CTransaction& tx, CCoinsViewCache& inputs, CTxUndo &txundo, int nHeight)
1183 // mark inputs spent
1184 if (!tx.IsCoinBase()) {
1185 txundo.vprevout.reserve(tx.vin.size());
1186 for (const CTxIn &txin : tx.vin) {
1187 txundo.vprevout.emplace_back();
1188 bool is_spent = inputs.SpendCoin(txin.prevout, &txundo.vprevout.back());
1189 assert(is_spent);
1192 // add outputs
1193 AddCoins(inputs, tx, nHeight);
1196 void UpdateCoins(const CTransaction& tx, CCoinsViewCache& inputs, int nHeight)
1198 CTxUndo txundo;
1199 UpdateCoins(tx, inputs, txundo, nHeight);
1202 bool CScriptCheck::operator()() {
1203 const CScript &scriptSig = ptxTo->vin[nIn].scriptSig;
1204 const CScriptWitness *witness = &ptxTo->vin[nIn].scriptWitness;
1205 return VerifyScript(scriptSig, scriptPubKey, witness, nFlags, CachingTransactionSignatureChecker(ptxTo, nIn, amount, cacheStore, *txdata), &error);
1208 int GetSpendHeight(const CCoinsViewCache& inputs)
1210 LOCK(cs_main);
1211 CBlockIndex* pindexPrev = mapBlockIndex.find(inputs.GetBestBlock())->second;
1212 return pindexPrev->nHeight + 1;
1216 static CuckooCache::cache<uint256, SignatureCacheHasher> scriptExecutionCache;
1217 static uint256 scriptExecutionCacheNonce(GetRandHash());
1219 void InitScriptExecutionCache() {
1220 // nMaxCacheSize is unsigned. If -maxsigcachesize is set to zero,
1221 // setup_bytes creates the minimum possible cache (2 elements).
1222 size_t nMaxCacheSize = std::min(std::max((int64_t)0, gArgs.GetArg("-maxsigcachesize", DEFAULT_MAX_SIG_CACHE_SIZE) / 2), MAX_MAX_SIG_CACHE_SIZE) * ((size_t) 1 << 20);
1223 size_t nElems = scriptExecutionCache.setup_bytes(nMaxCacheSize);
1224 LogPrintf("Using %zu MiB out of %zu/2 requested for script execution cache, able to store %zu elements\n",
1225 (nElems*sizeof(uint256)) >>20, (nMaxCacheSize*2)>>20, nElems);
1229 * Check whether all inputs of this transaction are valid (no double spends, scripts & sigs, amounts)
1230 * This does not modify the UTXO set.
1232 * If pvChecks is not nullptr, script checks are pushed onto it instead of being performed inline. Any
1233 * script checks which are not necessary (eg due to script execution cache hits) are, obviously,
1234 * not pushed onto pvChecks/run.
1236 * Setting cacheSigStore/cacheFullScriptStore to false will remove elements from the corresponding cache
1237 * which are matched. This is useful for checking blocks where we will likely never need the cache
1238 * entry again.
1240 * Non-static (and re-declared) in src/test/txvalidationcache_tests.cpp
1242 bool CheckInputs(const CTransaction& tx, CValidationState &state, const CCoinsViewCache &inputs, bool fScriptChecks, unsigned int flags, bool cacheSigStore, bool cacheFullScriptStore, PrecomputedTransactionData& txdata, std::vector<CScriptCheck> *pvChecks)
1244 if (!tx.IsCoinBase())
1246 if (!Consensus::CheckTxInputs(tx, state, inputs, GetSpendHeight(inputs)))
1247 return false;
1249 if (pvChecks)
1250 pvChecks->reserve(tx.vin.size());
1252 // The first loop above does all the inexpensive checks.
1253 // Only if ALL inputs pass do we perform expensive ECDSA signature checks.
1254 // Helps prevent CPU exhaustion attacks.
1256 // Skip script verification when connecting blocks under the
1257 // assumevalid block. Assuming the assumevalid block is valid this
1258 // is safe because block merkle hashes are still computed and checked,
1259 // Of course, if an assumed valid block is invalid due to false scriptSigs
1260 // this optimization would allow an invalid chain to be accepted.
1261 if (fScriptChecks) {
1262 // First check if script executions have been cached with the same
1263 // flags. Note that this assumes that the inputs provided are
1264 // correct (ie that the transaction hash which is in tx's prevouts
1265 // properly commits to the scriptPubKey in the inputs view of that
1266 // transaction).
1267 uint256 hashCacheEntry;
1268 // We only use the first 19 bytes of nonce to avoid a second SHA
1269 // round - giving us 19 + 32 + 4 = 55 bytes (+ 8 + 1 = 64)
1270 static_assert(55 - sizeof(flags) - 32 >= 128/8, "Want at least 128 bits of nonce for script execution cache");
1271 CSHA256().Write(scriptExecutionCacheNonce.begin(), 55 - sizeof(flags) - 32).Write(tx.GetWitnessHash().begin(), 32).Write((unsigned char*)&flags, sizeof(flags)).Finalize(hashCacheEntry.begin());
1272 AssertLockHeld(cs_main); //TODO: Remove this requirement by making CuckooCache not require external locks
1273 if (scriptExecutionCache.contains(hashCacheEntry, !cacheFullScriptStore)) {
1274 return true;
1277 for (unsigned int i = 0; i < tx.vin.size(); i++) {
1278 const COutPoint &prevout = tx.vin[i].prevout;
1279 const Coin& coin = inputs.AccessCoin(prevout);
1280 assert(!coin.IsSpent());
1282 // We very carefully only pass in things to CScriptCheck which
1283 // are clearly committed to by tx' witness hash. This provides
1284 // a sanity check that our caching is not introducing consensus
1285 // failures through additional data in, eg, the coins being
1286 // spent being checked as a part of CScriptCheck.
1287 const CScript& scriptPubKey = coin.out.scriptPubKey;
1288 const CAmount amount = coin.out.nValue;
1290 // Verify signature
1291 CScriptCheck check(scriptPubKey, amount, tx, i, flags, cacheSigStore, &txdata);
1292 if (pvChecks) {
1293 pvChecks->push_back(CScriptCheck());
1294 check.swap(pvChecks->back());
1295 } else if (!check()) {
1296 if (flags & STANDARD_NOT_MANDATORY_VERIFY_FLAGS) {
1297 // Check whether the failure was caused by a
1298 // non-mandatory script verification check, such as
1299 // non-standard DER encodings or non-null dummy
1300 // arguments; if so, don't trigger DoS protection to
1301 // avoid splitting the network between upgraded and
1302 // non-upgraded nodes.
1303 CScriptCheck check2(scriptPubKey, amount, tx, i,
1304 flags & ~STANDARD_NOT_MANDATORY_VERIFY_FLAGS, cacheSigStore, &txdata);
1305 if (check2())
1306 return state.Invalid(false, REJECT_NONSTANDARD, strprintf("non-mandatory-script-verify-flag (%s)", ScriptErrorString(check.GetScriptError())));
1308 // Failures of other flags indicate a transaction that is
1309 // invalid in new blocks, e.g. an invalid P2SH. We DoS ban
1310 // such nodes as they are not following the protocol. That
1311 // said during an upgrade careful thought should be taken
1312 // as to the correct behavior - we may want to continue
1313 // peering with non-upgraded nodes even after soft-fork
1314 // super-majority signaling has occurred.
1315 return state.DoS(100,false, REJECT_INVALID, strprintf("mandatory-script-verify-flag-failed (%s)", ScriptErrorString(check.GetScriptError())));
1319 if (cacheFullScriptStore && !pvChecks) {
1320 // We executed all of the provided scripts, and were told to
1321 // cache the result. Do so now.
1322 scriptExecutionCache.insert(hashCacheEntry);
1327 return true;
1330 namespace {
1332 bool UndoWriteToDisk(const CBlockUndo& blockundo, CDiskBlockPos& pos, const uint256& hashBlock, const CMessageHeader::MessageStartChars& messageStart)
1334 // Open history file to append
1335 CAutoFile fileout(OpenUndoFile(pos), SER_DISK, CLIENT_VERSION);
1336 if (fileout.IsNull())
1337 return error("%s: OpenUndoFile failed", __func__);
1339 // Write index header
1340 unsigned int nSize = GetSerializeSize(fileout, blockundo);
1341 fileout << FLATDATA(messageStart) << nSize;
1343 // Write undo data
1344 long fileOutPos = ftell(fileout.Get());
1345 if (fileOutPos < 0)
1346 return error("%s: ftell failed", __func__);
1347 pos.nPos = (unsigned int)fileOutPos;
1348 fileout << blockundo;
1350 // calculate & write checksum
1351 CHashWriter hasher(SER_GETHASH, PROTOCOL_VERSION);
1352 hasher << hashBlock;
1353 hasher << blockundo;
1354 fileout << hasher.GetHash();
1356 return true;
1359 bool UndoReadFromDisk(CBlockUndo& blockundo, const CDiskBlockPos& pos, const uint256& hashBlock)
1361 // Open history file to read
1362 CAutoFile filein(OpenUndoFile(pos, true), SER_DISK, CLIENT_VERSION);
1363 if (filein.IsNull())
1364 return error("%s: OpenUndoFile failed", __func__);
1366 // Read block
1367 uint256 hashChecksum;
1368 CHashVerifier<CAutoFile> verifier(&filein); // We need a CHashVerifier as reserializing may lose data
1369 try {
1370 verifier << hashBlock;
1371 verifier >> blockundo;
1372 filein >> hashChecksum;
1374 catch (const std::exception& e) {
1375 return error("%s: Deserialize or I/O error - %s", __func__, e.what());
1378 // Verify checksum
1379 if (hashChecksum != verifier.GetHash())
1380 return error("%s: Checksum mismatch", __func__);
1382 return true;
1385 /** Abort with a message */
1386 bool AbortNode(const std::string& strMessage, const std::string& userMessage="")
1388 SetMiscWarning(strMessage);
1389 LogPrintf("*** %s\n", strMessage);
1390 uiInterface.ThreadSafeMessageBox(
1391 userMessage.empty() ? _("Error: A fatal internal error occurred, see debug.log for details") : userMessage,
1392 "", CClientUIInterface::MSG_ERROR);
1393 StartShutdown();
1394 return false;
1397 bool AbortNode(CValidationState& state, const std::string& strMessage, const std::string& userMessage="")
1399 AbortNode(strMessage, userMessage);
1400 return state.Error(strMessage);
1403 } // namespace
1405 enum DisconnectResult
1407 DISCONNECT_OK, // All good.
1408 DISCONNECT_UNCLEAN, // Rolled back, but UTXO set was inconsistent with block.
1409 DISCONNECT_FAILED // Something else went wrong.
1413 * Restore the UTXO in a Coin at a given COutPoint
1414 * @param undo The Coin to be restored.
1415 * @param view The coins view to which to apply the changes.
1416 * @param out The out point that corresponds to the tx input.
1417 * @return A DisconnectResult as an int
1419 int ApplyTxInUndo(Coin&& undo, CCoinsViewCache& view, const COutPoint& out)
1421 bool fClean = true;
1423 if (view.HaveCoin(out)) fClean = false; // overwriting transaction output
1425 if (undo.nHeight == 0) {
1426 // Missing undo metadata (height and coinbase). Older versions included this
1427 // information only in undo records for the last spend of a transactions'
1428 // outputs. This implies that it must be present for some other output of the same tx.
1429 const Coin& alternate = AccessByTxid(view, out.hash);
1430 if (!alternate.IsSpent()) {
1431 undo.nHeight = alternate.nHeight;
1432 undo.fCoinBase = alternate.fCoinBase;
1433 } else {
1434 return DISCONNECT_FAILED; // adding output for transaction without known metadata
1437 // The potential_overwrite parameter to AddCoin is only allowed to be false if we know for
1438 // sure that the coin did not already exist in the cache. As we have queried for that above
1439 // using HaveCoin, we don't need to guess. When fClean is false, a coin already existed and
1440 // it is an overwrite.
1441 view.AddCoin(out, std::move(undo), !fClean);
1443 return fClean ? DISCONNECT_OK : DISCONNECT_UNCLEAN;
1446 /** Undo the effects of this block (with given index) on the UTXO set represented by coins.
1447 * When FAILED is returned, view is left in an indeterminate state. */
1448 static DisconnectResult DisconnectBlock(const CBlock& block, const CBlockIndex* pindex, CCoinsViewCache& view)
1450 bool fClean = true;
1452 CBlockUndo blockUndo;
1453 CDiskBlockPos pos = pindex->GetUndoPos();
1454 if (pos.IsNull()) {
1455 error("DisconnectBlock(): no undo data available");
1456 return DISCONNECT_FAILED;
1458 if (!UndoReadFromDisk(blockUndo, pos, pindex->pprev->GetBlockHash())) {
1459 error("DisconnectBlock(): failure reading undo data");
1460 return DISCONNECT_FAILED;
1463 if (blockUndo.vtxundo.size() + 1 != block.vtx.size()) {
1464 error("DisconnectBlock(): block and undo data inconsistent");
1465 return DISCONNECT_FAILED;
1468 // undo transactions in reverse order
1469 for (int i = block.vtx.size() - 1; i >= 0; i--) {
1470 const CTransaction &tx = *(block.vtx[i]);
1471 uint256 hash = tx.GetHash();
1472 bool is_coinbase = tx.IsCoinBase();
1474 // Check that all outputs are available and match the outputs in the block itself
1475 // exactly.
1476 for (size_t o = 0; o < tx.vout.size(); o++) {
1477 if (!tx.vout[o].scriptPubKey.IsUnspendable()) {
1478 COutPoint out(hash, o);
1479 Coin coin;
1480 bool is_spent = view.SpendCoin(out, &coin);
1481 if (!is_spent || tx.vout[o] != coin.out || pindex->nHeight != coin.nHeight || is_coinbase != coin.fCoinBase) {
1482 fClean = false; // transaction output mismatch
1487 // restore inputs
1488 if (i > 0) { // not coinbases
1489 CTxUndo &txundo = blockUndo.vtxundo[i-1];
1490 if (txundo.vprevout.size() != tx.vin.size()) {
1491 error("DisconnectBlock(): transaction and undo data inconsistent");
1492 return DISCONNECT_FAILED;
1494 for (unsigned int j = tx.vin.size(); j-- > 0;) {
1495 const COutPoint &out = tx.vin[j].prevout;
1496 int res = ApplyTxInUndo(std::move(txundo.vprevout[j]), view, out);
1497 if (res == DISCONNECT_FAILED) return DISCONNECT_FAILED;
1498 fClean = fClean && res != DISCONNECT_UNCLEAN;
1500 // At this point, all of txundo.vprevout should have been moved out.
1504 // move best block pointer to prevout block
1505 view.SetBestBlock(pindex->pprev->GetBlockHash());
1507 return fClean ? DISCONNECT_OK : DISCONNECT_UNCLEAN;
1510 void static FlushBlockFile(bool fFinalize = false)
1512 LOCK(cs_LastBlockFile);
1514 CDiskBlockPos posOld(nLastBlockFile, 0);
1516 FILE *fileOld = OpenBlockFile(posOld);
1517 if (fileOld) {
1518 if (fFinalize)
1519 TruncateFile(fileOld, vinfoBlockFile[nLastBlockFile].nSize);
1520 FileCommit(fileOld);
1521 fclose(fileOld);
1524 fileOld = OpenUndoFile(posOld);
1525 if (fileOld) {
1526 if (fFinalize)
1527 TruncateFile(fileOld, vinfoBlockFile[nLastBlockFile].nUndoSize);
1528 FileCommit(fileOld);
1529 fclose(fileOld);
1533 static bool FindUndoPos(CValidationState &state, int nFile, CDiskBlockPos &pos, unsigned int nAddSize);
1535 static CCheckQueue<CScriptCheck> scriptcheckqueue(128);
1537 void ThreadScriptCheck() {
1538 RenameThread("bitcoin-scriptch");
1539 scriptcheckqueue.Thread();
1542 // Protected by cs_main
1543 VersionBitsCache versionbitscache;
1545 int32_t ComputeBlockVersion(const CBlockIndex* pindexPrev, const Consensus::Params& params)
1547 LOCK(cs_main);
1548 int32_t nVersion = VERSIONBITS_TOP_BITS;
1550 for (int i = 0; i < (int)Consensus::MAX_VERSION_BITS_DEPLOYMENTS; i++) {
1551 ThresholdState state = VersionBitsState(pindexPrev, params, (Consensus::DeploymentPos)i, versionbitscache);
1552 if (state == THRESHOLD_LOCKED_IN || state == THRESHOLD_STARTED) {
1553 nVersion |= VersionBitsMask(params, (Consensus::DeploymentPos)i);
1557 return nVersion;
1561 * Threshold condition checker that triggers when unknown versionbits are seen on the network.
1563 class WarningBitsConditionChecker : public AbstractThresholdConditionChecker
1565 private:
1566 int bit;
1568 public:
1569 explicit WarningBitsConditionChecker(int bitIn) : bit(bitIn) {}
1571 int64_t BeginTime(const Consensus::Params& params) const override { return 0; }
1572 int64_t EndTime(const Consensus::Params& params) const override { return std::numeric_limits<int64_t>::max(); }
1573 int Period(const Consensus::Params& params) const override { return params.nMinerConfirmationWindow; }
1574 int Threshold(const Consensus::Params& params) const override { return params.nRuleChangeActivationThreshold; }
1576 bool Condition(const CBlockIndex* pindex, const Consensus::Params& params) const override
1578 return ((pindex->nVersion & VERSIONBITS_TOP_MASK) == VERSIONBITS_TOP_BITS) &&
1579 ((pindex->nVersion >> bit) & 1) != 0 &&
1580 ((ComputeBlockVersion(pindex->pprev, params) >> bit) & 1) == 0;
1584 // Protected by cs_main
1585 static ThresholdConditionCache warningcache[VERSIONBITS_NUM_BITS];
1587 static unsigned int GetBlockScriptFlags(const CBlockIndex* pindex, const Consensus::Params& consensusparams) {
1588 AssertLockHeld(cs_main);
1590 // BIP16 didn't become active until Apr 1 2012
1591 int64_t nBIP16SwitchTime = 1333238400;
1592 bool fStrictPayToScriptHash = (pindex->GetBlockTime() >= nBIP16SwitchTime);
1594 unsigned int flags = fStrictPayToScriptHash ? SCRIPT_VERIFY_P2SH : SCRIPT_VERIFY_NONE;
1596 // Start enforcing the DERSIG (BIP66) rule
1597 if (pindex->nHeight >= consensusparams.BIP66Height) {
1598 flags |= SCRIPT_VERIFY_DERSIG;
1601 // Start enforcing CHECKLOCKTIMEVERIFY (BIP65) rule
1602 if (pindex->nHeight >= consensusparams.BIP65Height) {
1603 flags |= SCRIPT_VERIFY_CHECKLOCKTIMEVERIFY;
1606 // Start enforcing BIP68 (sequence locks) and BIP112 (CHECKSEQUENCEVERIFY) using versionbits logic.
1607 if (VersionBitsState(pindex->pprev, consensusparams, Consensus::DEPLOYMENT_CSV, versionbitscache) == THRESHOLD_ACTIVE) {
1608 flags |= SCRIPT_VERIFY_CHECKSEQUENCEVERIFY;
1611 // Start enforcing WITNESS rules using versionbits logic.
1612 if (IsWitnessEnabled(pindex->pprev, consensusparams)) {
1613 flags |= SCRIPT_VERIFY_WITNESS;
1614 flags |= SCRIPT_VERIFY_NULLDUMMY;
1617 return flags;
1622 static int64_t nTimeCheck = 0;
1623 static int64_t nTimeForks = 0;
1624 static int64_t nTimeVerify = 0;
1625 static int64_t nTimeConnect = 0;
1626 static int64_t nTimeIndex = 0;
1627 static int64_t nTimeCallbacks = 0;
1628 static int64_t nTimeTotal = 0;
1629 static int64_t nBlocksTotal = 0;
1631 /** Apply the effects of this block (with given index) on the UTXO set represented by coins.
1632 * Validity checks that depend on the UTXO set are also done; ConnectBlock()
1633 * can fail if those validity checks fail (among other reasons). */
1634 static bool ConnectBlock(const CBlock& block, CValidationState& state, CBlockIndex* pindex,
1635 CCoinsViewCache& view, const CChainParams& chainparams, bool fJustCheck = false)
1637 AssertLockHeld(cs_main);
1638 assert(pindex);
1639 // pindex->phashBlock can be null if called by CreateNewBlock/TestBlockValidity
1640 assert((pindex->phashBlock == nullptr) ||
1641 (*pindex->phashBlock == block.GetHash()));
1642 int64_t nTimeStart = GetTimeMicros();
1644 // Check it again in case a previous version let a bad block in
1645 if (!CheckBlock(block, state, chainparams.GetConsensus(), !fJustCheck, !fJustCheck))
1646 return error("%s: Consensus::CheckBlock: %s", __func__, FormatStateMessage(state));
1648 // verify that the view's current state corresponds to the previous block
1649 uint256 hashPrevBlock = pindex->pprev == nullptr ? uint256() : pindex->pprev->GetBlockHash();
1650 assert(hashPrevBlock == view.GetBestBlock());
1652 // Special case for the genesis block, skipping connection of its transactions
1653 // (its coinbase is unspendable)
1654 if (block.GetHash() == chainparams.GetConsensus().hashGenesisBlock) {
1655 if (!fJustCheck)
1656 view.SetBestBlock(pindex->GetBlockHash());
1657 return true;
1660 nBlocksTotal++;
1662 bool fScriptChecks = true;
1663 if (!hashAssumeValid.IsNull()) {
1664 // We've been configured with the hash of a block which has been externally verified to have a valid history.
1665 // A suitable default value is included with the software and updated from time to time. Because validity
1666 // relative to a piece of software is an objective fact these defaults can be easily reviewed.
1667 // This setting doesn't force the selection of any particular chain but makes validating some faster by
1668 // effectively caching the result of part of the verification.
1669 BlockMap::const_iterator it = mapBlockIndex.find(hashAssumeValid);
1670 if (it != mapBlockIndex.end()) {
1671 if (it->second->GetAncestor(pindex->nHeight) == pindex &&
1672 pindexBestHeader->GetAncestor(pindex->nHeight) == pindex &&
1673 pindexBestHeader->nChainWork >= UintToArith256(chainparams.GetConsensus().nMinimumChainWork)) {
1674 // This block is a member of the assumed verified chain and an ancestor of the best header.
1675 // The equivalent time check discourages hash power from extorting the network via DOS attack
1676 // into accepting an invalid block through telling users they must manually set assumevalid.
1677 // Requiring a software change or burying the invalid block, regardless of the setting, makes
1678 // it hard to hide the implication of the demand. This also avoids having release candidates
1679 // that are hardly doing any signature verification at all in testing without having to
1680 // artificially set the default assumed verified block further back.
1681 // The test against nMinimumChainWork prevents the skipping when denied access to any chain at
1682 // least as good as the expected chain.
1683 fScriptChecks = (GetBlockProofEquivalentTime(*pindexBestHeader, *pindex, *pindexBestHeader, chainparams.GetConsensus()) <= 60 * 60 * 24 * 7 * 2);
1688 int64_t nTime1 = GetTimeMicros(); nTimeCheck += nTime1 - nTimeStart;
1689 LogPrint(BCLog::BENCH, " - Sanity checks: %.2fms [%.2fs (%.2fms/blk)]\n", MILLI * (nTime1 - nTimeStart), nTimeCheck * MICRO, nTimeCheck * MILLI / nBlocksTotal);
1691 // Do not allow blocks that contain transactions which 'overwrite' older transactions,
1692 // unless those are already completely spent.
1693 // If such overwrites are allowed, coinbases and transactions depending upon those
1694 // can be duplicated to remove the ability to spend the first instance -- even after
1695 // being sent to another address.
1696 // See BIP30 and http://r6.ca/blog/20120206T005236Z.html for more information.
1697 // This logic is not necessary for memory pool transactions, as AcceptToMemoryPool
1698 // already refuses previously-known transaction ids entirely.
1699 // This rule was originally applied to all blocks with a timestamp after March 15, 2012, 0:00 UTC.
1700 // Now that the whole chain is irreversibly beyond that time it is applied to all blocks except the
1701 // two in the chain that violate it. This prevents exploiting the issue against nodes during their
1702 // initial block download.
1703 bool fEnforceBIP30 = (!pindex->phashBlock) || // Enforce on CreateNewBlock invocations which don't have a hash.
1704 !((pindex->nHeight==91842 && pindex->GetBlockHash() == uint256S("0x00000000000a4d0a398161ffc163c503763b1f4360639393e0e4c8e300e0caec")) ||
1705 (pindex->nHeight==91880 && pindex->GetBlockHash() == uint256S("0x00000000000743f190a18c5577a3c2d2a1f610ae9601ac046a38084ccb7cd721")));
1707 // Once BIP34 activated it was not possible to create new duplicate coinbases and thus other than starting
1708 // with the 2 existing duplicate coinbase pairs, not possible to create overwriting txs. But by the
1709 // time BIP34 activated, in each of the existing pairs the duplicate coinbase had overwritten the first
1710 // before the first had been spent. Since those coinbases are sufficiently buried its no longer possible to create further
1711 // duplicate transactions descending from the known pairs either.
1712 // If we're on the known chain at height greater than where BIP34 activated, we can save the db accesses needed for the BIP30 check.
1713 CBlockIndex *pindexBIP34height = pindex->pprev->GetAncestor(chainparams.GetConsensus().BIP34Height);
1714 //Only continue to enforce if we're below BIP34 activation height or the block hash at that height doesn't correspond.
1715 fEnforceBIP30 = fEnforceBIP30 && (!pindexBIP34height || !(pindexBIP34height->GetBlockHash() == chainparams.GetConsensus().BIP34Hash));
1717 if (fEnforceBIP30) {
1718 for (const auto& tx : block.vtx) {
1719 for (size_t o = 0; o < tx->vout.size(); o++) {
1720 if (view.HaveCoin(COutPoint(tx->GetHash(), o))) {
1721 return state.DoS(100, error("ConnectBlock(): tried to overwrite transaction"),
1722 REJECT_INVALID, "bad-txns-BIP30");
1728 // Start enforcing BIP68 (sequence locks) and BIP112 (CHECKSEQUENCEVERIFY) using versionbits logic.
1729 int nLockTimeFlags = 0;
1730 if (VersionBitsState(pindex->pprev, chainparams.GetConsensus(), Consensus::DEPLOYMENT_CSV, versionbitscache) == THRESHOLD_ACTIVE) {
1731 nLockTimeFlags |= LOCKTIME_VERIFY_SEQUENCE;
1734 // Get the script flags for this block
1735 unsigned int flags = GetBlockScriptFlags(pindex, chainparams.GetConsensus());
1737 int64_t nTime2 = GetTimeMicros(); nTimeForks += nTime2 - nTime1;
1738 LogPrint(BCLog::BENCH, " - Fork checks: %.2fms [%.2fs (%.2fms/blk)]\n", MILLI * (nTime2 - nTime1), nTimeForks * MICRO, nTimeForks * MILLI / nBlocksTotal);
1740 CBlockUndo blockundo;
1742 CCheckQueueControl<CScriptCheck> control(fScriptChecks && nScriptCheckThreads ? &scriptcheckqueue : nullptr);
1744 std::vector<int> prevheights;
1745 CAmount nFees = 0;
1746 int nInputs = 0;
1747 int64_t nSigOpsCost = 0;
1748 CDiskTxPos pos(pindex->GetBlockPos(), GetSizeOfCompactSize(block.vtx.size()));
1749 std::vector<std::pair<uint256, CDiskTxPos> > vPos;
1750 vPos.reserve(block.vtx.size());
1751 blockundo.vtxundo.reserve(block.vtx.size() - 1);
1752 std::vector<PrecomputedTransactionData> txdata;
1753 txdata.reserve(block.vtx.size()); // Required so that pointers to individual PrecomputedTransactionData don't get invalidated
1754 for (unsigned int i = 0; i < block.vtx.size(); i++)
1756 const CTransaction &tx = *(block.vtx[i]);
1758 nInputs += tx.vin.size();
1760 if (!tx.IsCoinBase())
1762 if (!view.HaveInputs(tx))
1763 return state.DoS(100, error("ConnectBlock(): inputs missing/spent"),
1764 REJECT_INVALID, "bad-txns-inputs-missingorspent");
1766 // Check that transaction is BIP68 final
1767 // BIP68 lock checks (as opposed to nLockTime checks) must
1768 // be in ConnectBlock because they require the UTXO set
1769 prevheights.resize(tx.vin.size());
1770 for (size_t j = 0; j < tx.vin.size(); j++) {
1771 prevheights[j] = view.AccessCoin(tx.vin[j].prevout).nHeight;
1774 if (!SequenceLocks(tx, nLockTimeFlags, &prevheights, *pindex)) {
1775 return state.DoS(100, error("%s: contains a non-BIP68-final transaction", __func__),
1776 REJECT_INVALID, "bad-txns-nonfinal");
1780 // GetTransactionSigOpCost counts 3 types of sigops:
1781 // * legacy (always)
1782 // * p2sh (when P2SH enabled in flags and excludes coinbase)
1783 // * witness (when witness enabled in flags and excludes coinbase)
1784 nSigOpsCost += GetTransactionSigOpCost(tx, view, flags);
1785 if (nSigOpsCost > MAX_BLOCK_SIGOPS_COST)
1786 return state.DoS(100, error("ConnectBlock(): too many sigops"),
1787 REJECT_INVALID, "bad-blk-sigops");
1789 txdata.emplace_back(tx);
1790 if (!tx.IsCoinBase())
1792 nFees += view.GetValueIn(tx)-tx.GetValueOut();
1794 std::vector<CScriptCheck> vChecks;
1795 bool fCacheResults = fJustCheck; /* Don't cache results if we're actually connecting blocks (still consult the cache, though) */
1796 if (!CheckInputs(tx, state, view, fScriptChecks, flags, fCacheResults, fCacheResults, txdata[i], nScriptCheckThreads ? &vChecks : nullptr))
1797 return error("ConnectBlock(): CheckInputs on %s failed with %s",
1798 tx.GetHash().ToString(), FormatStateMessage(state));
1799 control.Add(vChecks);
1802 CTxUndo undoDummy;
1803 if (i > 0) {
1804 blockundo.vtxundo.push_back(CTxUndo());
1806 UpdateCoins(tx, view, i == 0 ? undoDummy : blockundo.vtxundo.back(), pindex->nHeight);
1808 vPos.push_back(std::make_pair(tx.GetHash(), pos));
1809 pos.nTxOffset += ::GetSerializeSize(tx, SER_DISK, CLIENT_VERSION);
1811 int64_t nTime3 = GetTimeMicros(); nTimeConnect += nTime3 - nTime2;
1812 LogPrint(BCLog::BENCH, " - Connect %u transactions: %.2fms (%.3fms/tx, %.3fms/txin) [%.2fs (%.2fms/blk)]\n", (unsigned)block.vtx.size(), MILLI * (nTime3 - nTime2), MILLI * (nTime3 - nTime2) / block.vtx.size(), nInputs <= 1 ? 0 : MILLI * (nTime3 - nTime2) / (nInputs-1), nTimeConnect * MICRO, nTimeConnect * MILLI / nBlocksTotal);
1814 CAmount blockReward = nFees + GetBlockSubsidy(pindex->nHeight, chainparams.GetConsensus());
1815 if (block.vtx[0]->GetValueOut() > blockReward)
1816 return state.DoS(100,
1817 error("ConnectBlock(): coinbase pays too much (actual=%d vs limit=%d)",
1818 block.vtx[0]->GetValueOut(), blockReward),
1819 REJECT_INVALID, "bad-cb-amount");
1821 if (!control.Wait())
1822 return state.DoS(100, error("%s: CheckQueue failed", __func__), REJECT_INVALID, "block-validation-failed");
1823 int64_t nTime4 = GetTimeMicros(); nTimeVerify += nTime4 - nTime2;
1824 LogPrint(BCLog::BENCH, " - Verify %u txins: %.2fms (%.3fms/txin) [%.2fs (%.2fms/blk)]\n", nInputs - 1, MILLI * (nTime4 - nTime2), nInputs <= 1 ? 0 : MILLI * (nTime4 - nTime2) / (nInputs-1), nTimeVerify * MICRO, nTimeVerify * MILLI / nBlocksTotal);
1826 if (fJustCheck)
1827 return true;
1829 // Write undo information to disk
1830 if (pindex->GetUndoPos().IsNull() || !pindex->IsValid(BLOCK_VALID_SCRIPTS))
1832 if (pindex->GetUndoPos().IsNull()) {
1833 CDiskBlockPos _pos;
1834 if (!FindUndoPos(state, pindex->nFile, _pos, ::GetSerializeSize(blockundo, SER_DISK, CLIENT_VERSION) + 40))
1835 return error("ConnectBlock(): FindUndoPos failed");
1836 if (!UndoWriteToDisk(blockundo, _pos, pindex->pprev->GetBlockHash(), chainparams.MessageStart()))
1837 return AbortNode(state, "Failed to write undo data");
1839 // update nUndoPos in block index
1840 pindex->nUndoPos = _pos.nPos;
1841 pindex->nStatus |= BLOCK_HAVE_UNDO;
1844 pindex->RaiseValidity(BLOCK_VALID_SCRIPTS);
1845 setDirtyBlockIndex.insert(pindex);
1848 if (fTxIndex)
1849 if (!pblocktree->WriteTxIndex(vPos))
1850 return AbortNode(state, "Failed to write transaction index");
1852 // add this block to the view's block chain
1853 view.SetBestBlock(pindex->GetBlockHash());
1855 int64_t nTime5 = GetTimeMicros(); nTimeIndex += nTime5 - nTime4;
1856 LogPrint(BCLog::BENCH, " - Index writing: %.2fms [%.2fs (%.2fms/blk)]\n", MILLI * (nTime5 - nTime4), nTimeIndex * MICRO, nTimeIndex * MILLI / nBlocksTotal);
1858 int64_t nTime6 = GetTimeMicros(); nTimeCallbacks += nTime6 - nTime5;
1859 LogPrint(BCLog::BENCH, " - Callbacks: %.2fms [%.2fs (%.2fms/blk)]\n", MILLI * (nTime6 - nTime5), nTimeCallbacks * MICRO, nTimeCallbacks * MILLI / nBlocksTotal);
1861 return true;
1865 * Update the on-disk chain state.
1866 * The caches and indexes are flushed depending on the mode we're called with
1867 * if they're too large, if it's been a while since the last write,
1868 * or always and in all cases if we're in prune mode and are deleting files.
1870 bool static FlushStateToDisk(const CChainParams& chainparams, CValidationState &state, FlushStateMode mode, int nManualPruneHeight) {
1871 int64_t nMempoolUsage = mempool.DynamicMemoryUsage();
1872 LOCK(cs_main);
1873 static int64_t nLastWrite = 0;
1874 static int64_t nLastFlush = 0;
1875 static int64_t nLastSetChain = 0;
1876 std::set<int> setFilesToPrune;
1877 bool fFlushForPrune = false;
1878 bool fDoFullFlush = false;
1879 int64_t nNow = 0;
1880 try {
1882 LOCK(cs_LastBlockFile);
1883 if (fPruneMode && (fCheckForPruning || nManualPruneHeight > 0) && !fReindex) {
1884 if (nManualPruneHeight > 0) {
1885 FindFilesToPruneManual(setFilesToPrune, nManualPruneHeight);
1886 } else {
1887 FindFilesToPrune(setFilesToPrune, chainparams.PruneAfterHeight());
1888 fCheckForPruning = false;
1890 if (!setFilesToPrune.empty()) {
1891 fFlushForPrune = true;
1892 if (!fHavePruned) {
1893 pblocktree->WriteFlag("prunedblockfiles", true);
1894 fHavePruned = true;
1898 nNow = GetTimeMicros();
1899 // Avoid writing/flushing immediately after startup.
1900 if (nLastWrite == 0) {
1901 nLastWrite = nNow;
1903 if (nLastFlush == 0) {
1904 nLastFlush = nNow;
1906 if (nLastSetChain == 0) {
1907 nLastSetChain = nNow;
1909 int64_t nMempoolSizeMax = gArgs.GetArg("-maxmempool", DEFAULT_MAX_MEMPOOL_SIZE) * 1000000;
1910 int64_t cacheSize = pcoinsTip->DynamicMemoryUsage();
1911 int64_t nTotalSpace = nCoinCacheUsage + std::max<int64_t>(nMempoolSizeMax - nMempoolUsage, 0);
1912 // The cache is large and we're within 10% and 10 MiB of the limit, but we have time now (not in the middle of a block processing).
1913 bool fCacheLarge = mode == FLUSH_STATE_PERIODIC && cacheSize > std::max((9 * nTotalSpace) / 10, nTotalSpace - MAX_BLOCK_COINSDB_USAGE * 1024 * 1024);
1914 // The cache is over the limit, we have to write now.
1915 bool fCacheCritical = mode == FLUSH_STATE_IF_NEEDED && cacheSize > nTotalSpace;
1916 // It's been a while since we wrote the block index to disk. Do this frequently, so we don't need to redownload after a crash.
1917 bool fPeriodicWrite = mode == FLUSH_STATE_PERIODIC && nNow > nLastWrite + (int64_t)DATABASE_WRITE_INTERVAL * 1000000;
1918 // It's been very long since we flushed the cache. Do this infrequently, to optimize cache usage.
1919 bool fPeriodicFlush = mode == FLUSH_STATE_PERIODIC && nNow > nLastFlush + (int64_t)DATABASE_FLUSH_INTERVAL * 1000000;
1920 // Combine all conditions that result in a full cache flush.
1921 fDoFullFlush = (mode == FLUSH_STATE_ALWAYS) || fCacheLarge || fCacheCritical || fPeriodicFlush || fFlushForPrune;
1922 // Write blocks and block index to disk.
1923 if (fDoFullFlush || fPeriodicWrite) {
1924 // Depend on nMinDiskSpace to ensure we can write block index
1925 if (!CheckDiskSpace(0))
1926 return state.Error("out of disk space");
1927 // First make sure all block and undo data is flushed to disk.
1928 FlushBlockFile();
1929 // Then update all block file information (which may refer to block and undo files).
1931 std::vector<std::pair<int, const CBlockFileInfo*> > vFiles;
1932 vFiles.reserve(setDirtyFileInfo.size());
1933 for (std::set<int>::iterator it = setDirtyFileInfo.begin(); it != setDirtyFileInfo.end(); ) {
1934 vFiles.push_back(std::make_pair(*it, &vinfoBlockFile[*it]));
1935 setDirtyFileInfo.erase(it++);
1937 std::vector<const CBlockIndex*> vBlocks;
1938 vBlocks.reserve(setDirtyBlockIndex.size());
1939 for (std::set<CBlockIndex*>::iterator it = setDirtyBlockIndex.begin(); it != setDirtyBlockIndex.end(); ) {
1940 vBlocks.push_back(*it);
1941 setDirtyBlockIndex.erase(it++);
1943 if (!pblocktree->WriteBatchSync(vFiles, nLastBlockFile, vBlocks)) {
1944 return AbortNode(state, "Failed to write to block index database");
1947 // Finally remove any pruned files
1948 if (fFlushForPrune)
1949 UnlinkPrunedFiles(setFilesToPrune);
1950 nLastWrite = nNow;
1952 // Flush best chain related state. This can only be done if the blocks / block index write was also done.
1953 if (fDoFullFlush) {
1954 // Typical Coin structures on disk are around 48 bytes in size.
1955 // Pushing a new one to the database can cause it to be written
1956 // twice (once in the log, and once in the tables). This is already
1957 // an overestimation, as most will delete an existing entry or
1958 // overwrite one. Still, use a conservative safety factor of 2.
1959 if (!CheckDiskSpace(48 * 2 * 2 * pcoinsTip->GetCacheSize()))
1960 return state.Error("out of disk space");
1961 // Flush the chainstate (which may refer to block index entries).
1962 if (!pcoinsTip->Flush())
1963 return AbortNode(state, "Failed to write to coin database");
1964 nLastFlush = nNow;
1967 if (fDoFullFlush || ((mode == FLUSH_STATE_ALWAYS || mode == FLUSH_STATE_PERIODIC) && nNow > nLastSetChain + (int64_t)DATABASE_WRITE_INTERVAL * 1000000)) {
1968 // Update best block in wallet (so we can detect restored wallets).
1969 GetMainSignals().SetBestChain(chainActive.GetLocator());
1970 nLastSetChain = nNow;
1972 } catch (const std::runtime_error& e) {
1973 return AbortNode(state, std::string("System error while flushing: ") + e.what());
1975 return true;
1978 void FlushStateToDisk() {
1979 CValidationState state;
1980 const CChainParams& chainparams = Params();
1981 FlushStateToDisk(chainparams, state, FLUSH_STATE_ALWAYS);
1984 void PruneAndFlush() {
1985 CValidationState state;
1986 fCheckForPruning = true;
1987 const CChainParams& chainparams = Params();
1988 FlushStateToDisk(chainparams, state, FLUSH_STATE_NONE);
1991 static void DoWarning(const std::string& strWarning)
1993 static bool fWarned = false;
1994 SetMiscWarning(strWarning);
1995 if (!fWarned) {
1996 AlertNotify(strWarning);
1997 fWarned = true;
2001 /** Update chainActive and related internal data structures. */
2002 void static UpdateTip(CBlockIndex *pindexNew, const CChainParams& chainParams) {
2003 chainActive.SetTip(pindexNew);
2005 // New best block
2006 mempool.AddTransactionsUpdated(1);
2008 cvBlockChange.notify_all();
2010 std::vector<std::string> warningMessages;
2011 if (!IsInitialBlockDownload())
2013 int nUpgraded = 0;
2014 const CBlockIndex* pindex = chainActive.Tip();
2015 for (int bit = 0; bit < VERSIONBITS_NUM_BITS; bit++) {
2016 WarningBitsConditionChecker checker(bit);
2017 ThresholdState state = checker.GetStateFor(pindex, chainParams.GetConsensus(), warningcache[bit]);
2018 if (state == THRESHOLD_ACTIVE || state == THRESHOLD_LOCKED_IN) {
2019 const std::string strWarning = strprintf(_("Warning: unknown new rules activated (versionbit %i)"), bit);
2020 if (state == THRESHOLD_ACTIVE) {
2021 DoWarning(strWarning);
2022 } else {
2023 warningMessages.push_back(strWarning);
2027 // Check the version of the last 100 blocks to see if we need to upgrade:
2028 for (int i = 0; i < 100 && pindex != nullptr; i++)
2030 int32_t nExpectedVersion = ComputeBlockVersion(pindex->pprev, chainParams.GetConsensus());
2031 if (pindex->nVersion > VERSIONBITS_LAST_OLD_BLOCK_VERSION && (pindex->nVersion & ~nExpectedVersion) != 0)
2032 ++nUpgraded;
2033 pindex = pindex->pprev;
2035 if (nUpgraded > 0)
2036 warningMessages.push_back(strprintf(_("%d of last 100 blocks have unexpected version"), nUpgraded));
2037 if (nUpgraded > 100/2)
2039 std::string strWarning = _("Warning: Unknown block versions being mined! It's possible unknown rules are in effect");
2040 // notify GetWarnings(), called by Qt and the JSON-RPC code to warn the user:
2041 DoWarning(strWarning);
2044 LogPrintf("%s: new best=%s height=%d version=0x%08x log2_work=%.8g tx=%lu date='%s' progress=%f cache=%.1fMiB(%utxo)", __func__,
2045 chainActive.Tip()->GetBlockHash().ToString(), chainActive.Height(), chainActive.Tip()->nVersion,
2046 log(chainActive.Tip()->nChainWork.getdouble())/log(2.0), (unsigned long)chainActive.Tip()->nChainTx,
2047 DateTimeStrFormat("%Y-%m-%d %H:%M:%S", chainActive.Tip()->GetBlockTime()),
2048 GuessVerificationProgress(chainParams.TxData(), chainActive.Tip()), pcoinsTip->DynamicMemoryUsage() * (1.0 / (1<<20)), pcoinsTip->GetCacheSize());
2049 if (!warningMessages.empty())
2050 LogPrintf(" warning='%s'", boost::algorithm::join(warningMessages, ", "));
2051 LogPrintf("\n");
2055 /** Disconnect chainActive's tip.
2056 * After calling, the mempool will be in an inconsistent state, with
2057 * transactions from disconnected blocks being added to disconnectpool. You
2058 * should make the mempool consistent again by calling UpdateMempoolForReorg.
2059 * with cs_main held.
2061 * If disconnectpool is nullptr, then no disconnected transactions are added to
2062 * disconnectpool (note that the caller is responsible for mempool consistency
2063 * in any case).
2065 bool static DisconnectTip(CValidationState& state, const CChainParams& chainparams, DisconnectedBlockTransactions *disconnectpool)
2067 CBlockIndex *pindexDelete = chainActive.Tip();
2068 assert(pindexDelete);
2069 // Read block from disk.
2070 std::shared_ptr<CBlock> pblock = std::make_shared<CBlock>();
2071 CBlock& block = *pblock;
2072 if (!ReadBlockFromDisk(block, pindexDelete, chainparams.GetConsensus()))
2073 return AbortNode(state, "Failed to read block");
2074 // Apply the block atomically to the chain state.
2075 int64_t nStart = GetTimeMicros();
2077 CCoinsViewCache view(pcoinsTip);
2078 assert(view.GetBestBlock() == pindexDelete->GetBlockHash());
2079 if (DisconnectBlock(block, pindexDelete, view) != DISCONNECT_OK)
2080 return error("DisconnectTip(): DisconnectBlock %s failed", pindexDelete->GetBlockHash().ToString());
2081 bool flushed = view.Flush();
2082 assert(flushed);
2084 LogPrint(BCLog::BENCH, "- Disconnect block: %.2fms\n", (GetTimeMicros() - nStart) * MILLI);
2085 // Write the chain state to disk, if necessary.
2086 if (!FlushStateToDisk(chainparams, state, FLUSH_STATE_IF_NEEDED))
2087 return false;
2089 if (disconnectpool) {
2090 // Save transactions to re-add to mempool at end of reorg
2091 for (auto it = block.vtx.rbegin(); it != block.vtx.rend(); ++it) {
2092 disconnectpool->addTransaction(*it);
2094 while (disconnectpool->DynamicMemoryUsage() > MAX_DISCONNECTED_TX_POOL_SIZE * 1000) {
2095 // Drop the earliest entry, and remove its children from the mempool.
2096 auto it = disconnectpool->queuedTx.get<insertion_order>().begin();
2097 mempool.removeRecursive(**it, MemPoolRemovalReason::REORG);
2098 disconnectpool->removeEntry(it);
2102 // Update chainActive and related variables.
2103 UpdateTip(pindexDelete->pprev, chainparams);
2104 // Let wallets know transactions went from 1-confirmed to
2105 // 0-confirmed or conflicted:
2106 GetMainSignals().BlockDisconnected(pblock);
2107 return true;
2110 static int64_t nTimeReadFromDisk = 0;
2111 static int64_t nTimeConnectTotal = 0;
2112 static int64_t nTimeFlush = 0;
2113 static int64_t nTimeChainState = 0;
2114 static int64_t nTimePostConnect = 0;
2116 struct PerBlockConnectTrace {
2117 CBlockIndex* pindex = nullptr;
2118 std::shared_ptr<const CBlock> pblock;
2119 std::shared_ptr<std::vector<CTransactionRef>> conflictedTxs;
2120 PerBlockConnectTrace() : conflictedTxs(std::make_shared<std::vector<CTransactionRef>>()) {}
2123 * Used to track blocks whose transactions were applied to the UTXO state as a
2124 * part of a single ActivateBestChainStep call.
2126 * This class also tracks transactions that are removed from the mempool as
2127 * conflicts (per block) and can be used to pass all those transactions
2128 * through SyncTransaction.
2130 * This class assumes (and asserts) that the conflicted transactions for a given
2131 * block are added via mempool callbacks prior to the BlockConnected() associated
2132 * with those transactions. If any transactions are marked conflicted, it is
2133 * assumed that an associated block will always be added.
2135 * This class is single-use, once you call GetBlocksConnected() you have to throw
2136 * it away and make a new one.
2138 class ConnectTrace {
2139 private:
2140 std::vector<PerBlockConnectTrace> blocksConnected;
2141 CTxMemPool &pool;
2143 public:
2144 explicit ConnectTrace(CTxMemPool &_pool) : blocksConnected(1), pool(_pool) {
2145 pool.NotifyEntryRemoved.connect(boost::bind(&ConnectTrace::NotifyEntryRemoved, this, _1, _2));
2148 ~ConnectTrace() {
2149 pool.NotifyEntryRemoved.disconnect(boost::bind(&ConnectTrace::NotifyEntryRemoved, this, _1, _2));
2152 void BlockConnected(CBlockIndex* pindex, std::shared_ptr<const CBlock> pblock) {
2153 assert(!blocksConnected.back().pindex);
2154 assert(pindex);
2155 assert(pblock);
2156 blocksConnected.back().pindex = pindex;
2157 blocksConnected.back().pblock = std::move(pblock);
2158 blocksConnected.emplace_back();
2161 std::vector<PerBlockConnectTrace>& GetBlocksConnected() {
2162 // We always keep one extra block at the end of our list because
2163 // blocks are added after all the conflicted transactions have
2164 // been filled in. Thus, the last entry should always be an empty
2165 // one waiting for the transactions from the next block. We pop
2166 // the last entry here to make sure the list we return is sane.
2167 assert(!blocksConnected.back().pindex);
2168 assert(blocksConnected.back().conflictedTxs->empty());
2169 blocksConnected.pop_back();
2170 return blocksConnected;
2173 void NotifyEntryRemoved(CTransactionRef txRemoved, MemPoolRemovalReason reason) {
2174 assert(!blocksConnected.back().pindex);
2175 if (reason == MemPoolRemovalReason::CONFLICT) {
2176 blocksConnected.back().conflictedTxs->emplace_back(std::move(txRemoved));
2182 * Connect a new block to chainActive. pblock is either nullptr or a pointer to a CBlock
2183 * corresponding to pindexNew, to bypass loading it again from disk.
2185 * The block is added to connectTrace if connection succeeds.
2187 bool static ConnectTip(CValidationState& state, const CChainParams& chainparams, CBlockIndex* pindexNew, const std::shared_ptr<const CBlock>& pblock, ConnectTrace& connectTrace, DisconnectedBlockTransactions &disconnectpool)
2189 assert(pindexNew->pprev == chainActive.Tip());
2190 // Read block from disk.
2191 int64_t nTime1 = GetTimeMicros();
2192 std::shared_ptr<const CBlock> pthisBlock;
2193 if (!pblock) {
2194 std::shared_ptr<CBlock> pblockNew = std::make_shared<CBlock>();
2195 if (!ReadBlockFromDisk(*pblockNew, pindexNew, chainparams.GetConsensus()))
2196 return AbortNode(state, "Failed to read block");
2197 pthisBlock = pblockNew;
2198 } else {
2199 pthisBlock = pblock;
2201 const CBlock& blockConnecting = *pthisBlock;
2202 // Apply the block atomically to the chain state.
2203 int64_t nTime2 = GetTimeMicros(); nTimeReadFromDisk += nTime2 - nTime1;
2204 int64_t nTime3;
2205 LogPrint(BCLog::BENCH, " - Load block from disk: %.2fms [%.2fs]\n", (nTime2 - nTime1) * MILLI, nTimeReadFromDisk * MICRO);
2207 CCoinsViewCache view(pcoinsTip);
2208 bool rv = ConnectBlock(blockConnecting, state, pindexNew, view, chainparams);
2209 GetMainSignals().BlockChecked(blockConnecting, state);
2210 if (!rv) {
2211 if (state.IsInvalid())
2212 InvalidBlockFound(pindexNew, state);
2213 return error("ConnectTip(): ConnectBlock %s failed", pindexNew->GetBlockHash().ToString());
2215 nTime3 = GetTimeMicros(); nTimeConnectTotal += nTime3 - nTime2;
2216 LogPrint(BCLog::BENCH, " - Connect total: %.2fms [%.2fs (%.2fms/blk)]\n", (nTime3 - nTime2) * MILLI, nTimeConnectTotal * MICRO, nTimeConnectTotal * MILLI / nBlocksTotal);
2217 bool flushed = view.Flush();
2218 assert(flushed);
2220 int64_t nTime4 = GetTimeMicros(); nTimeFlush += nTime4 - nTime3;
2221 LogPrint(BCLog::BENCH, " - Flush: %.2fms [%.2fs (%.2fms/blk)]\n", (nTime4 - nTime3) * MILLI, nTimeFlush * MICRO, nTimeFlush * MILLI / nBlocksTotal);
2222 // Write the chain state to disk, if necessary.
2223 if (!FlushStateToDisk(chainparams, state, FLUSH_STATE_IF_NEEDED))
2224 return false;
2225 int64_t nTime5 = GetTimeMicros(); nTimeChainState += nTime5 - nTime4;
2226 LogPrint(BCLog::BENCH, " - Writing chainstate: %.2fms [%.2fs (%.2fms/blk)]\n", (nTime5 - nTime4) * MILLI, nTimeChainState * MICRO, nTimeChainState * MILLI / nBlocksTotal);
2227 // Remove conflicting transactions from the mempool.;
2228 mempool.removeForBlock(blockConnecting.vtx, pindexNew->nHeight);
2229 disconnectpool.removeForBlock(blockConnecting.vtx);
2230 // Update chainActive & related variables.
2231 UpdateTip(pindexNew, chainparams);
2233 int64_t nTime6 = GetTimeMicros(); nTimePostConnect += nTime6 - nTime5; nTimeTotal += nTime6 - nTime1;
2234 LogPrint(BCLog::BENCH, " - Connect postprocess: %.2fms [%.2fs (%.2fms/blk)]\n", (nTime6 - nTime5) * MILLI, nTimePostConnect * MICRO, nTimePostConnect * MILLI / nBlocksTotal);
2235 LogPrint(BCLog::BENCH, "- Connect block: %.2fms [%.2fs (%.2fms/blk)]\n", (nTime6 - nTime1) * MILLI, nTimeTotal * MICRO, nTimeTotal * MILLI / nBlocksTotal);
2237 connectTrace.BlockConnected(pindexNew, std::move(pthisBlock));
2238 return true;
2242 * Return the tip of the chain with the most work in it, that isn't
2243 * known to be invalid (it's however far from certain to be valid).
2245 static CBlockIndex* FindMostWorkChain() {
2246 do {
2247 CBlockIndex *pindexNew = nullptr;
2249 // Find the best candidate header.
2251 std::set<CBlockIndex*, CBlockIndexWorkComparator>::reverse_iterator it = setBlockIndexCandidates.rbegin();
2252 if (it == setBlockIndexCandidates.rend())
2253 return nullptr;
2254 pindexNew = *it;
2257 // Check whether all blocks on the path between the currently active chain and the candidate are valid.
2258 // Just going until the active chain is an optimization, as we know all blocks in it are valid already.
2259 CBlockIndex *pindexTest = pindexNew;
2260 bool fInvalidAncestor = false;
2261 while (pindexTest && !chainActive.Contains(pindexTest)) {
2262 assert(pindexTest->nChainTx || pindexTest->nHeight == 0);
2264 // Pruned nodes may have entries in setBlockIndexCandidates for
2265 // which block files have been deleted. Remove those as candidates
2266 // for the most work chain if we come across them; we can't switch
2267 // to a chain unless we have all the non-active-chain parent blocks.
2268 bool fFailedChain = pindexTest->nStatus & BLOCK_FAILED_MASK;
2269 bool fMissingData = !(pindexTest->nStatus & BLOCK_HAVE_DATA);
2270 if (fFailedChain || fMissingData) {
2271 // Candidate chain is not usable (either invalid or missing data)
2272 if (fFailedChain && (pindexBestInvalid == nullptr || pindexNew->nChainWork > pindexBestInvalid->nChainWork))
2273 pindexBestInvalid = pindexNew;
2274 CBlockIndex *pindexFailed = pindexNew;
2275 // Remove the entire chain from the set.
2276 while (pindexTest != pindexFailed) {
2277 if (fFailedChain) {
2278 pindexFailed->nStatus |= BLOCK_FAILED_CHILD;
2279 } else if (fMissingData) {
2280 // If we're missing data, then add back to mapBlocksUnlinked,
2281 // so that if the block arrives in the future we can try adding
2282 // to setBlockIndexCandidates again.
2283 mapBlocksUnlinked.insert(std::make_pair(pindexFailed->pprev, pindexFailed));
2285 setBlockIndexCandidates.erase(pindexFailed);
2286 pindexFailed = pindexFailed->pprev;
2288 setBlockIndexCandidates.erase(pindexTest);
2289 fInvalidAncestor = true;
2290 break;
2292 pindexTest = pindexTest->pprev;
2294 if (!fInvalidAncestor)
2295 return pindexNew;
2296 } while(true);
2299 /** Delete all entries in setBlockIndexCandidates that are worse than the current tip. */
2300 static void PruneBlockIndexCandidates() {
2301 // Note that we can't delete the current block itself, as we may need to return to it later in case a
2302 // reorganization to a better block fails.
2303 std::set<CBlockIndex*, CBlockIndexWorkComparator>::iterator it = setBlockIndexCandidates.begin();
2304 while (it != setBlockIndexCandidates.end() && setBlockIndexCandidates.value_comp()(*it, chainActive.Tip())) {
2305 setBlockIndexCandidates.erase(it++);
2307 // Either the current tip or a successor of it we're working towards is left in setBlockIndexCandidates.
2308 assert(!setBlockIndexCandidates.empty());
2312 * Try to make some progress towards making pindexMostWork the active block.
2313 * pblock is either nullptr or a pointer to a CBlock corresponding to pindexMostWork.
2315 static bool ActivateBestChainStep(CValidationState& state, const CChainParams& chainparams, CBlockIndex* pindexMostWork, const std::shared_ptr<const CBlock>& pblock, bool& fInvalidFound, ConnectTrace& connectTrace)
2317 AssertLockHeld(cs_main);
2318 const CBlockIndex *pindexOldTip = chainActive.Tip();
2319 const CBlockIndex *pindexFork = chainActive.FindFork(pindexMostWork);
2321 // Disconnect active blocks which are no longer in the best chain.
2322 bool fBlocksDisconnected = false;
2323 DisconnectedBlockTransactions disconnectpool;
2324 while (chainActive.Tip() && chainActive.Tip() != pindexFork) {
2325 if (!DisconnectTip(state, chainparams, &disconnectpool)) {
2326 // This is likely a fatal error, but keep the mempool consistent,
2327 // just in case. Only remove from the mempool in this case.
2328 UpdateMempoolForReorg(disconnectpool, false);
2329 return false;
2331 fBlocksDisconnected = true;
2334 // Build list of new blocks to connect.
2335 std::vector<CBlockIndex*> vpindexToConnect;
2336 bool fContinue = true;
2337 int nHeight = pindexFork ? pindexFork->nHeight : -1;
2338 while (fContinue && nHeight != pindexMostWork->nHeight) {
2339 // Don't iterate the entire list of potential improvements toward the best tip, as we likely only need
2340 // a few blocks along the way.
2341 int nTargetHeight = std::min(nHeight + 32, pindexMostWork->nHeight);
2342 vpindexToConnect.clear();
2343 vpindexToConnect.reserve(nTargetHeight - nHeight);
2344 CBlockIndex *pindexIter = pindexMostWork->GetAncestor(nTargetHeight);
2345 while (pindexIter && pindexIter->nHeight != nHeight) {
2346 vpindexToConnect.push_back(pindexIter);
2347 pindexIter = pindexIter->pprev;
2349 nHeight = nTargetHeight;
2351 // Connect new blocks.
2352 for (CBlockIndex *pindexConnect : reverse_iterate(vpindexToConnect)) {
2353 if (!ConnectTip(state, chainparams, pindexConnect, pindexConnect == pindexMostWork ? pblock : std::shared_ptr<const CBlock>(), connectTrace, disconnectpool)) {
2354 if (state.IsInvalid()) {
2355 // The block violates a consensus rule.
2356 if (!state.CorruptionPossible())
2357 InvalidChainFound(vpindexToConnect.back());
2358 state = CValidationState();
2359 fInvalidFound = true;
2360 fContinue = false;
2361 break;
2362 } else {
2363 // A system error occurred (disk space, database error, ...).
2364 // Make the mempool consistent with the current tip, just in case
2365 // any observers try to use it before shutdown.
2366 UpdateMempoolForReorg(disconnectpool, false);
2367 return false;
2369 } else {
2370 PruneBlockIndexCandidates();
2371 if (!pindexOldTip || chainActive.Tip()->nChainWork > pindexOldTip->nChainWork) {
2372 // We're in a better position than we were. Return temporarily to release the lock.
2373 fContinue = false;
2374 break;
2380 if (fBlocksDisconnected) {
2381 // If any blocks were disconnected, disconnectpool may be non empty. Add
2382 // any disconnected transactions back to the mempool.
2383 UpdateMempoolForReorg(disconnectpool, true);
2385 mempool.check(pcoinsTip);
2387 // Callbacks/notifications for a new best chain.
2388 if (fInvalidFound)
2389 CheckForkWarningConditionsOnNewFork(vpindexToConnect.back());
2390 else
2391 CheckForkWarningConditions();
2393 return true;
2396 static void NotifyHeaderTip() {
2397 bool fNotify = false;
2398 bool fInitialBlockDownload = false;
2399 static CBlockIndex* pindexHeaderOld = nullptr;
2400 CBlockIndex* pindexHeader = nullptr;
2402 LOCK(cs_main);
2403 pindexHeader = pindexBestHeader;
2405 if (pindexHeader != pindexHeaderOld) {
2406 fNotify = true;
2407 fInitialBlockDownload = IsInitialBlockDownload();
2408 pindexHeaderOld = pindexHeader;
2411 // Send block tip changed notifications without cs_main
2412 if (fNotify) {
2413 uiInterface.NotifyHeaderTip(fInitialBlockDownload, pindexHeader);
2418 * Make the best chain active, in multiple steps. The result is either failure
2419 * or an activated best chain. pblock is either nullptr or a pointer to a block
2420 * that is already loaded (to avoid loading it again from disk).
2422 bool ActivateBestChain(CValidationState &state, const CChainParams& chainparams, std::shared_ptr<const CBlock> pblock) {
2423 // Note that while we're often called here from ProcessNewBlock, this is
2424 // far from a guarantee. Things in the P2P/RPC will often end up calling
2425 // us in the middle of ProcessNewBlock - do not assume pblock is set
2426 // sanely for performance or correctness!
2428 CBlockIndex *pindexMostWork = nullptr;
2429 CBlockIndex *pindexNewTip = nullptr;
2430 int nStopAtHeight = gArgs.GetArg("-stopatheight", DEFAULT_STOPATHEIGHT);
2431 do {
2432 boost::this_thread::interruption_point();
2433 if (ShutdownRequested())
2434 break;
2436 const CBlockIndex *pindexFork;
2437 bool fInitialDownload;
2439 LOCK(cs_main);
2440 ConnectTrace connectTrace(mempool); // Destructed before cs_main is unlocked
2442 CBlockIndex *pindexOldTip = chainActive.Tip();
2443 if (pindexMostWork == nullptr) {
2444 pindexMostWork = FindMostWorkChain();
2447 // Whether we have anything to do at all.
2448 if (pindexMostWork == nullptr || pindexMostWork == chainActive.Tip())
2449 return true;
2451 bool fInvalidFound = false;
2452 std::shared_ptr<const CBlock> nullBlockPtr;
2453 if (!ActivateBestChainStep(state, chainparams, pindexMostWork, pblock && pblock->GetHash() == pindexMostWork->GetBlockHash() ? pblock : nullBlockPtr, fInvalidFound, connectTrace))
2454 return false;
2456 if (fInvalidFound) {
2457 // Wipe cache, we may need another branch now.
2458 pindexMostWork = nullptr;
2460 pindexNewTip = chainActive.Tip();
2461 pindexFork = chainActive.FindFork(pindexOldTip);
2462 fInitialDownload = IsInitialBlockDownload();
2464 for (const PerBlockConnectTrace& trace : connectTrace.GetBlocksConnected()) {
2465 assert(trace.pblock && trace.pindex);
2466 GetMainSignals().BlockConnected(trace.pblock, trace.pindex, *trace.conflictedTxs);
2469 // When we reach this point, we switched to a new tip (stored in pindexNewTip).
2471 // Notifications/callbacks that can run without cs_main
2473 // Notify external listeners about the new tip.
2474 GetMainSignals().UpdatedBlockTip(pindexNewTip, pindexFork, fInitialDownload);
2476 // Always notify the UI if a new block tip was connected
2477 if (pindexFork != pindexNewTip) {
2478 uiInterface.NotifyBlockTip(fInitialDownload, pindexNewTip);
2481 if (nStopAtHeight && pindexNewTip && pindexNewTip->nHeight >= nStopAtHeight) StartShutdown();
2482 } while (pindexNewTip != pindexMostWork);
2483 CheckBlockIndex(chainparams.GetConsensus());
2485 // Write changes periodically to disk, after relay.
2486 if (!FlushStateToDisk(chainparams, state, FLUSH_STATE_PERIODIC)) {
2487 return false;
2490 return true;
2494 bool PreciousBlock(CValidationState& state, const CChainParams& params, CBlockIndex *pindex)
2497 LOCK(cs_main);
2498 if (pindex->nChainWork < chainActive.Tip()->nChainWork) {
2499 // Nothing to do, this block is not at the tip.
2500 return true;
2502 if (chainActive.Tip()->nChainWork > nLastPreciousChainwork) {
2503 // The chain has been extended since the last call, reset the counter.
2504 nBlockReverseSequenceId = -1;
2506 nLastPreciousChainwork = chainActive.Tip()->nChainWork;
2507 setBlockIndexCandidates.erase(pindex);
2508 pindex->nSequenceId = nBlockReverseSequenceId;
2509 if (nBlockReverseSequenceId > std::numeric_limits<int32_t>::min()) {
2510 // We can't keep reducing the counter if somebody really wants to
2511 // call preciousblock 2**31-1 times on the same set of tips...
2512 nBlockReverseSequenceId--;
2514 if (pindex->IsValid(BLOCK_VALID_TRANSACTIONS) && pindex->nChainTx) {
2515 setBlockIndexCandidates.insert(pindex);
2516 PruneBlockIndexCandidates();
2520 return ActivateBestChain(state, params);
2523 bool InvalidateBlock(CValidationState& state, const CChainParams& chainparams, CBlockIndex *pindex)
2525 AssertLockHeld(cs_main);
2527 // Mark the block itself as invalid.
2528 pindex->nStatus |= BLOCK_FAILED_VALID;
2529 setDirtyBlockIndex.insert(pindex);
2530 setBlockIndexCandidates.erase(pindex);
2532 DisconnectedBlockTransactions disconnectpool;
2533 while (chainActive.Contains(pindex)) {
2534 CBlockIndex *pindexWalk = chainActive.Tip();
2535 pindexWalk->nStatus |= BLOCK_FAILED_CHILD;
2536 setDirtyBlockIndex.insert(pindexWalk);
2537 setBlockIndexCandidates.erase(pindexWalk);
2538 // ActivateBestChain considers blocks already in chainActive
2539 // unconditionally valid already, so force disconnect away from it.
2540 if (!DisconnectTip(state, chainparams, &disconnectpool)) {
2541 // It's probably hopeless to try to make the mempool consistent
2542 // here if DisconnectTip failed, but we can try.
2543 UpdateMempoolForReorg(disconnectpool, false);
2544 return false;
2548 // DisconnectTip will add transactions to disconnectpool; try to add these
2549 // back to the mempool.
2550 UpdateMempoolForReorg(disconnectpool, true);
2552 // The resulting new best tip may not be in setBlockIndexCandidates anymore, so
2553 // add it again.
2554 BlockMap::iterator it = mapBlockIndex.begin();
2555 while (it != mapBlockIndex.end()) {
2556 if (it->second->IsValid(BLOCK_VALID_TRANSACTIONS) && it->second->nChainTx && !setBlockIndexCandidates.value_comp()(it->second, chainActive.Tip())) {
2557 setBlockIndexCandidates.insert(it->second);
2559 it++;
2562 InvalidChainFound(pindex);
2563 uiInterface.NotifyBlockTip(IsInitialBlockDownload(), pindex->pprev);
2564 return true;
2567 bool ResetBlockFailureFlags(CBlockIndex *pindex) {
2568 AssertLockHeld(cs_main);
2570 int nHeight = pindex->nHeight;
2572 // Remove the invalidity flag from this block and all its descendants.
2573 BlockMap::iterator it = mapBlockIndex.begin();
2574 while (it != mapBlockIndex.end()) {
2575 if (!it->second->IsValid() && it->second->GetAncestor(nHeight) == pindex) {
2576 it->second->nStatus &= ~BLOCK_FAILED_MASK;
2577 setDirtyBlockIndex.insert(it->second);
2578 if (it->second->IsValid(BLOCK_VALID_TRANSACTIONS) && it->second->nChainTx && setBlockIndexCandidates.value_comp()(chainActive.Tip(), it->second)) {
2579 setBlockIndexCandidates.insert(it->second);
2581 if (it->second == pindexBestInvalid) {
2582 // Reset invalid block marker if it was pointing to one of those.
2583 pindexBestInvalid = nullptr;
2586 it++;
2589 // Remove the invalidity flag from all ancestors too.
2590 while (pindex != nullptr) {
2591 if (pindex->nStatus & BLOCK_FAILED_MASK) {
2592 pindex->nStatus &= ~BLOCK_FAILED_MASK;
2593 setDirtyBlockIndex.insert(pindex);
2595 pindex = pindex->pprev;
2597 return true;
2600 static CBlockIndex* AddToBlockIndex(const CBlockHeader& block)
2602 // Check for duplicate
2603 uint256 hash = block.GetHash();
2604 BlockMap::iterator it = mapBlockIndex.find(hash);
2605 if (it != mapBlockIndex.end())
2606 return it->second;
2608 // Construct new block index object
2609 CBlockIndex* pindexNew = new CBlockIndex(block);
2610 assert(pindexNew);
2611 // We assign the sequence id to blocks only when the full data is available,
2612 // to avoid miners withholding blocks but broadcasting headers, to get a
2613 // competitive advantage.
2614 pindexNew->nSequenceId = 0;
2615 BlockMap::iterator mi = mapBlockIndex.insert(std::make_pair(hash, pindexNew)).first;
2616 pindexNew->phashBlock = &((*mi).first);
2617 BlockMap::iterator miPrev = mapBlockIndex.find(block.hashPrevBlock);
2618 if (miPrev != mapBlockIndex.end())
2620 pindexNew->pprev = (*miPrev).second;
2621 pindexNew->nHeight = pindexNew->pprev->nHeight + 1;
2622 pindexNew->BuildSkip();
2624 pindexNew->nTimeMax = (pindexNew->pprev ? std::max(pindexNew->pprev->nTimeMax, pindexNew->nTime) : pindexNew->nTime);
2625 pindexNew->nChainWork = (pindexNew->pprev ? pindexNew->pprev->nChainWork : 0) + GetBlockProof(*pindexNew);
2626 pindexNew->RaiseValidity(BLOCK_VALID_TREE);
2627 if (pindexBestHeader == nullptr || pindexBestHeader->nChainWork < pindexNew->nChainWork)
2628 pindexBestHeader = pindexNew;
2630 setDirtyBlockIndex.insert(pindexNew);
2632 return pindexNew;
2635 /** Mark a block as having its data received and checked (up to BLOCK_VALID_TRANSACTIONS). */
2636 static bool ReceivedBlockTransactions(const CBlock &block, CValidationState& state, CBlockIndex *pindexNew, const CDiskBlockPos& pos, const Consensus::Params& consensusParams)
2638 pindexNew->nTx = block.vtx.size();
2639 pindexNew->nChainTx = 0;
2640 pindexNew->nFile = pos.nFile;
2641 pindexNew->nDataPos = pos.nPos;
2642 pindexNew->nUndoPos = 0;
2643 pindexNew->nStatus |= BLOCK_HAVE_DATA;
2644 if (IsWitnessEnabled(pindexNew->pprev, consensusParams)) {
2645 pindexNew->nStatus |= BLOCK_OPT_WITNESS;
2647 pindexNew->RaiseValidity(BLOCK_VALID_TRANSACTIONS);
2648 setDirtyBlockIndex.insert(pindexNew);
2650 if (pindexNew->pprev == nullptr || pindexNew->pprev->nChainTx) {
2651 // If pindexNew is the genesis block or all parents are BLOCK_VALID_TRANSACTIONS.
2652 std::deque<CBlockIndex*> queue;
2653 queue.push_back(pindexNew);
2655 // Recursively process any descendant blocks that now may be eligible to be connected.
2656 while (!queue.empty()) {
2657 CBlockIndex *pindex = queue.front();
2658 queue.pop_front();
2659 pindex->nChainTx = (pindex->pprev ? pindex->pprev->nChainTx : 0) + pindex->nTx;
2661 LOCK(cs_nBlockSequenceId);
2662 pindex->nSequenceId = nBlockSequenceId++;
2664 if (chainActive.Tip() == nullptr || !setBlockIndexCandidates.value_comp()(pindex, chainActive.Tip())) {
2665 setBlockIndexCandidates.insert(pindex);
2667 std::pair<std::multimap<CBlockIndex*, CBlockIndex*>::iterator, std::multimap<CBlockIndex*, CBlockIndex*>::iterator> range = mapBlocksUnlinked.equal_range(pindex);
2668 while (range.first != range.second) {
2669 std::multimap<CBlockIndex*, CBlockIndex*>::iterator it = range.first;
2670 queue.push_back(it->second);
2671 range.first++;
2672 mapBlocksUnlinked.erase(it);
2675 } else {
2676 if (pindexNew->pprev && pindexNew->pprev->IsValid(BLOCK_VALID_TREE)) {
2677 mapBlocksUnlinked.insert(std::make_pair(pindexNew->pprev, pindexNew));
2681 return true;
2684 static bool FindBlockPos(CValidationState &state, CDiskBlockPos &pos, unsigned int nAddSize, unsigned int nHeight, uint64_t nTime, bool fKnown = false)
2686 LOCK(cs_LastBlockFile);
2688 unsigned int nFile = fKnown ? pos.nFile : nLastBlockFile;
2689 if (vinfoBlockFile.size() <= nFile) {
2690 vinfoBlockFile.resize(nFile + 1);
2693 if (!fKnown) {
2694 while (vinfoBlockFile[nFile].nSize + nAddSize >= MAX_BLOCKFILE_SIZE) {
2695 nFile++;
2696 if (vinfoBlockFile.size() <= nFile) {
2697 vinfoBlockFile.resize(nFile + 1);
2700 pos.nFile = nFile;
2701 pos.nPos = vinfoBlockFile[nFile].nSize;
2704 if ((int)nFile != nLastBlockFile) {
2705 if (!fKnown) {
2706 LogPrintf("Leaving block file %i: %s\n", nLastBlockFile, vinfoBlockFile[nLastBlockFile].ToString());
2708 FlushBlockFile(!fKnown);
2709 nLastBlockFile = nFile;
2712 vinfoBlockFile[nFile].AddBlock(nHeight, nTime);
2713 if (fKnown)
2714 vinfoBlockFile[nFile].nSize = std::max(pos.nPos + nAddSize, vinfoBlockFile[nFile].nSize);
2715 else
2716 vinfoBlockFile[nFile].nSize += nAddSize;
2718 if (!fKnown) {
2719 unsigned int nOldChunks = (pos.nPos + BLOCKFILE_CHUNK_SIZE - 1) / BLOCKFILE_CHUNK_SIZE;
2720 unsigned int nNewChunks = (vinfoBlockFile[nFile].nSize + BLOCKFILE_CHUNK_SIZE - 1) / BLOCKFILE_CHUNK_SIZE;
2721 if (nNewChunks > nOldChunks) {
2722 if (fPruneMode)
2723 fCheckForPruning = true;
2724 if (CheckDiskSpace(nNewChunks * BLOCKFILE_CHUNK_SIZE - pos.nPos)) {
2725 FILE *file = OpenBlockFile(pos);
2726 if (file) {
2727 LogPrintf("Pre-allocating up to position 0x%x in blk%05u.dat\n", nNewChunks * BLOCKFILE_CHUNK_SIZE, pos.nFile);
2728 AllocateFileRange(file, pos.nPos, nNewChunks * BLOCKFILE_CHUNK_SIZE - pos.nPos);
2729 fclose(file);
2732 else
2733 return state.Error("out of disk space");
2737 setDirtyFileInfo.insert(nFile);
2738 return true;
2741 static bool FindUndoPos(CValidationState &state, int nFile, CDiskBlockPos &pos, unsigned int nAddSize)
2743 pos.nFile = nFile;
2745 LOCK(cs_LastBlockFile);
2747 unsigned int nNewSize;
2748 pos.nPos = vinfoBlockFile[nFile].nUndoSize;
2749 nNewSize = vinfoBlockFile[nFile].nUndoSize += nAddSize;
2750 setDirtyFileInfo.insert(nFile);
2752 unsigned int nOldChunks = (pos.nPos + UNDOFILE_CHUNK_SIZE - 1) / UNDOFILE_CHUNK_SIZE;
2753 unsigned int nNewChunks = (nNewSize + UNDOFILE_CHUNK_SIZE - 1) / UNDOFILE_CHUNK_SIZE;
2754 if (nNewChunks > nOldChunks) {
2755 if (fPruneMode)
2756 fCheckForPruning = true;
2757 if (CheckDiskSpace(nNewChunks * UNDOFILE_CHUNK_SIZE - pos.nPos)) {
2758 FILE *file = OpenUndoFile(pos);
2759 if (file) {
2760 LogPrintf("Pre-allocating up to position 0x%x in rev%05u.dat\n", nNewChunks * UNDOFILE_CHUNK_SIZE, pos.nFile);
2761 AllocateFileRange(file, pos.nPos, nNewChunks * UNDOFILE_CHUNK_SIZE - pos.nPos);
2762 fclose(file);
2765 else
2766 return state.Error("out of disk space");
2769 return true;
2772 static bool CheckBlockHeader(const CBlockHeader& block, CValidationState& state, const Consensus::Params& consensusParams, bool fCheckPOW = true)
2774 // Check proof of work matches claimed amount
2775 if (fCheckPOW && !CheckProofOfWork(block.GetHash(), block.nBits, consensusParams))
2776 return state.DoS(50, false, REJECT_INVALID, "high-hash", false, "proof of work failed");
2778 return true;
2781 bool CheckBlock(const CBlock& block, CValidationState& state, const Consensus::Params& consensusParams, bool fCheckPOW, bool fCheckMerkleRoot)
2783 // These are checks that are independent of context.
2785 if (block.fChecked)
2786 return true;
2788 // Check that the header is valid (particularly PoW). This is mostly
2789 // redundant with the call in AcceptBlockHeader.
2790 if (!CheckBlockHeader(block, state, consensusParams, fCheckPOW))
2791 return false;
2793 // Check the merkle root.
2794 if (fCheckMerkleRoot) {
2795 bool mutated;
2796 uint256 hashMerkleRoot2 = BlockMerkleRoot(block, &mutated);
2797 if (block.hashMerkleRoot != hashMerkleRoot2)
2798 return state.DoS(100, false, REJECT_INVALID, "bad-txnmrklroot", true, "hashMerkleRoot mismatch");
2800 // Check for merkle tree malleability (CVE-2012-2459): repeating sequences
2801 // of transactions in a block without affecting the merkle root of a block,
2802 // while still invalidating it.
2803 if (mutated)
2804 return state.DoS(100, false, REJECT_INVALID, "bad-txns-duplicate", true, "duplicate transaction");
2807 // All potential-corruption validation must be done before we do any
2808 // transaction validation, as otherwise we may mark the header as invalid
2809 // because we receive the wrong transactions for it.
2810 // Note that witness malleability is checked in ContextualCheckBlock, so no
2811 // checks that use witness data may be performed here.
2813 // Size limits
2814 if (block.vtx.empty() || block.vtx.size() * WITNESS_SCALE_FACTOR > MAX_BLOCK_WEIGHT || ::GetSerializeSize(block, SER_NETWORK, PROTOCOL_VERSION | SERIALIZE_TRANSACTION_NO_WITNESS) * WITNESS_SCALE_FACTOR > MAX_BLOCK_WEIGHT)
2815 return state.DoS(100, false, REJECT_INVALID, "bad-blk-length", false, "size limits failed");
2817 // First transaction must be coinbase, the rest must not be
2818 if (block.vtx.empty() || !block.vtx[0]->IsCoinBase())
2819 return state.DoS(100, false, REJECT_INVALID, "bad-cb-missing", false, "first tx is not coinbase");
2820 for (unsigned int i = 1; i < block.vtx.size(); i++)
2821 if (block.vtx[i]->IsCoinBase())
2822 return state.DoS(100, false, REJECT_INVALID, "bad-cb-multiple", false, "more than one coinbase");
2824 // Check transactions
2825 for (const auto& tx : block.vtx)
2826 if (!CheckTransaction(*tx, state, false))
2827 return state.Invalid(false, state.GetRejectCode(), state.GetRejectReason(),
2828 strprintf("Transaction check failed (tx hash %s) %s", tx->GetHash().ToString(), state.GetDebugMessage()));
2830 unsigned int nSigOps = 0;
2831 for (const auto& tx : block.vtx)
2833 nSigOps += GetLegacySigOpCount(*tx);
2835 if (nSigOps * WITNESS_SCALE_FACTOR > MAX_BLOCK_SIGOPS_COST)
2836 return state.DoS(100, false, REJECT_INVALID, "bad-blk-sigops", false, "out-of-bounds SigOpCount");
2838 if (fCheckPOW && fCheckMerkleRoot)
2839 block.fChecked = true;
2841 return true;
2844 bool IsWitnessEnabled(const CBlockIndex* pindexPrev, const Consensus::Params& params)
2846 LOCK(cs_main);
2847 return (VersionBitsState(pindexPrev, params, Consensus::DEPLOYMENT_SEGWIT, versionbitscache) == THRESHOLD_ACTIVE);
2850 // Compute at which vout of the block's coinbase transaction the witness
2851 // commitment occurs, or -1 if not found.
2852 static int GetWitnessCommitmentIndex(const CBlock& block)
2854 int commitpos = -1;
2855 if (!block.vtx.empty()) {
2856 for (size_t o = 0; o < block.vtx[0]->vout.size(); o++) {
2857 if (block.vtx[0]->vout[o].scriptPubKey.size() >= 38 && block.vtx[0]->vout[o].scriptPubKey[0] == OP_RETURN && block.vtx[0]->vout[o].scriptPubKey[1] == 0x24 && block.vtx[0]->vout[o].scriptPubKey[2] == 0xaa && block.vtx[0]->vout[o].scriptPubKey[3] == 0x21 && block.vtx[0]->vout[o].scriptPubKey[4] == 0xa9 && block.vtx[0]->vout[o].scriptPubKey[5] == 0xed) {
2858 commitpos = o;
2862 return commitpos;
2865 void UpdateUncommittedBlockStructures(CBlock& block, const CBlockIndex* pindexPrev, const Consensus::Params& consensusParams)
2867 int commitpos = GetWitnessCommitmentIndex(block);
2868 static const std::vector<unsigned char> nonce(32, 0x00);
2869 if (commitpos != -1 && IsWitnessEnabled(pindexPrev, consensusParams) && !block.vtx[0]->HasWitness()) {
2870 CMutableTransaction tx(*block.vtx[0]);
2871 tx.vin[0].scriptWitness.stack.resize(1);
2872 tx.vin[0].scriptWitness.stack[0] = nonce;
2873 block.vtx[0] = MakeTransactionRef(std::move(tx));
2877 std::vector<unsigned char> GenerateCoinbaseCommitment(CBlock& block, const CBlockIndex* pindexPrev, const Consensus::Params& consensusParams)
2879 std::vector<unsigned char> commitment;
2880 int commitpos = GetWitnessCommitmentIndex(block);
2881 std::vector<unsigned char> ret(32, 0x00);
2882 if (consensusParams.vDeployments[Consensus::DEPLOYMENT_SEGWIT].nTimeout != 0) {
2883 if (commitpos == -1) {
2884 uint256 witnessroot = BlockWitnessMerkleRoot(block, nullptr);
2885 CHash256().Write(witnessroot.begin(), 32).Write(ret.data(), 32).Finalize(witnessroot.begin());
2886 CTxOut out;
2887 out.nValue = 0;
2888 out.scriptPubKey.resize(38);
2889 out.scriptPubKey[0] = OP_RETURN;
2890 out.scriptPubKey[1] = 0x24;
2891 out.scriptPubKey[2] = 0xaa;
2892 out.scriptPubKey[3] = 0x21;
2893 out.scriptPubKey[4] = 0xa9;
2894 out.scriptPubKey[5] = 0xed;
2895 memcpy(&out.scriptPubKey[6], witnessroot.begin(), 32);
2896 commitment = std::vector<unsigned char>(out.scriptPubKey.begin(), out.scriptPubKey.end());
2897 CMutableTransaction tx(*block.vtx[0]);
2898 tx.vout.push_back(out);
2899 block.vtx[0] = MakeTransactionRef(std::move(tx));
2902 UpdateUncommittedBlockStructures(block, pindexPrev, consensusParams);
2903 return commitment;
2906 /** Context-dependent validity checks.
2907 * By "context", we mean only the previous block headers, but not the UTXO
2908 * set; UTXO-related validity checks are done in ConnectBlock(). */
2909 static bool ContextualCheckBlockHeader(const CBlockHeader& block, CValidationState& state, const CChainParams& params, const CBlockIndex* pindexPrev, int64_t nAdjustedTime)
2911 assert(pindexPrev != nullptr);
2912 const int nHeight = pindexPrev->nHeight + 1;
2914 // Check proof of work
2915 const Consensus::Params& consensusParams = params.GetConsensus();
2916 if (block.nBits != GetNextWorkRequired(pindexPrev, &block, consensusParams))
2917 return state.DoS(100, false, REJECT_INVALID, "bad-diffbits", false, "incorrect proof of work");
2919 // Check against checkpoints
2920 if (fCheckpointsEnabled) {
2921 // Don't accept any forks from the main chain prior to last checkpoint.
2922 // GetLastCheckpoint finds the last checkpoint in MapCheckpoints that's in our
2923 // MapBlockIndex.
2924 CBlockIndex* pcheckpoint = Checkpoints::GetLastCheckpoint(params.Checkpoints());
2925 if (pcheckpoint && nHeight < pcheckpoint->nHeight)
2926 return state.DoS(100, error("%s: forked chain older than last checkpoint (height %d)", __func__, nHeight), REJECT_CHECKPOINT, "bad-fork-prior-to-checkpoint");
2929 // Check timestamp against prev
2930 if (block.GetBlockTime() <= pindexPrev->GetMedianTimePast())
2931 return state.Invalid(false, REJECT_INVALID, "time-too-old", "block's timestamp is too early");
2933 // Check timestamp
2934 if (block.GetBlockTime() > nAdjustedTime + MAX_FUTURE_BLOCK_TIME)
2935 return state.Invalid(false, REJECT_INVALID, "time-too-new", "block timestamp too far in the future");
2937 // Reject outdated version blocks when 95% (75% on testnet) of the network has upgraded:
2938 // check for version 2, 3 and 4 upgrades
2939 if((block.nVersion < 2 && nHeight >= consensusParams.BIP34Height) ||
2940 (block.nVersion < 3 && nHeight >= consensusParams.BIP66Height) ||
2941 (block.nVersion < 4 && nHeight >= consensusParams.BIP65Height))
2942 return state.Invalid(false, REJECT_OBSOLETE, strprintf("bad-version(0x%08x)", block.nVersion),
2943 strprintf("rejected nVersion=0x%08x block", block.nVersion));
2945 return true;
2948 static bool ContextualCheckBlock(const CBlock& block, CValidationState& state, const Consensus::Params& consensusParams, const CBlockIndex* pindexPrev)
2950 const int nHeight = pindexPrev == nullptr ? 0 : pindexPrev->nHeight + 1;
2952 // Start enforcing BIP113 (Median Time Past) using versionbits logic.
2953 int nLockTimeFlags = 0;
2954 if (VersionBitsState(pindexPrev, consensusParams, Consensus::DEPLOYMENT_CSV, versionbitscache) == THRESHOLD_ACTIVE) {
2955 nLockTimeFlags |= LOCKTIME_MEDIAN_TIME_PAST;
2958 int64_t nLockTimeCutoff = (nLockTimeFlags & LOCKTIME_MEDIAN_TIME_PAST)
2959 ? pindexPrev->GetMedianTimePast()
2960 : block.GetBlockTime();
2962 // Check that all transactions are finalized
2963 for (const auto& tx : block.vtx) {
2964 if (!IsFinalTx(*tx, nHeight, nLockTimeCutoff)) {
2965 return state.DoS(10, false, REJECT_INVALID, "bad-txns-nonfinal", false, "non-final transaction");
2969 // Enforce rule that the coinbase starts with serialized block height
2970 if (nHeight >= consensusParams.BIP34Height)
2972 CScript expect = CScript() << nHeight;
2973 if (block.vtx[0]->vin[0].scriptSig.size() < expect.size() ||
2974 !std::equal(expect.begin(), expect.end(), block.vtx[0]->vin[0].scriptSig.begin())) {
2975 return state.DoS(100, false, REJECT_INVALID, "bad-cb-height", false, "block height mismatch in coinbase");
2979 // Validation for witness commitments.
2980 // * We compute the witness hash (which is the hash including witnesses) of all the block's transactions, except the
2981 // coinbase (where 0x0000....0000 is used instead).
2982 // * The coinbase scriptWitness is a stack of a single 32-byte vector, containing a witness nonce (unconstrained).
2983 // * We build a merkle tree with all those witness hashes as leaves (similar to the hashMerkleRoot in the block header).
2984 // * There must be at least one output whose scriptPubKey is a single 36-byte push, the first 4 bytes of which are
2985 // {0xaa, 0x21, 0xa9, 0xed}, and the following 32 bytes are SHA256^2(witness root, witness nonce). In case there are
2986 // multiple, the last one is used.
2987 bool fHaveWitness = false;
2988 if (VersionBitsState(pindexPrev, consensusParams, Consensus::DEPLOYMENT_SEGWIT, versionbitscache) == THRESHOLD_ACTIVE) {
2989 int commitpos = GetWitnessCommitmentIndex(block);
2990 if (commitpos != -1) {
2991 bool malleated = false;
2992 uint256 hashWitness = BlockWitnessMerkleRoot(block, &malleated);
2993 // The malleation check is ignored; as the transaction tree itself
2994 // already does not permit it, it is impossible to trigger in the
2995 // witness tree.
2996 if (block.vtx[0]->vin[0].scriptWitness.stack.size() != 1 || block.vtx[0]->vin[0].scriptWitness.stack[0].size() != 32) {
2997 return state.DoS(100, false, REJECT_INVALID, "bad-witness-nonce-size", true, strprintf("%s : invalid witness nonce size", __func__));
2999 CHash256().Write(hashWitness.begin(), 32).Write(&block.vtx[0]->vin[0].scriptWitness.stack[0][0], 32).Finalize(hashWitness.begin());
3000 if (memcmp(hashWitness.begin(), &block.vtx[0]->vout[commitpos].scriptPubKey[6], 32)) {
3001 return state.DoS(100, false, REJECT_INVALID, "bad-witness-merkle-match", true, strprintf("%s : witness merkle commitment mismatch", __func__));
3003 fHaveWitness = true;
3007 // No witness data is allowed in blocks that don't commit to witness data, as this would otherwise leave room for spam
3008 if (!fHaveWitness) {
3009 for (const auto& tx : block.vtx) {
3010 if (tx->HasWitness()) {
3011 return state.DoS(100, false, REJECT_INVALID, "unexpected-witness", true, strprintf("%s : unexpected witness data found", __func__));
3016 // After the coinbase witness nonce and commitment are verified,
3017 // we can check if the block weight passes (before we've checked the
3018 // coinbase witness, it would be possible for the weight to be too
3019 // large by filling up the coinbase witness, which doesn't change
3020 // the block hash, so we couldn't mark the block as permanently
3021 // failed).
3022 if (GetBlockWeight(block) > MAX_BLOCK_WEIGHT) {
3023 return state.DoS(100, false, REJECT_INVALID, "bad-blk-weight", false, strprintf("%s : weight limit failed", __func__));
3026 return true;
3029 static bool AcceptBlockHeader(const CBlockHeader& block, CValidationState& state, const CChainParams& chainparams, CBlockIndex** ppindex)
3031 AssertLockHeld(cs_main);
3032 // Check for duplicate
3033 uint256 hash = block.GetHash();
3034 BlockMap::iterator miSelf = mapBlockIndex.find(hash);
3035 CBlockIndex *pindex = nullptr;
3036 if (hash != chainparams.GetConsensus().hashGenesisBlock) {
3038 if (miSelf != mapBlockIndex.end()) {
3039 // Block header is already known.
3040 pindex = miSelf->second;
3041 if (ppindex)
3042 *ppindex = pindex;
3043 if (pindex->nStatus & BLOCK_FAILED_MASK)
3044 return state.Invalid(error("%s: block %s is marked invalid", __func__, hash.ToString()), 0, "duplicate");
3045 return true;
3048 if (!CheckBlockHeader(block, state, chainparams.GetConsensus()))
3049 return error("%s: Consensus::CheckBlockHeader: %s, %s", __func__, hash.ToString(), FormatStateMessage(state));
3051 // Get prev block index
3052 CBlockIndex* pindexPrev = nullptr;
3053 BlockMap::iterator mi = mapBlockIndex.find(block.hashPrevBlock);
3054 if (mi == mapBlockIndex.end())
3055 return state.DoS(10, error("%s: prev block not found", __func__), 0, "prev-blk-not-found");
3056 pindexPrev = (*mi).second;
3057 if (pindexPrev->nStatus & BLOCK_FAILED_MASK)
3058 return state.DoS(100, error("%s: prev block invalid", __func__), REJECT_INVALID, "bad-prevblk");
3059 if (!ContextualCheckBlockHeader(block, state, chainparams, pindexPrev, GetAdjustedTime()))
3060 return error("%s: Consensus::ContextualCheckBlockHeader: %s, %s", __func__, hash.ToString(), FormatStateMessage(state));
3062 if (pindex == nullptr)
3063 pindex = AddToBlockIndex(block);
3065 if (ppindex)
3066 *ppindex = pindex;
3068 CheckBlockIndex(chainparams.GetConsensus());
3070 return true;
3073 // Exposed wrapper for AcceptBlockHeader
3074 bool ProcessNewBlockHeaders(const std::vector<CBlockHeader>& headers, CValidationState& state, const CChainParams& chainparams, const CBlockIndex** ppindex)
3077 LOCK(cs_main);
3078 for (const CBlockHeader& header : headers) {
3079 CBlockIndex *pindex = nullptr; // Use a temp pindex instead of ppindex to avoid a const_cast
3080 if (!AcceptBlockHeader(header, state, chainparams, &pindex)) {
3081 return false;
3083 if (ppindex) {
3084 *ppindex = pindex;
3088 NotifyHeaderTip();
3089 return true;
3092 /** Store block on disk. If dbp is non-nullptr, the file is known to already reside on disk */
3093 static bool AcceptBlock(const std::shared_ptr<const CBlock>& pblock, CValidationState& state, const CChainParams& chainparams, CBlockIndex** ppindex, bool fRequested, const CDiskBlockPos* dbp, bool* fNewBlock)
3095 const CBlock& block = *pblock;
3097 if (fNewBlock) *fNewBlock = false;
3098 AssertLockHeld(cs_main);
3100 CBlockIndex *pindexDummy = nullptr;
3101 CBlockIndex *&pindex = ppindex ? *ppindex : pindexDummy;
3103 if (!AcceptBlockHeader(block, state, chainparams, &pindex))
3104 return false;
3106 // Try to process all requested blocks that we don't have, but only
3107 // process an unrequested block if it's new and has enough work to
3108 // advance our tip, and isn't too many blocks ahead.
3109 bool fAlreadyHave = pindex->nStatus & BLOCK_HAVE_DATA;
3110 bool fHasMoreWork = (chainActive.Tip() ? pindex->nChainWork > chainActive.Tip()->nChainWork : true);
3111 // Blocks that are too out-of-order needlessly limit the effectiveness of
3112 // pruning, because pruning will not delete block files that contain any
3113 // blocks which are too close in height to the tip. Apply this test
3114 // regardless of whether pruning is enabled; it should generally be safe to
3115 // not process unrequested blocks.
3116 bool fTooFarAhead = (pindex->nHeight > int(chainActive.Height() + MIN_BLOCKS_TO_KEEP));
3118 // TODO: Decouple this function from the block download logic by removing fRequested
3119 // This requires some new chain data structure to efficiently look up if a
3120 // block is in a chain leading to a candidate for best tip, despite not
3121 // being such a candidate itself.
3123 // TODO: deal better with return value and error conditions for duplicate
3124 // and unrequested blocks.
3125 if (fAlreadyHave) return true;
3126 if (!fRequested) { // If we didn't ask for it:
3127 if (pindex->nTx != 0) return true; // This is a previously-processed block that was pruned
3128 if (!fHasMoreWork) return true; // Don't process less-work chains
3129 if (fTooFarAhead) return true; // Block height is too high
3131 if (fNewBlock) *fNewBlock = true;
3133 if (!CheckBlock(block, state, chainparams.GetConsensus()) ||
3134 !ContextualCheckBlock(block, state, chainparams.GetConsensus(), pindex->pprev)) {
3135 if (state.IsInvalid() && !state.CorruptionPossible()) {
3136 pindex->nStatus |= BLOCK_FAILED_VALID;
3137 setDirtyBlockIndex.insert(pindex);
3139 return error("%s: %s", __func__, FormatStateMessage(state));
3142 // Header is valid/has work, merkle tree and segwit merkle tree are good...RELAY NOW
3143 // (but if it does not build on our best tip, let the SendMessages loop relay it)
3144 if (!IsInitialBlockDownload() && chainActive.Tip() == pindex->pprev)
3145 GetMainSignals().NewPoWValidBlock(pindex, pblock);
3147 int nHeight = pindex->nHeight;
3149 // Write block to history file
3150 try {
3151 unsigned int nBlockSize = ::GetSerializeSize(block, SER_DISK, CLIENT_VERSION);
3152 CDiskBlockPos blockPos;
3153 if (dbp != nullptr)
3154 blockPos = *dbp;
3155 if (!FindBlockPos(state, blockPos, nBlockSize+8, nHeight, block.GetBlockTime(), dbp != nullptr))
3156 return error("AcceptBlock(): FindBlockPos failed");
3157 if (dbp == nullptr)
3158 if (!WriteBlockToDisk(block, blockPos, chainparams.MessageStart()))
3159 AbortNode(state, "Failed to write block");
3160 if (!ReceivedBlockTransactions(block, state, pindex, blockPos, chainparams.GetConsensus()))
3161 return error("AcceptBlock(): ReceivedBlockTransactions failed");
3162 } catch (const std::runtime_error& e) {
3163 return AbortNode(state, std::string("System error: ") + e.what());
3166 if (fCheckForPruning)
3167 FlushStateToDisk(chainparams, state, FLUSH_STATE_NONE); // we just allocated more disk space for block files
3169 return true;
3172 bool ProcessNewBlock(const CChainParams& chainparams, const std::shared_ptr<const CBlock> pblock, bool fForceProcessing, bool *fNewBlock)
3175 CBlockIndex *pindex = nullptr;
3176 if (fNewBlock) *fNewBlock = false;
3177 CValidationState state;
3178 // Ensure that CheckBlock() passes before calling AcceptBlock, as
3179 // belt-and-suspenders.
3180 bool ret = CheckBlock(*pblock, state, chainparams.GetConsensus());
3182 LOCK(cs_main);
3184 if (ret) {
3185 // Store to disk
3186 ret = AcceptBlock(pblock, state, chainparams, &pindex, fForceProcessing, nullptr, fNewBlock);
3188 CheckBlockIndex(chainparams.GetConsensus());
3189 if (!ret) {
3190 GetMainSignals().BlockChecked(*pblock, state);
3191 return error("%s: AcceptBlock FAILED", __func__);
3195 NotifyHeaderTip();
3197 CValidationState state; // Only used to report errors, not invalidity - ignore it
3198 if (!ActivateBestChain(state, chainparams, pblock))
3199 return error("%s: ActivateBestChain failed", __func__);
3201 return true;
3204 bool TestBlockValidity(CValidationState& state, const CChainParams& chainparams, const CBlock& block, CBlockIndex* pindexPrev, bool fCheckPOW, bool fCheckMerkleRoot)
3206 AssertLockHeld(cs_main);
3207 assert(pindexPrev && pindexPrev == chainActive.Tip());
3208 CCoinsViewCache viewNew(pcoinsTip);
3209 CBlockIndex indexDummy(block);
3210 indexDummy.pprev = pindexPrev;
3211 indexDummy.nHeight = pindexPrev->nHeight + 1;
3213 // NOTE: CheckBlockHeader is called by CheckBlock
3214 if (!ContextualCheckBlockHeader(block, state, chainparams, pindexPrev, GetAdjustedTime()))
3215 return error("%s: Consensus::ContextualCheckBlockHeader: %s", __func__, FormatStateMessage(state));
3216 if (!CheckBlock(block, state, chainparams.GetConsensus(), fCheckPOW, fCheckMerkleRoot))
3217 return error("%s: Consensus::CheckBlock: %s", __func__, FormatStateMessage(state));
3218 if (!ContextualCheckBlock(block, state, chainparams.GetConsensus(), pindexPrev))
3219 return error("%s: Consensus::ContextualCheckBlock: %s", __func__, FormatStateMessage(state));
3220 if (!ConnectBlock(block, state, &indexDummy, viewNew, chainparams, true))
3221 return false;
3222 assert(state.IsValid());
3224 return true;
3228 * BLOCK PRUNING CODE
3231 /* Calculate the amount of disk space the block & undo files currently use */
3232 static uint64_t CalculateCurrentUsage()
3234 uint64_t retval = 0;
3235 for (const CBlockFileInfo &file : vinfoBlockFile) {
3236 retval += file.nSize + file.nUndoSize;
3238 return retval;
3241 /* Prune a block file (modify associated database entries)*/
3242 void PruneOneBlockFile(const int fileNumber)
3244 for (BlockMap::iterator it = mapBlockIndex.begin(); it != mapBlockIndex.end(); ++it) {
3245 CBlockIndex* pindex = it->second;
3246 if (pindex->nFile == fileNumber) {
3247 pindex->nStatus &= ~BLOCK_HAVE_DATA;
3248 pindex->nStatus &= ~BLOCK_HAVE_UNDO;
3249 pindex->nFile = 0;
3250 pindex->nDataPos = 0;
3251 pindex->nUndoPos = 0;
3252 setDirtyBlockIndex.insert(pindex);
3254 // Prune from mapBlocksUnlinked -- any block we prune would have
3255 // to be downloaded again in order to consider its chain, at which
3256 // point it would be considered as a candidate for
3257 // mapBlocksUnlinked or setBlockIndexCandidates.
3258 std::pair<std::multimap<CBlockIndex*, CBlockIndex*>::iterator, std::multimap<CBlockIndex*, CBlockIndex*>::iterator> range = mapBlocksUnlinked.equal_range(pindex->pprev);
3259 while (range.first != range.second) {
3260 std::multimap<CBlockIndex *, CBlockIndex *>::iterator _it = range.first;
3261 range.first++;
3262 if (_it->second == pindex) {
3263 mapBlocksUnlinked.erase(_it);
3269 vinfoBlockFile[fileNumber].SetNull();
3270 setDirtyFileInfo.insert(fileNumber);
3274 void UnlinkPrunedFiles(const std::set<int>& setFilesToPrune)
3276 for (std::set<int>::iterator it = setFilesToPrune.begin(); it != setFilesToPrune.end(); ++it) {
3277 CDiskBlockPos pos(*it, 0);
3278 fs::remove(GetBlockPosFilename(pos, "blk"));
3279 fs::remove(GetBlockPosFilename(pos, "rev"));
3280 LogPrintf("Prune: %s deleted blk/rev (%05u)\n", __func__, *it);
3284 /* Calculate the block/rev files to delete based on height specified by user with RPC command pruneblockchain */
3285 static void FindFilesToPruneManual(std::set<int>& setFilesToPrune, int nManualPruneHeight)
3287 assert(fPruneMode && nManualPruneHeight > 0);
3289 LOCK2(cs_main, cs_LastBlockFile);
3290 if (chainActive.Tip() == nullptr)
3291 return;
3293 // last block to prune is the lesser of (user-specified height, MIN_BLOCKS_TO_KEEP from the tip)
3294 unsigned int nLastBlockWeCanPrune = std::min((unsigned)nManualPruneHeight, chainActive.Tip()->nHeight - MIN_BLOCKS_TO_KEEP);
3295 int count=0;
3296 for (int fileNumber = 0; fileNumber < nLastBlockFile; fileNumber++) {
3297 if (vinfoBlockFile[fileNumber].nSize == 0 || vinfoBlockFile[fileNumber].nHeightLast > nLastBlockWeCanPrune)
3298 continue;
3299 PruneOneBlockFile(fileNumber);
3300 setFilesToPrune.insert(fileNumber);
3301 count++;
3303 LogPrintf("Prune (Manual): prune_height=%d removed %d blk/rev pairs\n", nLastBlockWeCanPrune, count);
3306 /* This function is called from the RPC code for pruneblockchain */
3307 void PruneBlockFilesManual(int nManualPruneHeight)
3309 CValidationState state;
3310 const CChainParams& chainparams = Params();
3311 FlushStateToDisk(chainparams, state, FLUSH_STATE_NONE, nManualPruneHeight);
3315 * Prune block and undo files (blk???.dat and undo???.dat) so that the disk space used is less than a user-defined target.
3316 * The user sets the target (in MB) on the command line or in config file. This will be run on startup and whenever new
3317 * space is allocated in a block or undo file, staying below the target. Changing back to unpruned requires a reindex
3318 * (which in this case means the blockchain must be re-downloaded.)
3320 * Pruning functions are called from FlushStateToDisk when the global fCheckForPruning flag has been set.
3321 * Block and undo files are deleted in lock-step (when blk00003.dat is deleted, so is rev00003.dat.)
3322 * Pruning cannot take place until the longest chain is at least a certain length (100000 on mainnet, 1000 on testnet, 1000 on regtest).
3323 * Pruning will never delete a block within a defined distance (currently 288) from the active chain's tip.
3324 * The block index is updated by unsetting HAVE_DATA and HAVE_UNDO for any blocks that were stored in the deleted files.
3325 * A db flag records the fact that at least some block files have been pruned.
3327 * @param[out] setFilesToPrune The set of file indices that can be unlinked will be returned
3329 static void FindFilesToPrune(std::set<int>& setFilesToPrune, uint64_t nPruneAfterHeight)
3331 LOCK2(cs_main, cs_LastBlockFile);
3332 if (chainActive.Tip() == nullptr || nPruneTarget == 0) {
3333 return;
3335 if ((uint64_t)chainActive.Tip()->nHeight <= nPruneAfterHeight) {
3336 return;
3339 unsigned int nLastBlockWeCanPrune = chainActive.Tip()->nHeight - MIN_BLOCKS_TO_KEEP;
3340 uint64_t nCurrentUsage = CalculateCurrentUsage();
3341 // We don't check to prune until after we've allocated new space for files
3342 // So we should leave a buffer under our target to account for another allocation
3343 // before the next pruning.
3344 uint64_t nBuffer = BLOCKFILE_CHUNK_SIZE + UNDOFILE_CHUNK_SIZE;
3345 uint64_t nBytesToPrune;
3346 int count=0;
3348 if (nCurrentUsage + nBuffer >= nPruneTarget) {
3349 for (int fileNumber = 0; fileNumber < nLastBlockFile; fileNumber++) {
3350 nBytesToPrune = vinfoBlockFile[fileNumber].nSize + vinfoBlockFile[fileNumber].nUndoSize;
3352 if (vinfoBlockFile[fileNumber].nSize == 0)
3353 continue;
3355 if (nCurrentUsage + nBuffer < nPruneTarget) // are we below our target?
3356 break;
3358 // don't prune files that could have a block within MIN_BLOCKS_TO_KEEP of the main chain's tip but keep scanning
3359 if (vinfoBlockFile[fileNumber].nHeightLast > nLastBlockWeCanPrune)
3360 continue;
3362 PruneOneBlockFile(fileNumber);
3363 // Queue up the files for removal
3364 setFilesToPrune.insert(fileNumber);
3365 nCurrentUsage -= nBytesToPrune;
3366 count++;
3370 LogPrint(BCLog::PRUNE, "Prune: target=%dMiB actual=%dMiB diff=%dMiB max_prune_height=%d removed %d blk/rev pairs\n",
3371 nPruneTarget/1024/1024, nCurrentUsage/1024/1024,
3372 ((int64_t)nPruneTarget - (int64_t)nCurrentUsage)/1024/1024,
3373 nLastBlockWeCanPrune, count);
3376 bool CheckDiskSpace(uint64_t nAdditionalBytes)
3378 uint64_t nFreeBytesAvailable = fs::space(GetDataDir()).available;
3380 // Check for nMinDiskSpace bytes (currently 50MB)
3381 if (nFreeBytesAvailable < nMinDiskSpace + nAdditionalBytes)
3382 return AbortNode("Disk space is low!", _("Error: Disk space is low!"));
3384 return true;
3387 static FILE* OpenDiskFile(const CDiskBlockPos &pos, const char *prefix, bool fReadOnly)
3389 if (pos.IsNull())
3390 return nullptr;
3391 fs::path path = GetBlockPosFilename(pos, prefix);
3392 fs::create_directories(path.parent_path());
3393 FILE* file = fsbridge::fopen(path, "rb+");
3394 if (!file && !fReadOnly)
3395 file = fsbridge::fopen(path, "wb+");
3396 if (!file) {
3397 LogPrintf("Unable to open file %s\n", path.string());
3398 return nullptr;
3400 if (pos.nPos) {
3401 if (fseek(file, pos.nPos, SEEK_SET)) {
3402 LogPrintf("Unable to seek to position %u of %s\n", pos.nPos, path.string());
3403 fclose(file);
3404 return nullptr;
3407 return file;
3410 FILE* OpenBlockFile(const CDiskBlockPos &pos, bool fReadOnly) {
3411 return OpenDiskFile(pos, "blk", fReadOnly);
3414 /** Open an undo file (rev?????.dat) */
3415 static FILE* OpenUndoFile(const CDiskBlockPos &pos, bool fReadOnly) {
3416 return OpenDiskFile(pos, "rev", fReadOnly);
3419 fs::path GetBlockPosFilename(const CDiskBlockPos &pos, const char *prefix)
3421 return GetDataDir() / "blocks" / strprintf("%s%05u.dat", prefix, pos.nFile);
3424 CBlockIndex * InsertBlockIndex(uint256 hash)
3426 if (hash.IsNull())
3427 return nullptr;
3429 // Return existing
3430 BlockMap::iterator mi = mapBlockIndex.find(hash);
3431 if (mi != mapBlockIndex.end())
3432 return (*mi).second;
3434 // Create new
3435 CBlockIndex* pindexNew = new CBlockIndex();
3436 if (!pindexNew)
3437 throw std::runtime_error(std::string(__func__) + ": new CBlockIndex failed");
3438 mi = mapBlockIndex.insert(std::make_pair(hash, pindexNew)).first;
3439 pindexNew->phashBlock = &((*mi).first);
3441 return pindexNew;
3444 bool static LoadBlockIndexDB(const CChainParams& chainparams)
3446 if (!pblocktree->LoadBlockIndexGuts(chainparams.GetConsensus(), InsertBlockIndex))
3447 return false;
3449 boost::this_thread::interruption_point();
3451 // Calculate nChainWork
3452 std::vector<std::pair<int, CBlockIndex*> > vSortedByHeight;
3453 vSortedByHeight.reserve(mapBlockIndex.size());
3454 for (const std::pair<uint256, CBlockIndex*>& item : mapBlockIndex)
3456 CBlockIndex* pindex = item.second;
3457 vSortedByHeight.push_back(std::make_pair(pindex->nHeight, pindex));
3459 sort(vSortedByHeight.begin(), vSortedByHeight.end());
3460 for (const std::pair<int, CBlockIndex*>& item : vSortedByHeight)
3462 CBlockIndex* pindex = item.second;
3463 pindex->nChainWork = (pindex->pprev ? pindex->pprev->nChainWork : 0) + GetBlockProof(*pindex);
3464 pindex->nTimeMax = (pindex->pprev ? std::max(pindex->pprev->nTimeMax, pindex->nTime) : pindex->nTime);
3465 // We can link the chain of blocks for which we've received transactions at some point.
3466 // Pruned nodes may have deleted the block.
3467 if (pindex->nTx > 0) {
3468 if (pindex->pprev) {
3469 if (pindex->pprev->nChainTx) {
3470 pindex->nChainTx = pindex->pprev->nChainTx + pindex->nTx;
3471 } else {
3472 pindex->nChainTx = 0;
3473 mapBlocksUnlinked.insert(std::make_pair(pindex->pprev, pindex));
3475 } else {
3476 pindex->nChainTx = pindex->nTx;
3479 if (pindex->IsValid(BLOCK_VALID_TRANSACTIONS) && (pindex->nChainTx || pindex->pprev == nullptr))
3480 setBlockIndexCandidates.insert(pindex);
3481 if (pindex->nStatus & BLOCK_FAILED_MASK && (!pindexBestInvalid || pindex->nChainWork > pindexBestInvalid->nChainWork))
3482 pindexBestInvalid = pindex;
3483 if (pindex->pprev)
3484 pindex->BuildSkip();
3485 if (pindex->IsValid(BLOCK_VALID_TREE) && (pindexBestHeader == nullptr || CBlockIndexWorkComparator()(pindexBestHeader, pindex)))
3486 pindexBestHeader = pindex;
3489 // Load block file info
3490 pblocktree->ReadLastBlockFile(nLastBlockFile);
3491 vinfoBlockFile.resize(nLastBlockFile + 1);
3492 LogPrintf("%s: last block file = %i\n", __func__, nLastBlockFile);
3493 for (int nFile = 0; nFile <= nLastBlockFile; nFile++) {
3494 pblocktree->ReadBlockFileInfo(nFile, vinfoBlockFile[nFile]);
3496 LogPrintf("%s: last block file info: %s\n", __func__, vinfoBlockFile[nLastBlockFile].ToString());
3497 for (int nFile = nLastBlockFile + 1; true; nFile++) {
3498 CBlockFileInfo info;
3499 if (pblocktree->ReadBlockFileInfo(nFile, info)) {
3500 vinfoBlockFile.push_back(info);
3501 } else {
3502 break;
3506 // Check presence of blk files
3507 LogPrintf("Checking all blk files are present...\n");
3508 std::set<int> setBlkDataFiles;
3509 for (const std::pair<uint256, CBlockIndex*>& item : mapBlockIndex)
3511 CBlockIndex* pindex = item.second;
3512 if (pindex->nStatus & BLOCK_HAVE_DATA) {
3513 setBlkDataFiles.insert(pindex->nFile);
3516 for (std::set<int>::iterator it = setBlkDataFiles.begin(); it != setBlkDataFiles.end(); it++)
3518 CDiskBlockPos pos(*it, 0);
3519 if (CAutoFile(OpenBlockFile(pos, true), SER_DISK, CLIENT_VERSION).IsNull()) {
3520 return false;
3524 // Check whether we have ever pruned block & undo files
3525 pblocktree->ReadFlag("prunedblockfiles", fHavePruned);
3526 if (fHavePruned)
3527 LogPrintf("LoadBlockIndexDB(): Block files have previously been pruned\n");
3529 // Check whether we need to continue reindexing
3530 bool fReindexing = false;
3531 pblocktree->ReadReindexing(fReindexing);
3532 fReindex |= fReindexing;
3534 // Check whether we have a transaction index
3535 pblocktree->ReadFlag("txindex", fTxIndex);
3536 LogPrintf("%s: transaction index %s\n", __func__, fTxIndex ? "enabled" : "disabled");
3538 return true;
3541 bool LoadChainTip(const CChainParams& chainparams)
3543 if (chainActive.Tip() && chainActive.Tip()->GetBlockHash() == pcoinsTip->GetBestBlock()) return true;
3545 if (pcoinsTip->GetBestBlock().IsNull() && mapBlockIndex.size() == 1) {
3546 // In case we just added the genesis block, connect it now, so
3547 // that we always have a chainActive.Tip() when we return.
3548 LogPrintf("%s: Connecting genesis block...\n", __func__);
3549 CValidationState state;
3550 if (!ActivateBestChain(state, chainparams)) {
3551 return false;
3555 // Load pointer to end of best chain
3556 BlockMap::iterator it = mapBlockIndex.find(pcoinsTip->GetBestBlock());
3557 if (it == mapBlockIndex.end())
3558 return false;
3559 chainActive.SetTip(it->second);
3561 PruneBlockIndexCandidates();
3563 LogPrintf("Loaded best chain: hashBestChain=%s height=%d date=%s progress=%f\n",
3564 chainActive.Tip()->GetBlockHash().ToString(), chainActive.Height(),
3565 DateTimeStrFormat("%Y-%m-%d %H:%M:%S", chainActive.Tip()->GetBlockTime()),
3566 GuessVerificationProgress(chainparams.TxData(), chainActive.Tip()));
3567 return true;
3570 CVerifyDB::CVerifyDB()
3572 uiInterface.ShowProgress(_("Verifying blocks..."), 0);
3575 CVerifyDB::~CVerifyDB()
3577 uiInterface.ShowProgress("", 100);
3580 bool CVerifyDB::VerifyDB(const CChainParams& chainparams, CCoinsView *coinsview, int nCheckLevel, int nCheckDepth)
3582 LOCK(cs_main);
3583 if (chainActive.Tip() == nullptr || chainActive.Tip()->pprev == nullptr)
3584 return true;
3586 // Verify blocks in the best chain
3587 if (nCheckDepth <= 0 || nCheckDepth > chainActive.Height())
3588 nCheckDepth = chainActive.Height();
3589 nCheckLevel = std::max(0, std::min(4, nCheckLevel));
3590 LogPrintf("Verifying last %i blocks at level %i\n", nCheckDepth, nCheckLevel);
3591 CCoinsViewCache coins(coinsview);
3592 CBlockIndex* pindexState = chainActive.Tip();
3593 CBlockIndex* pindexFailure = nullptr;
3594 int nGoodTransactions = 0;
3595 CValidationState state;
3596 int reportDone = 0;
3597 LogPrintf("[0%%]...");
3598 for (CBlockIndex* pindex = chainActive.Tip(); pindex && pindex->pprev; pindex = pindex->pprev)
3600 boost::this_thread::interruption_point();
3601 int percentageDone = std::max(1, std::min(99, (int)(((double)(chainActive.Height() - pindex->nHeight)) / (double)nCheckDepth * (nCheckLevel >= 4 ? 50 : 100))));
3602 if (reportDone < percentageDone/10) {
3603 // report every 10% step
3604 LogPrintf("[%d%%]...", percentageDone);
3605 reportDone = percentageDone/10;
3607 uiInterface.ShowProgress(_("Verifying blocks..."), percentageDone);
3608 if (pindex->nHeight < chainActive.Height()-nCheckDepth)
3609 break;
3610 if (fPruneMode && !(pindex->nStatus & BLOCK_HAVE_DATA)) {
3611 // If pruning, only go back as far as we have data.
3612 LogPrintf("VerifyDB(): block verification stopping at height %d (pruning, no data)\n", pindex->nHeight);
3613 break;
3615 CBlock block;
3616 // check level 0: read from disk
3617 if (!ReadBlockFromDisk(block, pindex, chainparams.GetConsensus()))
3618 return error("VerifyDB(): *** ReadBlockFromDisk failed at %d, hash=%s", pindex->nHeight, pindex->GetBlockHash().ToString());
3619 // check level 1: verify block validity
3620 if (nCheckLevel >= 1 && !CheckBlock(block, state, chainparams.GetConsensus()))
3621 return error("%s: *** found bad block at %d, hash=%s (%s)\n", __func__,
3622 pindex->nHeight, pindex->GetBlockHash().ToString(), FormatStateMessage(state));
3623 // check level 2: verify undo validity
3624 if (nCheckLevel >= 2 && pindex) {
3625 CBlockUndo undo;
3626 CDiskBlockPos pos = pindex->GetUndoPos();
3627 if (!pos.IsNull()) {
3628 if (!UndoReadFromDisk(undo, pos, pindex->pprev->GetBlockHash()))
3629 return error("VerifyDB(): *** found bad undo data at %d, hash=%s\n", pindex->nHeight, pindex->GetBlockHash().ToString());
3632 // check level 3: check for inconsistencies during memory-only disconnect of tip blocks
3633 if (nCheckLevel >= 3 && pindex == pindexState && (coins.DynamicMemoryUsage() + pcoinsTip->DynamicMemoryUsage()) <= nCoinCacheUsage) {
3634 assert(coins.GetBestBlock() == pindex->GetBlockHash());
3635 DisconnectResult res = DisconnectBlock(block, pindex, coins);
3636 if (res == DISCONNECT_FAILED) {
3637 return error("VerifyDB(): *** irrecoverable inconsistency in block data at %d, hash=%s", pindex->nHeight, pindex->GetBlockHash().ToString());
3639 pindexState = pindex->pprev;
3640 if (res == DISCONNECT_UNCLEAN) {
3641 nGoodTransactions = 0;
3642 pindexFailure = pindex;
3643 } else {
3644 nGoodTransactions += block.vtx.size();
3647 if (ShutdownRequested())
3648 return true;
3650 if (pindexFailure)
3651 return error("VerifyDB(): *** coin database inconsistencies found (last %i blocks, %i good transactions before that)\n", chainActive.Height() - pindexFailure->nHeight + 1, nGoodTransactions);
3653 // check level 4: try reconnecting blocks
3654 if (nCheckLevel >= 4) {
3655 CBlockIndex *pindex = pindexState;
3656 while (pindex != chainActive.Tip()) {
3657 boost::this_thread::interruption_point();
3658 uiInterface.ShowProgress(_("Verifying blocks..."), std::max(1, std::min(99, 100 - (int)(((double)(chainActive.Height() - pindex->nHeight)) / (double)nCheckDepth * 50))));
3659 pindex = chainActive.Next(pindex);
3660 CBlock block;
3661 if (!ReadBlockFromDisk(block, pindex, chainparams.GetConsensus()))
3662 return error("VerifyDB(): *** ReadBlockFromDisk failed at %d, hash=%s", pindex->nHeight, pindex->GetBlockHash().ToString());
3663 if (!ConnectBlock(block, state, pindex, coins, chainparams))
3664 return error("VerifyDB(): *** found unconnectable block at %d, hash=%s", pindex->nHeight, pindex->GetBlockHash().ToString());
3668 LogPrintf("[DONE].\n");
3669 LogPrintf("No coin database inconsistencies in last %i blocks (%i transactions)\n", chainActive.Height() - pindexState->nHeight, nGoodTransactions);
3671 return true;
3674 /** Apply the effects of a block on the utxo cache, ignoring that it may already have been applied. */
3675 static bool RollforwardBlock(const CBlockIndex* pindex, CCoinsViewCache& inputs, const CChainParams& params)
3677 // TODO: merge with ConnectBlock
3678 CBlock block;
3679 if (!ReadBlockFromDisk(block, pindex, params.GetConsensus())) {
3680 return error("ReplayBlock(): ReadBlockFromDisk failed at %d, hash=%s", pindex->nHeight, pindex->GetBlockHash().ToString());
3683 for (const CTransactionRef& tx : block.vtx) {
3684 if (!tx->IsCoinBase()) {
3685 for (const CTxIn &txin : tx->vin) {
3686 inputs.SpendCoin(txin.prevout);
3689 // Pass check = true as every addition may be an overwrite.
3690 AddCoins(inputs, *tx, pindex->nHeight, true);
3692 return true;
3695 bool ReplayBlocks(const CChainParams& params, CCoinsView* view)
3697 LOCK(cs_main);
3699 CCoinsViewCache cache(view);
3701 std::vector<uint256> hashHeads = view->GetHeadBlocks();
3702 if (hashHeads.empty()) return true; // We're already in a consistent state.
3703 if (hashHeads.size() != 2) return error("ReplayBlocks(): unknown inconsistent state");
3705 uiInterface.ShowProgress(_("Replaying blocks..."), 0);
3706 LogPrintf("Replaying blocks\n");
3708 const CBlockIndex* pindexOld = nullptr; // Old tip during the interrupted flush.
3709 const CBlockIndex* pindexNew; // New tip during the interrupted flush.
3710 const CBlockIndex* pindexFork = nullptr; // Latest block common to both the old and the new tip.
3712 if (mapBlockIndex.count(hashHeads[0]) == 0) {
3713 return error("ReplayBlocks(): reorganization to unknown block requested");
3715 pindexNew = mapBlockIndex[hashHeads[0]];
3717 if (!hashHeads[1].IsNull()) { // The old tip is allowed to be 0, indicating it's the first flush.
3718 if (mapBlockIndex.count(hashHeads[1]) == 0) {
3719 return error("ReplayBlocks(): reorganization from unknown block requested");
3721 pindexOld = mapBlockIndex[hashHeads[1]];
3722 pindexFork = LastCommonAncestor(pindexOld, pindexNew);
3723 assert(pindexFork != nullptr);
3726 // Rollback along the old branch.
3727 while (pindexOld != pindexFork) {
3728 if (pindexOld->nHeight > 0) { // Never disconnect the genesis block.
3729 CBlock block;
3730 if (!ReadBlockFromDisk(block, pindexOld, params.GetConsensus())) {
3731 return error("RollbackBlock(): ReadBlockFromDisk() failed at %d, hash=%s", pindexOld->nHeight, pindexOld->GetBlockHash().ToString());
3733 LogPrintf("Rolling back %s (%i)\n", pindexOld->GetBlockHash().ToString(), pindexOld->nHeight);
3734 DisconnectResult res = DisconnectBlock(block, pindexOld, cache);
3735 if (res == DISCONNECT_FAILED) {
3736 return error("RollbackBlock(): DisconnectBlock failed at %d, hash=%s", pindexOld->nHeight, pindexOld->GetBlockHash().ToString());
3738 // If DISCONNECT_UNCLEAN is returned, it means a non-existing UTXO was deleted, or an existing UTXO was
3739 // overwritten. It corresponds to cases where the block-to-be-disconnect never had all its operations
3740 // applied to the UTXO set. However, as both writing a UTXO and deleting a UTXO are idempotent operations,
3741 // the result is still a version of the UTXO set with the effects of that block undone.
3743 pindexOld = pindexOld->pprev;
3746 // Roll forward from the forking point to the new tip.
3747 int nForkHeight = pindexFork ? pindexFork->nHeight : 0;
3748 for (int nHeight = nForkHeight + 1; nHeight <= pindexNew->nHeight; ++nHeight) {
3749 const CBlockIndex* pindex = pindexNew->GetAncestor(nHeight);
3750 LogPrintf("Rolling forward %s (%i)\n", pindex->GetBlockHash().ToString(), nHeight);
3751 if (!RollforwardBlock(pindex, cache, params)) return false;
3754 cache.SetBestBlock(pindexNew->GetBlockHash());
3755 cache.Flush();
3756 uiInterface.ShowProgress("", 100);
3757 return true;
3760 bool RewindBlockIndex(const CChainParams& params)
3762 LOCK(cs_main);
3764 // Note that during -reindex-chainstate we are called with an empty chainActive!
3766 int nHeight = 1;
3767 while (nHeight <= chainActive.Height()) {
3768 if (IsWitnessEnabled(chainActive[nHeight - 1], params.GetConsensus()) && !(chainActive[nHeight]->nStatus & BLOCK_OPT_WITNESS)) {
3769 break;
3771 nHeight++;
3774 // nHeight is now the height of the first insufficiently-validated block, or tipheight + 1
3775 CValidationState state;
3776 CBlockIndex* pindex = chainActive.Tip();
3777 while (chainActive.Height() >= nHeight) {
3778 if (fPruneMode && !(chainActive.Tip()->nStatus & BLOCK_HAVE_DATA)) {
3779 // If pruning, don't try rewinding past the HAVE_DATA point;
3780 // since older blocks can't be served anyway, there's
3781 // no need to walk further, and trying to DisconnectTip()
3782 // will fail (and require a needless reindex/redownload
3783 // of the blockchain).
3784 break;
3786 if (!DisconnectTip(state, params, nullptr)) {
3787 return error("RewindBlockIndex: unable to disconnect block at height %i", pindex->nHeight);
3789 // Occasionally flush state to disk.
3790 if (!FlushStateToDisk(params, state, FLUSH_STATE_PERIODIC))
3791 return false;
3794 // Reduce validity flag and have-data flags.
3795 // We do this after actual disconnecting, otherwise we'll end up writing the lack of data
3796 // to disk before writing the chainstate, resulting in a failure to continue if interrupted.
3797 for (BlockMap::iterator it = mapBlockIndex.begin(); it != mapBlockIndex.end(); it++) {
3798 CBlockIndex* pindexIter = it->second;
3800 // Note: If we encounter an insufficiently validated block that
3801 // is on chainActive, it must be because we are a pruning node, and
3802 // this block or some successor doesn't HAVE_DATA, so we were unable to
3803 // rewind all the way. Blocks remaining on chainActive at this point
3804 // must not have their validity reduced.
3805 if (IsWitnessEnabled(pindexIter->pprev, params.GetConsensus()) && !(pindexIter->nStatus & BLOCK_OPT_WITNESS) && !chainActive.Contains(pindexIter)) {
3806 // Reduce validity
3807 pindexIter->nStatus = std::min<unsigned int>(pindexIter->nStatus & BLOCK_VALID_MASK, BLOCK_VALID_TREE) | (pindexIter->nStatus & ~BLOCK_VALID_MASK);
3808 // Remove have-data flags.
3809 pindexIter->nStatus &= ~(BLOCK_HAVE_DATA | BLOCK_HAVE_UNDO);
3810 // Remove storage location.
3811 pindexIter->nFile = 0;
3812 pindexIter->nDataPos = 0;
3813 pindexIter->nUndoPos = 0;
3814 // Remove various other things
3815 pindexIter->nTx = 0;
3816 pindexIter->nChainTx = 0;
3817 pindexIter->nSequenceId = 0;
3818 // Make sure it gets written.
3819 setDirtyBlockIndex.insert(pindexIter);
3820 // Update indexes
3821 setBlockIndexCandidates.erase(pindexIter);
3822 std::pair<std::multimap<CBlockIndex*, CBlockIndex*>::iterator, std::multimap<CBlockIndex*, CBlockIndex*>::iterator> ret = mapBlocksUnlinked.equal_range(pindexIter->pprev);
3823 while (ret.first != ret.second) {
3824 if (ret.first->second == pindexIter) {
3825 mapBlocksUnlinked.erase(ret.first++);
3826 } else {
3827 ++ret.first;
3830 } else if (pindexIter->IsValid(BLOCK_VALID_TRANSACTIONS) && pindexIter->nChainTx) {
3831 setBlockIndexCandidates.insert(pindexIter);
3835 if (chainActive.Tip() != nullptr) {
3836 // We can't prune block index candidates based on our tip if we have
3837 // no tip due to chainActive being empty!
3838 PruneBlockIndexCandidates();
3840 CheckBlockIndex(params.GetConsensus());
3842 // FlushStateToDisk can possibly read chainActive. Be conservative
3843 // and skip it here, we're about to -reindex-chainstate anyway, so
3844 // it'll get called a bunch real soon.
3845 if (!FlushStateToDisk(params, state, FLUSH_STATE_ALWAYS)) {
3846 return false;
3850 return true;
3853 // May NOT be used after any connections are up as much
3854 // of the peer-processing logic assumes a consistent
3855 // block index state
3856 void UnloadBlockIndex()
3858 LOCK(cs_main);
3859 setBlockIndexCandidates.clear();
3860 chainActive.SetTip(nullptr);
3861 pindexBestInvalid = nullptr;
3862 pindexBestHeader = nullptr;
3863 mempool.clear();
3864 mapBlocksUnlinked.clear();
3865 vinfoBlockFile.clear();
3866 nLastBlockFile = 0;
3867 nBlockSequenceId = 1;
3868 setDirtyBlockIndex.clear();
3869 setDirtyFileInfo.clear();
3870 versionbitscache.Clear();
3871 for (int b = 0; b < VERSIONBITS_NUM_BITS; b++) {
3872 warningcache[b].clear();
3875 for (BlockMap::value_type& entry : mapBlockIndex) {
3876 delete entry.second;
3878 mapBlockIndex.clear();
3879 fHavePruned = false;
3882 bool LoadBlockIndex(const CChainParams& chainparams)
3884 // Load block index from databases
3885 bool needs_init = fReindex;
3886 if (!fReindex) {
3887 bool ret = LoadBlockIndexDB(chainparams);
3888 if (!ret) return false;
3889 needs_init = mapBlockIndex.empty();
3892 if (needs_init) {
3893 // Everything here is for *new* reindex/DBs. Thus, though
3894 // LoadBlockIndexDB may have set fReindex if we shut down
3895 // mid-reindex previously, we don't check fReindex and
3896 // instead only check it prior to LoadBlockIndexDB to set
3897 // needs_init.
3899 LogPrintf("Initializing databases...\n");
3900 // Use the provided setting for -txindex in the new database
3901 fTxIndex = gArgs.GetBoolArg("-txindex", DEFAULT_TXINDEX);
3902 pblocktree->WriteFlag("txindex", fTxIndex);
3904 return true;
3907 bool LoadGenesisBlock(const CChainParams& chainparams)
3909 LOCK(cs_main);
3911 // Check whether we're already initialized by checking for genesis in
3912 // mapBlockIndex. Note that we can't use chainActive here, since it is
3913 // set based on the coins db, not the block index db, which is the only
3914 // thing loaded at this point.
3915 if (mapBlockIndex.count(chainparams.GenesisBlock().GetHash()))
3916 return true;
3918 try {
3919 CBlock &block = const_cast<CBlock&>(chainparams.GenesisBlock());
3920 // Start new block file
3921 unsigned int nBlockSize = ::GetSerializeSize(block, SER_DISK, CLIENT_VERSION);
3922 CDiskBlockPos blockPos;
3923 CValidationState state;
3924 if (!FindBlockPos(state, blockPos, nBlockSize+8, 0, block.GetBlockTime()))
3925 return error("%s: FindBlockPos failed", __func__);
3926 if (!WriteBlockToDisk(block, blockPos, chainparams.MessageStart()))
3927 return error("%s: writing genesis block to disk failed", __func__);
3928 CBlockIndex *pindex = AddToBlockIndex(block);
3929 if (!ReceivedBlockTransactions(block, state, pindex, blockPos, chainparams.GetConsensus()))
3930 return error("%s: genesis block not accepted", __func__);
3931 } catch (const std::runtime_error& e) {
3932 return error("%s: failed to write genesis block: %s", __func__, e.what());
3935 return true;
3938 bool LoadExternalBlockFile(const CChainParams& chainparams, FILE* fileIn, CDiskBlockPos *dbp)
3940 // Map of disk positions for blocks with unknown parent (only used for reindex)
3941 static std::multimap<uint256, CDiskBlockPos> mapBlocksUnknownParent;
3942 int64_t nStart = GetTimeMillis();
3944 int nLoaded = 0;
3945 try {
3946 // This takes over fileIn and calls fclose() on it in the CBufferedFile destructor
3947 CBufferedFile blkdat(fileIn, 2*MAX_BLOCK_SERIALIZED_SIZE, MAX_BLOCK_SERIALIZED_SIZE+8, SER_DISK, CLIENT_VERSION);
3948 uint64_t nRewind = blkdat.GetPos();
3949 while (!blkdat.eof()) {
3950 boost::this_thread::interruption_point();
3952 blkdat.SetPos(nRewind);
3953 nRewind++; // start one byte further next time, in case of failure
3954 blkdat.SetLimit(); // remove former limit
3955 unsigned int nSize = 0;
3956 try {
3957 // locate a header
3958 unsigned char buf[CMessageHeader::MESSAGE_START_SIZE];
3959 blkdat.FindByte(chainparams.MessageStart()[0]);
3960 nRewind = blkdat.GetPos()+1;
3961 blkdat >> FLATDATA(buf);
3962 if (memcmp(buf, chainparams.MessageStart(), CMessageHeader::MESSAGE_START_SIZE))
3963 continue;
3964 // read size
3965 blkdat >> nSize;
3966 if (nSize < 80 || nSize > MAX_BLOCK_SERIALIZED_SIZE)
3967 continue;
3968 } catch (const std::exception&) {
3969 // no valid block header found; don't complain
3970 break;
3972 try {
3973 // read block
3974 uint64_t nBlockPos = blkdat.GetPos();
3975 if (dbp)
3976 dbp->nPos = nBlockPos;
3977 blkdat.SetLimit(nBlockPos + nSize);
3978 blkdat.SetPos(nBlockPos);
3979 std::shared_ptr<CBlock> pblock = std::make_shared<CBlock>();
3980 CBlock& block = *pblock;
3981 blkdat >> block;
3982 nRewind = blkdat.GetPos();
3984 // detect out of order blocks, and store them for later
3985 uint256 hash = block.GetHash();
3986 if (hash != chainparams.GetConsensus().hashGenesisBlock && mapBlockIndex.find(block.hashPrevBlock) == mapBlockIndex.end()) {
3987 LogPrint(BCLog::REINDEX, "%s: Out of order block %s, parent %s not known\n", __func__, hash.ToString(),
3988 block.hashPrevBlock.ToString());
3989 if (dbp)
3990 mapBlocksUnknownParent.insert(std::make_pair(block.hashPrevBlock, *dbp));
3991 continue;
3994 // process in case the block isn't known yet
3995 if (mapBlockIndex.count(hash) == 0 || (mapBlockIndex[hash]->nStatus & BLOCK_HAVE_DATA) == 0) {
3996 LOCK(cs_main);
3997 CValidationState state;
3998 if (AcceptBlock(pblock, state, chainparams, nullptr, true, dbp, nullptr))
3999 nLoaded++;
4000 if (state.IsError())
4001 break;
4002 } else if (hash != chainparams.GetConsensus().hashGenesisBlock && mapBlockIndex[hash]->nHeight % 1000 == 0) {
4003 LogPrint(BCLog::REINDEX, "Block Import: already had block %s at height %d\n", hash.ToString(), mapBlockIndex[hash]->nHeight);
4006 // Activate the genesis block so normal node progress can continue
4007 if (hash == chainparams.GetConsensus().hashGenesisBlock) {
4008 CValidationState state;
4009 if (!ActivateBestChain(state, chainparams)) {
4010 break;
4014 NotifyHeaderTip();
4016 // Recursively process earlier encountered successors of this block
4017 std::deque<uint256> queue;
4018 queue.push_back(hash);
4019 while (!queue.empty()) {
4020 uint256 head = queue.front();
4021 queue.pop_front();
4022 std::pair<std::multimap<uint256, CDiskBlockPos>::iterator, std::multimap<uint256, CDiskBlockPos>::iterator> range = mapBlocksUnknownParent.equal_range(head);
4023 while (range.first != range.second) {
4024 std::multimap<uint256, CDiskBlockPos>::iterator it = range.first;
4025 std::shared_ptr<CBlock> pblockrecursive = std::make_shared<CBlock>();
4026 if (ReadBlockFromDisk(*pblockrecursive, it->second, chainparams.GetConsensus()))
4028 LogPrint(BCLog::REINDEX, "%s: Processing out of order child %s of %s\n", __func__, pblockrecursive->GetHash().ToString(),
4029 head.ToString());
4030 LOCK(cs_main);
4031 CValidationState dummy;
4032 if (AcceptBlock(pblockrecursive, dummy, chainparams, nullptr, true, &it->second, nullptr))
4034 nLoaded++;
4035 queue.push_back(pblockrecursive->GetHash());
4038 range.first++;
4039 mapBlocksUnknownParent.erase(it);
4040 NotifyHeaderTip();
4043 } catch (const std::exception& e) {
4044 LogPrintf("%s: Deserialize or I/O error - %s\n", __func__, e.what());
4047 } catch (const std::runtime_error& e) {
4048 AbortNode(std::string("System error: ") + e.what());
4050 if (nLoaded > 0)
4051 LogPrintf("Loaded %i blocks from external file in %dms\n", nLoaded, GetTimeMillis() - nStart);
4052 return nLoaded > 0;
4055 void static CheckBlockIndex(const Consensus::Params& consensusParams)
4057 if (!fCheckBlockIndex) {
4058 return;
4061 LOCK(cs_main);
4063 // During a reindex, we read the genesis block and call CheckBlockIndex before ActivateBestChain,
4064 // so we have the genesis block in mapBlockIndex but no active chain. (A few of the tests when
4065 // iterating the block tree require that chainActive has been initialized.)
4066 if (chainActive.Height() < 0) {
4067 assert(mapBlockIndex.size() <= 1);
4068 return;
4071 // Build forward-pointing map of the entire block tree.
4072 std::multimap<CBlockIndex*,CBlockIndex*> forward;
4073 for (BlockMap::iterator it = mapBlockIndex.begin(); it != mapBlockIndex.end(); it++) {
4074 forward.insert(std::make_pair(it->second->pprev, it->second));
4077 assert(forward.size() == mapBlockIndex.size());
4079 std::pair<std::multimap<CBlockIndex*,CBlockIndex*>::iterator,std::multimap<CBlockIndex*,CBlockIndex*>::iterator> rangeGenesis = forward.equal_range(nullptr);
4080 CBlockIndex *pindex = rangeGenesis.first->second;
4081 rangeGenesis.first++;
4082 assert(rangeGenesis.first == rangeGenesis.second); // There is only one index entry with parent nullptr.
4084 // Iterate over the entire block tree, using depth-first search.
4085 // Along the way, remember whether there are blocks on the path from genesis
4086 // block being explored which are the first to have certain properties.
4087 size_t nNodes = 0;
4088 int nHeight = 0;
4089 CBlockIndex* pindexFirstInvalid = nullptr; // Oldest ancestor of pindex which is invalid.
4090 CBlockIndex* pindexFirstMissing = nullptr; // Oldest ancestor of pindex which does not have BLOCK_HAVE_DATA.
4091 CBlockIndex* pindexFirstNeverProcessed = nullptr; // Oldest ancestor of pindex for which nTx == 0.
4092 CBlockIndex* pindexFirstNotTreeValid = nullptr; // Oldest ancestor of pindex which does not have BLOCK_VALID_TREE (regardless of being valid or not).
4093 CBlockIndex* pindexFirstNotTransactionsValid = nullptr; // Oldest ancestor of pindex which does not have BLOCK_VALID_TRANSACTIONS (regardless of being valid or not).
4094 CBlockIndex* pindexFirstNotChainValid = nullptr; // Oldest ancestor of pindex which does not have BLOCK_VALID_CHAIN (regardless of being valid or not).
4095 CBlockIndex* pindexFirstNotScriptsValid = nullptr; // Oldest ancestor of pindex which does not have BLOCK_VALID_SCRIPTS (regardless of being valid or not).
4096 while (pindex != nullptr) {
4097 nNodes++;
4098 if (pindexFirstInvalid == nullptr && pindex->nStatus & BLOCK_FAILED_VALID) pindexFirstInvalid = pindex;
4099 if (pindexFirstMissing == nullptr && !(pindex->nStatus & BLOCK_HAVE_DATA)) pindexFirstMissing = pindex;
4100 if (pindexFirstNeverProcessed == nullptr && pindex->nTx == 0) pindexFirstNeverProcessed = pindex;
4101 if (pindex->pprev != nullptr && pindexFirstNotTreeValid == nullptr && (pindex->nStatus & BLOCK_VALID_MASK) < BLOCK_VALID_TREE) pindexFirstNotTreeValid = pindex;
4102 if (pindex->pprev != nullptr && pindexFirstNotTransactionsValid == nullptr && (pindex->nStatus & BLOCK_VALID_MASK) < BLOCK_VALID_TRANSACTIONS) pindexFirstNotTransactionsValid = pindex;
4103 if (pindex->pprev != nullptr && pindexFirstNotChainValid == nullptr && (pindex->nStatus & BLOCK_VALID_MASK) < BLOCK_VALID_CHAIN) pindexFirstNotChainValid = pindex;
4104 if (pindex->pprev != nullptr && pindexFirstNotScriptsValid == nullptr && (pindex->nStatus & BLOCK_VALID_MASK) < BLOCK_VALID_SCRIPTS) pindexFirstNotScriptsValid = pindex;
4106 // Begin: actual consistency checks.
4107 if (pindex->pprev == nullptr) {
4108 // Genesis block checks.
4109 assert(pindex->GetBlockHash() == consensusParams.hashGenesisBlock); // Genesis block's hash must match.
4110 assert(pindex == chainActive.Genesis()); // The current active chain's genesis block must be this block.
4112 if (pindex->nChainTx == 0) assert(pindex->nSequenceId <= 0); // nSequenceId can't be set positive for blocks that aren't linked (negative is used for preciousblock)
4113 // VALID_TRANSACTIONS is equivalent to nTx > 0 for all nodes (whether or not pruning has occurred).
4114 // HAVE_DATA is only equivalent to nTx > 0 (or VALID_TRANSACTIONS) if no pruning has occurred.
4115 if (!fHavePruned) {
4116 // If we've never pruned, then HAVE_DATA should be equivalent to nTx > 0
4117 assert(!(pindex->nStatus & BLOCK_HAVE_DATA) == (pindex->nTx == 0));
4118 assert(pindexFirstMissing == pindexFirstNeverProcessed);
4119 } else {
4120 // If we have pruned, then we can only say that HAVE_DATA implies nTx > 0
4121 if (pindex->nStatus & BLOCK_HAVE_DATA) assert(pindex->nTx > 0);
4123 if (pindex->nStatus & BLOCK_HAVE_UNDO) assert(pindex->nStatus & BLOCK_HAVE_DATA);
4124 assert(((pindex->nStatus & BLOCK_VALID_MASK) >= BLOCK_VALID_TRANSACTIONS) == (pindex->nTx > 0)); // This is pruning-independent.
4125 // All parents having had data (at some point) is equivalent to all parents being VALID_TRANSACTIONS, which is equivalent to nChainTx being set.
4126 assert((pindexFirstNeverProcessed != nullptr) == (pindex->nChainTx == 0)); // nChainTx != 0 is used to signal that all parent blocks have been processed (but may have been pruned).
4127 assert((pindexFirstNotTransactionsValid != nullptr) == (pindex->nChainTx == 0));
4128 assert(pindex->nHeight == nHeight); // nHeight must be consistent.
4129 assert(pindex->pprev == nullptr || pindex->nChainWork >= pindex->pprev->nChainWork); // For every block except the genesis block, the chainwork must be larger than the parent's.
4130 assert(nHeight < 2 || (pindex->pskip && (pindex->pskip->nHeight < nHeight))); // The pskip pointer must point back for all but the first 2 blocks.
4131 assert(pindexFirstNotTreeValid == nullptr); // All mapBlockIndex entries must at least be TREE valid
4132 if ((pindex->nStatus & BLOCK_VALID_MASK) >= BLOCK_VALID_TREE) assert(pindexFirstNotTreeValid == nullptr); // TREE valid implies all parents are TREE valid
4133 if ((pindex->nStatus & BLOCK_VALID_MASK) >= BLOCK_VALID_CHAIN) assert(pindexFirstNotChainValid == nullptr); // CHAIN valid implies all parents are CHAIN valid
4134 if ((pindex->nStatus & BLOCK_VALID_MASK) >= BLOCK_VALID_SCRIPTS) assert(pindexFirstNotScriptsValid == nullptr); // SCRIPTS valid implies all parents are SCRIPTS valid
4135 if (pindexFirstInvalid == nullptr) {
4136 // Checks for not-invalid blocks.
4137 assert((pindex->nStatus & BLOCK_FAILED_MASK) == 0); // The failed mask cannot be set for blocks without invalid parents.
4139 if (!CBlockIndexWorkComparator()(pindex, chainActive.Tip()) && pindexFirstNeverProcessed == nullptr) {
4140 if (pindexFirstInvalid == nullptr) {
4141 // If this block sorts at least as good as the current tip and
4142 // is valid and we have all data for its parents, it must be in
4143 // setBlockIndexCandidates. chainActive.Tip() must also be there
4144 // even if some data has been pruned.
4145 if (pindexFirstMissing == nullptr || pindex == chainActive.Tip()) {
4146 assert(setBlockIndexCandidates.count(pindex));
4148 // If some parent is missing, then it could be that this block was in
4149 // setBlockIndexCandidates but had to be removed because of the missing data.
4150 // In this case it must be in mapBlocksUnlinked -- see test below.
4152 } else { // If this block sorts worse than the current tip or some ancestor's block has never been seen, it cannot be in setBlockIndexCandidates.
4153 assert(setBlockIndexCandidates.count(pindex) == 0);
4155 // Check whether this block is in mapBlocksUnlinked.
4156 std::pair<std::multimap<CBlockIndex*,CBlockIndex*>::iterator,std::multimap<CBlockIndex*,CBlockIndex*>::iterator> rangeUnlinked = mapBlocksUnlinked.equal_range(pindex->pprev);
4157 bool foundInUnlinked = false;
4158 while (rangeUnlinked.first != rangeUnlinked.second) {
4159 assert(rangeUnlinked.first->first == pindex->pprev);
4160 if (rangeUnlinked.first->second == pindex) {
4161 foundInUnlinked = true;
4162 break;
4164 rangeUnlinked.first++;
4166 if (pindex->pprev && (pindex->nStatus & BLOCK_HAVE_DATA) && pindexFirstNeverProcessed != nullptr && pindexFirstInvalid == nullptr) {
4167 // If this block has block data available, some parent was never received, and has no invalid parents, it must be in mapBlocksUnlinked.
4168 assert(foundInUnlinked);
4170 if (!(pindex->nStatus & BLOCK_HAVE_DATA)) assert(!foundInUnlinked); // Can't be in mapBlocksUnlinked if we don't HAVE_DATA
4171 if (pindexFirstMissing == nullptr) assert(!foundInUnlinked); // We aren't missing data for any parent -- cannot be in mapBlocksUnlinked.
4172 if (pindex->pprev && (pindex->nStatus & BLOCK_HAVE_DATA) && pindexFirstNeverProcessed == nullptr && pindexFirstMissing != nullptr) {
4173 // We HAVE_DATA for this block, have received data for all parents at some point, but we're currently missing data for some parent.
4174 assert(fHavePruned); // We must have pruned.
4175 // This block may have entered mapBlocksUnlinked if:
4176 // - it has a descendant that at some point had more work than the
4177 // tip, and
4178 // - we tried switching to that descendant but were missing
4179 // data for some intermediate block between chainActive and the
4180 // tip.
4181 // So if this block is itself better than chainActive.Tip() and it wasn't in
4182 // setBlockIndexCandidates, then it must be in mapBlocksUnlinked.
4183 if (!CBlockIndexWorkComparator()(pindex, chainActive.Tip()) && setBlockIndexCandidates.count(pindex) == 0) {
4184 if (pindexFirstInvalid == nullptr) {
4185 assert(foundInUnlinked);
4189 // assert(pindex->GetBlockHash() == pindex->GetBlockHeader().GetHash()); // Perhaps too slow
4190 // End: actual consistency checks.
4192 // Try descending into the first subnode.
4193 std::pair<std::multimap<CBlockIndex*,CBlockIndex*>::iterator,std::multimap<CBlockIndex*,CBlockIndex*>::iterator> range = forward.equal_range(pindex);
4194 if (range.first != range.second) {
4195 // A subnode was found.
4196 pindex = range.first->second;
4197 nHeight++;
4198 continue;
4200 // This is a leaf node.
4201 // Move upwards until we reach a node of which we have not yet visited the last child.
4202 while (pindex) {
4203 // We are going to either move to a parent or a sibling of pindex.
4204 // If pindex was the first with a certain property, unset the corresponding variable.
4205 if (pindex == pindexFirstInvalid) pindexFirstInvalid = nullptr;
4206 if (pindex == pindexFirstMissing) pindexFirstMissing = nullptr;
4207 if (pindex == pindexFirstNeverProcessed) pindexFirstNeverProcessed = nullptr;
4208 if (pindex == pindexFirstNotTreeValid) pindexFirstNotTreeValid = nullptr;
4209 if (pindex == pindexFirstNotTransactionsValid) pindexFirstNotTransactionsValid = nullptr;
4210 if (pindex == pindexFirstNotChainValid) pindexFirstNotChainValid = nullptr;
4211 if (pindex == pindexFirstNotScriptsValid) pindexFirstNotScriptsValid = nullptr;
4212 // Find our parent.
4213 CBlockIndex* pindexPar = pindex->pprev;
4214 // Find which child we just visited.
4215 std::pair<std::multimap<CBlockIndex*,CBlockIndex*>::iterator,std::multimap<CBlockIndex*,CBlockIndex*>::iterator> rangePar = forward.equal_range(pindexPar);
4216 while (rangePar.first->second != pindex) {
4217 assert(rangePar.first != rangePar.second); // Our parent must have at least the node we're coming from as child.
4218 rangePar.first++;
4220 // Proceed to the next one.
4221 rangePar.first++;
4222 if (rangePar.first != rangePar.second) {
4223 // Move to the sibling.
4224 pindex = rangePar.first->second;
4225 break;
4226 } else {
4227 // Move up further.
4228 pindex = pindexPar;
4229 nHeight--;
4230 continue;
4235 // Check that we actually traversed the entire map.
4236 assert(nNodes == forward.size());
4239 std::string CBlockFileInfo::ToString() const
4241 return strprintf("CBlockFileInfo(blocks=%u, size=%u, heights=%u...%u, time=%s...%s)", nBlocks, nSize, nHeightFirst, nHeightLast, DateTimeStrFormat("%Y-%m-%d", nTimeFirst), DateTimeStrFormat("%Y-%m-%d", nTimeLast));
4244 CBlockFileInfo* GetBlockFileInfo(size_t n)
4246 return &vinfoBlockFile.at(n);
4249 ThresholdState VersionBitsTipState(const Consensus::Params& params, Consensus::DeploymentPos pos)
4251 LOCK(cs_main);
4252 return VersionBitsState(chainActive.Tip(), params, pos, versionbitscache);
4255 BIP9Stats VersionBitsTipStatistics(const Consensus::Params& params, Consensus::DeploymentPos pos)
4257 LOCK(cs_main);
4258 return VersionBitsStatistics(chainActive.Tip(), params, pos);
4261 int VersionBitsTipStateSinceHeight(const Consensus::Params& params, Consensus::DeploymentPos pos)
4263 LOCK(cs_main);
4264 return VersionBitsStateSinceHeight(chainActive.Tip(), params, pos, versionbitscache);
4267 static const uint64_t MEMPOOL_DUMP_VERSION = 1;
4269 bool LoadMempool(void)
4271 const CChainParams& chainparams = Params();
4272 int64_t nExpiryTimeout = gArgs.GetArg("-mempoolexpiry", DEFAULT_MEMPOOL_EXPIRY) * 60 * 60;
4273 FILE* filestr = fsbridge::fopen(GetDataDir() / "mempool.dat", "rb");
4274 CAutoFile file(filestr, SER_DISK, CLIENT_VERSION);
4275 if (file.IsNull()) {
4276 LogPrintf("Failed to open mempool file from disk. Continuing anyway.\n");
4277 return false;
4280 int64_t count = 0;
4281 int64_t skipped = 0;
4282 int64_t failed = 0;
4283 int64_t nNow = GetTime();
4285 try {
4286 uint64_t version;
4287 file >> version;
4288 if (version != MEMPOOL_DUMP_VERSION) {
4289 return false;
4291 uint64_t num;
4292 file >> num;
4293 while (num--) {
4294 CTransactionRef tx;
4295 int64_t nTime;
4296 int64_t nFeeDelta;
4297 file >> tx;
4298 file >> nTime;
4299 file >> nFeeDelta;
4301 CAmount amountdelta = nFeeDelta;
4302 if (amountdelta) {
4303 mempool.PrioritiseTransaction(tx->GetHash(), amountdelta);
4305 CValidationState state;
4306 if (nTime + nExpiryTimeout > nNow) {
4307 LOCK(cs_main);
4308 AcceptToMemoryPoolWithTime(chainparams, mempool, state, tx, true, nullptr, nTime, nullptr, false, 0);
4309 if (state.IsValid()) {
4310 ++count;
4311 } else {
4312 ++failed;
4314 } else {
4315 ++skipped;
4317 if (ShutdownRequested())
4318 return false;
4320 std::map<uint256, CAmount> mapDeltas;
4321 file >> mapDeltas;
4323 for (const auto& i : mapDeltas) {
4324 mempool.PrioritiseTransaction(i.first, i.second);
4326 } catch (const std::exception& e) {
4327 LogPrintf("Failed to deserialize mempool data on disk: %s. Continuing anyway.\n", e.what());
4328 return false;
4331 LogPrintf("Imported mempool transactions from disk: %i successes, %i failed, %i expired\n", count, failed, skipped);
4332 return true;
4335 void DumpMempool(void)
4337 int64_t start = GetTimeMicros();
4339 std::map<uint256, CAmount> mapDeltas;
4340 std::vector<TxMempoolInfo> vinfo;
4343 LOCK(mempool.cs);
4344 for (const auto &i : mempool.mapDeltas) {
4345 mapDeltas[i.first] = i.second;
4347 vinfo = mempool.infoAll();
4350 int64_t mid = GetTimeMicros();
4352 try {
4353 FILE* filestr = fsbridge::fopen(GetDataDir() / "mempool.dat.new", "wb");
4354 if (!filestr) {
4355 return;
4358 CAutoFile file(filestr, SER_DISK, CLIENT_VERSION);
4360 uint64_t version = MEMPOOL_DUMP_VERSION;
4361 file << version;
4363 file << (uint64_t)vinfo.size();
4364 for (const auto& i : vinfo) {
4365 file << *(i.tx);
4366 file << (int64_t)i.nTime;
4367 file << (int64_t)i.nFeeDelta;
4368 mapDeltas.erase(i.tx->GetHash());
4371 file << mapDeltas;
4372 FileCommit(file.Get());
4373 file.fclose();
4374 RenameOver(GetDataDir() / "mempool.dat.new", GetDataDir() / "mempool.dat");
4375 int64_t last = GetTimeMicros();
4376 LogPrintf("Dumped mempool: %gs to copy, %gs to dump\n", (mid-start)*MICRO, (last-mid)*MICRO);
4377 } catch (const std::exception& e) {
4378 LogPrintf("Failed to dump mempool: %s. Continuing anyway.\n", e.what());
4382 //! Guess how far we are in the verification process at the given block index
4383 double GuessVerificationProgress(const ChainTxData& data, CBlockIndex *pindex) {
4384 if (pindex == nullptr)
4385 return 0.0;
4387 int64_t nNow = time(nullptr);
4389 double fTxTotal;
4391 if (pindex->nChainTx <= data.nTxCount) {
4392 fTxTotal = data.nTxCount + (nNow - data.nTime) * data.dTxRate;
4393 } else {
4394 fTxTotal = pindex->nChainTx + (nNow - pindex->GetBlockTime()) * data.dTxRate;
4397 return pindex->nChainTx / fTxTotal;
4400 class CMainCleanup
4402 public:
4403 CMainCleanup() {}
4404 ~CMainCleanup() {
4405 // block headers
4406 BlockMap::iterator it1 = mapBlockIndex.begin();
4407 for (; it1 != mapBlockIndex.end(); it1++)
4408 delete (*it1).second;
4409 mapBlockIndex.clear();
4411 } instance_of_cmaincleanup;