7 #ifndef BITCOIN_VALIDATION_H
8 #define BITCOIN_VALIDATION_H
10 #if defined(HAVE_CONFIG_H)
11 #include <config/bitcoin-config.h>
69 class SnapshotMetadata;
78 #define MIN_TRANSACTION_SIZE \
79 (::GetSerializeSize(CTransaction(), PROTOCOL_VERSION))
133 bool _checkPow =
true,
134 bool _checkMerkleRoot =
true)
180 int nManualPruneHeight);
251 const std::vector<TxId> &txids_fee_calculations) {
253 txids_fee_calculations);
259 const std::vector<TxId> &txids_fee_calculations) {
261 effective_feerate, txids_fee_calculations);
287 const std::vector<TxId> &txids_fee_calculations)
295 const std::vector<TxId> &txids_fee_calculations)
322 std::map<TxId, MempoolAcceptResult> &&results)
358 int64_t accept_time,
bool bypass_limits,
359 bool test_accept =
false,
unsigned int heightOverride = 0)
375 const
Package &txns,
bool test_accept)
390 auto newvalue = (remaining -= consumed);
391 return newvalue >= 0;
394 bool check() {
return remaining >= 0; }
452 bool sigCacheStore,
bool scriptCacheStore,
456 std::vector<CScriptCheck> *pvChecks)
465 bool sigCacheStore,
bool scriptCacheStore,
470 scriptCacheStore, txdata, nSigChecksOut,
471 nSigChecksTxLimiter,
nullptr,
nullptr);
541 unsigned int nInIn, uint32_t nFlagsIn,
bool cacheIn,
629 int nCheckLevel,
int nCheckDepth)
708 std::atomic<int32_t> nBlockSequenceId{1};
710 int32_t nBlockReverseSequenceId = -1;
720 mutable std::atomic<bool> m_cached_finished_ibd{
false};
778 std::optional<BlockHash> from_snapshot_blockhash = std::nullopt);
786 void InitCoinsDB(
size_t cache_size_bytes,
bool in_memory,
bool should_wipe,
787 std::string leveldb_name =
"chainstate");
791 void InitCoinsCache(
size_t cache_size_bytes)
799 return m_coins_views && m_coins_views->m_cacheview;
812 const std::optional<BlockHash> m_from_snapshot_blockhash{};
817 return m_from_snapshot_blockhash.has_value();
833 return *
Assert(m_coins_views->m_cacheview);
839 return Assert(m_coins_views)->m_dbview;
850 return Assert(m_coins_views)->m_catcherview;
860 size_t m_coinsdb_cache_size_bytes{0};
863 size_t m_coinstip_cache_size_bytes{0};
867 bool ResizeCoinsCaches(
size_t coinstip_size,
size_t coinsdb_size)
902 std::multimap<BlockHash, FlatFilePos>
903 *blocks_with_unknown_parent =
nullptr,
906 !cs_avalancheFinalizedBlockIndex);
920 int nManualPruneHeight = 0);
923 void ForceFlushStateToDisk();
927 void PruneAndFlush();
956 std::shared_ptr<const
CBlock> pblock =
nullptr,
958 bool skip_checkblockindex = false)
960 !cs_avalancheFinalizedBlockIndex)
963 bool AcceptBlock(const
std::shared_ptr<const
CBlock> &pblock,
976 Amount *blockFees =
nullptr,
bool fJustCheck = false)
993 !cs_avalancheFinalizedBlockIndex)
999 !cs_avalancheFinalizedBlockIndex);
1004 !cs_avalancheFinalizedBlockIndex);
1016 void ClearAvalancheFinalizedBlock()
1022 bool IsBlockAvalancheFinalized(const
CBlockIndex *pindex) const
1028 template <typename F>
1031 template <typename F, typename C, typename AC>
1033 C fChild, AC fAncestorWasChanged)
1044 bool ReplayBlocks();
1050 bool LoadGenesisBlock();
1052 void PruneBlockIndexCandidates();
1060 bool IsInitialBlockDownload() const;
1072 void CheckBlockIndex();
1090 GetCoinsCacheSizeState(
size_t max_coins_cache_size_bytes,
1091 size_t max_mempool_size_bytes)
1099 return m_mempool ? &m_mempool->
cs :
nullptr;
1106 const std::shared_ptr<const CBlock> &pblock,
1110 !cs_avalancheFinalizedBlockIndex);
1114 const
std::shared_ptr<const
CBlock> &pblock,
1119 !cs_avalancheFinalizedBlockIndex);
1124 FindMostWorkChain(
std::vector<const
CBlockIndex *> &blocksToReconcile,
1134 void UnparkBlockImpl(
CBlockIndex *pindex,
bool fClearChildren)
1140 !cs_avalancheFinalizedBlockIndex);
1143 void CheckForkWarningConditionsOnNewFork(
CBlockIndex *pindexNewForkTip)
1157 std::chrono::microseconds m_last_write{0};
1158 std::chrono::microseconds m_last_flush{0};
1264 PopulateAndValidateSnapshot(
Chainstate &snapshot_chainstate,
1275 bool AcceptBlockHeader(
1278 const std::optional<CCheckpointData> &test_checkpoints = std::nullopt)
1288 std::optional<
int> GetSnapshotBaseHeight() const
1296 bool IsUsable(const
Chainstate *const pchainstate) const
1298 return pchainstate && !pchainstate->m_disabled;
1313 return m_options.config.GetChainParams();
1316 return m_options.config.GetChainParams().GetConsensus();
1319 return *
Assert(m_options.check_block_index);
1322 return *
Assert(m_options.minimum_chain_work);
1325 return *
Assert(m_options.assumed_valid_block);
1328 return m_options.notifications;
1381 int64_t m_total_coinstip_cache{0};
1385 int64_t m_total_coinsdb_cache{0};
1410 [[nodiscard]]
bool ActivateSnapshot(
AutoFile &coins_file,
1429 return ActiveChainstate().m_chain;
1432 return ActiveChain().Height();
1435 return ActiveChain().Tip();
1440 return m_blockman.m_block_index;
1445 bool IsSnapshotActive()
const;
1447 std::optional<BlockHash> SnapshotBlockhash()
const;
1451 return m_snapshot_chainstate && m_ibd_chainstate &&
1452 m_ibd_chainstate->m_disabled;
1482 bool ProcessNewBlock(
const std::shared_ptr<const CBlock> &block,
1483 bool force_processing,
bool min_pow_checked,
1503 bool ProcessNewBlockHeaders(
1518 ProcessTransaction(const
CTransactionRef &tx,
bool test_accept = false)
1535 void ReportHeadersPresync(const
arith_uint256 &work, int64_t height,
1540 bool DetectSnapshotChainstate(
CTxMemPool *mempool)
1564 template <typename DEP>
1570 template <
typename DEP>
const CChainParams & Params()
Return the currently selected parameters.
#define Assert(val)
Identity function.
#define Assume(val)
Assume is the identity function.
Non-refcounted RAII wrapper for FILE*.
uint64_t getExcessiveBlockSize() const
BlockValidationOptions withCheckPoW(bool _checkPoW=true) const
BlockValidationOptions(uint64_t _excessiveBlockSize, bool _checkPow=true, bool _checkMerkleRoot=true)
BlockValidationOptions withCheckMerkleRoot(bool _checkMerkleRoot=true) const
BlockValidationOptions(const Config &config)
bool shouldValidatePoW() const
uint64_t excessiveBlockSize
bool shouldValidateMerkleRoot() const
The block chain is a tree shaped structure starting with the genesis block at the root,...
An in-memory indexed chain of blocks.
CChainParams defines various tweakable parameters of a given instance of the Bitcoin system.
CCoinsView that adds a memory cache for transactions to another CCoinsView.
CCoinsView backed by the coin database (chainstate/)
This is a minimally invasive approach to shutdown on LevelDB read errors from the chainstate,...
Abstract view on the open txout dataset.
Fee rate in satoshis per kilobyte: Amount / kB.
RollingBloomFilter is a probabilistic "keep track of most recently inserted" set.
Closure representing one script verification.
CScriptCheck & operator=(CScriptCheck &&)=default
CScriptCheck(const CTxOut &outIn, const CTransaction &txToIn, unsigned int nInIn, uint32_t nFlagsIn, bool cacheIn, const PrecomputedTransactionData &txdataIn, TxSigCheckLimiter *pTxLimitSigChecksIn=nullptr, CheckInputsLimiter *pBlockLimitSigChecksIn=nullptr)
ScriptError GetScriptError() const
ScriptExecutionMetrics GetScriptExecutionMetrics() const
CScriptCheck(const CScriptCheck &)=delete
TxSigCheckLimiter * pTxLimitSigChecks
ScriptExecutionMetrics metrics
CScriptCheck(CScriptCheck &&)=default
CScriptCheck & operator=(const CScriptCheck &)=delete
PrecomputedTransactionData txdata
const CTransaction * ptxTo
CheckInputsLimiter * pBlockLimitSigChecks
The basic transaction that is broadcasted on the network and contained in blocks.
CTxMemPool stores valid-according-to-the-current-best-chain transactions that may be included in the ...
RecursiveMutex cs
This mutex needs to be locked when accessing mapTx or other members that are guarded by it.
An output of a transaction.
Restore the UTXO in a Coin at a given COutPoint.
RAII wrapper for VerifyDB: Verify consistency of the block and coin databases.
VerifyDBResult VerifyDB(Chainstate &chainstate, CCoinsView &coinsview, int nCheckLevel, int nCheckDepth) EXCLUSIVE_LOCKS_REQUIRED(cs_main)
kernel::Notifications & m_notifications
Chainstate stores and provides an API to update our local knowledge of the current best chain.
std::set< CBlockIndex *, CBlockIndexWorkComparator > setBlockIndexCandidates
The set of all CBlockIndex entries with either BLOCK_VALID_TRANSACTIONS (for itself and all ancestors...
CCoinsViewErrorCatcher & CoinsErrorCatcher() EXCLUSIVE_LOCKS_REQUIRED(cs_main)
CTxMemPool * GetMempool()
Mutex m_chainstate_mutex
The ChainState Mutex.
CChain m_chain
The current chain of blockheaders we consult and build on.
bool HasCoinsViews() const
Does this chainstate have a UTXO set attached?
CCoinsViewDB & CoinsDB() EXCLUSIVE_LOCKS_REQUIRED(
Mutex cs_avalancheFinalizedBlockIndex
CTxMemPool * m_mempool
Optional mempool that is kept in sync with the chain.
bool reliesOnAssumedValid()
Return true if this chainstate relies on blocks that are assumed-valid.
bool m_disabled GUARDED_BY(::cs_main)
This toggle exists for use when doing background validation for UTXO snapshots.
ChainstateManager & m_chainman
The chainstate manager that owns this chainstate.
std::unique_ptr< CoinsViews > m_coins_views
Manages the UTXO set, which is a reflection of the contents of m_chain.
void ResetCoinsViews()
Destructs all objects related to accessing the UTXO set.
CCoinsViewCache & CoinsTip() EXCLUSIVE_LOCKS_REQUIRED(
node::BlockManager & m_blockman
Reference to a BlockManager instance which itself is shared across all Chainstate instances.
const CBlockIndex *m_avalancheFinalizedBlockIndex GUARDED_BY(cs_avalancheFinalizedBlockIndex)
The best block via avalanche voting.
Provides an interface for creating and interacting with one or two chainstates: an IBD chainstate gen...
CChain & ActiveChain() const EXCLUSIVE_LOCKS_REQUIRED(GetMutex())
std::unique_ptr< Chainstate > m_ibd_chainstate GUARDED_BY(::cs_main)
The chainstate used under normal operation (i.e.
Chainstate *m_active_chainstate GUARDED_BY(::cs_main)
Points to either the ibd or snapshot chainstate; indicates our most-work chain.
CBlockIndex *m_best_parked GUARDED_BY(::cs_main)
const CChainParams & GetParams() const
const arith_uint256 & MinimumChainWork() const
SteadyMilliseconds m_last_presync_update GUARDED_BY(::cs_main)
Most recent headers presync progress update, for rate-limiting.
bool ShouldCheckBlockIndex() const
const Config & GetConfig() const
const BlockHash & AssumedValidBlock() const
node::BlockMap & BlockIndex() EXCLUSIVE_LOCKS_REQUIRED(
bool IsSnapshotValidated() const EXCLUSIVE_LOCKS_REQUIRED(
Is there a snapshot in use and has it been fully validated?
RecursiveMutex & GetMutex() const LOCK_RETURNED(
Alias for cs_main.
int ActiveHeight() const EXCLUSIVE_LOCKS_REQUIRED(GetMutex())
CBlockIndex * ActiveTip() const EXCLUSIVE_LOCKS_REQUIRED(GetMutex())
CBlockIndex *m_best_invalid GUARDED_BY(::cs_main)
CBlockIndex *m_best_header GUARDED_BY(::cs_main)
Best header we've seen so far (used for getheaders queries' starting points).
Chainstate &InitializeChainstate(CTxMemPool *mempool) EXCLUSIVE_LOCKS_REQUIRED(std::vector< Chainstate * GetAll)()
Instantiate a new chainstate.
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...
std::unique_ptr< Chainstate > m_snapshot_chainstate GUARDED_BY(::cs_main)
A chainstate initialized on the basis of a UTXO snapshot.
kernel::Notifications & GetNotifications() const
const Consensus::Params & GetConsensus() const
node::BlockManager m_blockman
A single BlockManager instance is shared across each constructed chainstate to avoid duplicating bloc...
A convenience class for constructing the CCoinsView* hierarchy used to facilitate access to the UTXO ...
std::unique_ptr< CCoinsViewCache > m_cacheview GUARDED_BY(cs_main)
This is the top layer of the cache hierarchy - it keeps as many coins in memory as can fit per the db...
CCoinsViewErrorCatcher m_catcherview GUARDED_BY(cs_main)
This view wraps access to the leveldb instance and handles read errors gracefully.
CCoinsViewDB m_dbview GUARDED_BY(cs_main)
The lowest level of the CoinsViews cache hierarchy sits in a leveldb database on disk.
CoinsViews(DBParams db_params, CoinsViewOptions options)
This constructor initializes CCoinsViewDB and CCoinsViewErrorCatcher instances, but it does not creat...
Used to track blocks whose transactions were applied to the UTXO state as a part of a single Activate...
Different type to mark Mutex at global scope.
static TxSigCheckLimiter getDisabled()
TxSigCheckLimiter & operator=(const TxSigCheckLimiter &rhs)
TxSigCheckLimiter(const TxSigCheckLimiter &rhs)
256-bit unsigned big integer.
A base class defining functions for notifying about certain kernel events.
Maintains a tree of blocks (stored in m_block_index) which is consulted to determine where the most-w...
static const uint64_t MAX_TX_SIGCHECKS
Allowed number of signature check operations per transaction.
RecursiveMutex cs_main
Mutex to guard access to validation specific variables, such as reading or changing the chainstate.
static void LoadExternalBlockFile(benchmark::Bench &bench)
The LoadExternalBlockFile() function is used during -reindex and -loadblock.
Filesystem operations and types.
Bridge operations to C stdio.
FILE * fopen(const fs::path &p, const char *mode)
std::function< FILE *(const fs::path &, const char *)> FopenFn
bool LoadMempool(CTxMemPool &pool, const fs::path &load_path, Chainstate &active_chainstate, FopenFn mockable_fopen_function)
std::unordered_map< BlockHash, CBlockIndex, BlockHasher > BlockMap
Implement std::hash so RCUPtr can be used as a key for maps or sets.
std::vector< CTransactionRef > Package
A package is an ordered list of transactions.
std::shared_ptr< const CTransaction > CTransactionRef
@ PERIODIC
Called by RandAddPeriodic()
std::string ToString(const T &t)
Locale-independent version of std::to_string.
Holds configuration for use during UTXO snapshot load and validation.
A BlockHash is a unqiue identifier for a block.
Describes a place in the block chain to another node such that if the other node doesn't have the sam...
Holds various statistics on transactions within a chain.
User-controlled performance and debug options.
Parameters that influence chain consensus.
Application-specific storage settings.
Validation result for a transaction evaluated by MemPoolAccept (single or package).
const std::optional< int64_t > m_vsize
Virtual size as used by the mempool, calculated using serialized size and sigchecks.
MempoolAcceptResult(ResultType result_type, int64_t vsize, Amount fees, CFeeRate effective_feerate, const std::vector< TxId > &txids_fee_calculations)
Generic constructor for success cases.
const ResultType m_result_type
Result type.
const std::optional< std::vector< TxId > > m_txids_fee_calculations
Contains the txids of the transactions used for fee-related checks.
MempoolAcceptResult(TxValidationState state)
Constructor for failure case.
const TxValidationState m_state
Contains information about why the transaction failed.
MempoolAcceptResult(TxValidationState state, CFeeRate effective_feerate, const std::vector< TxId > &txids_fee_calculations)
Constructor for fee-related failure case.
ResultType
Used to indicate the results of mempool validation.
@ MEMPOOL_ENTRY
Valid, transaction was already in the mempool.
@ VALID
Fully validated, valid.
static MempoolAcceptResult Failure(TxValidationState state)
const std::optional< CFeeRate > m_effective_feerate
The feerate at which this transaction was considered.
static MempoolAcceptResult FeeFailure(TxValidationState state, CFeeRate effective_feerate, const std::vector< TxId > &txids_fee_calculations)
static MempoolAcceptResult Success(int64_t vsize, Amount fees, CFeeRate effective_feerate, const std::vector< TxId > &txids_fee_calculations)
Constructor for success case.
static MempoolAcceptResult MempoolTx(int64_t vsize, Amount fees)
Constructor for already-in-mempool case.
MempoolAcceptResult(int64_t vsize, Amount fees)
Constructor for already-in-mempool case.
const std::optional< Amount > m_base_fees
Raw base fees in satoshis.
std::chrono::time_point< NodeClock > time_point
Validation result for package mempool acceptance.
PackageMempoolAcceptResult(const TxId &txid, const MempoolAcceptResult &result)
Constructor to create a PackageMempoolAcceptResult from a MempoolAcceptResult.
PackageMempoolAcceptResult(PackageValidationState state, std::map< TxId, MempoolAcceptResult > &&results)
PackageValidationState m_state
std::map< TxId, MempoolAcceptResult > m_tx_results
Map from txid to finished MempoolAcceptResults.
Precompute sighash midstate to avoid quadratic hashing.
Struct for holding cumulative results from executing a script or a sequence of scripts.
A TxId is the identifier of a transaction.
An options struct for BlockManager, more ergonomically referred to as BlockManager::Options due to th...
An options struct for ChainstateManager, more ergonomically referred to as ChainstateManager::Options...
#define EXCLUSIVE_LOCKS_REQUIRED(...)
#define LOCKS_EXCLUDED(...)
std::chrono::time_point< std::chrono::steady_clock, std::chrono::milliseconds > SteadyMilliseconds
bool ContextualCheckTransactionForCurrentBlock(const CBlockIndex &active_chain_tip, const Consensus::Params ¶ms, const CTransaction &tx, TxValidationState &state)
void StartScriptCheckWorkerThreads(int threads_num)
Run instances of script checking worker threads.
GlobalMutex g_best_block_mutex
Amount GetBlockSubsidy(int nHeight, const Consensus::Params &consensusParams)
std::condition_variable g_best_block_cv
static constexpr int DEFAULT_CHECKLEVEL
PackageMempoolAcceptResult ProcessNewPackage(Chainstate &active_chainstate, CTxMemPool &pool, const Package &txns, bool test_accept) EXCLUSIVE_LOCKS_REQUIRED(cs_main)
Validate (and maybe submit) a package to the mempool.
arith_uint256 CalculateHeadersWork(const std::vector< CBlockHeader > &headers)
Return the sum of the work on a given set of headers.
double GuessVerificationProgress(const ChainTxData &data, const CBlockIndex *pindex)
Guess verification progress (as a fraction between 0.0=genesis and 1.0=current tip).
static const uint64_t MIN_DISK_SPACE_FOR_BLOCK_FILES
Require that user allocate at least 550 MiB for block & undo files (blk???.dat and rev?...
bool CheckSequenceLocksAtTip(CBlockIndex *tip, const LockPoints &lock_points)
Check if transaction will be BIP68 final in the next block to be created on top of tip.
bool CheckInputScripts(const CTransaction &tx, TxValidationState &state, const CCoinsViewCache &view, const uint32_t flags, bool sigCacheStore, bool scriptCacheStore, const PrecomputedTransactionData &txdata, int &nSigChecksOut, TxSigCheckLimiter &txLimitSigChecks, CheckInputsLimiter *pBlockLimitSigChecks, std::vector< CScriptCheck > *pvChecks) EXCLUSIVE_LOCKS_REQUIRED(cs_main)
Check whether all of this transaction's input scripts succeed.
static const unsigned int MIN_BLOCKS_TO_KEEP
Block files containing a block-height within MIN_BLOCKS_TO_KEEP of ActiveChain().Tip() will not be pr...
const CBlockIndex * g_best_block
Used to notify getblocktemplate RPC of new tips.
bool HasValidProofOfWork(const std::vector< CBlockHeader > &headers, const Consensus::Params &consensusParams)
Check with the proof of work on each blockheader matches the value in nBits.
bool DeploymentActiveAfter(const CBlockIndex *pindexPrev, const ChainstateManager &chainman, DEP dep)
Deployment* info via ChainstateManager.
@ BASE_BLOCKHASH_MISMATCH
static const int MAX_SCRIPTCHECK_THREADS
Maximum number of dedicated script-checking threads allowed.
const AssumeutxoData * ExpectedAssumeutxo(const int height, const CChainParams ¶ms)
Return the expected assumeutxo value for a given height, if one exists.
SynchronizationState
Current sync state passed to tip changed callbacks.
static const int DEFAULT_SCRIPTCHECK_THREADS
-par default (number of script-checking threads, 0 = auto)
bool AbortNode(BlockValidationState &state, const std::string &strMessage, const bilingual_str &userMessage=bilingual_str{})
MempoolAcceptResult AcceptToMemoryPool(Chainstate &active_chainstate, const CTransactionRef &tx, int64_t accept_time, bool bypass_limits, bool test_accept=false, unsigned int heightOverride=0) EXCLUSIVE_LOCKS_REQUIRED(cs_main)
Try to add a transaction to the mempool.
void StopScriptCheckWorkerThreads()
Stop all of the script checking worker threads.
void SpendCoins(CCoinsViewCache &view, const CTransaction &tx, CTxUndo &txundo, int nHeight)
Mark all the coins corresponding to a given transaction inputs as spent.
bool CheckBlock(const CBlock &block, BlockValidationState &state, const Consensus::Params ¶ms, BlockValidationOptions validationOptions)
Functions for validating blocks and updating the block tree.
const std::vector< std::string > CHECKLEVEL_DOC
Documentation for argument 'checklevel'.
bool ContextualCheckTransactionForCurrentBlock(const CBlockIndex &active_chain_tip, const Consensus::Params ¶ms, const CTransaction &tx, TxValidationState &state) EXCLUSIVE_LOCKS_REQUIRED(bool TestBlockValidity(BlockValidationState &state, const CChainParams ¶ms, Chainstate &chainstate, const CBlock &block, CBlockIndex *pindexPrev, const std::function< NodeClock::time_point()> &adjusted_time_callback, BlockValidationOptions validationOptions) EXCLUSIVE_LOCKS_REQUIRED(cs_main)
This is a variant of ContextualCheckTransaction which computes the contextual check for a transaction...
void PruneBlockFilesManual(Chainstate &active_chainstate, int nManualPruneHeight)
Prune block files up to a given height.
@ LARGE
The cache is at >= 90% capacity.
@ CRITICAL
The coins cache is in immediate need of a flush.
std::optional< LockPoints > CalculateLockPointsAtTip(CBlockIndex *tip, const CCoinsView &coins_view, const CTransaction &tx)
Calculate LockPoints required to check if transaction will be BIP68 final in the next block to be cre...
bool DeploymentActiveAt(const CBlockIndex &index, const ChainstateManager &chainman, DEP dep)
void UpdateCoins(CCoinsViewCache &view, const CTransaction &tx, CTxUndo &txundo, int nHeight)
Apply the effects of this transaction on the UTXO set represented by view.
static const signed int DEFAULT_CHECKBLOCKS
static const bool DEFAULT_PEERBLOOMFILTERS
static const int DEFAULT_STOPATHEIGHT
Default for -stopatheight.