7 #ifndef BITCOIN_VALIDATION_H
8 #define BITCOIN_VALIDATION_H
10 #if defined(HAVE_CONFIG_H)
11 #include <config/bitcoin-config.h>
67 class SnapshotMetadata;
77 #define MIN_TRANSACTION_SIZE \
78 (::GetSerializeSize(CTransaction(), PROTOCOL_VERSION))
153 bool _checkPow =
true,
154 bool _checkMerkleRoot =
true)
200 int nManualPruneHeight);
277 std::map<const TxId, const MempoolAcceptResult> &&results)
313 int64_t accept_time,
bool bypass_limits,
314 bool test_accept =
false,
unsigned int heightOverride = 0)
330 const
Package &txns,
bool test_accept)
345 auto newvalue = (remaining -= consumed);
346 return newvalue >= 0;
349 bool check() {
return remaining >= 0; }
407 bool sigCacheStore,
bool scriptCacheStore,
411 std::vector<CScriptCheck> *pvChecks)
420 bool sigCacheStore,
bool scriptCacheStore,
425 scriptCacheStore, txdata, nSigChecksOut,
426 nSigChecksTxLimiter,
nullptr,
nullptr);
461 bool useExistingLockPoints =
false);
490 unsigned int nInIn, uint32_t nFlagsIn,
bool cacheIn,
502 std::swap(
ptxTo, check.ptxTo);
503 std::swap(
m_tx_out, check.m_tx_out);
504 std::swap(
nIn, check.nIn);
505 std::swap(
nFlags, check.nFlags);
507 std::swap(
error, check.error);
508 std::swap(
metrics, check.metrics);
509 std::swap(
txdata, check.txdata);
581 CCoinsView &coinsview,
int nCheckLevel,
int nCheckDepth)
619 CoinsViews(std::string ldb_name,
size_t cache_size_bytes,
bool in_memory,
661 std::atomic<int32_t> nBlockSequenceId{1};
663 int32_t nBlockReverseSequenceId = -1;
673 mutable std::atomic<bool> m_cached_finished_ibd{
false};
731 std::optional<BlockHash> from_snapshot_blockhash = std::nullopt);
739 void InitCoinsDB(
size_t cache_size_bytes,
bool in_memory,
bool should_wipe,
740 std::string leveldb_name =
"chainstate");
744 void InitCoinsCache(
size_t cache_size_bytes)
752 return m_coins_views && m_coins_views->m_cacheview;
765 const std::optional<BlockHash> m_from_snapshot_blockhash{};
770 return m_from_snapshot_blockhash.has_value();
786 return *
Assert(m_coins_views->m_cacheview);
792 return Assert(m_coins_views)->m_dbview;
803 return Assert(m_coins_views)->m_catcherview;
813 size_t m_coinsdb_cache_size_bytes{0};
816 size_t m_coinstip_cache_size_bytes{0};
820 bool ResizeCoinsCaches(
size_t coinstip_size,
size_t coinsdb_size)
854 void LoadExternalBlockFile(
856 std::multimap<BlockHash, FlatFilePos> *blocks_with_unknown_parent =
858 !cs_avalancheFinalizedBlockIndex);
872 int nManualPruneHeight = 0);
875 void ForceFlushStateToDisk();
879 void PruneAndFlush();
903 std::shared_ptr<const
CBlock> pblock =
nullptr)
905 !cs_avalancheFinalizedBlockIndex)
908 bool AcceptBlock(const
Config &config,
909 const
std::shared_ptr<const
CBlock> &pblock,
922 Amount *blockFees =
nullptr,
bool fJustCheck = false)
938 !cs_avalancheFinalizedBlockIndex)
944 !cs_avalancheFinalizedBlockIndex);
949 !cs_avalancheFinalizedBlockIndex);
960 void ClearAvalancheFinalizedBlock()
966 bool IsBlockAvalancheFinalized(const
CBlockIndex *pindex) const
972 template <typename F>
975 template <typename F, typename C, typename AC>
977 C fChild, AC fAncestorWasChanged)
994 bool LoadGenesisBlock();
996 void PruneBlockIndexCandidates();
1004 bool IsInitialBlockDownload() const;
1016 void CheckBlockIndex();
1034 GetCoinsCacheSizeState(
size_t max_coins_cache_size_bytes,
1035 size_t max_mempool_size_bytes)
1043 return m_mempool ? &m_mempool->
cs :
nullptr;
1049 const std::shared_ptr<const CBlock> &pblock,
1052 !cs_avalancheFinalizedBlockIndex);
1056 const std::shared_ptr<const CBlock> &pblock,
1060 !cs_avalancheFinalizedBlockIndex);
1065 FindMostWorkChain(
std::vector<const
CBlockIndex *> &blocksToReconcile)
1074 void UnparkBlockImpl(
CBlockIndex *pindex,
bool fClearChildren)
1080 !cs_avalancheFinalizedBlockIndex);
1083 void CheckForkWarningConditionsOnNewFork(
CBlockIndex *pindexNewForkTip)
1097 std::chrono::microseconds m_last_write{0};
1098 std::chrono::microseconds m_last_flush{0};
1203 PopulateAndValidateSnapshot(
Chainstate &snapshot_chainstate,
1216 bool min_pow_checked)
1226 std::optional<
int> GetSnapshotBaseHeight() const
1234 bool IsUsable(const
Chainstate *const pchainstate) const
1236 return pchainstate && !pchainstate->m_disabled;
1246 : m_options{
std::move(options)} {
1247 Assert(m_options.adjusted_time_callback);
1253 return m_options.config.GetChainParams();
1256 return m_options.config.GetChainParams().GetConsensus();
1309 int64_t m_total_coinstip_cache{0};
1313 int64_t m_total_coinsdb_cache{0};
1338 [[nodiscard]]
bool ActivateSnapshot(
AutoFile &coins_file,
1357 return ActiveChainstate().m_chain;
1360 return ActiveChain().Height();
1363 return ActiveChain().Tip();
1368 return m_blockman.m_block_index;
1373 bool IsSnapshotActive()
const;
1375 std::optional<BlockHash> SnapshotBlockhash()
const;
1379 return m_snapshot_chainstate && m_ibd_chainstate &&
1380 m_ibd_chainstate->m_disabled;
1411 bool ProcessNewBlock(
const Config &config,
1412 const std::shared_ptr<const CBlock> &block,
1413 bool force_processing,
bool min_pow_checked,
1432 bool ProcessNewBlockHeaders(
const Config &config,
1433 const std::vector<CBlockHeader> &block,
1434 bool min_pow_checked,
1448 ProcessTransaction(const
CTransactionRef &tx,
bool test_accept = false)
1465 void ReportHeadersPresync(const
arith_uint256 &work, int64_t height,
1470 bool DetectSnapshotChainstate(
CTxMemPool *mempool)
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.
RollingBloomFilter is a probabilistic "keep track of most recently inserted" set.
Closure representing one script verification.
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
TxSigCheckLimiter * pTxLimitSigChecks
ScriptExecutionMetrics metrics
void swap(CScriptCheck &check) noexcept
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, const Config &config, CCoinsView &coinsview, int nCheckLevel, int nCheckDepth) EXCLUSIVE_LOCKS_REQUIRED(cs_main)
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
ChainstateManager(Options options)
SteadyMilliseconds m_last_presync_update GUARDED_BY(::cs_main)
Most recent headers presync progress update, for rate-limiting.
const Config & GetConfig() 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.
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(std::string 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...
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.
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.
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.
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 sigchecks.
const ResultType m_result_type
static MempoolAcceptResult Success(int64_t vsize, Amount fees)
Constructor for success case.
MempoolAcceptResult(ResultType result_type, int64_t vsize, Amount fees)
Generic constructor for success cases.
MempoolAcceptResult(TxValidationState state)
Constructor for failure case.
const TxValidationState m_state
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)
static MempoolAcceptResult MempoolTx(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.
std::map< const TxId, const MempoolAcceptResult > m_tx_results
Map from txid to finished MempoolAcceptResults.
PackageMempoolAcceptResult(PackageValidationState state, std::map< const TxId, const MempoolAcceptResult > &&results)
const PackageValidationState m_state
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 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.
arith_uint256 nMinimumChainWork
Minimum work we will assume exists on some valid chain.
static const bool DEFAULT_CHECKPOINTS_ENABLED
GlobalMutex g_best_block_mutex
Amount GetBlockSubsidy(int nHeight, const Consensus::Params &consensusParams)
std::condition_variable g_best_block_cv
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 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 DEFAULT_CHECKLEVEL
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...
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.
@ 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.
bool ContextualCheckTransactionForCurrentBlock(const CBlockIndex *active_chain_tip, const Consensus::Params ¶ms, const CTransaction &tx, TxValidationState &state) EXCLUSIVE_LOCKS_REQUIRED(boo 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 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 CheckSequenceLocksAtTip(CBlockIndex *tip, const CCoinsView &coins_view, const CTransaction &tx, LockPoints *lp=nullptr, bool useExistingLockPoints=false)
Check if transaction will be BIP68 final in the next block to be created on top of tip.
BlockHash hashAssumeValid
Block hash whose ancestors we will assume to have valid scripts without checking them.
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.
static const int64_t DEFAULT_MAX_TIP_AGE
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
uint256 g_best_block
Used to notify getblocktemplate RPC of new tips.
static const bool DEFAULT_PEERBLOOMFILTERS
static const int DEFAULT_STOPATHEIGHT
Default for -stopatheight.
int64_t nMaxTipAge
If the tip is older than this (in seconds), the node is considered to be in initial block download.