7 #ifndef BITCOIN_VALIDATION_H
8 #define BITCOIN_VALIDATION_H
10 #if defined(HAVE_CONFIG_H)
11 #include <config/bitcoin-config.h>
66 class SnapshotMetadata;
76 #define MIN_TRANSACTION_SIZE \
77 (::GetSerializeSize(CTransaction(), PROTOCOL_VERSION))
157 bool _checkPow =
true,
158 bool _checkMerkleRoot =
true)
204 int nManualPruneHeight);
281 std::map<const TxId, const MempoolAcceptResult> &&results)
319 bool bypass_limits,
bool test_accept =
false,
320 unsigned int heightOverride = 0)
351 auto newvalue = (remaining -= consumed);
352 return newvalue >= 0;
355 bool check() {
return remaining >= 0; }
413 bool sigCacheStore,
bool scriptCacheStore,
417 std::vector<CScriptCheck> *pvChecks)
426 bool sigCacheStore,
bool scriptCacheStore,
431 scriptCacheStore, txdata, nSigChecksOut,
432 nSigChecksTxLimiter,
nullptr,
nullptr);
467 bool useExistingLockPoints =
false);
496 unsigned int nInIn, uint32_t nFlagsIn,
bool cacheIn,
508 std::swap(
ptxTo, check.ptxTo);
509 std::swap(
m_tx_out, check.m_tx_out);
510 std::swap(
nIn, check.nIn);
511 std::swap(
nFlags, check.nFlags);
513 std::swap(
error, check.error);
514 std::swap(
metrics, check.metrics);
515 std::swap(
txdata, check.txdata);
587 CCoinsView &coinsview,
int nCheckLevel,
int nCheckDepth)
625 CoinsViews(std::string ldb_name,
size_t cache_size_bytes,
bool in_memory,
667 std::atomic<int32_t> nBlockSequenceId{1};
669 int32_t nBlockReverseSequenceId = -1;
679 mutable std::atomic<bool> m_cached_finished_ibd{
false};
737 std::optional<BlockHash> from_snapshot_blockhash = std::nullopt);
745 void InitCoinsDB(
size_t cache_size_bytes,
bool in_memory,
bool should_wipe,
746 std::string leveldb_name =
"chainstate");
750 void InitCoinsCache(
size_t cache_size_bytes)
758 return m_coins_views && m_coins_views->m_cacheview;
771 const std::optional<BlockHash> m_from_snapshot_blockhash{};
776 return m_from_snapshot_blockhash.has_value();
792 return *
Assert(m_coins_views->m_cacheview);
798 return Assert(m_coins_views)->m_dbview;
809 return Assert(m_coins_views)->m_catcherview;
819 size_t m_coinsdb_cache_size_bytes{0};
822 size_t m_coinstip_cache_size_bytes{0};
826 bool ResizeCoinsCaches(
size_t coinstip_size,
size_t coinsdb_size)
860 void LoadExternalBlockFile(
862 std::multimap<BlockHash, FlatFilePos> *blocks_with_unknown_parent =
864 !cs_avalancheFinalizedBlockIndex);
878 int nManualPruneHeight = 0);
881 void ForceFlushStateToDisk();
885 void PruneAndFlush();
909 std::shared_ptr<const
CBlock> pblock =
nullptr)
911 !cs_avalancheFinalizedBlockIndex)
914 bool AcceptBlock(const
Config &config,
915 const
std::shared_ptr<const
CBlock> &pblock,
928 Amount *blockFees =
nullptr,
bool fJustCheck = false)
945 !cs_avalancheFinalizedBlockIndex)
951 !cs_avalancheFinalizedBlockIndex);
956 !cs_avalancheFinalizedBlockIndex);
967 void ClearAvalancheFinalizedBlock()
973 bool IsBlockAvalancheFinalized(const
CBlockIndex *pindex) const
979 template <typename F>
982 template <typename F, typename C, typename AC>
984 C fChild, AC fAncestorWasChanged)
1001 bool LoadGenesisBlock();
1003 void PruneBlockIndexCandidates();
1011 bool IsInitialBlockDownload() const;
1023 void CheckBlockIndex();
1041 GetCoinsCacheSizeState(
size_t max_coins_cache_size_bytes,
1042 size_t max_mempool_size_bytes)
1050 return m_mempool ? &m_mempool->
cs :
nullptr;
1054 bool ActivateBestChainStep(
const Config &config,
1057 const std::shared_ptr<const CBlock> &pblock,
1060 !cs_avalancheFinalizedBlockIndex);
1064 const std::shared_ptr<const CBlock> &pblock,
1068 !cs_avalancheFinalizedBlockIndex);
1073 FindMostWorkChain(
std::vector<const
CBlockIndex *> &blocksToReconcile)
1082 void UnparkBlockImpl(
CBlockIndex *pindex,
bool fClearChildren)
1088 !cs_avalancheFinalizedBlockIndex);
1091 void CheckForkWarningConditionsOnNewFork(
CBlockIndex *pindexNewForkTip)
1105 std::chrono::microseconds m_last_write{0};
1106 std::chrono::microseconds m_last_flush{0};
1211 PopulateAndValidateSnapshot(
Chainstate &snapshot_chainstate,
1224 bool min_pow_checked)
1234 std::optional<
int> GetSnapshotBaseHeight() const
1242 bool IsUsable(const
Chainstate *const pchainstate) const
1244 return pchainstate && !pchainstate->m_disabled;
1254 : m_options{
std::move(options)} {
1255 Assert(m_options.adjusted_time_callback);
1259 return m_options.config.GetChainParams();
1262 return m_options.config.GetChainParams().GetConsensus();
1315 int64_t m_total_coinstip_cache{0};
1319 int64_t m_total_coinsdb_cache{0};
1344 [[nodiscard]]
bool ActivateSnapshot(
AutoFile &coins_file,
1363 return ActiveChainstate().m_chain;
1366 return ActiveChain().Height();
1369 return ActiveChain().Tip();
1374 return m_blockman.m_block_index;
1379 bool IsSnapshotActive()
const;
1381 std::optional<BlockHash> SnapshotBlockhash()
const;
1385 return m_snapshot_chainstate && m_ibd_chainstate &&
1386 m_ibd_chainstate->m_disabled;
1417 bool ProcessNewBlock(
const Config &config,
1418 const std::shared_ptr<const CBlock> &block,
1419 bool force_processing,
bool min_pow_checked,
1438 bool ProcessNewBlockHeaders(
const Config &config,
1439 const std::vector<CBlockHeader> &block,
1440 bool min_pow_checked,
1454 ProcessTransaction(const
CTransactionRef &tx,
bool test_accept = false)
1471 void ReportHeadersPresync(const
arith_uint256 &work, int64_t height,
1476 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.
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.
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(const Config &config, 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
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{})
static const char *const DEFAULT_BLOCKFILTERINDEX
void StopScriptCheckWorkerThreads()
Stop all of the script checking worker threads.
MempoolAcceptResult AcceptToMemoryPool(const Config &config, 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.
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...
static constexpr bool DEFAULT_COINSTATSINDEX
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'.
PackageMempoolAcceptResult ProcessNewPackage(const Config &config, 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.
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.
RecursiveMutex cs_main
Global state.
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.
static const bool DEFAULT_TXINDEX