 |
Bitcoin Core
21.99.0
P2P Digital Currency
|
Go to the documentation of this file.
6 #ifndef BITCOIN_VALIDATION_H
7 #define BITCOIN_VALIDATION_H
9 #if defined(HAVE_CONFIG_H)
111 typedef std::unordered_map<uint256, CBlockIndex*, BlockHasher>
BlockMap;
288 std::swap(ptxTo, check.
ptxTo);
289 std::swap(m_tx_out, check.
m_tx_out);
290 std::swap(nIn, check.
nIn);
291 std::swap(nFlags, check.
nFlags);
294 std::swap(txdata, check.
txdata);
314 bool fCheckPOW =
true,
370 void FindFilesToPruneManual(std::set<int>& setFilesToPrune,
int nManualPruneHeight,
int chain_tip_height);
387 void FindFilesToPrune(std::set<int>& setFilesToPrune, uint64_t nPruneAfterHeight,
int chain_tip_height,
int prune_height,
bool is_ibd);
429 std::set<CBlockIndex*, CBlockIndexWorkComparator>& block_index_candidates)
501 CoinsViews(std::string ldb_name,
size_t cache_size_bytes,
bool in_memory,
bool should_wipe);
579 size_t cache_size_bytes,
582 std::string leveldb_name =
"chainstate");
643 bool ResizeCoinsCaches(
size_t coinstip_size,
size_t coinsdb_size)
664 int nManualPruneHeight = 0);
748 size_t max_coins_cache_size_bytes,
851 bool m_snapshot_validated{
false};
854 [[nodiscard]]
bool PopulateAndValidateSnapshot(
871 int64_t m_total_coinstip_cache{0};
875 int64_t m_total_coinsdb_cache{0};
903 [[nodiscard]]
bool ActivateSnapshot(
908 CChain& ActiveChain()
const {
return ActiveChainstate().m_chain; }
917 bool IsSnapshotActive()
const;
919 std::optional<uint256> SnapshotBlockhash()
const;
926 bool IsBackgroundIBD(
CChainState* chainstate)
const;
957 bool ProcessNewBlock(
const CChainParams& chainparams,
const std::shared_ptr<const CBlock> pblock,
bool fForceProcessing,
bool* fNewBlock)
LOCKS_EXCLUDED(
cs_main);
1008 using
FopenFn = std::function<FILE*(const fs::path&, const
char*)>;
1031 #endif // BITCOIN_VALIDATION_H
bool RollforwardBlock(const CBlockIndex *pindex, CCoinsViewCache &inputs, const CChainParams ¶ms) EXCLUSIVE_LOCKS_REQUIRED(cs_main)
Apply the effects of a block on the utxo cache, ignoring that it may already have been applied.
CTransactionRef GetTransaction(const CBlockIndex *const block_index, const CTxMemPool *const mempool, const uint256 &hash, const Consensus::Params &consensusParams, uint256 &hashBlock)
Return transaction from the block at block_index.
bool LoadChainTip(const CChainParams &chainparams) EXCLUSIVE_LOCKS_REQUIRED(cs_main)
Update the chain tip based on database information, i.e.
void ReceivedBlockTransactions(const CBlock &block, CBlockIndex *pindexNew, const FlatFilePos &pos, const Consensus::Params &consensusParams) EXCLUSIVE_LOCKS_REQUIRED(cs_main)
Mark a block as having its data received and checked (up to BLOCK_VALID_TRANSACTIONS).
void PruneOneBlockFile(const int fileNumber) EXCLUSIVE_LOCKS_REQUIRED(cs_main)
Mark one block file as pruned (modify associated database entries)
CBlockIndex * FindMostWorkChain() EXCLUSIVE_LOCKS_REQUIRED(cs_main)
Return the tip of the chain with the most work in it, that isn't known to be invalid (it's however fa...
bool FlushStateToDisk(const CChainParams &chainparams, BlockValidationState &state, FlushStateMode mode, int nManualPruneHeight=0)
Update the on-disk chain state.
CCoinsView backed by the coin database (chainstate/)
const AssumeutxoData * ExpectedAssumeutxo(const int height, const CChainParams ¶ms)
Return the expected assumeutxo value for a given height, if one exists.
BlockMap & BlockIndex() EXCLUSIVE_LOCKS_REQUIRED(
std::string ToString(const T &t)
Locale-independent version of std::to_string.
static const unsigned int DEFAULT_CHECKLEVEL
bool DisconnectTip(BlockValidationState &state, const CChainParams &chainparams, DisconnectedBlockTransactions *disconnectpool) EXCLUSIVE_LOCKS_REQUIRED(cs_main
Disconnect m_chain's tip.
void ForceFlushStateToDisk()
Unconditionally flush all changes to disk.
static const bool DEFAULT_PERSIST_MEMPOOL
Default for -persistmempool.
bool g_parallel_script_checks
Whether there are dedicated script-checking threads running.
bool CheckSequenceLocks(CChainState &active_chainstate, const CTxMemPool &pool, const CTransaction &tx, int flags, LockPoints *lp, bool useExistingLockPoints)
uint256 hashAssumeValid
Block hash whose ancestors we will assume to have valid scripts without checking them.
static const unsigned int DEFAULT_ANCESTOR_SIZE_LIMIT
Default for -limitancestorsize, maximum kilobytes of tx + all in-mempool ancestors.
FILE * fopen(const fs::path &p, const char *mode)
std::unique_ptr< CBlockTreeDB > pblocktree
Global variable that points to the active block tree (protected by cs_main)
void CheckBlockIndex(const Consensus::Params &consensusParams)
Make various assertions about the state of the block index.
std::optional< CAmount > m_base_fees
Raw base fees.
@ CRITICAL
The coins cache is in immediate need of a flush.
Holds configuration for use during UTXO snapshot load and validation.
void UnlinkPrunedFiles(const std::set< int > &setFilesToPrune)
Actually unlink the specified files.
int64_t nMaxTipAge
If the tip is older than this (in seconds), the node is considered to be in initial block download.
CBlockFileInfo * GetBlockFileInfo(size_t n)
Get block file info entry for one block file.
CTxMemPool stores valid-according-to-the-current-best-chain transactions that may be included in the ...
CChain & ValidatedChain() const
static const int MAX_SCRIPTCHECK_THREADS
Maximum number of dedicated script-checking threads allowed.
256-bit unsigned big integer.
BlockMap m_block_index GUARDED_BY(cs_main)
CChainState(CTxMemPool &mempool, BlockManager &blockman, uint256 from_snapshot_blockhash=uint256())
const CTransaction * ptxTo
const std::vector< std::string > CHECKLEVEL_DOC
Documentation for argument 'checklevel'.
bool operator()(const CBlockIndex *pa, const CBlockIndex *pb) const
static const unsigned int DEFAULT_MEMPOOL_EXPIRY
Default for -mempoolexpiry, expiration time for mempool transactions in hours.
void PruneBlockIndexCandidates()
Delete all entries in setBlockIndexCandidates that are worse than the current tip.
@ LARGE
The cache is at >= 90% capacity.
static const int DEFAULT_STOPATHEIGHT
Default for -stopatheight.
CChainParams defines various tweakable parameters of a given instance of the Bitcoin system.
bool fPruneMode
True if we're running in -prune mode.
uint64_t CalculateCurrentUsage()
Calculate the amount of disk space the block & undo files currently use.
void InvalidBlockFound(CBlockIndex *pindex, const BlockValidationState &state) EXCLUSIVE_LOCKS_REQUIRED(cs_main)
bool LoadBlockIndex(const Consensus::Params &consensus_params, CBlockTreeDB &blocktree, std::set< CBlockIndex *, CBlockIndexWorkComparator > &block_index_candidates) EXCLUSIVE_LOCKS_REQUIRED(cs_main)
Load the blocktree off disk and into memory.
VersionBitsCache versionbitscache
bool ActivateBestChainStep(BlockValidationState &state, const CChainParams &chainparams, CBlockIndex *pindexMostWork, const std::shared_ptr< const CBlock > &pblock, bool &fInvalidFound, ConnectTrace &connectTrace) EXCLUSIVE_LOCKS_REQUIRED(cs_main
Dictates whether we need to flush the cache to disk or not.
static const unsigned int MIN_BLOCKS_TO_KEEP
Block files containing a block-height within MIN_BLOCKS_TO_KEEP of ChainActive().Tip() will not be pr...
Maintains a tree of blocks (stored in m_block_index) which is consulted to determine where the most-w...
BIP 9 allows multiple softforks to be deployed in parallel.
std::shared_ptr< const CTransaction > CTransactionRef
CAmount GetBlockSubsidy(int nHeight, const Consensus::Params &consensusParams)
int32_t ComputeBlockVersion(const CBlockIndex *pindexPrev, const Consensus::Params ¶ms)
Determine what nVersion a new block should use.
void InitScriptExecutionCache()
Initializes the script-execution cache.
RecursiveMutex m_cs_chainstate
the ChainState CriticalSection A lock that must be held when modifying this ChainState - held in Acti...
static const unsigned int DEFAULT_DESCENDANT_LIMIT
Default for -limitdescendantcount, max number of in-mempool descendants.
fs::path GetBlockPosFilename(const FlatFilePos &pos)
Translation to a filesystem path.
Fee rate in satoshis per kilobyte: CAmount / kB.
std::atomic< bool > m_cached_finished_ibd
Whether this chainstate is undergoing initial block download.
ResultType
Used to indicate the results of mempool validation, including the possibility of unfinished validatio...
The basic transaction that is broadcasted on the network and contained in blocks.
enum ScriptError_t ScriptError
bool ConnectBlock(const CBlock &block, BlockValidationState &state, CBlockIndex *pindex, CCoinsViewCache &view, const CChainParams &chainparams, bool fJustCheck=false) EXCLUSIVE_LOCKS_REQUIRED(cs_main)
Apply the effects of this block (with given index) on the UTXO set represented by coins.
static const bool DEFAULT_FEEFILTER
Default for using fee filter.
void UpdateUncommittedBlockStructures(CBlock &block, const CBlockIndex *pindexPrev, const Consensus::Params &consensusParams)
Update uncommitted block structures (currently: only the witness reserved value).
void ResetCoinsViews()
Destructs all objects related to accessing the UTXO set.
Abstract view on the open txout dataset.
void PruneBlockFilesManual(CChainState &active_chainstate, int nManualPruneHeight)
Prune block files up to a given height.
bool RewindBlockIndex(const CChainParams ¶ms) LOCKS_EXCLUDED(cs_main)
bool LoadBlockIndexDB(const CChainParams &chainparams) EXCLUSIVE_LOCKS_REQUIRED(cs_main)
Non-refcounted RAII wrapper for FILE*.
#define Assume(val)
Assume is the identity function.
Parameters that influence chain consensus.
CBlockIndex * ValidatedTip() const
bool ConnectTip(BlockValidationState &state, const CChainParams &chainparams, CBlockIndex *pindexNew, const std::shared_ptr< const CBlock > &pblock, ConnectTrace &connectTrace, DisconnectedBlockTransactions &disconnectpool) EXCLUSIVE_LOCKS_REQUIRED(cs_main
Connect a new block to m_chain.
FILE * OpenBlockFile(const FlatFilePos &pos, bool fReadOnly=false)
Open a block file (blk?????.dat)
std::optional< std::list< CTransactionRef > > m_replaced_transactions
Mempool transactions replaced by the tx per BIP 125 rules.
static const unsigned int MAX_BLOCKFILE_SIZE
The maximum size of a blk?????.dat file (since 0.8)
void FindFilesToPruneManual(std::set< int > &setFilesToPrune, int nManualPruneHeight, int chain_tip_height)
void swap(CScriptCheck &check)
bool AcceptBlockHeader(const CBlockHeader &block, BlockValidationState &state, const CChainParams &chainparams, CBlockIndex **ppindex) EXCLUSIVE_LOCKS_REQUIRED(cs_main)
If a block header hasn't already been seen, call CheckBlockHeader on it, ensure that it doesn't desce...
std::function< FILE *(const fs::path &, const char *)> FopenFn
bool IsWitnessEnabled(const CBlockIndex *pindexPrev, const Consensus::Params ¶ms)
Check whether witness commitments are required for a block, and whether to enforce NULLDUMMY (BIP 147...
static const unsigned int DEFAULT_ANCESTOR_LIMIT
Default for -limitancestorcount, max number of in-mempool ancestors.
void PruneAndFlush()
Prune blockfiles from the disk if necessary and then flush chainstate changes if we pruned.
ScriptError GetScriptError() const
An output of a transaction.
Transaction validation functions.
void StopScriptCheckWorkerThreads()
Stop all of the script checking worker threads.
CBlockIndex * ActiveTip() const
uint64_t nPruneTarget
Number of MiB of block files that we're trying to stay below.
bool LoadGenesisBlock(const CChainParams &chainparams)
Ensures we have a genesis block in the block tree, possibly writing one to disk.
static const bool DEFAULT_CHECKPOINTS_ENABLED
CFeeRate minRelayTxFee
A fee rate smaller than this is considered zero fee (for relaying, mining and transaction creation)
@ INVALID
Fully validated, valid.
bool IsSnapshotValidated() const
Is there a snapshot in use and has it been fully validated?
Holds various statistics on transactions within a chain.
TxValidationState m_state
static const int64_t DEFAULT_MAX_TIP_AGE
void LoadMempool(const ArgsManager &args)
Load the persisted mempool from disk.
arith_uint256 nLastPreciousChainwork
chainwork for the last block that preciousblock has been applied to.
Access to the block database (blocks/index/)
ChainstateManager g_chainman
int64_t CAmount
Amount in satoshis (Can be negative)
RecursiveMutex cs_main
Mutex to guard access to validation specific variables, such as reading or changing the chainstate.
Used to track blocks whose transactions were applied to the UTXO state as a part of a single Activate...
double GuessVerificationProgress(const ChainTxData &data, const CBlockIndex *pindex)
Guess verification progress (as a fraction between 0.0=genesis and 1.0=current tip).
MempoolAcceptResult AcceptToMemoryPool(CChainState &active_chainstate, CTxMemPool &pool, const CTransactionRef &tx, bool bypass_limits, bool test_accept=false) EXCLUSIVE_LOCKS_REQUIRED(cs_main)
(Try to) add a transaction to the memory pool.
bool ActivateBestChain(BlockValidationState &state, const CChainParams &chainparams, std::shared_ptr< const CBlock > pblock=nullptr) LOCKS_EXCLUDED(cs_main)
Find the best known block, and make it the tip of the block chain.
std::unique_ptr< CoinsViews > m_coins_views
Manages the UTXO set, which is a reflection of the contents of m_chain.
CBlockIndex * FindForkInGlobalIndex(const CChain &chain, const CBlockLocator &locator) EXCLUSIVE_LOCKS_REQUIRED(cs_main)
Find the last common block between the parameter chain and a locator.
std::atomic_bool fReindex
CChainState stores and provides an API to update our local knowledge of the current best chain.
CCoinsViewDB & CoinsDB() EXCLUSIVE_LOCKS_REQUIRED(cs_main)
DisconnectResult DisconnectBlock(const CBlock &block, const CBlockIndex *pindex, CCoinsViewCache &view)
Undo the effects of this block (with given index) on the UTXO set represented by coins.
CChainState *m_active_chainstate GUARDED_BY(::cs_main)
Points to either the ibd or snapshot chainstate; indicates our most-work chain.
bool fHavePruned
Pruning-related variables and constants.
bool TestBlockValidity(BlockValidationState &state, const CChainParams &chainparams, CChainState &chainstate, const CBlock &block, CBlockIndex *pindexPrev, bool fCheckPOW=true, bool fCheckMerkleRoot=true) EXCLUSIVE_LOCKS_REQUIRED(cs_main)
Check a block is completely valid from start to finish (only works on top of our current best block)
void StartScriptCheckWorkerThreads(int threads_num)
Run instances of script checking worker threads.
size_t m_coinsdb_cache_size_bytes
The cache size of the on-disk coins view.
bool TestLockPointValidity(CChain &active_chain, const LockPoints *lp) EXCLUSIVE_LOCKS_REQUIRED(cs_main)
Test whether the LockPoints height and time are still valid on the current chain.
static const unsigned int DEFAULT_MIN_RELAY_TX_FEE
Default for -minrelaytxfee, minimum relay fee for transactions.
CCoinsViewDB m_dbview GUARDED_BY(cs_main)
The lowest level of the CoinsViews cache hierarchy sits in a leveldb database on disk.
CChain & ChainActive()
Please prefer the identical ChainstateManager::ActiveChain.
void FindFilesToPrune(std::set< int > &setFilesToPrune, uint64_t nPruneAfterHeight, int chain_tip_height, int prune_height, bool is_ibd)
Prune block and undo files (blk???.dat and undo???.dat) so that the disk space used is less than a us...
int GetSpendHeight(const CCoinsViewCache &inputs) EXCLUSIVE_LOCKS_REQUIRED(cs_main)
Return the spend height, which is one more than the inputs.GetBestBlock().
Provides an interface for creating and interacting with one or two chainstates: an IBD chainstate gen...
RAII wrapper for VerifyDB: Verify consistency of the block and coin databases.
bool CheckBlock(const CBlock &block, BlockValidationState &state, const Consensus::Params &consensusParams, bool fCheckPOW=true, bool fCheckMerkleRoot=true)
Functions for validating blocks and updating the block tree.
void CheckForkWarningConditions() EXCLUSIVE_LOCKS_REQUIRED(cs_main)
CScriptCheck(const CTxOut &outIn, const CTransaction &txToIn, unsigned int nInIn, unsigned int nFlagsIn, bool cacheIn, PrecomputedTransactionData *txdataIn)
CBlockIndex * LookupBlockIndex(const uint256 &hash) const EXCLUSIVE_LOCKS_REQUIRED(cs_main)
bool IsInitialBlockDownload() const
Check whether we are doing an initial block download (synchronizing from disk or network)
const uint256 m_from_snapshot_blockhash
The blockhash which is the base of the snapshot this chainstate was created from.
void UnloadBlockIndex(CTxMemPool *mempool, ChainstateManager &chainman)
Unload database information.
int32_t nBlockSequenceId
Blocks loaded from disk are assigned id 0, so start the counter at 1.
MempoolAcceptResult(TxValidationState state)
Constructor for failure case.
An in-memory indexed chain of blocks.
static const uint64_t MIN_DISK_SPACE_FOR_BLOCK_FILES
#define LOCKS_EXCLUDED(...)
int32_t nBlockReverseSequenceId
Decreasing counter (used by subsequent preciousblock calls).
CBlockIndex * AddToBlockIndex(const CBlockHeader &block) EXCLUSIVE_LOCKS_REQUIRED(cs_main)
std::set< CBlockIndex * > m_failed_blocks
In order to efficiently track invalidity of headers, we keep the set of blocks which we tried to conn...
CCoinsView that adds a memory cache for transactions to another CCoinsView.
#define EXCLUSIVE_LOCKS_REQUIRED(...)
std::condition_variable g_best_block_cv
Validation result for a single transaction mempool acceptance.
std::set< CBlockIndex *, CBlockIndexWorkComparator > setBlockIndexCandidates
The set of all CBlockIndex entries with BLOCK_VALID_TRANSACTIONS (for itself and all ancestors) and a...
This is a minimally invasive approach to shutdown on LevelDB read errors from the chainstate,...
BlockManager & m_blockman
Reference to a BlockManager instance which itself is shared across all CChainState instances.
const CChainParams & Params()
Return the currently selected parameters.
Check if transaction will be BIP 68 final in the next block to be created.
void InitCoinsDB(size_t cache_size_bytes, bool in_memory, bool should_wipe, std::string leveldb_name="chainstate")
Initialize the CoinsViews UTXO set database management data structures.
static const char *const DEFAULT_BLOCKFILTERINDEX
std::atomic_bool fImporting
void ResetBlockFailureFlags(CBlockIndex *pindex) EXCLUSIVE_LOCKS_REQUIRED(cs_main)
Remove invalidity status from a block and its descendants.
static const int DEFAULT_SCRIPTCHECK_THREADS
-par default (number of script-checking threads, 0 = auto)
CBlockIndex * GetLastCheckpoint(const CCheckpointData &data) EXCLUSIVE_LOCKS_REQUIRED(cs_main)
Returns last CBlockIndex* that is a checkpoint.
SynchronizationState
Current sync state passed to tip changed callbacks.
A convenience class for constructing the CCoinsView* hierarchy used to facilitate access to the UTXO ...
CBlockIndex * pindexBestHeader
Best header we've seen so far (used for getheaders queries' starting points).
bool AcceptBlock(const std::shared_ptr< const CBlock > &pblock, BlockValidationState &state, const CChainParams &chainparams, CBlockIndex **ppindex, bool fRequested, const FlatFilePos *dbp, bool *fNewBlock) EXCLUSIVE_LOCKS_REQUIRED(cs_main)
Store block on disk.
bool InvalidateBlock(BlockValidationState &state, const CChainParams &chainparams, CBlockIndex *pindex) LOCKS_EXCLUDED(cs_main)
Mark a block as invalid.
std::multimap< CBlockIndex *, CBlockIndex * > m_blocks_unlinked
All pairs A->B, where A (or one of its ancestors) misses transactions, but B has transactions.
static const bool DEFAULT_TXINDEX
CTxMemPool & m_mempool
mempool that is kept in sync with the chain
static const unsigned int DEFAULT_DESCENDANT_SIZE_LIMIT
Default for -limitdescendantsize, maximum kilobytes of in-mempool descendants.
bool error(const char *fmt, const Args &... args)
bool ReplayBlocks(const CChainParams ¶ms)
Replay blocks that aren't fully applied to the database.
MempoolAcceptResult(std::list< CTransactionRef > &&replaced_txns, CAmount fees)
Constructor for success case.
bool CheckFinalTx(const CBlockIndex *active_chain_tip, const CTransaction &tx, int flags=-1) EXCLUSIVE_LOCKS_REQUIRED(cs_main)
Transaction validation functions.
@ BLOCK_HAVE_DATA
full block available in blk*.dat
Describes a place in the block chain to another node such that if the other node doesn't have the sam...
arith_uint256 nMinimumChainWork
Minimum work we will assume exists on some valid chain.
The block chain is a tree shaped structure starting with the genesis block at the root,...
@ SCRIPT_ERR_UNKNOWN_ERROR
size_t m_coinstip_cache_size_bytes
The cache size of the in-memory coins view.
void EraseBlockData(CBlockIndex *index) EXCLUSIVE_LOCKS_REQUIRED(cs_main)
Mark a block as not having block data.
assert(std::addressof(::ChainstateActive().CoinsTip())==std::addressof(coins_cache))
CoinsViews(std::string ldb_name, size_t cache_size_bytes, bool in_memory, bool should_wipe)
This constructor initializes CCoinsViewDB and CCoinsViewErrorCatcher instances, but it does not creat...
PrecomputedTransactionData * txdata
RecursiveMutex cs_nBlockSequenceId
Every received block is assigned a unique and increasing identifier, so we know which one to give pri...
bool IsBlockPruned(const CBlockIndex *pblockindex)
Check whether the block associated with this index entry is pruned or not.
bool PreciousBlock(BlockValidationState &state, const CChainParams ¶ms, CBlockIndex *pindex) LOCKS_EXCLUDED(cs_main)
Mark a block as precious and reorganize.
CCoinsViewErrorCatcher & CoinsErrorCatcher() EXCLUSIVE_LOCKS_REQUIRED(cs_main)
ChainstateManager g_chainman GUARDED_BY(::cs_main)
DEPRECATED! Please use node.chainman instead.
CCoinsViewCache & CoinsTip() EXCLUSIVE_LOCKS_REQUIRED(cs_main)
CChainState & ChainstateActive()
Please prefer the identical ChainstateManager::ActiveChainstate.
void UpdateCoins(const CTransaction &tx, CCoinsViewCache &inputs, int nHeight)
Apply the effects of this transaction on the UTXO set represented by view.
Undo information for a CBlock.
CBlockIndex * InsertBlockIndex(const uint256 &hash) EXCLUSIVE_LOCKS_REQUIRED(cs_main)
Create a new block index entry for a given block hash.
CChain m_chain
The current chain of blockheaders we consult and build on.
bool DumpMempool(const CTxMemPool &pool, FopenFn mockable_fopen_function=fsbridge::fopen, bool skip_file_commit=false)
Dump the mempool to disk.
void Unload() EXCLUSIVE_LOCKS_REQUIRED(cs_main)
Clear all data members.
@ PERIODIC
Called by RandAddPeriodic()
std::unordered_map< uint256, CBlockIndex *, BlockHasher > BlockMap
static const signed int DEFAULT_CHECKBLOCKS
std::vector< unsigned char > GenerateCoinbaseCommitment(CBlock &block, const CBlockIndex *pindexPrev, const Consensus::Params &consensusParams)
Produce the necessary coinbase commitment for a block (modifies the hash, don't call for mined blocks...
Filesystem operations and types.
void InvalidChainFound(CBlockIndex *pindexNew) EXCLUSIVE_LOCKS_REQUIRED(cs_main)