6 #ifndef BITCOIN_VALIDATION_H
7 #define BITCOIN_VALIDATION_H
43 #include <type_traits>
56 class SnapshotMetadata;
62 class SignalInterrupt;
169 const std::vector<Wtxid>& wtxids_fee_calculations) {
177 const std::vector<Wtxid>& wtxids_fee_calculations) {
179 effective_feerate, wtxids_fee_calculations);
203 const std::vector<Wtxid>& wtxids_fee_calculations)
214 const std::vector<Wtxid>& wtxids_fee_calculations)
244 std::map<uint256, MempoolAcceptResult>&& results)
248 std::map<uint256, MempoolAcceptResult>&& results)
271 int64_t accept_time,
bool bypass_limits,
bool test_accept)
285 const Package& txns,
bool test_accept,
const std::optional<CFeeRate>& client_maxfeerate)
360 static_assert(std::is_nothrow_move_assignable_v<CScriptCheck>);
361 static_assert(std::is_nothrow_move_constructible_v<CScriptCheck>);
362 static_assert(std::is_nothrow_destructible_v<CScriptCheck>);
378 bool fCheckPOW =
true,
537 std::optional<uint256> from_snapshot_blockhash = std::nullopt);
552 size_t cache_size_bytes,
555 fs::path leveldb_name = "chainstate");
566 return m_coins_views && m_coins_views->m_cacheview;
601 return *
Assert(m_coins_views->m_cacheview);
608 return Assert(m_coins_views)->m_dbview;
622 return Assert(m_coins_views)->m_catcherview;
632 size_t m_coinsdb_cache_size_bytes{0};
635 size_t m_coinstip_cache_size_bytes{0};
639 bool ResizeCoinsCaches(
size_t coinstip_size,
size_t coinsdb_size)
653 bool FlushStateToDisk(
656 int nManualPruneHeight = 0);
659 void ForceFlushStateToDisk();
663 void PruneAndFlush();
686 bool ActivateBestChain(
688 std::shared_ptr<const CBlock> pblock =
nullptr)
724 bool LoadGenesisBlock();
728 void PruneBlockIndexCandidates();
744 size_t max_coins_cache_size_bytes,
752 return m_mempool ? &m_mempool->
cs :
nullptr;
780 void MaybeUpdateMempoolForReorg(
789 SteadyClock::time_point m_last_flush{};
889 [[nodiscard]]
bool PopulateAndValidateSnapshot(
901 bool AcceptBlockHeader(
909 std::chrono::time_point<std::chrono::steady_clock> m_last_presync_update
GUARDED_BY(::
cs_main) {};
919 return cs && !
cs->m_disabled;
932 std::function<void()> restart_indexes = std::function<void()>();
946 void CheckBlockIndex();
975 mutable std::atomic<bool> m_cached_finished_ibd{
false};
984 int32_t nBlockReverseSequenceId = -1;
993 nBlockSequenceId = 1;
994 nBlockReverseSequenceId = -1;
1024 int64_t m_total_coinstip_cache{0};
1028 int64_t m_total_coinsdb_cache{0};
1052 [[nodiscard]]
bool ActivateSnapshot(
1075 return IsUsable(m_snapshot_chainstate.get()) && IsUsable(m_ibd_chainstate.get());
1080 return BackgroundSyncInProgress() ? m_ibd_chainstate->m_chain.Tip() :
nullptr;
1086 return m_blockman.m_block_index;
1096 bool IsSnapshotActive()
const;
1098 std::optional<uint256> SnapshotBlockhash()
const;
1103 return m_snapshot_chainstate && m_ibd_chainstate && m_ibd_chainstate->m_disabled;
1107 bool IsInitialBlockDownload()
const;
1138 std::multimap<uint256, FlatFilePos>* blocks_with_unknown_parent =
nullptr);
1164 bool ProcessNewBlock(
const std::shared_ptr<const CBlock>& block,
bool force_processing,
bool min_pow_checked,
bool* new_block)
LOCKS_EXCLUDED(
cs_main);
1219 void UpdateUncommittedBlockStructures(
CBlock& block, const
CBlockIndex* pindexPrev) const;
1222 std::vector<
unsigned char> GenerateCoinbaseCommitment(
CBlock& block, const
CBlockIndex* pindexPrev) const;
1228 void ReportHeadersPresync(const
arith_uint256& work, int64_t height, int64_t timestamp);
1268 std::pair<
int,
int> GetPruneRange(
1281 template<
typename DEP>
1287 template<
typename DEP>
1293 template<
typename DEP>
int64_t CAmount
Amount in satoshis (Can be negative)
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*.
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 kilovirtualbyte: CAmount / kvB.
Closure representing one script verification Note that this stores references to the spending transac...
CScriptCheck & operator=(CScriptCheck &&)=default
ScriptError GetScriptError() const
CScriptCheck(const CScriptCheck &)=delete
PrecomputedTransactionData * txdata
CScriptCheck(const CTxOut &outIn, const CTransaction &txToIn, unsigned int nInIn, unsigned int nFlagsIn, bool cacheIn, PrecomputedTransactionData *txdataIn)
CScriptCheck(CScriptCheck &&)=default
CScriptCheck & operator=(const CScriptCheck &)=delete
const CTransaction * ptxTo
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.
RAII wrapper for VerifyDB: Verify consistency of the block and coin databases.
VerifyDBResult VerifyDB(Chainstate &chainstate, const Consensus::Params &consensus_params, CCoinsView &coinsview, int nCheckLevel, int nCheckDepth) EXCLUSIVE_LOCKS_REQUIRED(cs_main)
kernel::Notifications & m_notifications
CVerifyDB(kernel::Notifications ¬ifications)
Chainstate stores and provides an API to update our local knowledge of the current best chain.
CTxMemPool * GetMempool()
Mutex m_chainstate_mutex
The ChainState Mutex A lock that must be held when modifying this ChainState - held in ActivateBestCh...
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(
const std::optional< uint256 > m_from_snapshot_blockhash
The blockhash which is the base of the snapshot this chainstate was created from.
CTxMemPool * m_mempool
Optional mempool that is kept in sync with the chain.
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.
const CBlockIndex *m_cached_snapshot_base GUARDED_BY(::cs_main)
Cached result of LookupBlockIndex(*m_from_snapshot_blockhash)
void ResetCoinsViews()
Destructs all objects related to accessing the UTXO set.
CCoinsViewErrorCatcher & CoinsErrorCatcher() EXCLUSIVE_LOCKS_REQUIRED(
node::BlockManager & m_blockman
Reference to a BlockManager instance which itself is shared across all Chainstate instances.
Provides an interface for creating and interacting with one or two chainstates: an IBD chainstate gen...
std::array< ThresholdConditionCache, VERSIONBITS_NUM_BITS > m_warningcache GUARDED_BY(::cs_main)
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.
const CChainParams & GetParams() const
const arith_uint256 & MinimumChainWork() const
std::thread m_thread_load
bool ShouldCheckBlockIndex() 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.
CCheckQueue< CScriptCheck > m_script_check_queue
A queue for script verifications that have to be performed by worker threads.
bool BackgroundSyncInProgress() const EXCLUSIVE_LOCKS_REQUIRED(GetMutex())
The state of a background sync (for net processing)
const util::SignalInterrupt & m_interrupt
int ActiveHeight() const EXCLUSIVE_LOCKS_REQUIRED(GetMutex())
VersionBitsCache m_versionbitscache
Track versionbit status.
CBlockIndex * ActiveTip() const EXCLUSIVE_LOCKS_REQUIRED(GetMutex())
std::chrono::time_point< std::chrono::steady_clock > m_last_presync_update GUARDED_BY(::cs_main)
Most recent headers presync progress update, for rate-limiting.
const CBlockIndex * GetBackgroundSyncTip() const EXCLUSIVE_LOCKS_REQUIRED(GetMutex())
The tip of the background sync chain.
CBlockIndex *m_best_invalid GUARDED_BY(::cs_main)
int32_t nBlockSequenceId GUARDED_BY(::cs_main)
Every received block is assigned a unique and increasing identifier, so we know which one to give pri...
const uint256 & AssumedValidBlock() const
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
bool IsUsable(const Chainstate *const cs) const EXCLUSIVE_LOCKS_REQUIRED(
Return true if a chainstate is considered usable.
void ResetBlockSequenceCounters() EXCLUSIVE_LOCKS_REQUIRED(
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...
DisconnectedBlockTransactions.
Different type to mark Mutex at global scope.
BIP 9 allows multiple softforks to be deployed in parallel.
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...
Helper class that manages an interrupt flag, and allows a thread or signal to interrupt another threa...
RecursiveMutex cs_main
Mutex to guard access to validation specific variables, such as reading or changing the chainstate.
ChainstateRole
This enum describes the various roles a specific Chainstate instance can take.
static void LoadExternalBlockFile(benchmark::Bench &bench)
The LoadExternalBlockFile() function is used during -reindex and -loadblock.
Transaction validation functions.
Filesystem operations and types.
std::unordered_map< uint256, CBlockIndex, BlockHasher > BlockMap
std::vector< CTransactionRef > Package
A package is an ordered list of transactions.
std::shared_ptr< const CTransaction > CTransactionRef
@ PERIODIC
Called by RandAddPeriodic()
enum ScriptError_t ScriptError
@ SCRIPT_ERR_UNKNOWN_ERROR
std::string ToString(const T &t)
Locale-independent version of std::to_string.
Holds configuration for use during UTXO snapshot load and validation.
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 sigops.
const ResultType m_result_type
Result type.
MempoolAcceptResult(int64_t vsize, CAmount fees)
Constructor for already-in-mempool case.
const std::optional< CAmount > m_base_fees
Raw base fees in satoshis.
const std::optional< std::list< CTransactionRef > > m_replaced_transactions
Mempool transactions replaced by the tx.
MempoolAcceptResult(TxValidationState state)
Constructor for failure case.
const TxValidationState m_state
Contains information about why the transaction failed.
static MempoolAcceptResult MempoolTxDifferentWitness(const uint256 &other_wtxid)
ResultType
Used to indicate the results of mempool validation.
@ DIFFERENT_WITNESS
Valid, transaction was already in the mempool.
@ INVALID
Fully validated, valid.
static MempoolAcceptResult Failure(TxValidationState state)
static MempoolAcceptResult FeeFailure(TxValidationState state, CFeeRate effective_feerate, const std::vector< Wtxid > &wtxids_fee_calculations)
const std::optional< CFeeRate > m_effective_feerate
The feerate at which this transaction was considered.
MempoolAcceptResult(std::list< CTransactionRef > &&replaced_txns, int64_t vsize, CAmount fees, CFeeRate effective_feerate, const std::vector< Wtxid > &wtxids_fee_calculations)
Constructor for success case.
const std::optional< uint256 > m_other_wtxid
The wtxid of the transaction in the mempool which has the same txid but different witness.
static MempoolAcceptResult MempoolTx(int64_t vsize, CAmount fees)
static MempoolAcceptResult Success(std::list< CTransactionRef > &&replaced_txns, int64_t vsize, CAmount fees, CFeeRate effective_feerate, const std::vector< Wtxid > &wtxids_fee_calculations)
MempoolAcceptResult(TxValidationState state, CFeeRate effective_feerate, const std::vector< Wtxid > &wtxids_fee_calculations)
Constructor for fee-related failure case.
const std::optional< std::vector< Wtxid > > m_wtxids_fee_calculations
Contains the wtxids of the transactions used for fee-related checks.
MempoolAcceptResult(const uint256 &other_wtxid)
Constructor for witness-swapped case.
Validation result for package mempool acceptance.
PackageValidationState m_state
PackageMempoolAcceptResult(PackageValidationState state, std::map< uint256, MempoolAcceptResult > &&results)
PackageMempoolAcceptResult(const uint256 &wtxid, const MempoolAcceptResult &result)
Constructor to create a PackageMempoolAcceptResult from a single MempoolAcceptResult.
std::map< uint256, MempoolAcceptResult > m_tx_results
Map from wtxid to finished MempoolAcceptResults.
PackageMempoolAcceptResult(PackageValidationState state, CFeeRate feerate, std::map< uint256, MempoolAcceptResult > &&results)
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::steady_clock SteadyClock
bool CheckFinalTxAtTip(const CBlockIndex &active_chain_tip, const CTransaction &tx)
bool IsBlockMutated(const CBlock &block, bool check_witness_root)
Check if a block has been mutated (with respect to its merkle root and witness commitments).
GlobalMutex g_best_block_mutex
std::condition_variable g_best_block_cv
static constexpr int DEFAULT_CHECKLEVEL
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
CAmount GetBlockSubsidy(int nHeight, const Consensus::Params &consensusParams)
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 CheckFinalTxAtTip(const CBlockIndex &active_chain_tip, const CTransaction &tx) EXCLUSIVE_LOCKS_REQUIRED(std::optional< LockPoints > CalculateLockPointsAtTip(CBlockIndex *tip, const CCoinsView &coins_view, const CTransaction &tx)
Check if transaction will be final in the next block to be created.
bool InitScriptExecutionCache(size_t max_size_bytes)
Initializes the script-execution cache.
bool FatalError(kernel::Notifications ¬ifications, BlockValidationState &state, const bilingual_str &message)
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...
MempoolAcceptResult AcceptToMemoryPool(Chainstate &active_chainstate, const CTransactionRef &tx, int64_t accept_time, bool bypass_limits, bool test_accept) EXCLUSIVE_LOCKS_REQUIRED(cs_main)
Try to add a transaction to the mempool.
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
bool DeploymentEnabled(const ChainstateManager &chainman, DEP dep)
SynchronizationState
Current sync state passed to tip changed callbacks.
PackageMempoolAcceptResult ProcessNewPackage(Chainstate &active_chainstate, CTxMemPool &pool, const Package &txns, bool test_accept, const std::optional< CFeeRate > &client_maxfeerate) EXCLUSIVE_LOCKS_REQUIRED(cs_main)
Validate (and maybe submit) a package to the mempool.
bool IsBIP30Unspendable(const CBlockIndex &block_index)
Identifies blocks which coinbase output was subsequently overwritten in the UTXO set (see BIP30)
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.
const std::vector< std::string > CHECKLEVEL_DOC
Documentation for argument 'checklevel'.
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.
bool TestBlockValidity(BlockValidationState &state, const CChainParams &chainparams, Chainstate &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)
bool DeploymentActiveAt(const CBlockIndex &index, const ChainstateManager &chainman, DEP dep)
arith_uint256 CalculateClaimedHeadersWork(const std::vector< CBlockHeader > &headers)
Return the sum of the claimed work on a given set of headers.
bool IsBIP30Repeat(const CBlockIndex &block_index)
Identifies blocks that overwrote an existing coinbase output in the UTXO set (see BIP30)
static const signed int DEFAULT_CHECKBLOCKS
uint256 g_best_block
Used to notify getblocktemplate RPC of new tips.