6 #ifndef BITCOIN_VALIDATION_H
7 #define BITCOIN_VALIDATION_H
9 #if defined(HAVE_CONFIG_H)
57 class SnapshotMetadata;
163 const std::vector<uint256>& wtxids_fee_calculations) {
165 effective_feerate, wtxids_fee_calculations);
189 const std::vector<uint256>& wtxids_fee_calculations)
221 std::map<const uint256, const MempoolAcceptResult>&& results)
225 std::map<const uint256, const MempoolAcceptResult>&& results)
247 int64_t accept_time,
bool bypass_limits,
bool test_accept)
259 const Package& txns,
bool test_accept)
290 bool useExistingLockPoints =
false);
316 std::swap(
ptxTo, check.ptxTo);
317 std::swap(
m_tx_out, check.m_tx_out);
318 std::swap(
nIn, check.nIn);
319 std::swap(
nFlags, check.nFlags);
321 std::swap(
error, check.error);
322 std::swap(
txdata, check.txdata);
343 bool fCheckPOW =
true,
411 CoinsViews(
fs::path ldb_name,
size_t cache_size_bytes,
bool in_memory,
bool should_wipe);
450 int32_t nBlockReverseSequenceId = -1;
467 mutable std::atomic<bool> m_cached_finished_ibd{
false};
490 std::optional<uint256> from_snapshot_blockhash = std::nullopt);
499 size_t cache_size_bytes,
502 fs::path leveldb_name =
"chainstate");
513 return m_coins_views && m_coins_views->m_cacheview;
543 assert(m_coins_views->m_cacheview);
544 return *m_coins_views->m_cacheview.get();
551 return m_coins_views->m_dbview;
565 return m_coins_views->m_catcherview;
572 size_t m_coinsdb_cache_size_bytes{0};
575 size_t m_coinstip_cache_size_bytes{0};
579 bool ResizeCoinsCaches(
size_t coinstip_size,
size_t coinsdb_size)
611 std::multimap<uint256, FlatFilePos>* blocks_with_unknown_parent =
nullptr)
625 bool FlushStateToDisk(
628 int nManualPruneHeight = 0);
631 void ForceFlushStateToDisk();
635 void PruneAndFlush();
652 bool ActivateBestChain(
654 std::shared_ptr<const
CBlock> pblock =
nullptr)
692 bool LoadGenesisBlock();
694 void PruneBlockIndexCandidates();
699 bool IsInitialBlockDownload() const;
709 void CheckBlockIndex();
723 size_t max_coins_cache_size_bytes,
744 return m_mempool ? &m_mempool->
cs :
nullptr;
760 void MaybeUpdateMempoolForReorg(
768 std::chrono::microseconds m_last_write{0};
769 std::chrono::microseconds m_last_flush{0};
850 [[nodiscard]]
bool PopulateAndValidateSnapshot(
862 bool AcceptBlockHeader(
870 std::chrono::time_point<std::chrono::steady_clock> m_last_presync_update
GUARDED_BY(::
cs_main) {};
928 int64_t m_total_coinstip_cache{0};
932 int64_t m_total_coinsdb_cache{0};
956 [[nodiscard]]
bool ActivateSnapshot(
968 return m_blockman.m_block_index;
978 bool IsSnapshotActive()
const;
980 std::optional<uint256> SnapshotBlockhash()
const;
1009 bool ProcessNewBlock(
const std::shared_ptr<const CBlock>& block,
bool force_processing,
bool min_pow_checked,
bool* new_block)
LOCKS_EXCLUDED(
cs_main);
1041 void UpdateUncommittedBlockStructures(
CBlock& block, const
CBlockIndex* pindexPrev) const;
1044 std::vector<
unsigned char> GenerateCoinbaseCommitment(
CBlock& block, const
CBlockIndex* pindexPrev) const;
1050 void ReportHeadersPresync(const
arith_uint256& work, int64_t height, int64_t timestamp);
1067 template<typename DEP>
1070 return DeploymentActiveAfter(pindexPrev, chainman.GetConsensus(), dep, chainman.m_versionbitscache);
1073 template<
typename DEP>
1079 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,...
Access to the block database (blocks/index/)
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...
ScriptError GetScriptError() const
PrecomputedTransactionData * txdata
CScriptCheck(const CTxOut &outIn, const CTransaction &txToIn, unsigned int nInIn, unsigned int nFlagsIn, bool cacheIn, PrecomputedTransactionData *txdataIn)
void swap(CScriptCheck &check) noexcept
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.
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.
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 reliesOnAssumedValid()
Return true if this chainstate relies on blocks that are assumed-valid.
std::set< CBlockIndex *, node::CBlockIndexWorkComparator > setBlockIndexCandidates
The set of all CBlockIndex entries with either BLOCK_VALID_TRANSACTIONS (for itself and all ancestors...
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(
CCoinsViewErrorCatcher & CoinsErrorCatcher() EXCLUSIVE_LOCKS_REQUIRED(
node::BlockManager & m_blockman
Reference to a BlockManager instance which itself is shared across all Chainstate instances.
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...
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.
const CChainParams & GetParams() const
const arith_uint256 & MinimumChainWork() const
bool m_snapshot_validated GUARDED_BY(::cs_main)
If true, the assumed-valid chainstate has been fully validated by the background validation chainstat...
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.
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.
CBlockIndex *m_best_invalid GUARDED_BY(::cs_main)
const uint256 & AssumedValidBlock() const
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.
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...
CoinsViews(fs::path ldb_name, size_t cache_size_bytes, bool in_memory, bool should_wipe)
This constructor initializes CCoinsViewDB and CCoinsViewErrorCatcher instances, but it does not creat...
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.
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.
BIP 9 allows multiple softforks to be deployed in parallel.
256-bit unsigned big integer.
Path class wrapper to block calls to the fs::path(std::string) implicit constructor and the fs::path:...
Maintains a tree of blocks (stored in m_block_index) which is consulted to determine where the most-w...
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.
Transaction validation functions.
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< 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.
Parameters that influence chain consensus.
Validation result for a single transaction mempool acceptance.
const std::optional< int64_t > m_vsize
Virtual size as used by the mempool, calculated using serialized size and sigops.
static MempoolAcceptResult Success(std::list< CTransactionRef > &&replaced_txns, int64_t vsize, CAmount fees, CFeeRate effective_feerate, const std::vector< uint256 > &wtxids_fee_calculations)
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)
const std::optional< CFeeRate > m_effective_feerate
The feerate at which this transaction was considered.
const std::optional< uint256 > m_other_wtxid
The wtxid of the transaction in the mempool which has the same txid but different witness.
const std::optional< std::vector< uint256 > > m_wtxids_fee_calculations
Contains the wtxids of the transactions used for fee-related checks.
MempoolAcceptResult(std::list< CTransactionRef > &&replaced_txns, int64_t vsize, CAmount fees, CFeeRate effective_feerate, const std::vector< uint256 > &wtxids_fee_calculations)
Constructor for success case.
static MempoolAcceptResult MempoolTx(int64_t vsize, CAmount fees)
MempoolAcceptResult(const uint256 &other_wtxid)
Constructor for witness-swapped case.
std::chrono::time_point< NodeClock > time_point
Validation result for package mempool acceptance.
std::map< const uint256, const MempoolAcceptResult > m_tx_results
Map from wtxid to finished MempoolAcceptResults.
PackageMempoolAcceptResult(PackageValidationState state, std::map< const uint256, const MempoolAcceptResult > &&results)
PackageMempoolAcceptResult(PackageValidationState state, CFeeRate feerate, std::map< const uint256, const MempoolAcceptResult > &&results)
PackageMempoolAcceptResult(const uint256 &wtxid, const MempoolAcceptResult &result)
Constructor to create a PackageMempoolAcceptResult from a single MempoolAcceptResult.
const PackageValidationState m_state
An options struct for ChainstateManager, more ergonomically referred to as ChainstateManager::Options...
#define EXCLUSIVE_LOCKS_REQUIRED(...)
#define LOCKS_EXCLUDED(...)
bool CheckFinalTxAtTip(const CBlockIndex &active_chain_tip, const CTransaction &tx)
void StartScriptCheckWorkerThreads(int threads_num)
Run instances of script checking worker threads.
GlobalMutex g_best_block_mutex
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
CAmount GetBlockSubsidy(int nHeight, const Consensus::Params &consensusParams)
bool CheckFinalTxAtTip(const CBlockIndex &active_chain_tip, const CTransaction &tx) EXCLUSIVE_LOCKS_REQUIRED(bool CheckSequenceLocksAtTip(CBlockIndex *tip, const CCoinsView &coins_view, const CTransaction &tx, LockPoints *lp=nullptr, bool useExistingLockPoints=false)
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.
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.
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.
bool DeploymentEnabled(const ChainstateManager &chainman, DEP dep)
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{})
bool IsBIP30Unspendable(const CBlockIndex &block_index)
Identifies blocks which coinbase output was subsequently overwritten in the UTXO set (see BIP30)
void StopScriptCheckWorkerThreads()
Stop all of the script checking worker threads.
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 DeploymentActiveAt(const CBlockIndex &index, const ChainstateManager &chainman, DEP dep)
bool IsBIP30Repeat(const CBlockIndex &block_index)
Identifies blocks that overwrote an existing coinbase output in the UTXO set (see BIP30)
bool TestBlockValidity(BlockValidationState &state, const CChainParams &chainparams, Chainstate &chainstate, const CBlock &block, CBlockIndex *pindexPrev, const std::function< NodeClock::time_point()> &adjusted_time_callback, 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 signed int DEFAULT_CHECKBLOCKS
uint256 g_best_block
Used to notify getblocktemplate RPC of new tips.
static const int DEFAULT_STOPATHEIGHT
Default for -stopatheight.