#include <validation.h>
#include <arith_uint256.h>
#include <chain.h>
#include <chainparams.h>
#include <checkqueue.h>
#include <consensus/consensus.h>
#include <consensus/merkle.h>
#include <consensus/tx_check.h>
#include <consensus/tx_verify.h>
#include <consensus/validation.h>
#include <cuckoocache.h>
#include <flatfile.h>
#include <hash.h>
#include <index/txindex.h>
#include <policy/fees.h>
#include <policy/policy.h>
#include <policy/settings.h>
#include <pow.h>
#include <primitives/block.h>
#include <primitives/transaction.h>
#include <random.h>
#include <reverse_iterator.h>
#include <script/script.h>
#include <script/sigcache.h>
#include <script/standard.h>
#include <shutdown.h>
#include <timedata.h>
#include <tinyformat.h>
#include <txdb.h>
#include <txmempool.h>
#include <ui_interface.h>
#include <uint256.h>
#include <undo.h>
#include <util/moneystr.h>
#include <util/rbf.h>
#include <util/strencodings.h>
#include <util/system.h>
#include <util/validation.h>
#include <validationinterface.h>
#include <warnings.h>
#include <future>
#include <sstream>
#include <string>
#include <boost/algorithm/string/replace.hpp>
#include <boost/thread.hpp>

Classes
class	WarningBitsConditionChecker

struct	PerBlockConnectTrace

class	ConnectTrace

class	CMainCleanup

Namespaces
	anonymous_namespace{validation.cpp}

Macros
#define	MICRO 0.000001

#define	MILLI 0.001

Functions
CChainState &	ChainstateActive ()

CChain &	ChainActive ()

std::atomic_bool	fImporting (false)

std::atomic_bool	fReindex (false)

CBlockIndex *	LookupBlockIndex (const uint256 &hash)

CBlockIndex *	FindForkInGlobalIndex (const CChain &chain, const CBlockLocator &locator)

static void	FindFilesToPruneManual (std::set< int > &setFilesToPrune, int nManualPruneHeight)

static void	FindFilesToPrune (std::set< int > &setFilesToPrune, uint64_t nPruneAfterHeight)

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)

static FILE *	OpenUndoFile (const FlatFilePos &pos, bool fReadOnly=false)

static FlatFileSeq	BlockFileSeq ()

static FlatFileSeq	UndoFileSeq ()

bool	CheckFinalTx (const CTransaction &tx, int flags)

bool	TestLockPointValidity (const LockPoints *lp)

bool	CheckSequenceLocks (const CTxMemPool &pool, const CTransaction &tx, int flags, LockPoints *lp, bool useExistingLockPoints)

static unsigned int	GetBlockScriptFlags (const CBlockIndex *pindex, const Consensus::Params &chainparams)

static void	LimitMempoolSize (CTxMemPool &pool, size_t limit, unsigned long age) EXCLUSIVE_LOCKS_REQUIRED(pool.cs)

static bool	IsCurrentForFeeEstimation () EXCLUSIVE_LOCKS_REQUIRED(cs_main)

static void	UpdateMempoolForReorg (DisconnectedBlockTransactions &disconnectpool, bool fAddToMempool) EXCLUSIVE_LOCKS_REQUIRED(cs_main

	while (it !=disconnectpool.queuedTx.get< insertion_order >().rend())

disconnectpool queuedTx	clear ()

mempool	UpdateTransactionsFromBlock (vHashUpdate)

mempool	removeForReorg (pcoinsTip.get(), ::ChainActive().Tip() ->nHeight+1, STANDARD_LOCKTIME_VERIFY_FLAGS)

	LimitMempoolSize (mempool, gArgs.GetArg("-maxmempool", DEFAULT_MAX_MEMPOOL_SIZE) 1000000, gArgs.GetArg("-mempoolexpiry", DEFAULT_MEMPOOL_EXPIRY) 60 *60)

static bool	CheckInputsFromMempoolAndCache (const CTransaction &tx, CValidationState &state, const CCoinsViewCache &view, const CTxMemPool &pool, unsigned int flags, bool cacheSigStore, PrecomputedTransactionData &txdata) EXCLUSIVE_LOCKS_REQUIRED(cs_main)

static bool	AcceptToMemoryPoolWorker (const CChainParams &chainparams, CTxMemPool &pool, CValidationState &state, const CTransactionRef &ptx, bool pfMissingInputs, int64_t nAcceptTime, std::list< CTransactionRef > plTxnReplaced, bool bypass_limits, const CAmount &nAbsurdFee, std::vector< COutPoint > &coins_to_uncache, bool test_accept) EXCLUSIVE_LOCKS_REQUIRED(cs_main)

static bool	AcceptToMemoryPoolWithTime (const CChainParams &chainparams, CTxMemPool &pool, CValidationState &state, const CTransactionRef &tx, bool pfMissingInputs, int64_t nAcceptTime, std::list< CTransactionRef > plTxnReplaced, bool bypass_limits, const CAmount nAbsurdFee, bool test_accept) EXCLUSIVE_LOCKS_REQUIRED(cs_main)

bool	AcceptToMemoryPool (CTxMemPool &pool, CValidationState &state, const CTransactionRef &tx, bool pfMissingInputs, std::list< CTransactionRef > plTxnReplaced, bool bypass_limits, const CAmount nAbsurdFee, bool test_accept)

bool	GetTransaction (const uint256 &hash, CTransactionRef &txOut, const Consensus::Params &consensusParams, uint256 &hashBlock, const CBlockIndex *const block_index)

static bool	WriteBlockToDisk (const CBlock &block, FlatFilePos &pos, const CMessageHeader::MessageStartChars &messageStart)

bool	ReadBlockFromDisk (CBlock &block, const FlatFilePos &pos, const Consensus::Params &consensusParams)

bool	ReadBlockFromDisk (CBlock &block, const CBlockIndex *pindex, const Consensus::Params &consensusParams)

bool	ReadRawBlockFromDisk (std::vector< uint8_t > &block, const FlatFilePos &pos, const CMessageHeader::MessageStartChars &message_start)

bool	ReadRawBlockFromDisk (std::vector< uint8_t > &block, const CBlockIndex *pindex, const CMessageHeader::MessageStartChars &message_start)

CAmount	GetBlockSubsidy (int nHeight, const Consensus::Params &consensusParams)

BlockMap &	BlockIndex ()

static void	AlertNotify (const std::string &strMessage)

static void	CheckForkWarningConditions () EXCLUSIVE_LOCKS_REQUIRED(cs_main)

static void	CheckForkWarningConditionsOnNewFork (CBlockIndex *pindexNewForkTip) EXCLUSIVE_LOCKS_REQUIRED(cs_main)

static void	InvalidChainFound (CBlockIndex *pindexNew) EXCLUSIVE_LOCKS_REQUIRED(cs_main)

void	UpdateCoins (const CTransaction &tx, CCoinsViewCache &inputs, CTxUndo &txundo, int nHeight)

void	UpdateCoins (const CTransaction &tx, CCoinsViewCache &inputs, int nHeight)

int	GetSpendHeight (const CCoinsViewCache &inputs)

void	InitScriptExecutionCache ()

static bool	UndoWriteToDisk (const CBlockUndo &blockundo, FlatFilePos &pos, const uint256 &hashBlock, const CMessageHeader::MessageStartChars &messageStart)

bool	UndoReadFromDisk (CBlockUndo &blockundo, const CBlockIndex *pindex)

static bool	AbortNode (const std::string &strMessage, const std::string &userMessage="", unsigned int prefix=0)

static bool	AbortNode (CValidationState &state, const std::string &strMessage, const std::string &userMessage="", unsigned int prefix=0)

int	ApplyTxInUndo (Coin &&undo, CCoinsViewCache &view, const COutPoint &out)

static void	FlushBlockFile (bool fFinalize=false)

static bool	FindUndoPos (CValidationState &state, int nFile, FlatFilePos &pos, unsigned int nAddSize)

static bool	WriteUndoDataForBlock (const CBlockUndo &blockundo, CValidationState &state, CBlockIndex *pindex, const CChainParams &chainparams)

void	ThreadScriptCheck (int worker_num)

VersionBitsCache versionbitscache	GUARDED_BY (cs_main)

int32_t	ComputeBlockVersion (const CBlockIndex *pindexPrev, const Consensus::Params &params)

static bool	IsScriptWitnessEnabled (const Consensus::Params &params)

static void	DoWarning (const std::string &strWarning)

static void	AppendWarning (std::string &res, const std::string &warn)

static void	UpdateTip (const CBlockIndex *pindexNew, const CChainParams &chainParams)

static void	NotifyHeaderTip () LOCKS_EXCLUDED(cs_main)

static void	LimitValidationInterfaceQueue () LOCKS_EXCLUDED(cs_main)

bool	ActivateBestChain (CValidationState &state, const CChainParams &chainparams, std::shared_ptr< const CBlock > pblock)

bool	PreciousBlock (CValidationState &state, const CChainParams &params, CBlockIndex *pindex)

bool	InvalidateBlock (CValidationState &state, const CChainParams &chainparams, CBlockIndex *pindex)

void	ResetBlockFailureFlags (CBlockIndex *pindex)

static bool	FindBlockPos (FlatFilePos &pos, unsigned int nAddSize, unsigned int nHeight, uint64_t nTime, bool fKnown=false)

static bool	CheckBlockHeader (const CBlockHeader &block, CValidationState &state, const Consensus::Params &consensusParams, bool fCheckPOW=true)

bool	CheckBlock (const CBlock &block, CValidationState &state, const Consensus::Params &consensusParams, bool fCheckPOW, bool fCheckMerkleRoot)

bool	IsWitnessEnabled (const CBlockIndex *pindexPrev, const Consensus::Params &params)

bool	IsNullDummyEnabled (const CBlockIndex *pindexPrev, const Consensus::Params &params)

static int	GetWitnessCommitmentIndex (const CBlock &block)

void	UpdateUncommittedBlockStructures (CBlock &block, const CBlockIndex *pindexPrev, const Consensus::Params &consensusParams)

std::vector< unsigned char >	GenerateCoinbaseCommitment (CBlock &block, const CBlockIndex *pindexPrev, const Consensus::Params &consensusParams)

static CBlockIndex *	GetLastCheckpoint (const CCheckpointData &data) EXCLUSIVE_LOCKS_REQUIRED(cs_main)
	Returns last CBlockIndex* that is a checkpoint. More...

static bool	ContextualCheckBlockHeader (const CBlockHeader &block, CValidationState &state, const CChainParams &params, const CBlockIndex *pindexPrev, int64_t nAdjustedTime) EXCLUSIVE_LOCKS_REQUIRED(cs_main)

static bool	ContextualCheckBlock (const CBlock &block, CValidationState &state, const Consensus::Params &consensusParams, const CBlockIndex *pindexPrev)

bool	ProcessNewBlockHeaders (const std::vector< CBlockHeader > &headers, CValidationState &state, const CChainParams &chainparams, const CBlockIndex *ppindex, CBlockHeader first_invalid)

static FlatFilePos	SaveBlockToDisk (const CBlock &block, int nHeight, const CChainParams &chainparams, const FlatFilePos *dbp)

bool	ProcessNewBlock (const CChainParams &chainparams, const std::shared_ptr< const CBlock > pblock, bool fForceProcessing, bool *fNewBlock)

bool	TestBlockValidity (CValidationState &state, const CChainParams &chainparams, const CBlock &block, CBlockIndex *pindexPrev, bool fCheckPOW, bool fCheckMerkleRoot)

uint64_t	CalculateCurrentUsage ()

void	PruneOneBlockFile (const int fileNumber)

void	UnlinkPrunedFiles (const std::set< int > &setFilesToPrune)

void	PruneBlockFilesManual (int nManualPruneHeight)

FILE *	OpenBlockFile (const FlatFilePos &pos, bool fReadOnly)

fs::path	GetBlockPosFilename (const FlatFilePos &pos)

static bool	LoadBlockIndexDB (const CChainParams &chainparams) EXCLUSIVE_LOCKS_REQUIRED(cs_main)

bool	LoadChainTip (const CChainParams &chainparams)

bool	ReplayBlocks (const CChainParams &params, CCoinsView *view)

bool	RewindBlockIndex (const CChainParams &params)

void	UnloadBlockIndex ()

bool	LoadBlockIndex (const CChainParams &chainparams)

bool	LoadGenesisBlock (const CChainParams &chainparams)

bool	LoadExternalBlockFile (const CChainParams &chainparams, FILE fileIn, FlatFilePos dbp)

CBlockFileInfo *	GetBlockFileInfo (size_t n)

ThresholdState	VersionBitsTipState (const Consensus::Params &params, Consensus::DeploymentPos pos)

BIP9Stats	VersionBitsTipStatistics (const Consensus::Params &params, Consensus::DeploymentPos pos)

int	VersionBitsTipStateSinceHeight (const Consensus::Params &params, Consensus::DeploymentPos pos)

bool	LoadMempool (CTxMemPool &pool)

bool	DumpMempool (const CTxMemPool &pool)

double	GuessVerificationProgress (const ChainTxData &data, const CBlockIndex *pindex)

Variables
BlockManager	anonymous_namespace{validation.cpp}::g_blockman

static CChainState	g_chainstate (g_blockman)

RecursiveMutex	cs_main

CBlockIndex *	pindexBestHeader = nullptr

Mutex	g_best_block_mutex

std::condition_variable	g_best_block_cv

uint256	g_best_block

int	nScriptCheckThreads = 0

bool	fHavePruned = false

bool	fPruneMode = false

bool	fRequireStandard = true

bool	fCheckBlockIndex = false

bool	fCheckpointsEnabled = DEFAULT_CHECKPOINTS_ENABLED

size_t	nCoinCacheUsage = 5000 * 300

uint64_t	nPruneTarget = 0

int64_t	nMaxTipAge = DEFAULT_MAX_TIP_AGE

uint256	hashAssumeValid

arith_uint256	nMinimumChainWork

CFeeRate	minRelayTxFee = CFeeRate(DEFAULT_MIN_RELAY_TX_FEE)

CBlockPolicyEstimator	feeEstimator

CScript	COINBASE_FLAGS

CBlockIndex *	anonymous_namespace{validation.cpp}::pindexBestInvalid = nullptr

CCriticalSection	anonymous_namespace{validation.cpp}::cs_LastBlockFile

std::vector< CBlockFileInfo >	anonymous_namespace{validation.cpp}::vinfoBlockFile

int	anonymous_namespace{validation.cpp}::nLastBlockFile = 0

bool	anonymous_namespace{validation.cpp}::fCheckForPruning = false

std::set< CBlockIndex * >	anonymous_namespace{validation.cpp}::setDirtyBlockIndex

std::set< int >	anonymous_namespace{validation.cpp}::setDirtyFileInfo

std::unique_ptr< CCoinsViewDB >	pcoinsdbview

std::unique_ptr< CCoinsViewCache >	pcoinsTip

std::unique_ptr< CBlockTreeDB >	pblocktree

static void ::mempool	cs

std::vector< uint256 >	vHashUpdate

auto	it = disconnectpool.queuedTx.get<insertion_order>().rbegin()

static CBlockIndex *	pindexBestForkTip = nullptr

static CBlockIndex *	pindexBestForkBase = nullptr

static CuckooCache::cache< uint256, SignatureCacheHasher >	scriptExecutionCache

static uint256	scriptExecutionCacheNonce (GetRandHash())

static CCheckQueue< CScriptCheck >	scriptcheckqueue (128)

static int64_t	nTimeCheck = 0

static int64_t	nTimeForks = 0

static int64_t	nTimeVerify = 0

static int64_t	nTimeConnect = 0

static int64_t	nTimeIndex = 0

static int64_t	nTimeCallbacks = 0

static int64_t	nTimeTotal = 0

static int64_t	nBlocksTotal = 0

static int64_t	nTimeReadFromDisk = 0

static int64_t	nTimeConnectTotal = 0

static int64_t	nTimeFlush = 0

static int64_t	nTimeChainState = 0

static int64_t	nTimePostConnect = 0

static const uint64_t	MEMPOOL_DUMP_VERSION = 1

static CMainCleanup	instance_of_cmaincleanup

Macro Definition Documentation

◆ MICRO

#define MICRO 0.000001

◆ MILLI

#define MILLI 0.001

Function Documentation

◆ AbortNode() [1/2]

static bool AbortNode	(	const std::string &	strMessage,
		const std::string &	userMessage = `""`,
		unsigned int	prefix = `0`
	)

static

Abort with a message

◆ AbortNode() [2/2]

static bool AbortNode	(	CValidationState &	state,
		const std::string &	strMessage,
		const std::string &	userMessage = `""`,
		unsigned int	prefix = `0`
	)

static

◆ AcceptToMemoryPool()

bool AcceptToMemoryPool	(	CTxMemPool &	pool,
		CValidationState &	state,
		const CTransactionRef &	tx,
		bool *	pfMissingInputs,
		std::list< CTransactionRef > *	plTxnReplaced,
		bool	bypass_limits,
		const CAmount	nAbsurdFee,
		bool	test_accept = `false`
	)

(try to) add transaction to memory pool plTxnReplaced will be appended to with all transactions replaced from mempool

◆ AcceptToMemoryPoolWithTime()

static bool AcceptToMemoryPoolWithTime	(	const CChainParams &	chainparams,
		CTxMemPool &	pool,
		CValidationState &	state,
		const CTransactionRef &	tx,
		bool *	pfMissingInputs,
		int64_t	nAcceptTime,
		std::list< CTransactionRef > *	plTxnReplaced,
		bool	bypass_limits,
		const CAmount	nAbsurdFee,
		bool	test_accept
	)

static

(try to) add transaction to memory pool with a specified acceptance time

◆ AcceptToMemoryPoolWorker()

static bool AcceptToMemoryPoolWorker	(	const CChainParams &	chainparams,
		CTxMemPool &	pool,
		CValidationState &	state,
		const CTransactionRef &	ptx,
		bool *	pfMissingInputs,
		int64_t	nAcceptTime,
		std::list< CTransactionRef > *	plTxnReplaced,
		bool	bypass_limits,
		const CAmount &	nAbsurdFee,
		std::vector< COutPoint > &	coins_to_uncache,
		bool	test_accept
	)

static

Parameters

[out] coins_to_uncache Return any outpoints which were not previously present in the coins cache, but were added as a result of validating the tx for mempool acceptance. This allows the caller to optionally remove the cache additions if the associated transaction ends up being rejected by the mempool.

◆ ActivateBestChain()

bool ActivateBestChain	(	CValidationState &	state,
		const CChainParams &	chainparams,
		std::shared_ptr< const CBlock >	pblock = `std::shared_ptr< const CBlock >()`
	)

Find the best known block, and make it the tip of the block chain

May not be called with cs_main held. May not be called in a validationinterface callback.

◆ AlertNotify()

static void AlertNotify ( const std::string & strMessage )

static

◆ AppendWarning()

static void AppendWarning	(	std::string &	res,
		const std::string &	warn
	)

static

Private helper function that concatenates warning messages.

◆ ApplyTxInUndo()

int ApplyTxInUndo	(	Coin &&	undo,
		CCoinsViewCache &	view,
		const COutPoint &	out
	)

Restore the UTXO in a Coin at a given COutPoint

Parameters

undo	The Coin to be restored.
view	The coins view to which to apply the changes.
out	The out point that corresponds to the tx input.

Returns: A DisconnectResult as an int

◆ BlockFileSeq()

static FlatFileSeq BlockFileSeq ( )

static

◆ BlockIndex()

BlockMap& BlockIndex ( )

Returns: the global block index map.

◆ CalculateCurrentUsage()

uint64_t CalculateCurrentUsage ( )

BLOCK PRUNING CODE

◆ ChainActive()

CChain& ChainActive ( )

Returns: the most-work chain.

◆ ChainstateActive()

CChainState& ChainstateActive ( )

Returns: the most-work valid chainstate.

◆ CheckBlock()

bool CheckBlock	(	const CBlock &	block,
		CValidationState &	state,
		const Consensus::Params &	consensusParams,
		bool	fCheckPOW = `true`,
		bool	fCheckMerkleRoot = `true`
	)

Functions for validating blocks and updating the block tree Context-independent validity checks

◆ CheckBlockHeader()

static bool CheckBlockHeader	(	const CBlockHeader &	block,
		CValidationState &	state,
		const Consensus::Params &	consensusParams,
		bool	fCheckPOW = `true`
	)

static

◆ CheckFinalTx()

bool CheckFinalTx	(	const CTransaction &	tx,
		int	flags = `-1`
	)

Transaction validation functions Check if transaction will be final in the next block to be created.

Calls IsFinalTx() with current block height and appropriate block time.

See consensus/consensus.h for flag definitions.

◆ CheckForkWarningConditions()

static void CheckForkWarningConditions ( )

static

◆ CheckForkWarningConditionsOnNewFork()

static void CheckForkWarningConditionsOnNewFork ( CBlockIndex * pindexNewForkTip )

static

◆ CheckInputs()

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
	)

Check whether all inputs of this transaction are valid (no double spends, scripts & sigs, amounts) This does not modify the UTXO set.

If pvChecks is not nullptr, script checks are pushed onto it instead of being performed inline. Any script checks which are not necessary (eg due to script execution cache hits) are, obviously, not pushed onto pvChecks/run.

Setting cacheSigStore/cacheFullScriptStore to false will remove elements from the corresponding cache which are matched. This is useful for checking blocks where we will likely never need the cache entry again.

Note that we may set state.reason to NOT_STANDARD for extra soft-fork flags in flags, block-checking callers should probably reset it to CONSENSUS in such cases.

Non-static (and re-declared) in src/test/txvalidationcache_tests.cpp

◆ CheckInputsFromMempoolAndCache()

static bool CheckInputsFromMempoolAndCache	(	const CTransaction &	tx,
		CValidationState &	state,
		const CCoinsViewCache &	view,
		const CTxMemPool &	pool,
		unsigned int	flags,
		bool	cacheSigStore,
		PrecomputedTransactionData &	txdata
	)

static

◆ CheckSequenceLocks()

bool CheckSequenceLocks	(	const CTxMemPool &	pool,
		const CTransaction &	tx,
		int	flags,
		LockPoints *	lp = `nullptr`,
		bool	useExistingLockPoints = `false`
	)

Check if transaction will be BIP 68 final in the next block to be created.

Simulates calling SequenceLocks() with data from the tip of the current active chain. Optionally stores in LockPoints the resulting height and time calculated and the hash of the block needed for calculation or skips the calculation and uses the LockPoints passed in for evaluation. The LockPoints should not be considered valid if CheckSequenceLocks returns false.

See consensus/consensus.h for flag definitions.

◆ clear()

disconnectpool queuedTx clear ( )

◆ ComputeBlockVersion()

int32_t ComputeBlockVersion	(	const CBlockIndex *	pindexPrev,
		const Consensus::Params &	params
	)

Determine what nVersion a new block should use.

◆ ContextualCheckBlock()

static bool ContextualCheckBlock	(	const CBlock &	block,
		CValidationState &	state,
		const Consensus::Params &	consensusParams,
		const CBlockIndex *	pindexPrev
	)

static

NOTE: This function is not currently invoked by ConnectBlock(), so we should consider upgrade issues if we change which consensus rules are enforced in this function (eg by adding a new consensus rule). See comment in ConnectBlock(). Note that -reindex-chainstate skips the validation that happens here!

◆ ContextualCheckBlockHeader()

static bool ContextualCheckBlockHeader	(	const CBlockHeader &	block,
		CValidationState &	state,
		const CChainParams &	params,
		const CBlockIndex *	pindexPrev,
		int64_t	nAdjustedTime
	)

static

Context-dependent validity checks. By "context", we mean only the previous block headers, but not the UTXO set; UTXO-related validity checks are done in ConnectBlock(). NOTE: This function is not currently invoked by ConnectBlock(), so we should consider upgrade issues if we change which consensus rules are enforced in this function (eg by adding a new consensus rule). See comment in ConnectBlock(). Note that -reindex-chainstate skips the validation that happens here!

◆ DoWarning()

static void DoWarning ( const std::string & strWarning )

static

◆ DumpMempool()

bool DumpMempool ( const CTxMemPool & pool )

Dump the mempool to disk.

◆ fImporting()

std::atomic_bool fImporting ( false )

◆ FindBlockPos()

static bool FindBlockPos	(	FlatFilePos &	pos,
		unsigned int	nAddSize,
		unsigned int	nHeight,
		uint64_t	nTime,
		bool	fKnown = `false`
	)

static

◆ FindFilesToPrune()

static void FindFilesToPrune	(	std::set< int > &	setFilesToPrune,
		uint64_t	nPruneAfterHeight
	)

static

Prune block and undo files (blk???.dat and undo???.dat) so that the disk space used is less than a user-defined target. The user sets the target (in MB) on the command line or in config file. This will be run on startup and whenever new space is allocated in a block or undo file, staying below the target. Changing back to unpruned requires a reindex (which in this case means the blockchain must be re-downloaded.)

Pruning functions are called from FlushStateToDisk when the global fCheckForPruning flag has been set. Block and undo files are deleted in lock-step (when blk00003.dat is deleted, so is rev00003.dat.) Pruning cannot take place until the longest chain is at least a certain length (100000 on mainnet, 1000 on testnet, 1000 on regtest). Pruning will never delete a block within a defined distance (currently 288) from the active chain's tip. The block index is updated by unsetting HAVE_DATA and HAVE_UNDO for any blocks that were stored in the deleted files. A db flag records the fact that at least some block files have been pruned.

Parameters

[out] setFilesToPrune The set of file indices that can be unlinked will be returned

◆ FindFilesToPruneManual()

static void FindFilesToPruneManual	(	std::set< int > &	setFilesToPrune,
		int	nManualPruneHeight
	)

static

◆ FindForkInGlobalIndex()

CBlockIndex* FindForkInGlobalIndex	(	const CChain &	chain,
		const CBlockLocator &	locator
	)

Find the last common block between the parameter chain and a locator.

◆ FindUndoPos()

static bool FindUndoPos	(	CValidationState &	state,
		int	nFile,
		FlatFilePos &	pos,
		unsigned int	nAddSize
	)

static

◆ FlushBlockFile()

static void FlushBlockFile ( bool fFinalize = false )

static

◆ fReindex()

std::atomic_bool fReindex ( false )

◆ GenerateCoinbaseCommitment()

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).

◆ GetBlockFileInfo()

CBlockFileInfo* GetBlockFileInfo ( size_t n )

Get block file info entry for one block file

◆ GetBlockPosFilename()

fs::path GetBlockPosFilename ( const FlatFilePos & pos )

Translation to a filesystem path

◆ GetBlockScriptFlags()

static unsigned int GetBlockScriptFlags	(	const CBlockIndex *	pindex,
		const Consensus::Params &	chainparams
	)

static

◆ GetBlockSubsidy()

CAmount GetBlockSubsidy	(	int	nHeight,
		const Consensus::Params &	consensusParams
	)

◆ GetLastCheckpoint()

static CBlockIndex* GetLastCheckpoint ( const CCheckpointData & data )

static

Returns last CBlockIndex* that is a checkpoint.

◆ GetSpendHeight()

int GetSpendHeight ( const CCoinsViewCache & inputs )

Return the spend height, which is one more than the inputs.GetBestBlock(). While checking, GetBestBlock() refers to the parent block. (protected by cs_main) This is also true for mempool checks.

◆ GetTransaction()

bool GetTransaction	(	const uint256 &	hash,
		CTransactionRef &	txOut,
		const Consensus::Params &	consensusParams,
		uint256 &	hashBlock,
		const CBlockIndex *const	block_index
	)

Return transaction in txOut, and if it was found inside a block, its hash is placed in hashBlock. If blockIndex is provided, the transaction is fetched from the corresponding block.

◆ GetWitnessCommitmentIndex()

static int GetWitnessCommitmentIndex ( const CBlock & block )

static

◆ GUARDED_BY()

VersionBitsCache versionbitscache GUARDED_BY ( cs_main )

◆ GuessVerificationProgress()

double GuessVerificationProgress	(	const ChainTxData &	data,
		const CBlockIndex *	pindex
	)

Guess how far we are in the verification process at the given block index require cs_main if pindex has not been validated yet (because nChainTx might be unset)

◆ InitScriptExecutionCache()

void InitScriptExecutionCache ( )

Initializes the script-execution cache

◆ InvalidateBlock()

bool InvalidateBlock	(	CValidationState &	state,
		const CChainParams &	chainparams,
		CBlockIndex *	pindex
	)

Mark a block as invalid.

◆ InvalidChainFound()

static void InvalidChainFound ( CBlockIndex * pindexNew )

static

◆ IsCurrentForFeeEstimation()

static bool IsCurrentForFeeEstimation ( )

static

◆ IsNullDummyEnabled()

bool IsNullDummyEnabled	(	const CBlockIndex *	pindexPrev,
		const Consensus::Params &	params
	)

Check whether NULLDUMMY (BIP 147) has activated.

◆ IsScriptWitnessEnabled()

static bool IsScriptWitnessEnabled ( const Consensus::Params & params )

static

◆ IsWitnessEnabled()

bool IsWitnessEnabled	(	const CBlockIndex *	pindexPrev,
		const Consensus::Params &	params
	)

Check whether witness commitments are required for block.

◆ LimitMempoolSize() [1/2]

static void LimitMempoolSize	(	CTxMemPool &	pool,
		size_t	limit,
		unsigned long	age
	)

static

◆ LimitMempoolSize() [2/2]

LimitMempoolSize	(	mempool	,
		gArgs.GetArg("-maxmempool", DEFAULT_MAX_MEMPOOL_SIZE) *	1000000,
		gArgs.GetArg("-mempoolexpiry", DEFAULT_MEMPOOL_EXPIRY) 60	60
	)

◆ LimitValidationInterfaceQueue()

static void LimitValidationInterfaceQueue ( )

static

◆ LoadBlockIndex()

bool LoadBlockIndex ( const CChainParams & chainparams )

Load the block tree and coins database from disk, initializing state if we're running with -reindex.

◆ LoadBlockIndexDB()

static bool LoadBlockIndexDB ( const CChainParams & chainparams )

static

◆ LoadChainTip()

bool LoadChainTip ( const CChainParams & chainparams )

Update the chain tip based on database information.

◆ LoadExternalBlockFile()

bool LoadExternalBlockFile	(	const CChainParams &	chainparams,
		FILE *	fileIn,
		FlatFilePos *	dbp = `nullptr`
	)

Import blocks from an external file

◆ LoadGenesisBlock()

bool LoadGenesisBlock ( const CChainParams & chainparams )

Ensures we have a genesis block in the block tree, possibly writing one to disk.

◆ LoadMempool()

bool LoadMempool ( CTxMemPool & pool )

Load the mempool from disk.

◆ LookupBlockIndex()

CBlockIndex* LookupBlockIndex ( const uint256 & hash )

◆ NotifyHeaderTip()

static void NotifyHeaderTip ( )

static

◆ OpenBlockFile()

FILE* OpenBlockFile	(	const FlatFilePos &	pos,
		bool	fReadOnly = `false`
	)

Open a block file (blk?????.dat)

◆ OpenUndoFile()

static FILE * OpenUndoFile	(	const FlatFilePos &	pos,
		bool	fReadOnly
	)

static

Open an undo file (rev?????.dat)

◆ PreciousBlock()

bool PreciousBlock	(	CValidationState &	state,
		const CChainParams &	params,
		CBlockIndex *	pindex
	)

Mark a block as precious and reorganize.

May not be called in a validationinterface callback.

◆ ProcessNewBlock()

bool ProcessNewBlock	(	const CChainParams &	chainparams,
		const std::shared_ptr< const CBlock >	pblock,
		bool	fForceProcessing,
		bool *	fNewBlock
	)

Process an incoming block. This only returns after the best known valid block is made active. Note that it does not, however, guarantee that the specific block passed to it has been checked for validity!

If you want to possibly get feedback on whether pblock is valid, you must install a CValidationInterface (see validationinterface.h) - this will have its BlockChecked method called whenever any block completes validation.

Note that we guarantee that either the proof-of-work is valid on pblock, or (and possibly also) BlockChecked will have been called.

May not be called in a validationinterface callback.

Parameters

[in]	pblock	The block we want to process.
[in]	fForceProcessing	Process this block even if unrequested; used for non-network block sources and whitelisted peers.
[out]	fNewBlock	A boolean which is set to indicate if the block was first received via this call

Returns: True if state.IsValid()

◆ ProcessNewBlockHeaders()

bool ProcessNewBlockHeaders	(	const std::vector< CBlockHeader > &	block,
		CValidationState &	state,
		const CChainParams &	chainparams,
		const CBlockIndex **	ppindex = `nullptr`,
		CBlockHeader *	first_invalid = `nullptr`
	)

Process incoming block headers.

May not be called in a validationinterface callback.

Parameters

[in]	block	The block headers themselves
[out]	state	This may be set to an Error state if any error occurred processing them
[in]	chainparams	The params for the chain we want to connect to
[out]	ppindex	If set, the pointer will be set to point to the last new block index object for the given headers
[out]	first_invalid	First header that fails validation, if one exists

◆ PruneBlockFilesManual()

void PruneBlockFilesManual ( int nManualPruneHeight )

Prune block files up to a given height

◆ PruneOneBlockFile()

void PruneOneBlockFile ( const int fileNumber )

Mark one block file as pruned.

◆ ReadBlockFromDisk() [1/2]

bool ReadBlockFromDisk	(	CBlock &	block,
		const FlatFilePos &	pos,
		const Consensus::Params &	consensusParams
	)

Functions for disk access for blocks

◆ ReadBlockFromDisk() [2/2]

bool ReadBlockFromDisk	(	CBlock &	block,
		const CBlockIndex *	pindex,
		const Consensus::Params &	consensusParams
	)

◆ ReadRawBlockFromDisk() [1/2]

bool ReadRawBlockFromDisk	(	std::vector< uint8_t > &	block,
		const FlatFilePos &	pos,
		const CMessageHeader::MessageStartChars &	message_start
	)

◆ ReadRawBlockFromDisk() [2/2]

bool ReadRawBlockFromDisk	(	std::vector< uint8_t > &	block,
		const CBlockIndex *	pindex,
		const CMessageHeader::MessageStartChars &	message_start
	)

◆ removeForReorg()

mempool removeForReorg	(	pcoinsTip.	get(),
		::ChainActive().Tip() ->nHeight+	1,
		STANDARD_LOCKTIME_VERIFY_FLAGS
	)

◆ ReplayBlocks()

bool ReplayBlocks	(	const CChainParams &	params,
		CCoinsView *	view
	)

Replay blocks that aren't fully applied to the database.

◆ ResetBlockFailureFlags()

void ResetBlockFailureFlags ( CBlockIndex * pindex )

Remove invalidity status from a block and its descendants.

◆ RewindBlockIndex()

bool RewindBlockIndex ( const CChainParams & params )

When there are blocks in the active chain with missing data, rewind the chainstate and remove them from the block index

◆ SaveBlockToDisk()

static FlatFilePos SaveBlockToDisk	(	const CBlock &	block,
		int	nHeight,
		const CChainParams &	chainparams,
		const FlatFilePos *	dbp
	)

static

Store block on disk. If dbp is non-nullptr, the file is known to already reside on disk

◆ TestBlockValidity()

bool TestBlockValidity	(	CValidationState &	state,
		const CChainParams &	chainparams,
		const CBlock &	block,
		CBlockIndex *	pindexPrev,
		bool	fCheckPOW = `true`,
		bool	fCheckMerkleRoot = `true`
	)

Check a block is completely valid from start to finish (only works on top of our current best block)

◆ TestLockPointValidity()

bool TestLockPointValidity ( const LockPoints * lp )

Test whether the LockPoints height and time are still valid on the current chain

◆ ThreadScriptCheck()

void ThreadScriptCheck ( int worker_num )

Run an instance of the script checking thread

◆ UndoFileSeq()

static FlatFileSeq UndoFileSeq ( )

static

◆ UndoReadFromDisk()

bool UndoReadFromDisk	(	CBlockUndo &	blockundo,
		const CBlockIndex *	pindex
	)

◆ UndoWriteToDisk()

static bool UndoWriteToDisk	(	const CBlockUndo &	blockundo,
		FlatFilePos &	pos,
		const uint256 &	hashBlock,
		const CMessageHeader::MessageStartChars &	messageStart
	)

static

◆ UnlinkPrunedFiles()

void UnlinkPrunedFiles ( const std::set< int > & setFilesToPrune )

Actually unlink the specified files

◆ UnloadBlockIndex()

void UnloadBlockIndex ( )

Unload database information

◆ UpdateCoins() [1/2]

void UpdateCoins	(	const CTransaction &	tx,
		CCoinsViewCache &	inputs,
		CTxUndo &	txundo,
		int	nHeight
	)

◆ UpdateCoins() [2/2]

void UpdateCoins	(	const CTransaction &	tx,
		CCoinsViewCache &	inputs,
		int	nHeight
	)

Apply the effects of this transaction on the UTXO set represented by view

◆ UpdateMempoolForReorg()

static void UpdateMempoolForReorg	(	DisconnectedBlockTransactions &	disconnectpool,
		bool	fAddToMempool
	)

static

◆ UpdateTip()

static void UpdateTip	(	const CBlockIndex *	pindexNew,
		const CChainParams &	chainParams
	)

static

Check warning conditions and do some notifications on new chain tip set.

◆ UpdateTransactionsFromBlock()

mempool UpdateTransactionsFromBlock ( vHashUpdate )

◆ UpdateUncommittedBlockStructures()

void UpdateUncommittedBlockStructures	(	CBlock &	block,
		const CBlockIndex *	pindexPrev,
		const Consensus::Params &	consensusParams
	)

Update uncommitted block structures (currently: only the witness reserved value). This is safe for submitted blocks.

◆ VersionBitsTipState()

ThresholdState VersionBitsTipState	(	const Consensus::Params &	params,
		Consensus::DeploymentPos	pos
	)

Get the BIP9 state for a given deployment at the current tip.

◆ VersionBitsTipStateSinceHeight()

int VersionBitsTipStateSinceHeight	(	const Consensus::Params &	params,
		Consensus::DeploymentPos	pos
	)

Get the block height at which the BIP9 deployment switched into the state for the block building on the current tip.

◆ VersionBitsTipStatistics()

BIP9Stats VersionBitsTipStatistics	(	const Consensus::Params &	params,
		Consensus::DeploymentPos	pos
	)

Get the numerical statistics for the BIP9 state for a given deployment at the current tip.

◆ while()

while ( it ! = disconnectpool.queuedTx.get<insertion_order>().rend() )

◆ WriteBlockToDisk()

static bool WriteBlockToDisk	(	const CBlock &	block,
		FlatFilePos &	pos,
		const CMessageHeader::MessageStartChars &	messageStart
	)

static

◆ WriteUndoDataForBlock()

static bool WriteUndoDataForBlock	(	const CBlockUndo &	blockundo,
		CValidationState &	state,
		CBlockIndex *	pindex,
		const CChainParams &	chainparams
	)

static

Variable Documentation

◆ COINBASE_FLAGS

CScript COINBASE_FLAGS

Constant stuff for coinbase transactions we create:

◆ cs

void ::mempool cs

Initial value:

{

AssertLockHeld(cs_main)

cs_main

RecursiveMutex cs_main

Definition: validation.cpp:100

AssertLockHeld

AssertLockHeld(g_cs_orphans)

◆ cs_main

RecursiveMutex cs_main

Mutex to guard access to validation specific variables, such as reading or changing the chainstate.

This may also need to be locked when updating the transaction pool, e.g. on AcceptToMemoryPool. See CTxMemPool::cs comment for details.

The transaction pool has a separate lock to allow reading from it and the chainstate at the same time.

◆ fCheckBlockIndex

bool fCheckBlockIndex = false

◆ fCheckpointsEnabled

bool fCheckpointsEnabled = DEFAULT_CHECKPOINTS_ENABLED

◆ feeEstimator

CTxMemPool mempool & feeEstimator

◆ fHavePruned

bool fHavePruned = false

Pruning-related variables and constants True if any block files have ever been pruned.

◆ fPruneMode

bool fPruneMode = false

True if we're running in -prune mode.

◆ fRequireStandard

bool fRequireStandard = true

◆ g_best_block

uint256 g_best_block

◆ g_best_block_cv

std::condition_variable g_best_block_cv

◆ g_best_block_mutex

Mutex g_best_block_mutex

◆ g_chainstate

CChainState g_chainstate(g_blockman)

static

◆ hashAssumeValid

uint256 hashAssumeValid

Block hash whose ancestors we will assume to have valid scripts without checking them.

◆ instance_of_cmaincleanup

CMainCleanup instance_of_cmaincleanup

static

◆ it

auto it = disconnectpool.queuedTx.get<insertion_order>().rbegin()

◆ MEMPOOL_DUMP_VERSION

const uint64_t MEMPOOL_DUMP_VERSION = 1

static

◆ minRelayTxFee

CFeeRate minRelayTxFee = CFeeRate(DEFAULT_MIN_RELAY_TX_FEE)

A fee rate smaller than this is considered zero fee (for relaying, mining and transaction creation)

◆ nBlocksTotal

int64_t nBlocksTotal = 0

static

◆ nCoinCacheUsage

size_t nCoinCacheUsage = 5000 * 300

◆ nMaxTipAge

int64_t nMaxTipAge = DEFAULT_MAX_TIP_AGE

If the tip is older than this (in seconds), the node is considered to be in initial block download.

◆ nMinimumChainWork

arith_uint256 nMinimumChainWork

Minimum work we will assume exists on some valid chain.

◆ nPruneTarget

uint64_t nPruneTarget = 0

Number of MiB of block files that we're trying to stay below.

◆ nScriptCheckThreads

int nScriptCheckThreads = 0

◆ nTimeCallbacks

int64_t nTimeCallbacks = 0

static

◆ nTimeChainState

int64_t nTimeChainState = 0

static

◆ nTimeCheck

int64_t nTimeCheck = 0

static

◆ nTimeConnect

int64_t nTimeConnect = 0

static

◆ nTimeConnectTotal

int64_t nTimeConnectTotal = 0

static

◆ nTimeFlush

int64_t nTimeFlush = 0

static

◆ nTimeForks

int64_t nTimeForks = 0

static

◆ nTimeIndex

int64_t nTimeIndex = 0

static

◆ nTimePostConnect

int64_t nTimePostConnect = 0

static

◆ nTimeReadFromDisk

int64_t nTimeReadFromDisk = 0

static

◆ nTimeTotal

int64_t nTimeTotal = 0

static

◆ nTimeVerify

int64_t nTimeVerify = 0

static

◆ pblocktree

std::unique_ptr<CBlockTreeDB> pblocktree

Global variable that points to the active block tree (protected by cs_main)

◆ pcoinsdbview

std::unique_ptr<CCoinsViewDB> pcoinsdbview

Global variable that points to the coins database (protected by cs_main)

◆ pcoinsTip

std::unique_ptr<CCoinsViewCache> pcoinsTip

Global variable that points to the active CCoinsView (protected by cs_main)

◆ pindexBestForkBase

CBlockIndex * pindexBestForkBase = nullptr

static

◆ pindexBestForkTip

CBlockIndex* pindexBestForkTip = nullptr

static

◆ pindexBestHeader

CBlockIndex* pindexBestHeader = nullptr

Best header we've seen so far (used for getheaders queries' starting points).

◆ scriptcheckqueue

CCheckQueue<CScriptCheck> scriptcheckqueue(128)

static

◆ scriptExecutionCache

CuckooCache::cache<uint256, SignatureCacheHasher> scriptExecutionCache

static

◆ scriptExecutionCacheNonce

uint256 scriptExecutionCacheNonce(GetRandHash())

static

◆ vHashUpdate

std::vector<uint256> vHashUpdate

Classes

Namespaces

Macros

Functions

Variables

Macro Definition Documentation

◆ MICRO

◆ MILLI

Function Documentation

◆ AbortNode() [1/2]

◆ AbortNode() [2/2]

◆ AcceptToMemoryPool()

◆ AcceptToMemoryPoolWithTime()

◆ AcceptToMemoryPoolWorker()

◆ ActivateBestChain()

◆ AlertNotify()

◆ AppendWarning()

◆ ApplyTxInUndo()

◆ BlockFileSeq()

◆ BlockIndex()

◆ CalculateCurrentUsage()

◆ ChainActive()

◆ ChainstateActive()

◆ CheckBlock()

◆ CheckBlockHeader()

◆ CheckFinalTx()

◆ CheckForkWarningConditions()

◆ CheckForkWarningConditionsOnNewFork()

◆ CheckInputs()

◆ CheckInputsFromMempoolAndCache()

◆ CheckSequenceLocks()

◆ clear()

◆ ComputeBlockVersion()

◆ ContextualCheckBlock()

◆ ContextualCheckBlockHeader()

◆ DoWarning()

◆ DumpMempool()

◆ fImporting()

◆ FindBlockPos()

◆ FindFilesToPrune()

◆ FindFilesToPruneManual()

◆ FindForkInGlobalIndex()

◆ FindUndoPos()

◆ FlushBlockFile()

◆ fReindex()

◆ GenerateCoinbaseCommitment()

◆ GetBlockFileInfo()

◆ GetBlockPosFilename()

◆ GetBlockScriptFlags()

◆ GetBlockSubsidy()

◆ GetLastCheckpoint()

◆ GetSpendHeight()

◆ GetTransaction()

◆ GetWitnessCommitmentIndex()

◆ GUARDED_BY()

◆ GuessVerificationProgress()

◆ InitScriptExecutionCache()

◆ InvalidateBlock()

◆ InvalidChainFound()

◆ IsCurrentForFeeEstimation()

◆ IsNullDummyEnabled()

◆ IsScriptWitnessEnabled()

◆ IsWitnessEnabled()

◆ LimitMempoolSize() [1/2]

◆ LimitMempoolSize() [2/2]

◆ LimitValidationInterfaceQueue()

◆ LoadBlockIndex()

◆ LoadBlockIndexDB()

◆ LoadChainTip()

◆ LoadExternalBlockFile()

◆ LoadGenesisBlock()

◆ LoadMempool()

◆ LookupBlockIndex()

◆ NotifyHeaderTip()

◆ OpenBlockFile()

◆ OpenUndoFile()

◆ PreciousBlock()

◆ ProcessNewBlock()

◆ ProcessNewBlockHeaders()

◆ PruneBlockFilesManual()