Bitcoin Core 29.99.0
P2P Digital Currency
validation.h
Go to the documentation of this file.
1// Copyright (c) 2009-2010 Satoshi Nakamoto
2// Copyright (c) 2009-present The Bitcoin Core developers
3// Distributed under the MIT software license, see the accompanying
4// file COPYING or http://www.opensource.org/licenses/mit-license.php.
5
6#ifndef BITCOIN_VALIDATION_H
7#define BITCOIN_VALIDATION_H
8
9#include <arith_uint256.h>
10#include <attributes.h>
11#include <chain.h>
12#include <checkqueue.h>
13#include <consensus/amount.h>
14#include <cuckoocache.h>
15#include <deploymentstatus.h>
16#include <kernel/chain.h>
17#include <kernel/chainparams.h>
19#include <kernel/cs_main.h> // IWYU pragma: export
20#include <node/blockstorage.h>
21#include <policy/feerate.h>
22#include <policy/packages.h>
23#include <policy/policy.h>
24#include <script/script_error.h>
25#include <script/sigcache.h>
26#include <sync.h>
27#include <txdb.h>
28#include <txmempool.h>
29#include <uint256.h>
30#include <util/byte_units.h>
31#include <util/check.h>
32#include <util/fs.h>
33#include <util/hasher.h>
34#include <util/result.h>
35#include <util/time.h>
36#include <util/translation.h>
37#include <versionbits.h>
38
39#include <algorithm>
40#include <atomic>
41#include <cstdint>
42#include <map>
43#include <memory>
44#include <optional>
45#include <set>
46#include <span>
47#include <string>
48#include <type_traits>
49#include <utility>
50#include <vector>
51
52class Chainstate;
53class CTxMemPool;
55struct ChainTxData;
58struct LockPoints;
59struct AssumeutxoData;
60namespace node {
61class SnapshotMetadata;
62} // namespace node
63namespace Consensus {
64struct Params;
65} // namespace Consensus
66namespace util {
67class SignalInterrupt;
68} // namespace util
69
71static const unsigned int MIN_BLOCKS_TO_KEEP = 288;
72static const signed int DEFAULT_CHECKBLOCKS = 6;
73static constexpr int DEFAULT_CHECKLEVEL{3};
74// Require that user allocate at least 550 MiB for block & undo files (blk???.dat and rev???.dat)
75// At 1MB per block, 288 blocks = 288MB.
76// Add 15% for Undo data = 331MB
77// Add 20% for Orphan block rate = 397MB
78// We want the low water mark after pruning to be at least 397 MB and since we prune in
79// full block file chunks, we need the high water mark which triggers the prune to be
80// one 128MB block file + added 15% undo data = 147MB greater for a total of 545MB
81// Setting the target to >= 550 MiB will make it likely we can respect the target.
82static const uint64_t MIN_DISK_SPACE_FOR_BLOCK_FILES = 550 * 1024 * 1024;
83
85static constexpr int MAX_SCRIPTCHECK_THREADS{15};
86
92};
93
95extern const std::vector<std::string> CHECKLEVEL_DOC;
96
97CAmount GetBlockSubsidy(int nHeight, const Consensus::Params& consensusParams);
98
99bool FatalError(kernel::Notifications& notifications, BlockValidationState& state, const bilingual_str& message);
100
102void PruneBlockFilesManual(Chainstate& active_chainstate, int nManualPruneHeight);
103
128 enum class ResultType {
129 VALID,
130 INVALID,
131 MEMPOOL_ENTRY,
132 DIFFERENT_WITNESS,
133 };
136
139
141 const std::list<CTransactionRef> m_replaced_transactions;
143 const std::optional<int64_t> m_vsize;
145 const std::optional<CAmount> m_base_fees;
151 const std::optional<CFeeRate> m_effective_feerate;
157 const std::optional<std::vector<Wtxid>> m_wtxids_fee_calculations;
158
160 const std::optional<Wtxid> m_other_wtxid;
161
163 return MempoolAcceptResult(state);
164 }
165
167 CFeeRate effective_feerate,
168 const std::vector<Wtxid>& wtxids_fee_calculations) {
169 return MempoolAcceptResult(state, effective_feerate, wtxids_fee_calculations);
170 }
171
172 static MempoolAcceptResult Success(std::list<CTransactionRef>&& replaced_txns,
173 int64_t vsize,
174 CAmount fees,
175 CFeeRate effective_feerate,
176 const std::vector<Wtxid>& wtxids_fee_calculations) {
177 return MempoolAcceptResult(std::move(replaced_txns), vsize, fees,
178 effective_feerate, wtxids_fee_calculations);
179 }
180
181 static MempoolAcceptResult MempoolTx(int64_t vsize, CAmount fees) {
182 return MempoolAcceptResult(vsize, fees);
183 }
184
186 return MempoolAcceptResult(other_wtxid);
187 }
188
189// Private constructors. Use static methods MempoolAcceptResult::Success, etc. to construct.
190private:
193 : m_result_type(ResultType::INVALID), m_state(state) {
194 Assume(!state.IsValid()); // Can be invalid or error
195 }
196
198 explicit MempoolAcceptResult(std::list<CTransactionRef>&& replaced_txns,
199 int64_t vsize,
200 CAmount fees,
201 CFeeRate effective_feerate,
202 const std::vector<Wtxid>& wtxids_fee_calculations)
203 : m_result_type(ResultType::VALID),
204 m_replaced_transactions(std::move(replaced_txns)),
205 m_vsize{vsize},
206 m_base_fees(fees),
207 m_effective_feerate(effective_feerate),
208 m_wtxids_fee_calculations(wtxids_fee_calculations) {}
209
212 CFeeRate effective_feerate,
213 const std::vector<Wtxid>& wtxids_fee_calculations)
214 : m_result_type(ResultType::INVALID),
215 m_state(state),
216 m_effective_feerate(effective_feerate),
217 m_wtxids_fee_calculations(wtxids_fee_calculations) {}
218
220 explicit MempoolAcceptResult(int64_t vsize, CAmount fees)
221 : m_result_type(ResultType::MEMPOOL_ENTRY), m_vsize{vsize}, m_base_fees(fees) {}
222
224 explicit MempoolAcceptResult(const Wtxid& other_wtxid)
225 : m_result_type(ResultType::DIFFERENT_WITNESS), m_other_wtxid(other_wtxid) {}
226};
227
232{
240 std::map<Wtxid, MempoolAcceptResult> m_tx_results;
241
243 std::map<Wtxid, MempoolAcceptResult>&& results)
244 : m_state{state}, m_tx_results(std::move(results)) {}
245
247 std::map<Wtxid, MempoolAcceptResult>&& results)
248 : m_state{state}, m_tx_results(std::move(results)) {}
249
251 explicit PackageMempoolAcceptResult(const Wtxid& wtxid, const MempoolAcceptResult& result)
252 : m_tx_results{ {wtxid, result} } {}
253};
254
270 int64_t accept_time, bool bypass_limits, bool test_accept)
272
284 const Package& txns, bool test_accept, const std::optional<CFeeRate>& client_maxfeerate)
286
287/* Mempool validation helper functions */
288
292bool CheckFinalTxAtTip(const CBlockIndex& active_chain_tip, const CTransaction& tx) EXCLUSIVE_LOCKS_REQUIRED(::cs_main);
293
312std::optional<LockPoints> CalculateLockPointsAtTip(
313 CBlockIndex* tip,
314 const CCoinsView& coins_view,
315 const CTransaction& tx);
316
327 const LockPoints& lock_points);
328
334{
335private:
338 unsigned int nIn;
339 unsigned int nFlags;
343
344public:
345 CScriptCheck(const CTxOut& outIn, const CTransaction& txToIn, SignatureCache& signature_cache, unsigned int nInIn, unsigned int nFlagsIn, bool cacheIn, PrecomputedTransactionData* txdataIn) :
346 m_tx_out(outIn), ptxTo(&txToIn), nIn(nInIn), nFlags(nFlagsIn), cacheStore(cacheIn), txdata(txdataIn), m_signature_cache(&signature_cache) { }
347
348 CScriptCheck(const CScriptCheck&) = delete;
352
353 std::optional<std::pair<ScriptError, std::string>> operator()();
354};
355
356// CScriptCheck is used a lot in std::vector, make sure that's efficient
357static_assert(std::is_nothrow_move_assignable_v<CScriptCheck>);
358static_assert(std::is_nothrow_move_constructible_v<CScriptCheck>);
359static_assert(std::is_nothrow_destructible_v<CScriptCheck>);
360
366{
367private:
370
371public:
374
375 ValidationCache(size_t script_execution_cache_bytes, size_t signature_cache_bytes);
376
379
382};
383
387bool CheckBlock(const CBlock& block, BlockValidationState& state, const Consensus::Params& consensusParams, bool fCheckPOW = true, bool fCheckMerkleRoot = true);
388
407 Chainstate& chainstate,
408 const CBlock& block,
409 bool check_pow,
410 bool check_merkle_root) EXCLUSIVE_LOCKS_REQUIRED(cs_main);
411
413bool HasValidProofOfWork(const std::vector<CBlockHeader>& headers, const Consensus::Params& consensusParams);
414
416bool IsBlockMutated(const CBlock& block, bool check_witness_root);
417
419arith_uint256 CalculateClaimedHeadersWork(std::span<const CBlockHeader> headers);
420
421enum class VerifyDBResult {
422 SUCCESS,
424 INTERRUPTED,
427};
428
431{
432private:
434
435public:
436 explicit CVerifyDB(kernel::Notifications& notifications);
437 ~CVerifyDB();
438 [[nodiscard]] VerifyDBResult VerifyDB(
439 Chainstate& chainstate,
440 const Consensus::Params& consensus_params,
441 CCoinsView& coinsview,
442 int nCheckLevel,
443 int nCheckDepth) EXCLUSIVE_LOCKS_REQUIRED(cs_main);
444};
445
447{
448 DISCONNECT_OK, // All good.
449 DISCONNECT_UNCLEAN, // Rolled back, but UTXO set was inconsistent with block.
450 DISCONNECT_FAILED // Something else went wrong.
452
453class ConnectTrace;
454
456inline constexpr std::array FlushStateModeNames{"NONE", "IF_NEEDED", "PERIODIC", "ALWAYS"};
457enum class FlushStateMode: uint8_t {
458 NONE,
459 IF_NEEDED,
460 PERIODIC,
461 ALWAYS
462};
463
474
475public:
479
482
485 std::unique_ptr<CCoinsViewCache> m_cacheview GUARDED_BY(cs_main);
486
493 CoinsViews(DBParams db_params, CoinsViewOptions options);
494
496 void InitCache() EXCLUSIVE_LOCKS_REQUIRED(::cs_main);
497};
498
500{
502 CRITICAL = 2,
504 LARGE = 1,
505 OK = 0
506};
507
508constexpr int64_t LargeCoinsCacheThreshold(int64_t total_space) noexcept
509{
510 // No periodic flush needed if at least this much space is free
511 constexpr int64_t MAX_BLOCK_COINSDB_USAGE_BYTES{int64_t(10_MiB)};
512 return std::max((total_space * 9) / 10,
513 total_space - MAX_BLOCK_COINSDB_USAGE_BYTES);
514}
515
531{
532protected:
539
543
545 std::unique_ptr<CoinsViews> m_coins_views;
546
558 bool m_disabled GUARDED_BY(::cs_main) {false};
559
561 mutable const CBlockIndex* m_cached_snapshot_base GUARDED_BY(::cs_main){nullptr};
562
563 std::atomic_bool m_prev_script_checks_logged{true};
564
565public:
569
574
575 explicit Chainstate(
576 CTxMemPool* mempool,
577 node::BlockManager& blockman,
578 ChainstateManager& chainman,
579 std::optional<uint256> from_snapshot_blockhash = std::nullopt);
580
586
593 void InitCoinsDB(
594 size_t cache_size_bytes,
595 bool in_memory,
596 bool should_wipe,
597 fs::path leveldb_name = "chainstate");
598
601 void InitCoinsCache(size_t cache_size_bytes) EXCLUSIVE_LOCKS_REQUIRED(::cs_main);
602
605 bool CanFlushToDisk() const EXCLUSIVE_LOCKS_REQUIRED(::cs_main)
606 {
608 return m_coins_views && m_coins_views->m_cacheview;
609 }
610
614
620 const std::optional<uint256> m_from_snapshot_blockhash;
621
627 const CBlockIndex* SnapshotBase() const EXCLUSIVE_LOCKS_REQUIRED(::cs_main);
628
636 std::set<CBlockIndex*, node::CBlockIndexWorkComparator> setBlockIndexCandidates;
637
640 {
642 Assert(m_coins_views);
643 return *Assert(m_coins_views->m_cacheview);
644 }
645
648 {
650 return Assert(m_coins_views)->m_dbview;
651 }
652
655 {
656 return m_mempool;
657 }
658
662 {
664 return Assert(m_coins_views)->m_catcherview;
665 }
666
668 void ResetCoinsViews() { m_coins_views.reset(); }
669
671 bool HasCoinsViews() const { return (bool)m_coins_views; }
672
674 size_t m_coinsdb_cache_size_bytes{0};
675
677 size_t m_coinstip_cache_size_bytes{0};
678
681 bool ResizeCoinsCaches(size_t coinstip_size, size_t coinsdb_size)
683
695 bool FlushStateToDisk(
697 FlushStateMode mode,
698 int nManualPruneHeight = 0);
699
701 void ForceFlushStateToDisk();
702
705 void PruneAndFlush();
706
728 bool ActivateBestChain(
730 std::shared_ptr<const CBlock> pblock = nullptr)
731 EXCLUSIVE_LOCKS_REQUIRED(!m_chainstate_mutex)
733
734 // Block (dis)connection on a given view:
735 DisconnectResult DisconnectBlock(const CBlock& block, const CBlockIndex* pindex, CCoinsViewCache& view)
737 bool ConnectBlock(const CBlock& block, BlockValidationState& state, CBlockIndex* pindex,
738 CCoinsViewCache& view, bool fJustCheck = false) EXCLUSIVE_LOCKS_REQUIRED(cs_main);
739
740 // Apply the effects of a block disconnection on the UTXO set.
741 bool DisconnectTip(BlockValidationState& state, DisconnectedBlockTransactions* disconnectpool) EXCLUSIVE_LOCKS_REQUIRED(cs_main, m_mempool->cs);
742
743 // Manual block validity manipulation:
748 bool PreciousBlock(BlockValidationState& state, CBlockIndex* pindex)
749 EXCLUSIVE_LOCKS_REQUIRED(!m_chainstate_mutex)
751
754 EXCLUSIVE_LOCKS_REQUIRED(!m_chainstate_mutex)
756
758 void SetBlockFailureFlags(CBlockIndex* pindex) EXCLUSIVE_LOCKS_REQUIRED(::cs_main);
759
761 void ResetBlockFailureFlags(CBlockIndex* pindex) EXCLUSIVE_LOCKS_REQUIRED(cs_main);
762
764 bool ReplayBlocks();
765
767 [[nodiscard]] bool NeedsRedownload() const EXCLUSIVE_LOCKS_REQUIRED(cs_main);
769 bool LoadGenesisBlock();
770
771 void TryAddBlockIndexCandidate(CBlockIndex* pindex) EXCLUSIVE_LOCKS_REQUIRED(cs_main);
772
773 void PruneBlockIndexCandidates();
774
775 void ClearBlockIndexCandidates() EXCLUSIVE_LOCKS_REQUIRED(::cs_main);
776
778 const CBlockIndex* FindForkInGlobalIndex(const CBlockLocator& locator) const EXCLUSIVE_LOCKS_REQUIRED(cs_main);
779
781 bool LoadChainTip() EXCLUSIVE_LOCKS_REQUIRED(cs_main);
782
786 CoinsCacheSizeState GetCoinsCacheSizeState() EXCLUSIVE_LOCKS_REQUIRED(::cs_main);
787
788 CoinsCacheSizeState GetCoinsCacheSizeState(
789 size_t max_coins_cache_size_bytes,
790 size_t max_mempool_size_bytes) EXCLUSIVE_LOCKS_REQUIRED(::cs_main);
791
793
795 RecursiveMutex* MempoolMutex() const LOCK_RETURNED(m_mempool->cs)
796 {
797 return m_mempool ? &m_mempool->cs : nullptr;
798 }
799
800protected:
801 bool ActivateBestChainStep(BlockValidationState& state, CBlockIndex* pindexMostWork, const std::shared_ptr<const CBlock>& pblock, bool& fInvalidFound, ConnectTrace& connectTrace) EXCLUSIVE_LOCKS_REQUIRED(cs_main, m_mempool->cs);
802 bool ConnectTip(
804 CBlockIndex* pindexNew,
805 std::shared_ptr<const CBlock> block_to_connect,
806 ConnectTrace& connectTrace,
808
809 void InvalidBlockFound(CBlockIndex* pindex, const BlockValidationState& state) EXCLUSIVE_LOCKS_REQUIRED(cs_main);
810 CBlockIndex* FindMostWorkChain() EXCLUSIVE_LOCKS_REQUIRED(cs_main);
811
812 bool RollforwardBlock(const CBlockIndex* pindex, CCoinsViewCache& inputs) EXCLUSIVE_LOCKS_REQUIRED(cs_main);
813
814 void CheckForkWarningConditions() EXCLUSIVE_LOCKS_REQUIRED(cs_main);
815 void InvalidChainFound(CBlockIndex* pindexNew) EXCLUSIVE_LOCKS_REQUIRED(cs_main);
816
830 void MaybeUpdateMempoolForReorg(
831 DisconnectedBlockTransactions& disconnectpool,
832 bool fAddToMempool) EXCLUSIVE_LOCKS_REQUIRED(cs_main, m_mempool->cs);
833
835 void UpdateTip(const CBlockIndex* pindexNew)
837
838 NodeClock::time_point m_next_write{NodeClock::time_point::max()};
839
844 [[nodiscard]] util::Result<void> InvalidateCoinsDBOnDisk() EXCLUSIVE_LOCKS_REQUIRED(::cs_main);
845
847};
848
850 SUCCESS,
851 SKIPPED,
852
853 // Expected assumeutxo configuration data is not found for the height of the
854 // base block.
856
857 // Failed to generate UTXO statistics (to check UTXO set hash) for the background
858 // chainstate.
860
861 // The UTXO set hash of the background validation chainstate does not match
862 // the one expected by assumeutxo chainparams.
864
865 // The blockhash of the current tip of the background validation chainstate does
866 // not match the one expected by the snapshot chainstate.
868};
869
898{
899private:
916 std::unique_ptr<Chainstate> m_ibd_chainstate GUARDED_BY(::cs_main);
917
928 std::unique_ptr<Chainstate> m_snapshot_chainstate GUARDED_BY(::cs_main);
929
932 Chainstate* m_active_chainstate GUARDED_BY(::cs_main) {nullptr};
933
934 CBlockIndex* m_best_invalid GUARDED_BY(::cs_main){nullptr};
935
937 CBlockIndex* m_last_notified_header GUARDED_BY(GetMutex()){nullptr};
938
939 bool NotifyHeaderTip() LOCKS_EXCLUDED(GetMutex());
940
948 [[nodiscard]] util::Result<void> PopulateAndValidateSnapshot(
949 Chainstate& snapshot_chainstate,
950 AutoFile& coins_file,
951 const node::SnapshotMetadata& metadata);
952
960 bool AcceptBlockHeader(
961 const CBlockHeader& block,
963 CBlockIndex** ppindex,
964 bool min_pow_checked) EXCLUSIVE_LOCKS_REQUIRED(cs_main);
966
968 MockableSteadyClock::time_point m_last_presync_update GUARDED_BY(GetMutex()){};
969
976 return cs && !cs->m_disabled;
977 }
978
981
984 SteadyClock::duration GUARDED_BY(::cs_main) time_check{};
985 SteadyClock::duration GUARDED_BY(::cs_main) time_forks{};
986 SteadyClock::duration GUARDED_BY(::cs_main) time_connect{};
987 SteadyClock::duration GUARDED_BY(::cs_main) time_verify{};
988 SteadyClock::duration GUARDED_BY(::cs_main) time_undo{};
989 SteadyClock::duration GUARDED_BY(::cs_main) time_index{};
990 SteadyClock::duration GUARDED_BY(::cs_main) time_total{};
991 int64_t GUARDED_BY(::cs_main) num_blocks_total{0};
992 SteadyClock::duration GUARDED_BY(::cs_main) time_connect_total{};
993 SteadyClock::duration GUARDED_BY(::cs_main) time_flush{};
994 SteadyClock::duration GUARDED_BY(::cs_main) time_chainstate{};
995 SteadyClock::duration GUARDED_BY(::cs_main) time_post_connect{};
996
997public:
999
1000 explicit ChainstateManager(const util::SignalInterrupt& interrupt, Options options, node::BlockManager::Options blockman_options);
1001
1004 std::function<void()> snapshot_download_completed = std::function<void()>();
1005
1006 const CChainParams& GetParams() const { return m_options.chainparams; }
1007 const Consensus::Params& GetConsensus() const { return m_options.chainparams.GetConsensus(); }
1008 bool ShouldCheckBlockIndex() const;
1009 const arith_uint256& MinimumChainWork() const { return *Assert(m_options.minimum_chain_work); }
1010 const uint256& AssumedValidBlock() const { return *Assert(m_options.assumed_valid_block); }
1011 kernel::Notifications& GetNotifications() const { return m_options.notifications; };
1012
1018 void CheckBlockIndex() const;
1019
1032
1038
1040
1048 mutable std::atomic<bool> m_cached_finished_ibd{false};
1049
1055 int32_t nBlockSequenceId GUARDED_BY(::cs_main) = 1;
1057 int32_t nBlockReverseSequenceId = -1;
1059 arith_uint256 nLastPreciousChainwork = 0;
1060
1061 // Reset the memory-only sequence counters we use to track block arrival
1062 // (used by tests to reset state)
1064 {
1066 nBlockSequenceId = 1;
1067 nBlockReverseSequenceId = -1;
1068 }
1069
1070
1075 CBlockIndex* m_best_header GUARDED_BY(::cs_main){nullptr};
1076
1079 size_t m_total_coinstip_cache{0};
1080 //
1083 size_t m_total_coinsdb_cache{0};
1084
1088 // constructor
1089 Chainstate& InitializeChainstate(CTxMemPool* mempool) EXCLUSIVE_LOCKS_REQUIRED(::cs_main);
1090
1092 std::vector<Chainstate*> GetAll();
1093
1106 [[nodiscard]] util::Result<CBlockIndex*> ActivateSnapshot(
1107 AutoFile& coins_file, const node::SnapshotMetadata& metadata, bool in_memory);
1108
1116 SnapshotCompletionResult MaybeCompleteSnapshotValidation() EXCLUSIVE_LOCKS_REQUIRED(::cs_main);
1117
1119 const CBlockIndex* GetSnapshotBaseBlock() const EXCLUSIVE_LOCKS_REQUIRED(::cs_main);
1120
1122 Chainstate& ActiveChainstate() const;
1123 CChain& ActiveChain() const EXCLUSIVE_LOCKS_REQUIRED(GetMutex()) { return ActiveChainstate().m_chain; }
1124 int ActiveHeight() const EXCLUSIVE_LOCKS_REQUIRED(GetMutex()) { return ActiveChain().Height(); }
1125 CBlockIndex* ActiveTip() const EXCLUSIVE_LOCKS_REQUIRED(GetMutex()) { return ActiveChain().Tip(); }
1126
1129 return IsUsable(m_snapshot_chainstate.get()) && IsUsable(m_ibd_chainstate.get());
1130 }
1131
1134 return BackgroundSyncInProgress() ? m_ibd_chainstate->m_chain.Tip() : nullptr;
1135 }
1136
1138 {
1140 return m_blockman.m_block_index;
1141 }
1142
1147
1150 bool IsSnapshotActive() const;
1151
1152 std::optional<uint256> SnapshotBlockhash() const;
1153
1156 {
1157 return m_snapshot_chainstate && m_ibd_chainstate && m_ibd_chainstate->m_disabled;
1158 }
1159
1161 bool IsInitialBlockDownload() const;
1162
1164 double GuessVerificationProgress(const CBlockIndex* pindex) const EXCLUSIVE_LOCKS_REQUIRED(GetMutex());
1165
1193 AutoFile& file_in,
1194 FlatFilePos* dbp = nullptr,
1195 std::multimap<uint256, FlatFilePos>* blocks_with_unknown_parent = nullptr);
1196
1221 bool ProcessNewBlock(const std::shared_ptr<const CBlock>& block, bool force_processing, bool min_pow_checked, bool* new_block) LOCKS_EXCLUDED(cs_main);
1222
1235 bool ProcessNewBlockHeaders(std::span<const CBlockHeader> headers, bool min_pow_checked, BlockValidationState& state, const CBlockIndex** ppindex = nullptr) LOCKS_EXCLUDED(cs_main);
1236
1256 bool AcceptBlock(const std::shared_ptr<const CBlock>& pblock, BlockValidationState& state, CBlockIndex** ppindex, bool fRequested, const FlatFilePos* dbp, bool* fNewBlock, bool min_pow_checked) EXCLUSIVE_LOCKS_REQUIRED(cs_main);
1257
1258 void ReceivedBlockTransactions(const CBlock& block, CBlockIndex* pindexNew, const FlatFilePos& pos) EXCLUSIVE_LOCKS_REQUIRED(cs_main);
1259
1266 [[nodiscard]] MempoolAcceptResult ProcessTransaction(const CTransactionRef& tx, bool test_accept=false)
1268
1270 bool LoadBlockIndex() EXCLUSIVE_LOCKS_REQUIRED(cs_main);
1271
1274 void MaybeRebalanceCaches() EXCLUSIVE_LOCKS_REQUIRED(::cs_main);
1275
1277 void UpdateUncommittedBlockStructures(CBlock& block, const CBlockIndex* pindexPrev) const;
1278
1280 std::vector<unsigned char> GenerateCoinbaseCommitment(CBlock& block, const CBlockIndex* pindexPrev) const;
1281
1286 void ReportHeadersPresync(const arith_uint256& work, int64_t height, int64_t timestamp);
1287
1290 bool DetectSnapshotChainstate() EXCLUSIVE_LOCKS_REQUIRED(::cs_main);
1291
1292 void ResetChainstates() EXCLUSIVE_LOCKS_REQUIRED(::cs_main);
1293
1296 [[nodiscard]] bool DeleteSnapshotChainstate() EXCLUSIVE_LOCKS_REQUIRED(::cs_main);
1297
1300 Chainstate& ActivateExistingSnapshot(uint256 base_blockhash) EXCLUSIVE_LOCKS_REQUIRED(::cs_main);
1301
1311 bool ValidatedSnapshotCleanup() EXCLUSIVE_LOCKS_REQUIRED(::cs_main);
1312
1321 Chainstate& GetChainstateForIndexing() EXCLUSIVE_LOCKS_REQUIRED(::cs_main);
1322
1326 std::pair<int, int> GetPruneRange(
1327 const Chainstate& chainstate, int last_height_can_prune) EXCLUSIVE_LOCKS_REQUIRED(::cs_main);
1328
1331 std::optional<int> GetSnapshotBaseHeight() const EXCLUSIVE_LOCKS_REQUIRED(::cs_main);
1332
1336 void RecalculateBestHeader() EXCLUSIVE_LOCKS_REQUIRED(::cs_main);
1337
1338 CCheckQueue<CScriptCheck>& GetCheckQueue() { return m_script_check_queue; }
1339
1341};
1342
1344template<typename DEP>
1345bool DeploymentActiveAfter(const CBlockIndex* pindexPrev, const ChainstateManager& chainman, DEP dep)
1346{
1347 return DeploymentActiveAfter(pindexPrev, chainman.GetConsensus(), dep, chainman.m_versionbitscache);
1348}
1349
1350template<typename DEP>
1351bool DeploymentActiveAt(const CBlockIndex& index, const ChainstateManager& chainman, DEP dep)
1352{
1353 return DeploymentActiveAt(index, chainman.GetConsensus(), dep, chainman.m_versionbitscache);
1354}
1355
1356template<typename DEP>
1357bool DeploymentEnabled(const ChainstateManager& chainman, DEP dep)
1358{
1359 return DeploymentEnabled(chainman.GetConsensus(), dep);
1360}
1361
1363bool IsBIP30Repeat(const CBlockIndex& block_index);
1364
1366bool IsBIP30Unspendable(const uint256& block_hash, int block_height);
1367
1368#endif // BITCOIN_VALIDATION_H
int64_t CAmount
Amount in satoshis (Can be negative)
Definition: amount.h:12
void InvalidateBlock(ChainstateManager &chainman, const uint256 block_hash)
const CChainParams & Params()
Return the currently selected parameters.
#define Assert(val)
Identity function.
Definition: check.h:106
#define Assume(val)
Assume is the identity function.
Definition: check.h:118
static void CheckBlockIndex(benchmark::Bench &bench)
Non-refcounted RAII wrapper for FILE*.
Definition: streams.h:371
Nodes collect new transactions into a block, hash them into a hash tree, and scan through nonce value...
Definition: block.h:22
Definition: block.h:69
The block chain is a tree shaped structure starting with the genesis block at the root,...
Definition: chain.h:141
An in-memory indexed chain of blocks.
Definition: chain.h:417
CChainParams defines various tweakable parameters of a given instance of the Bitcoin system.
Definition: chainparams.h:69
CCoinsView that adds a memory cache for transactions to another CCoinsView.
Definition: coins.h:363
CCoinsView backed by the coin database (chainstate/)
Definition: txdb.h:38
This is a minimally invasive approach to shutdown on LevelDB read errors from the chainstate,...
Definition: coins.h:512
Abstract view on the open txout dataset.
Definition: coins.h:310
Fee rate in satoshis per virtualbyte: CAmount / vB the feerate is represented internally as FeeFrac.
Definition: feerate.h:35
A hasher class for SHA-256.
Definition: sha256.h:14
Closure representing one script verification Note that this stores references to the spending transac...
Definition: validation.h:334
CScriptCheck & operator=(CScriptCheck &&)=default
SignatureCache * m_signature_cache
Definition: validation.h:342
CScriptCheck(const CScriptCheck &)=delete
PrecomputedTransactionData * txdata
Definition: validation.h:341
CTxOut m_tx_out
Definition: validation.h:336
CScriptCheck(CScriptCheck &&)=default
bool cacheStore
Definition: validation.h:340
std::optional< std::pair< ScriptError, std::string > > operator()()
unsigned int nFlags
Definition: validation.h:339
CScriptCheck(const CTxOut &outIn, const CTransaction &txToIn, SignatureCache &signature_cache, unsigned int nInIn, unsigned int nFlagsIn, bool cacheIn, PrecomputedTransactionData *txdataIn)
Definition: validation.h:345
const CTransaction * ptxTo
Definition: validation.h:337
unsigned int nIn
Definition: validation.h:338
CScriptCheck & operator=(const CScriptCheck &)=delete
The basic transaction that is broadcasted on the network and contained in blocks.
Definition: transaction.h:296
CTxMemPool stores valid-according-to-the-current-best-chain transactions that may be included in the ...
Definition: txmempool.h:281
RecursiveMutex cs
This mutex needs to be locked when accessing mapTx or other members that are guarded by it.
Definition: txmempool.h:367
An output of a transaction.
Definition: transaction.h:150
RAII wrapper for VerifyDB: Verify consistency of the block and coin databases.
Definition: validation.h:431
VerifyDBResult VerifyDB(Chainstate &chainstate, const Consensus::Params &consensus_params, CCoinsView &coinsview, int nCheckLevel, int nCheckDepth) EXCLUSIVE_LOCKS_REQUIRED(cs_main)
kernel::Notifications & m_notifications
Definition: validation.h:433
CVerifyDB(kernel::Notifications &notifications)
Chainstate stores and provides an API to update our local knowledge of the current best chain.
Definition: validation.h:531
Mutex m_chainstate_mutex
The ChainState Mutex A lock that must be held when modifying this ChainState - held in ActivateBestCh...
Definition: validation.h:538
CChain m_chain
The current chain of blockheaders we consult and build on.
Definition: validation.h:613
bool HasCoinsViews() const
Does this chainstate have a UTXO set attached?
Definition: validation.h:671
CTxMemPool * GetMempool()
Definition: validation.h:654
const std::optional< uint256 > m_from_snapshot_blockhash
The blockhash which is the base of the snapshot this chainstate was created from.
Definition: validation.h:620
CTxMemPool * m_mempool
Optional mempool that is kept in sync with the chain.
Definition: validation.h:542
bool m_disabled GUARDED_BY(::cs_main)
This toggle exists for use when doing background validation for UTXO snapshots.
Definition: validation.h:558
CCoinsViewDB & CoinsDB() EXCLUSIVE_LOCKS_REQUIRED(
Definition: validation.h:647
ChainstateManager & m_chainman
The chainstate manager that owns this chainstate.
Definition: validation.h:573
std::unique_ptr< CoinsViews > m_coins_views
Manages the UTXO set, which is a reflection of the contents of m_chain.
Definition: validation.h:545
void ResetCoinsViews()
Destructs all objects related to accessing the UTXO set.
Definition: validation.h:668
node::BlockManager & m_blockman
Reference to a BlockManager instance which itself is shared across all Chainstate instances.
Definition: validation.h:568
const CBlockIndex *m_cached_snapshot_base GUARDED_BY(::cs_main)
Cached result of LookupBlockIndex(*m_from_snapshot_blockhash)
Definition: validation.h:561
CCoinsViewErrorCatcher & CoinsErrorCatcher() EXCLUSIVE_LOCKS_REQUIRED(
Definition: validation.h:661
Provides an interface for creating and interacting with one or two chainstates: an IBD chainstate gen...
Definition: validation.h:898
SteadyClock::duration GUARDED_BY(::cs_main) time_connect_total
Definition: validation.h:992
std::unique_ptr< Chainstate > m_ibd_chainstate GUARDED_BY(::cs_main)
The chainstate used under normal operation (i.e.
const uint256 & AssumedValidBlock() const
Definition: validation.h:1010
node::BlockMap & BlockIndex() EXCLUSIVE_LOCKS_REQUIRED(
Definition: validation.h:1137
CBlockIndex *m_best_header GUARDED_BY(::cs_main)
Best header we've seen so far for which the block is not known to be invalid (used,...
Definition: validation.h:1075
ValidationCache m_validation_cache
Definition: validation.h:1039
int64_t GUARDED_BY(::cs_main) num_blocks_total
Definition: validation.h:991
SteadyClock::duration GUARDED_BY(::cs_main) time_undo
Definition: validation.h:988
SteadyClock::duration GUARDED_BY(::cs_main) time_index
Definition: validation.h:989
const CBlockIndex * GetBackgroundSyncTip() const EXCLUSIVE_LOCKS_REQUIRED(GetMutex())
The tip of the background sync chain.
Definition: validation.h:1133
SteadyClock::duration GUARDED_BY(::cs_main) time_post_connect
Definition: validation.h:995
kernel::Notifications & GetNotifications() const
Definition: validation.h:1011
SteadyClock::duration GUARDED_BY(::cs_main) time_check
Timers and counters used for benchmarking validation in both background and active chainstates.
Definition: validation.h:984
RecursiveMutex & GetMutex() const LOCK_RETURNED(
Alias for cs_main.
Definition: validation.h:1031
SteadyClock::duration GUARDED_BY(::cs_main) time_total
Definition: validation.h:990
SteadyClock::duration GUARDED_BY(::cs_main) time_chainstate
Definition: validation.h:994
bool IsSnapshotValidated() const EXCLUSIVE_LOCKS_REQUIRED(
Is there a snapshot in use and has it been fully validated?
Definition: validation.h:1155
CCheckQueue< CScriptCheck > m_script_check_queue
A queue for script verifications that have to be performed by worker threads.
Definition: validation.h:980
CBlockIndex * ActiveTip() const EXCLUSIVE_LOCKS_REQUIRED(GetMutex())
Definition: validation.h:1125
CBlockIndex *m_best_invalid GUARDED_BY(::cs_main)
Definition: validation.h:934
SteadyClock::duration GUARDED_BY(::cs_main) time_forks
Definition: validation.h:985
bool BackgroundSyncInProgress() const EXCLUSIVE_LOCKS_REQUIRED(GetMutex())
The state of a background sync (for net processing)
Definition: validation.h:1128
CBlockIndex *m_last_notified_header GUARDED_BY(GetMutex())
The last header for which a headerTip notification was issued.
Definition: validation.h:937
const util::SignalInterrupt & m_interrupt
Definition: validation.h:1033
int ActiveHeight() const EXCLUSIVE_LOCKS_REQUIRED(GetMutex())
Definition: validation.h:1124
VersionBitsCache m_versionbitscache
Track versionbit status.
Definition: validation.h:1146
const CChainParams & GetParams() const
Definition: validation.h:1006
const Consensus::Params & GetConsensus() const
Definition: validation.h:1007
const arith_uint256 & MinimumChainWork() const
Definition: validation.h:1009
const Options m_options
Definition: validation.h:1034
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...
SteadyClock::duration GUARDED_BY(::cs_main) time_verify
Definition: validation.h:987
Chainstate *m_active_chainstate GUARDED_BY(::cs_main)
Points to either the ibd or snapshot chainstate; indicates our most-work chain.
Definition: validation.h:932
Chainstate &InitializeChainstate(CTxMemPool *mempool) EXCLUSIVE_LOCKS_REQUIRED(std::vector< Chainstate * GetAll)()
Instantiate a new chainstate.
Definition: validation.h:1092
SteadyClock::duration GUARDED_BY(::cs_main) time_connect
Definition: validation.h:986
bool IsUsable(const Chainstate *const cs) const EXCLUSIVE_LOCKS_REQUIRED(
Return true if a chainstate is considered usable.
Definition: validation.h:975
std::unique_ptr< Chainstate > m_snapshot_chainstate GUARDED_BY(::cs_main)
A chainstate initialized on the basis of a UTXO snapshot.
void ResetBlockSequenceCounters() EXCLUSIVE_LOCKS_REQUIRED(
Definition: validation.h:1063
node::BlockManager m_blockman
A single BlockManager instance is shared across each constructed chainstate to avoid duplicating bloc...
Definition: validation.h:1037
SteadyClock::duration GUARDED_BY(::cs_main) time_flush
Definition: validation.h:993
A convenience class for constructing the CCoinsView* hierarchy used to facilitate access to the UTXO ...
Definition: validation.h:473
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.
Valid signature cache, to avoid doing expensive ECDSA signature checking twice for every transaction ...
Definition: sigcache.h:39
Convenience class for initializing and passing the script execution cache and signature cache.
Definition: validation.h:366
ValidationCache(size_t script_execution_cache_bytes, size_t signature_cache_bytes)
CuckooCache::cache< uint256, SignatureCacheHasher > m_script_execution_cache
Definition: validation.h:372
ValidationCache & operator=(const ValidationCache &)=delete
ValidationCache(const ValidationCache &)=delete
CSHA256 ScriptExecutionCacheHasher() const
Return a copy of the pre-initialized hasher.
Definition: validation.h:381
CSHA256 m_script_execution_cache_hasher
Pre-initialized hasher to avoid having to recreate it for every hash calculation.
Definition: validation.h:369
SignatureCache m_signature_cache
Definition: validation.h:373
bool IsValid() const
Definition: validation.h:105
BIP 9 allows multiple softforks to be deployed in parallel.
Definition: versionbits.h:77
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...
Definition: blockstorage.h:139
Metadata describing a serialized version of a UTXO set from which an assumeutxo Chainstate can be con...
Definition: utxo_snapshot.h:34
transaction_identifier represents the two canonical transaction identifier types (txid,...
256-bit opaque blob.
Definition: uint256.h:196
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.
Definition: cs_main.cpp:8
ChainstateRole
This enum describes the various roles a specific Chainstate instance can take.
Definition: chain.h:25
static void LoadExternalBlockFile(benchmark::Bench &bench)
The LoadExternalBlockFile() function is used during -reindex and -loadblock.
unsigned int nHeight
static void pool cs
Transaction validation functions.
Definition: messages.h:20
std::unordered_map< uint256, CBlockIndex, BlockHasher > BlockMap
Definition: blockstorage.h:87
std::string ToString(const T &t)
Locale-independent version of std::to_string.
Definition: string.h:245
std::vector< CTransactionRef > Package
A package is an ordered list of transactions.
Definition: packages.h:50
std::shared_ptr< const CTransaction > CTransactionRef
Definition: transaction.h:423
@ OK
The message verification was successful.
Holds configuration for use during UTXO snapshot load and validation.
Definition: chainparams.h:35
Describes a place in the block chain to another node such that if the other node doesn't have the sam...
Definition: block.h:124
Holds various statistics on transactions within a chain.
Definition: chainparams.h:58
User-controlled performance and debug options.
Definition: txdb.h:28
Parameters that influence chain consensus.
Definition: params.h:83
Application-specific storage settings.
Definition: dbwrapper.h:33
Validation result for a transaction evaluated by MemPoolAccept (single or package).
Definition: validation.h:126
const std::optional< int64_t > m_vsize
Virtual size as used by the mempool, calculated using serialized size and sigops.
Definition: validation.h:143
const ResultType m_result_type
Result type.
Definition: validation.h:135
MempoolAcceptResult(int64_t vsize, CAmount fees)
Constructor for already-in-mempool case.
Definition: validation.h:220
const std::optional< CAmount > m_base_fees
Raw base fees in satoshis.
Definition: validation.h:145
MempoolAcceptResult(TxValidationState state)
Constructor for failure case.
Definition: validation.h:192
const TxValidationState m_state
Contains information about why the transaction failed.
Definition: validation.h:138
ResultType
Used to indicate the results of mempool validation.
Definition: validation.h:128
static MempoolAcceptResult Failure(TxValidationState state)
Definition: validation.h:162
static MempoolAcceptResult FeeFailure(TxValidationState state, CFeeRate effective_feerate, const std::vector< Wtxid > &wtxids_fee_calculations)
Definition: validation.h:166
const std::optional< CFeeRate > m_effective_feerate
The feerate at which this transaction was considered.
Definition: validation.h:151
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.
Definition: validation.h:198
const std::optional< Wtxid > m_other_wtxid
The wtxid of the transaction in the mempool which has the same txid but different witness.
Definition: validation.h:160
const std::list< CTransactionRef > m_replaced_transactions
Mempool transactions replaced by the tx.
Definition: validation.h:141
MempoolAcceptResult(const Wtxid &other_wtxid)
Constructor for witness-swapped case.
Definition: validation.h:224
static MempoolAcceptResult MempoolTxDifferentWitness(const Wtxid &other_wtxid)
Definition: validation.h:185
static MempoolAcceptResult MempoolTx(int64_t vsize, CAmount fees)
Definition: validation.h:181
static MempoolAcceptResult Success(std::list< CTransactionRef > &&replaced_txns, int64_t vsize, CAmount fees, CFeeRate effective_feerate, const std::vector< Wtxid > &wtxids_fee_calculations)
Definition: validation.h:172
MempoolAcceptResult(TxValidationState state, CFeeRate effective_feerate, const std::vector< Wtxid > &wtxids_fee_calculations)
Constructor for fee-related failure case.
Definition: validation.h:211
const std::optional< std::vector< Wtxid > > m_wtxids_fee_calculations
Contains the wtxids of the transactions used for fee-related checks.
Definition: validation.h:157
Version of SteadyClock that is mockable in the context of tests (set the current value with SetMockTi...
Definition: time.h:38
Mockable clock in the context of tests, otherwise the system clock.
Definition: time.h:18
Validation result for package mempool acceptance.
Definition: validation.h:232
PackageValidationState m_state
Definition: validation.h:233
PackageMempoolAcceptResult(const Wtxid &wtxid, const MempoolAcceptResult &result)
Constructor to create a PackageMempoolAcceptResult from a single MempoolAcceptResult.
Definition: validation.h:251
PackageMempoolAcceptResult(PackageValidationState state, CFeeRate feerate, std::map< Wtxid, MempoolAcceptResult > &&results)
Definition: validation.h:246
PackageMempoolAcceptResult(PackageValidationState state, std::map< Wtxid, MempoolAcceptResult > &&results)
Definition: validation.h:242
std::map< Wtxid, MempoolAcceptResult > m_tx_results
Map from wtxid to finished MempoolAcceptResults.
Definition: validation.h:240
Bilingual messages:
Definition: translation.h:24
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(...)
Definition: threadsafety.h:51
#define LOCKS_EXCLUDED(...)
Definition: threadsafety.h:50
#define LOCK_RETURNED(x)
Definition: threadsafety.h:49
bool CheckFinalTxAtTip(const CBlockIndex &active_chain_tip, const CTransaction &tx)
Definition: validation.cpp:148
AssertLockHeld(pool.cs)
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).
static constexpr int MAX_SCRIPTCHECK_THREADS
Maximum number of dedicated script-checking threads allowed.
Definition: validation.h:85
static constexpr int DEFAULT_CHECKLEVEL
Definition: validation.h:73
static const uint64_t MIN_DISK_SPACE_FOR_BLOCK_FILES
Definition: validation.h:82
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.
Definition: validation.cpp:247
bool FatalError(kernel::Notifications &notifications, 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...
Definition: validation.h:71
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.
Definition: validation.h:1345
BlockValidationState TestBlockValidity(Chainstate &chainstate, const CBlock &block, bool check_pow, bool check_merkle_root) EXCLUSIVE_LOCKS_REQUIRED(cs_main)
Verify a block, including transactions.
SnapshotCompletionResult
Definition: validation.h:849
bool DeploymentEnabled(const ChainstateManager &chainman, DEP dep)
Definition: validation.h:1357
SynchronizationState
Current sync state passed to tip changed callbacks.
Definition: validation.h:88
constexpr std::array FlushStateModeNames
Definition: validation.h:456
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.
Definition: validation.h:312
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.
constexpr int64_t LargeCoinsCacheThreshold(int64_t total_space) noexcept
Definition: validation.h:508
arith_uint256 CalculateClaimedHeadersWork(std::span< const CBlockHeader > headers)
Return the sum of the claimed work on a given set of headers.
VerifyDBResult
Definition: validation.h:421
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'.
Definition: validation.cpp:101
void PruneBlockFilesManual(Chainstate &active_chainstate, int nManualPruneHeight)
Prune block files up to a given height.
FlushStateMode
Definition: validation.h:457
CoinsCacheSizeState
Definition: validation.h:500
@ 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)
Definition: validation.h:1351
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
Definition: validation.h:72
DisconnectResult
Definition: validation.h:447
@ DISCONNECT_FAILED
Definition: validation.h:450
@ DISCONNECT_UNCLEAN
Definition: validation.h:449
@ DISCONNECT_OK
Definition: validation.h:448
bool IsBIP30Unspendable(const uint256 &block_hash, int block_height)
Identifies blocks which coinbase output was subsequently overwritten in the UTXO set (see BIP30)