6 #ifndef BITCOIN_VALIDATION_H 7 #define BITCOIN_VALIDATION_H 9 #if defined(HAVE_CONFIG_H) 105 typedef std::unordered_map<uint256, CBlockIndex*, BlockHasher>
BlockMap;
194 std::list<CTransactionRef>* plTxnReplaced,
257 m_tx_out(outIn), ptxTo(&txToIn), nIn(nInIn), nFlags(nFlagsIn), cacheStore(cacheIn), error(
SCRIPT_ERR_UNKNOWN_ERROR), txdata(txdataIn) { }
261 void swap(CScriptCheck &check) {
262 std::swap(ptxTo, check.
ptxTo);
263 std::swap(m_tx_out, check.
m_tx_out);
264 std::swap(nIn, check.
nIn);
265 std::swap(nFlags, check.
nFlags);
267 std::swap(error, check.
error);
268 std::swap(txdata, check.
txdata);
352 void FindFilesToPruneManual(std::set<int>& setFilesToPrune,
int nManualPruneHeight,
int chain_tip_height);
369 void FindFilesToPrune(std::set<int>& setFilesToPrune, uint64_t nPruneAfterHeight,
int chain_tip_height,
bool is_ibd);
411 std::set<CBlockIndex*, CBlockIndexWorkComparator>& block_index_candidates)
415 void Unload() EXCLUSIVE_LOCKS_REQUIRED(cs_main);
422 void PruneOneBlockFile(const
int fileNumber) EXCLUSIVE_LOCKS_REQUIRED(cs_main);
428 bool AcceptBlockHeader(
432 CBlockIndex** ppindex) EXCLUSIVE_LOCKS_REQUIRED(cs_main);
460 std::unique_ptr<CCoinsViewCache> m_cacheview
GUARDED_BY(cs_main);
468 CoinsViews(std::string ldb_name,
size_t cache_size_bytes,
bool in_memory,
bool should_wipe);
506 int32_t nBlockSequenceId = 1;
508 int32_t nBlockReverseSequenceId = -1;
524 mutable std::atomic<bool> m_cached_finished_ibd{
false};
547 size_t cache_size_bytes,
550 std::string leveldb_name =
"chainstate");
558 bool CanFlushToDisk() const EXCLUSIVE_LOCKS_REQUIRED(cs_main) {
559 return m_coins_views && m_coins_views->m_cacheview;
583 assert(m_coins_views->m_cacheview);
584 return *m_coins_views->m_cacheview.get();
590 return m_coins_views->m_dbview;
597 return m_coins_views->m_catcherview;
604 size_t m_coinsdb_cache_size_bytes{0};
607 size_t m_coinstip_cache_size_bytes{0};
611 bool ResizeCoinsCaches(
size_t coinstip_size,
size_t coinsdb_size)
625 bool FlushStateToDisk(
629 int nManualPruneHeight = 0);
632 void ForceFlushStateToDisk();
636 void PruneAndFlush();
677 void PruneBlockIndexCandidates();
682 bool IsInitialBlockDownload()
const;
705 size_t max_coins_cache_size_bytes,
708 std::string
ToString() EXCLUSIVE_LOCKS_REQUIRED(::cs_main);
715 CBlockIndex* FindMostWorkChain() EXCLUSIVE_LOCKS_REQUIRED(cs_main);
721 void EraseBlockData(
CBlockIndex* index) EXCLUSIVE_LOCKS_REQUIRED(cs_main);
772 class ChainstateManager
822 bool m_snapshot_validated{
false};
835 int64_t m_total_coinstip_cache{0};
839 int64_t m_total_coinsdb_cache{0};
862 return m_blockman.m_block_index;
865 bool IsSnapshotActive()
const;
874 bool IsBackgroundIBD(
CChainState* chainstate)
const;
905 bool ProcessNewBlock(
const CChainParams& chainparams,
const std::shared_ptr<const CBlock> pblock,
bool fForceProcessing,
bool* fNewBlock)
LOCKS_EXCLUDED(cs_main);
944 extern std::unique_ptr<CBlockTreeDB>
pblocktree;
975 #endif // BITCOIN_VALIDATION_H std::shared_ptr< const CTransaction > CTransactionRef
static const unsigned int DEFAULT_ANCESTOR_SIZE_LIMIT
Default for -limitancestorsize, maximum kilobytes of tx + all in-mempool ancestors.
static const int DEFAULT_SCRIPTCHECK_THREADS
-par default (number of script-checking threads, 0 = auto)
Display status of an in-progress BIP9 softfork.
bool CheckFinalTx(const CTransaction &tx, int flags=-1) EXCLUSIVE_LOCKS_REQUIRED(cs_main)
Transaction validation functions.
static const unsigned int MAX_BLOCKFILE_SIZE
The maximum size of a blk?????.dat file (since 0.8)
static const unsigned int DEFAULT_DESCENDANT_LIMIT
Default for -limitdescendantcount, max number of in-mempool descendants.
int64_t nMaxTipAge
If the tip is older than this (in seconds), the node is considered to be in initial block download...
SynchronizationState
Current sync state passed to tip changed callbacks.
CChain m_chain
The current chain of blockheaders we consult and build on.
enum ScriptError_t ScriptError
Describes a place in the block chain to another node such that if the other node doesn't have the sam...
uint32_t nStatus
Verification status of this block. See enum BlockStatus.
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.
void swap(CScriptCheck &check)
Maintains a tree of blocks (stored in m_block_index) which is consulted to determine where the most-w...
void ThreadScriptCheck(int worker_num)
Run an instance of the script checking thread.
The cache is at >= 90% capacity.
A convenience class for constructing the CCoinsView* hierarchy used to facilitate access to the UTXO ...
Provides an interface for creating and interacting with one or two chainstates: an IBD chainstate gen...
An in-memory indexed chain of blocks.
uint64_t CalculateCurrentUsage()
Calculate the amount of disk space the block & undo files currently use.
static const int64_t DEFAULT_MAX_TIP_AGE
void PruneBlockFilesManual(int nManualPruneHeight)
Prune block files up to a given height.
bool PreciousBlock(BlockValidationState &state, const CChainParams ¶ms, CBlockIndex *pindex) LOCKS_EXCLUDED(cs_main)
Mark a block as precious and reorganize.
CBlockIndex * pindexBestHeader
Best header we've seen so far (used for getheaders queries' starting points).
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...
static const unsigned int DEFAULT_ANCESTOR_LIMIT
Default for -limitancestorcount, max number of in-mempool ancestors.
CChain & ValidatedChain() const
bool g_parallel_script_checks
Whether there are dedicated script-checking threads running.
The coins cache is in immediate need of a flush.
void ResetCoinsViews()
Destructs all objects related to accessing the UTXO set.
CChainState stores and provides an API to update our local knowledge of the current best chain...
bool ReadBlockFromDisk(CBlock &block, const FlatFilePos &pos, const Consensus::Params &consensusParams)
Functions for disk access for blocks.
CChainParams defines various tweakable parameters of a given instance of the Bitcoin system...
ThresholdState
BIP 9 defines a finite-state-machine to deploy a softfork in multiple stages.
void ResetBlockFailureFlags(CBlockIndex *pindex) EXCLUSIVE_LOCKS_REQUIRED(cs_main)
Remove invalidity status from a block and its descendants.
const std::vector< std::string > CHECKLEVEL_DOC
Documentation for argument 'checklevel'.
double GuessVerificationProgress(const ChainTxData &data, const CBlockIndex *pindex)
Guess verification progress (as a fraction between 0.0=genesis and 1.0=current tip).
bool CheckSequenceLocks(const CTxMemPool &pool, const CTransaction &tx, int flags, LockPoints *lp, bool useExistingLockPoints)
BIP9Stats VersionBitsTipStatistics(const Consensus::Params ¶ms, Consensus::DeploymentPos pos)
Get the numerical statistics for the BIP9 state for a given deployment at the current tip...
Called by RandAddPeriodic()
CScriptCheck(const CTxOut &outIn, const CTransaction &txToIn, unsigned int nInIn, unsigned int nFlagsIn, bool cacheIn, PrecomputedTransactionData *txdataIn)
Transaction validation functions.
void LoadExternalBlockFile(const CChainParams &chainparams, FILE *fileIn, FlatFilePos *dbp=nullptr)
Import blocks from an external file.
int64_t CAmount
Amount in satoshis (Can be negative)
RecursiveMutex m_cs_chainstate
the ChainState CriticalSection A lock that must be held when modifying this ChainState - held in Acti...
std::string ToString(const T &t)
Locale-independent version of std::to_string.
static const bool DEFAULT_PERSIST_MEMPOOL
Default for -persistmempool.
BIP 9 allows multiple softforks to be deployed in parallel.
void UpdateUncommittedBlockStructures(CBlock &block, const CBlockIndex *pindexPrev, const Consensus::Params &consensusParams)
Update uncommitted block structures (currently: only the witness reserved value). ...
CCoinsViewDB & CoinsDB() EXCLUSIVE_LOCKS_REQUIRED(cs_main)
Access to the block database (blocks/index/)
Abstract view on the open txout dataset.
bool UndoReadFromDisk(CBlockUndo &blockundo, const CBlockIndex *pindex)
bool ReadRawBlockFromDisk(std::vector< uint8_t > &block, const FlatFilePos &pos, const CMessageHeader::MessageStartChars &message_start)
bool fHavePruned
Pruning-related variables and constants.
void InitScriptExecutionCache()
Initializes the script-execution cache.
fs::path GetBlockPosFilename(const FlatFilePos &pos)
Translation to a filesystem path.
bool LoadMempool(CTxMemPool &pool)
Load the mempool from disk.
bool IsSnapshotValidated() const
Is there a snapshot in use and has it been fully validated?
RAII wrapper for VerifyDB: Verify consistency of the block and coin databases.
static const unsigned int DEFAULT_MIN_RELAY_TX_FEE
Default for -minrelaytxfee, minimum relay fee for transactions.
CChain & ChainActive()
Please prefer the identical ChainstateManager::ActiveChain.
bool TestLockPointValidity(const LockPoints *lp) EXCLUSIVE_LOCKS_REQUIRED(cs_main)
Test whether the LockPoints height and time are still valid on the current chain. ...
Holds various statistics on transactions within a chain.
static const unsigned int DEFAULT_DESCENDANT_SIZE_LIMIT
Default for -limitdescendantsize, maximum kilobytes of in-mempool descendants.
static const unsigned int DEFAULT_MEMPOOL_EXPIRY
Default for -mempoolexpiry, expiration time for mempool transactions in hours.
static const int DEFAULT_STOPATHEIGHT
Default for -stopatheight.
arith_uint256 nMinimumChainWork
Minimum work we will assume exists on some valid chain.
static const bool DEFAULT_FEEFILTER
Default for using fee filter.
ChainstateManager g_chainman
An output of a transaction.
ThresholdState VersionBitsTipState(const Consensus::Params ¶ms, Consensus::DeploymentPos pos)
Get the BIP9 state for a given deployment at the current tip.
std::atomic_bool fImporting
std::unique_ptr< CoinsViews > m_coins_views
Manages the UTXO set, which is a reflection of the contents of m_chain.
Parameters that influence chain consensus.
static const char *const DEFAULT_BLOCKFILTERINDEX
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.
256-bit unsigned big integer.
uint64_t nPruneTarget
Number of MiB of block files that we're trying to stay below.
Check if transaction will be BIP 68 final in the next block to be created.
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...
CFeeRate minRelayTxFee
A fee rate smaller than this is considered zero fee (for relaying, mining and transaction creation) ...
std::condition_variable g_best_block_cv
std::atomic_bool fReindex
bool ActivateBestChain(BlockValidationState &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.
const CTransaction * ptxTo
static const bool DEFAULT_CHECKPOINTS_ENABLED
#define EXCLUSIVE_LOCKS_REQUIRED(...)
CTxMemPool stores valid-according-to-the-current-best-chain transactions that may be included in the ...
FILE * OpenBlockFile(const FlatFilePos &pos, bool fReadOnly=false)
Open a block file (blk?????.dat)
#define LOCKS_EXCLUDED(...)
RecursiveMutex cs_main
Mutex to guard access to validation specific variables, such as reading or changing the chainstate...
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...
The block chain is a tree shaped structure starting with the genesis block at the root...
const CChainParams & Params()
Return the currently selected parameters.
bool IsBlockPruned(const CBlockIndex *pblockindex)
Check whether the block associated with this index entry is pruned or not.
Undo information for a CBlock.
std::unique_ptr< CChainState > m_snapshot_chainstate
A chainstate initialized on the basis of a UTXO snapshot.
static const signed int DEFAULT_CHECKBLOCKS
ChainstateManager g_chainman GUARDED_BY(::cs_main)
DEPRECATED! Please use node.chainman instead.
CCoinsView backed by the coin database (chainstate/)
std::unique_ptr< CChainState > m_ibd_chainstate
The chainstate used under normal operation (i.e.
void UpdateCoins(const CTransaction &tx, CCoinsViewCache &inputs, int nHeight)
Apply the effects of this transaction on the UTXO set represented by view.
bool InvalidateBlock(BlockValidationState &state, const CChainParams &chainparams, CBlockIndex *pindex) LOCKS_EXCLUDED(cs_main)
Mark a block as invalid.
uint256 hashAssumeValid
Block hash whose ancestors we will assume to have valid scripts without checking them.
CChainState &InitializeChainstate(CTxMemPool &mempool, const uint256 &snapshot_blockhash=uint256()) EXCLUSIVE_LOCKS_REQUIRED(std::vector< CChainState * > GetAll()
Instantiate a new chainstate and assign it based upon whether it is from a snapshot.
std::set< CBlockIndex *, CBlockIndexWorkComparator > setBlockIndexCandidates
The set of all CBlockIndex entries with BLOCK_VALID_TRANSACTIONS (for itself and all ancestors) and a...
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...
bool DumpMempool(const CTxMemPool &pool)
Dump the mempool to disk.
Fee rate in satoshis per kilobyte: CAmount / kB.
BlockManager & m_blockman
Reference to a BlockManager instance which itself is shared across all CChainState instances...
CBlockIndex * ValidatedTip() const
CBlockIndex * LookupBlockIndex(const uint256 &hash) EXCLUSIVE_LOCKS_REQUIRED(cs_main)
CCoinsViewCache & CoinsTip() EXCLUSIVE_LOCKS_REQUIRED(cs_main)
CTxMemPool & m_mempool
mempool that is kept in sync with the 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::multimap< CBlockIndex *, CBlockIndex * > m_blocks_unlinked
All pairs A->B, where A (or one of its ancestors) misses transactions, but B has transactions.
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.
CChainState & ChainstateActive()
Please prefer the identical ChainstateManager::ActiveChainstate.
The basic transaction that is broadcasted on the network and contained in blocks. ...
void UnloadBlockIndex(CTxMemPool *mempool, ChainstateManager &chainman)
Unload database information.
std::unordered_map< uint256, CBlockIndex *, BlockHasher > BlockMap
bool AcceptToMemoryPool(CTxMemPool &pool, TxValidationState &state, const CTransactionRef &tx, std::list< CTransactionRef > *plTxnReplaced, bool bypass_limits, bool test_accept=false, CAmount *fee_out=nullptr) EXCLUSIVE_LOCKS_REQUIRED(cs_main)
(try to) add transaction to memory pool plTxnReplaced will be appended to with all transactions repla...
bool fPruneMode
True if we're running in -prune mode.
CCoinsView that adds a memory cache for transactions to another CCoinsView.
full block available in blk*.dat
static const uint64_t MIN_DISK_SPACE_FOR_BLOCK_FILES
int GetSpendHeight(const CCoinsViewCache &inputs)
Return the spend height, which is one more than the inputs.GetBestBlock().
int VersionBitsTipStateSinceHeight(const Consensus::Params ¶ms, Consensus::DeploymentPos pos)
Get the block height at which the BIP9 deployment switched into the state for the block building on t...
bool LoadGenesisBlock(const CChainParams &chainparams)
Ensures we have a genesis block in the block tree, possibly writing one to disk.
This is a minimally invasive approach to shutdown on LevelDB read errors from the chainstate...
CBlockFileInfo * GetBlockFileInfo(size_t n)
Get block file info entry for one block file.
VersionBitsCache versionbitscache
ScriptError GetScriptError() const
bool error(const char *fmt, const Args &... args)
std::unique_ptr< CBlockTreeDB > pblocktree
Global variable that points to the active block tree (protected by cs_main)
bool TestBlockValidity(BlockValidationState &state, const CChainParams &chainparams, 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) ...
static const bool DEFAULT_TXINDEX
RecursiveMutex cs_nBlockSequenceId
Every received block is assigned a unique and increasing identifier, so we know which one to give pri...
unsigned int nTx
Number of transactions in this block.
std::optional< T > Optional
Substitute for C++17 std::optional DEPRECATED use std::optional in new code.
CChain & ActiveChain() const
void UnlinkPrunedFiles(const std::set< int > &setFilesToPrune)
Actually unlink the specified files.
CCoinsViewErrorCatcher & CoinsErrorCatcher() EXCLUSIVE_LOCKS_REQUIRED(cs_main)
static const unsigned int DEFAULT_CHECKLEVEL
RecursiveMutex cs
This mutex needs to be locked when accessing mapTx or other members that are guarded by it...
static const int MAX_SCRIPTCHECK_THREADS
Maximum number of dedicated script-checking threads allowed.
CBlockIndex * ActiveTip() const
Used to track blocks whose transactions were applied to the UTXO state as a part of a single Activate...
PrecomputedTransactionData * txdata
BlockMap & BlockIndex() EXCLUSIVE_LOCKS_REQUIRED(