41#include <unordered_map>
78bool BlockTreeDB::WriteBatchSync(
const std::vector<std::pair<int, const CBlockFileInfo*>>& fileInfo,
int nLastFile,
const std::vector<const CBlockIndex*>& blockinfo)
81 for (
const auto& [file, info] : fileInfo) {
93 return Write(std::make_pair(
DB_FLAG,
name), fValue ? uint8_t{
'1'} : uint8_t{
'0'});
102 fValue = ch == uint8_t{
'1'};
109 std::unique_ptr<CDBIterator> pcursor(
NewIterator());
113 while (pcursor->Valid()) {
114 if (interrupt)
return false;
115 std::pair<uint8_t, uint256> key;
118 if (pcursor->GetValue(diskindex)) {
123 pindexNew->nFile = diskindex.nFile;
124 pindexNew->nDataPos = diskindex.nDataPos;
125 pindexNew->nUndoPos = diskindex.nUndoPos;
131 pindexNew->nStatus = diskindex.nStatus;
132 pindexNew->
nTx = diskindex.
nTx;
135 LogError(
"%s: CheckProofOfWork failed: %s\n", __func__, pindexNew->
ToString());
141 LogError(
"%s: failed to read value\n", __func__);
167 if (pa < pb)
return false;
168 if (pa > pb)
return true;
179std::vector<CBlockIndex*> BlockManager::GetAllBlockIndices()
182 std::vector<CBlockIndex*> rv;
183 rv.reserve(m_block_index.size());
184 for (
auto& [
_, block_index] : m_block_index) {
185 rv.push_back(&block_index);
193 BlockMap::iterator it = m_block_index.find(hash);
194 return it == m_block_index.end() ? nullptr : &it->second;
200 BlockMap::const_iterator it = m_block_index.find(hash);
201 return it == m_block_index.end() ? nullptr : &it->second;
208 auto [mi, inserted] = m_block_index.try_emplace(block.
GetHash(), block);
220 BlockMap::iterator miPrev = m_block_index.find(block.
hashPrevBlock);
221 if (miPrev != m_block_index.end()) {
222 pindexNew->
pprev = &(*miPrev).second;
230 best_header = pindexNew;
243 for (
auto& entry : m_block_index) {
245 if (pindex->nFile == fileNumber) {
246 pindex->nStatus &= ~BLOCK_HAVE_DATA;
247 pindex->nStatus &= ~BLOCK_HAVE_UNDO;
249 pindex->nDataPos = 0;
250 pindex->nUndoPos = 0;
258 while (range.first != range.second) {
259 std::multimap<CBlockIndex*, CBlockIndex*>::iterator _it = range.first;
261 if (_it->second == pindex) {
273 std::set<int>& setFilesToPrune,
274 int nManualPruneHeight,
285 const auto [min_block_to_prune, last_block_can_prune] = chainman.GetPruneRange(chain, nManualPruneHeight);
288 for (
int fileNumber = 0; fileNumber < this->
MaxBlockfileNum(); fileNumber++) {
290 if (fileinfo.nSize == 0 || fileinfo.nHeightLast > (
unsigned)last_block_can_prune || fileinfo.nHeightFirst < (unsigned)min_block_to_prune) {
295 setFilesToPrune.insert(fileNumber);
298 LogPrintf(
"[%s] Prune (Manual): prune_height=%d removed %d blk/rev pairs\n",
299 chain.GetRole(), last_block_can_prune,
count);
303 std::set<int>& setFilesToPrune,
310 const auto target = std::max(
312 const uint64_t target_sync_height = chainman.m_best_header->nHeight;
321 const auto [min_block_to_prune, last_block_can_prune] = chainman.GetPruneRange(chain, last_prune);
328 uint64_t nBytesToPrune;
331 if (nCurrentUsage + nBuffer >= target) {
339 static constexpr uint64_t average_block_size = 1000000;
340 const uint64_t remaining_blocks = target_sync_height - chain_tip_height;
341 nBuffer += average_block_size * remaining_blocks;
344 for (
int fileNumber = 0; fileNumber < this->
MaxBlockfileNum(); fileNumber++) {
346 nBytesToPrune = fileinfo.nSize + fileinfo.nUndoSize;
348 if (fileinfo.nSize == 0) {
352 if (nCurrentUsage + nBuffer < target) {
358 if (fileinfo.nHeightLast > (
unsigned)last_block_can_prune || fileinfo.nHeightFirst < (unsigned)min_block_to_prune) {
364 setFilesToPrune.insert(fileNumber);
365 nCurrentUsage -= nBytesToPrune;
370 LogDebug(
BCLog::PRUNE,
"[%s] target=%dMiB actual=%dMiB diff=%dMiB min_height=%d max_prune_height=%d removed %d blk/rev pairs\n",
371 chain.GetRole(), target / 1024 / 1024, nCurrentUsage / 1024 / 1024,
372 (int64_t(target) - int64_t(nCurrentUsage)) / 1024 / 1024,
373 min_block_to_prune, last_block_can_prune,
count);
376void BlockManager::UpdatePruneLock(
const std::string&
name,
const PruneLockInfo& lock_info) {
378 m_prune_locks[
name] = lock_info;
389 const auto [mi, inserted]{m_block_index.try_emplace(hash)};
399 if (!m_block_tree_db->LoadBlockIndexGuts(
404 if (snapshot_blockhash) {
406 if (!maybe_au_data) {
429 std::vector<CBlockIndex*> vSortedByHeight{GetAllBlockIndices()};
430 std::sort(vSortedByHeight.begin(), vSortedByHeight.end(),
436 if (previous_index && pindex->nHeight > previous_index->nHeight + 1) {
437 LogError(
"%s: block index is non-contiguous, index of height %d missing\n", __func__, previous_index->nHeight + 1);
440 previous_index = pindex;
441 pindex->nChainWork = (pindex->pprev ? pindex->pprev->nChainWork : 0) +
GetBlockProof(*pindex);
442 pindex->nTimeMax = (pindex->pprev ? std::max(pindex->pprev->nTimeMax, pindex->nTime) : pindex->nTime);
448 if (pindex->nTx > 0) {
451 pindex->GetBlockHash() == *snapshot_blockhash) {
453 Assert(pindex->m_chain_tx_count > 0);
454 }
else if (pindex->pprev->m_chain_tx_count > 0) {
455 pindex->m_chain_tx_count = pindex->pprev->m_chain_tx_count + pindex->nTx;
457 pindex->m_chain_tx_count = 0;
461 pindex->m_chain_tx_count = pindex->nTx;
476bool BlockManager::WriteBlockIndexDB()
479 std::vector<std::pair<int, const CBlockFileInfo*>> vFiles;
485 std::vector<const CBlockIndex*> vBlocks;
488 vBlocks.push_back(*it);
492 if (!m_block_tree_db->WriteBatchSync(vFiles, max_blockfile, vBlocks)) {
498bool BlockManager::LoadBlockIndexDB(
const std::optional<uint256>& snapshot_blockhash)
503 int max_blockfile_num{0};
506 m_block_tree_db->ReadLastBlockFile(max_blockfile_num);
508 LogPrintf(
"%s: last block file = %i\n", __func__, max_blockfile_num);
509 for (
int nFile = 0; nFile <= max_blockfile_num; nFile++) {
513 for (
int nFile = max_blockfile_num + 1;
true; nFile++) {
515 if (m_block_tree_db->ReadBlockFileInfo(nFile, info)) {
523 LogPrintf(
"Checking all blk files are present...\n");
524 std::set<int> setBlkDataFiles;
525 for (
const auto& [
_, block_index] : m_block_index) {
527 setBlkDataFiles.insert(block_index.nFile);
530 for (std::set<int>::iterator it = setBlkDataFiles.begin(); it != setBlkDataFiles.end(); it++) {
547 m_block_tree_db->ReadFlag(
"prunedblockfiles",
m_have_pruned);
549 LogPrintf(
"LoadBlockIndexDB(): Block files have previously been pruned\n");
553 bool fReindexing =
false;
554 m_block_tree_db->ReadReindexing(fReindexing);
560void BlockManager::ScanAndUnlinkAlreadyPrunedFiles()
568 std::set<int> block_files_to_prune;
569 for (
int file_number = 0; file_number < max_blockfile; file_number++) {
571 block_files_to_prune.insert(file_number);
578bool BlockManager::IsBlockPruned(
const CBlockIndex& block)
const
588 assert((last_block->nStatus & status_mask) == status_mask);
589 while (last_block->
pprev && ((last_block->
pprev->nStatus & status_mask) == status_mask)) {
592 if (last_block == lower_block)
return lower_block;
597 last_block = last_block->
pprev;
599 assert(last_block !=
nullptr);
606 return GetFirstBlock(upper_block,
BLOCK_HAVE_DATA, &lower_block) == &lower_block;
617 std::map<std::string, fs::path> mapBlockFiles;
622 LogPrintf(
"Removing unusable blk?????.dat and rev?????.dat files for -reindex with -prune\n");
623 for (fs::directory_iterator it(
m_opts.
blocks_dir); it != fs::directory_iterator(); it++) {
625 if (fs::is_regular_file(*it) &&
626 path.length() == 12 &&
627 path.ends_with(
".dat"))
629 if (path.starts_with(
"blk")) {
630 mapBlockFiles[path.substr(3, 5)] = it->path();
631 }
else if (path.starts_with(
"rev")) {
641 int nContigCounter = 0;
642 for (
const std::pair<const std::string, fs::path>& item : mapBlockFiles) {
643 if (LocaleIndependentAtoi<int>(item.first) == nContigCounter) {
665 LogError(
"OpenUndoFile failed for %s while reading block undo", pos.ToString());
675 verifier >> blockundo;
678 filein >> hashChecksum;
681 if (hashChecksum != verifier.GetHash()) {
682 LogError(
"Checksum mismatch at %s while reading block undo", pos.ToString());
685 }
catch (
const std::exception& e) {
686 LogError(
"Deserialize or I/O error - %s at %s while reading block undo", e.what(), pos.ToString());
724 if (!fFinalize || finalize_undo) {
735 return BlockfileType::NORMAL;
760 retval += file.nSize + file.nUndoSize;
768 for (std::set<int>::iterator it = setFilesToPrune.begin(); it != setFilesToPrune.end(); ++it) {
772 if (removed_blockfile || removed_undofile) {
800 if (!m_blockfile_cursors[chain_type]) {
804 m_blockfile_cursors[chain_type] = new_cursor;
807 const int last_blockfile = m_blockfile_cursors[chain_type]->file_num;
809 int nFile = last_blockfile;
814 bool finalize_undo =
false;
819 max_blockfile_size = 0x10000;
820 if (nAddSize >= max_blockfile_size) {
822 max_blockfile_size = nAddSize + 1;
825 assert(nAddSize < max_blockfile_size);
832 Assert(m_blockfile_cursors[chain_type])->undo_height);
847 if (nFile != last_blockfile) {
860 "Failed to flush previous block file %05i (finalize=1, finalize_undo=%i) before opening new block file %05i\n",
861 last_blockfile, finalize_undo, nFile);
890 auto& cursor{m_blockfile_cursors[chain_type]};
891 if (!cursor || cursor->file_num < pos.
nFile) {
897 const int nFile = pos.
nFile;
937 const auto blockundo_size{
static_cast<uint32_t
>(
GetSerializeSize(blockundo))};
939 LogError(
"FindUndoPos failed for %s while writing block undo", pos.
ToString());
947 LogError(
"OpenUndoFile failed for %s while writing block undo", pos.
ToString());
960 fileout << blockundo << hasher.GetHash();
980 }
else if (pos.
nFile == cursor.file_num && block.
nHeight > cursor.undo_height) {
981 cursor.undo_height = block.
nHeight;
984 block.nUndoPos = pos.
nPos;
997 std::vector<uint8_t> block_data;
1005 }
catch (
const std::exception& e) {
1006 LogError(
"Deserialize or I/O error - %s at %s while reading block", e.what(), pos.
ToString());
1012 LogError(
"Errors in block header at %s while reading block", pos.
ToString());
1018 LogError(
"Errors in block solution at %s while reading block", pos.
ToString());
1033 LogError(
"GetHash() doesn't match index for %s at %s while reading block", index.
ToString(), block_pos.ToString());
1045 LogError(
"Failed for %s while reading raw block storage header", pos.
ToString());
1049 if (filein.IsNull()) {
1050 LogError(
"OpenBlockFile failed for %s while reading raw block", pos.
ToString());
1056 unsigned int blk_size;
1058 filein >> blk_start >> blk_size;
1060 if (blk_start !=
GetParams().MessageStart()) {
1061 LogError(
"Block magic mismatch for %s: %s versus expected %s while reading raw block",
1067 LogError(
"Block data is larger than maximum deserialization size for %s: %s versus %s while reading raw block",
1072 block.resize(blk_size);
1074 }
catch (
const std::exception& e) {
1075 LogError(
"Read from block file failed: %s for %s while reading raw block", e.what(), pos.
ToString());
1087 LogError(
"FindNextBlockPos failed for %s while writing block", pos.
ToString());
1091 if (file.IsNull()) {
1092 LogError(
"OpenBlockFile failed for %s while writing block", pos.
ToString());
1110 std::array<std::byte, 8> xor_key{};
1115 bool first_run =
true;
1116 for (
const auto& entry : fs::directory_iterator(opts.
blocks_dir)) {
1118 if (!entry.is_regular_file() || !path.starts_with(
'.')) {
1124 if (opts.
use_xor && first_run) {
1130 const fs::path xor_key_path{opts.
blocks_dir /
"xor.dat"};
1134 xor_key_file >> xor_key;
1144 xor_key_file << xor_key;
1147 if (!opts.
use_xor && xor_key !=
decltype(xor_key){}) {
1148 throw std::runtime_error{
1149 strprintf(
"The blocksdir XOR-key can not be disabled when a random key was already stored! "
1150 "Stored key: '%s', stored path: '%s'.",
1155 return std::vector<std::byte>{xor_key.begin(), xor_key.end()};
1159 : m_prune_mode{opts.prune_target > 0},
1161 m_opts{
std::move(opts)},
1164 m_interrupt{interrupt}
1169 m_block_tree_db->WriteReindexing(
true);
1204 std::multimap<uint256, FlatFilePos> blocks_with_unknown_parent;
1211 if (file.IsNull()) {
1214 LogPrintf(
"Reindexing block file blk%05u.dat...\n", (
unsigned int)nFile);
1217 LogPrintf(
"Interrupt requested. Exit %s\n", __func__);
1230 for (
const fs::path& path : import_paths) {
1232 if (!file.IsNull()) {
1236 LogPrintf(
"Interrupt requested. Exit %s\n", __func__);
1251 if (!chainstate->ActivateBestChain(state,
nullptr)) {
1261 case BlockfileType::NORMAL: os <<
"normal";
break;
1263 default: os.setstate(std::ios_base::failbit);
void CheckBlockDataAvailability(BlockManager &blockman, const CBlockIndex &blockindex, bool check_for_undo)
arith_uint256 GetBlockProof(const CBlockIndex &block)
@ BLOCK_VALID_TREE
All parent headers found, difficulty matches, timestamp >= median previous.
@ BLOCK_HAVE_UNDO
undo data available in rev*.dat
@ BLOCK_HAVE_DATA
full block available in blk*.dat
@ BLOCK_FAILED_CHILD
descends from failed block
#define Assert(val)
Identity function.
Non-refcounted RAII wrapper for FILE*.
Wrapper that buffers reads from an underlying stream.
Wrapper that buffers writes to an underlying stream.
The block chain is a tree shaped structure starting with the genesis block at the root,...
std::string ToString() const
CBlockIndex * pprev
pointer to the index of the predecessor of this block
uint64_t m_chain_tx_count
(memory only) Number of transactions in the chain up to and including this block.
void BuildSkip()
Build the skiplist pointer for this entry.
arith_uint256 nChainWork
(memory only) Total amount of work (expected number of hashes) in the chain up to and including this ...
unsigned int nTimeMax
(memory only) Maximum nTime in the chain up to and including this block.
int32_t nSequenceId
(memory only) Sequential id assigned to distinguish order in which blocks are received.
uint256 GetBlockHash() const
FlatFilePos GetUndoPos() const EXCLUSIVE_LOCKS_REQUIRED(
bool RaiseValidity(enum BlockStatus nUpTo) EXCLUSIVE_LOCKS_REQUIRED(
Raise the validity level of this block index entry.
unsigned int nTx
Number of transactions in this block.
int32_t nVersion
block header
int nHeight
height of the entry in the chain. The genesis block has height 0
FlatFilePos GetBlockPos() const EXCLUSIVE_LOCKS_REQUIRED(
const uint256 * phashBlock
pointer to the hash of the block, if any. Memory is owned by this CBlockIndex
Undo information for a CBlock.
int Height() const
Return the maximal height in the chain.
const MessageStartChars & MessageStart() const
std::optional< AssumeutxoData > AssumeutxoForBlockhash(const uint256 &blockhash) const
uint64_t PruneAfterHeight() const
Batch of changes queued to be written to a CDBWrapper.
void Write(const K &key, const V &value)
bool WriteBatch(CDBBatch &batch, bool fSync=false)
bool Read(const K &key, V &value) const
CDBIterator * NewIterator()
bool Erase(const K &key, bool fSync=false)
bool Write(const K &key, const V &value, bool fSync=false)
bool Exists(const K &key) const
Used to marshal pointers into hashes for db storage.
uint256 ConstructBlockHash() const
Chainstate stores and provides an API to update our local knowledge of the current best chain.
CChain m_chain
The current chain of blockheaders we consult and build on.
Provides an interface for creating and interacting with one or two chainstates: an IBD chainstate gen...
SnapshotCompletionResult MaybeCompleteSnapshotValidation() EXCLUSIVE_LOCKS_REQUIRED(const CBlockIndex *GetSnapshotBaseBlock() const EXCLUSIVE_LOCKS_REQUIRED(Chainstate ActiveChainstate)() const
Once the background validation chainstate has reached the height which is the base of the UTXO snapsh...
kernel::Notifications & GetNotifications() const
bool IsInitialBlockDownload() const
Check whether we are doing an initial block download (synchronizing from disk or network)
const util::SignalInterrupt & m_interrupt
void LoadExternalBlockFile(AutoFile &file_in, FlatFilePos *dbp=nullptr, std::multimap< uint256, FlatFilePos > *blocks_with_unknown_parent=nullptr)
Import blocks from an external file.
const CChainParams & GetParams() const
Chainstate &InitializeChainstate(CTxMemPool *mempool) EXCLUSIVE_LOCKS_REQUIRED(std::vector< Chainstate * GetAll)()
Instantiate a new chainstate.
node::BlockManager m_blockman
A single BlockManager instance is shared across each constructed chainstate to avoid duplicating bloc...
void fillrand(std::span< std::byte > output) noexcept
Fill a byte span with random bytes.
FlatFileSeq represents a sequence of numbered files storing raw data.
FILE * Open(const FlatFilePos &pos, bool read_only=false) const
Open a handle to the file at the given position.
fs::path FileName(const FlatFilePos &pos) const
Get the name of the file at the given position.
bool Flush(const FlatFilePos &pos, bool finalize=false) const
Commit a file to disk, and optionally truncate off extra pre-allocated bytes if final.
size_t Allocate(const FlatFilePos &pos, size_t add_size, bool &out_of_space) const
Allocate additional space in a file after the given starting position.
Reads data from an underlying stream, while hashing the read data.
A writer stream (for serialization) that computes a 256-bit hash.
Minimal stream for reading from an existing byte array by std::span.
std::string ToString() const
constexpr bool IsNull() const
bool ReadLastBlockFile(int &nFile)
bool ReadFlag(const std::string &name, bool &fValue)
bool ReadBlockFileInfo(int nFile, CBlockFileInfo &info)
void ReadReindexing(bool &fReindexing)
bool WriteFlag(const std::string &name, bool fValue)
bool WriteBatchSync(const std::vector< std::pair< int, const CBlockFileInfo * > > &fileInfo, int nLastFile, const std::vector< const CBlockIndex * > &blockinfo)
bool WriteReindexing(bool fReindexing)
virtual void fatalError(const bilingual_str &message)
The fatal error notification is sent to notify the user when an error occurs in kernel code that can'...
virtual void flushError(const bilingual_str &message)
The flush error notification is sent to notify the user that an error occurred while flushing block d...
const kernel::BlockManagerOpts m_opts
std::set< int > m_dirty_fileinfo
Dirty block file entries.
const FlatFileSeq m_undo_file_seq
RecursiveMutex cs_LastBlockFile
const CChainParams & GetParams() const
bool FlushChainstateBlockFile(int tip_height)
void FindFilesToPrune(std::set< int > &setFilesToPrune, int last_prune, const Chainstate &chain, ChainstateManager &chainman)
Prune block and undo files (blk???.dat and rev???.dat) so that the disk space used is less than a use...
void UpdateBlockInfo(const CBlock &block, unsigned int nHeight, const FlatFilePos &pos)
Update blockfile info while processing a block during reindex.
CBlockIndex * LookupBlockIndex(const uint256 &hash) EXCLUSIVE_LOCKS_REQUIRED(cs_main)
bool ReadBlockUndo(CBlockUndo &blockundo, const CBlockIndex &index) const
bool ReadRawBlock(std::vector< uint8_t > &block, const FlatFilePos &pos) const
void PruneOneBlockFile(const int fileNumber) EXCLUSIVE_LOCKS_REQUIRED(cs_main)
Mark one block file as pruned (modify associated database entries)
BlockfileType BlockfileTypeForHeight(int height)
std::atomic_bool m_blockfiles_indexed
Whether all blockfiles have been added to the block tree database.
std::vector< CBlockIndex * > GetAllBlockIndices() EXCLUSIVE_LOCKS_REQUIRED(std::multimap< CBlockIndex *, CBlockIndex * > m_blocks_unlinked
All pairs A->B, where A (or one of its ancestors) misses transactions, but B has transactions.
const Consensus::Params & GetConsensus() const
BlockManager(const util::SignalInterrupt &interrupt, Options opts)
std::set< CBlockIndex * > m_dirty_blockindex
Dirty block index entries.
const std::vector< std::byte > m_xor_key
fs::path GetBlockPosFilename(const FlatFilePos &pos) const
Translation to a filesystem path.
bool FlushBlockFile(int blockfile_num, bool fFinalize, bool finalize_undo)
Return false if block file or undo file flushing fails.
uint64_t GetPruneTarget() const
Attempt to stay below this number of bytes of block files.
int MaxBlockfileNum() const EXCLUSIVE_LOCKS_REQUIRED(cs_LastBlockFile)
void UnlinkPrunedFiles(const std::set< int > &setFilesToPrune) const
Actually unlink the specified files.
bool WriteBlockIndexDB() EXCLUSIVE_LOCKS_REQUIRED(bool LoadBlockIndexDB(const std::optional< uint256 > &snapshot_blockhash) EXCLUSIVE_LOCKS_REQUIRED(void ScanAndUnlinkAlreadyPrunedFiles() EXCLUSIVE_LOCKS_REQUIRED(CBlockIndex * AddToBlockIndex(const CBlockHeader &block, CBlockIndex *&best_header) EXCLUSIVE_LOCKS_REQUIRED(cs_main)
Remove any pruned block & undo files that are still on disk.
FlatFilePos FindNextBlockPos(unsigned int nAddSize, unsigned int nHeight, uint64_t nTime)
Helper function performing various preparations before a block can be saved to disk: Returns the corr...
bool CheckBlockDataAvailability(const CBlockIndex &upper_block LIFETIMEBOUND, const CBlockIndex &lower_block LIFETIMEBOUND) EXCLUSIVE_LOCKS_REQUIRED(const CBlockIndex *GetFirstBlock(const CBlockIndex &upper_block LIFETIMEBOUND, uint32_t status_mask, const CBlockIndex *lower_block=nullptr) const EXCLUSIVE_LOCKS_REQUIRED(boo m_have_pruned)
Check if all blocks in the [upper_block, lower_block] range have data available.
bool FlushUndoFile(int block_file, bool finalize=false)
Return false if undo file flushing fails.
uint64_t CalculateCurrentUsage()
Calculate the amount of disk space the block & undo files currently use.
const util::SignalInterrupt & m_interrupt
const FlatFileSeq m_block_file_seq
CBlockIndex * InsertBlockIndex(const uint256 &hash) EXCLUSIVE_LOCKS_REQUIRED(cs_main)
Create a new block index entry for a given block hash.
bool m_check_for_pruning
Global flag to indicate we should check to see if there are block/undo files that should be deleted.
bool FindUndoPos(BlockValidationState &state, int nFile, FlatFilePos &pos, unsigned int nAddSize)
bool IsPruneMode() const
Whether running in -prune mode.
void CleanupBlockRevFiles() const
void FindFilesToPruneManual(std::set< int > &setFilesToPrune, int nManualPruneHeight, const Chainstate &chain, ChainstateManager &chainman)
std::atomic< bool > m_importing
bool WriteBlockUndo(const CBlockUndo &blockundo, BlockValidationState &state, CBlockIndex &block) EXCLUSIVE_LOCKS_REQUIRED(FlatFilePos WriteBlock(const CBlock &block, int nHeight)
Store block on disk and update block file statistics.
bool IsBlockPruned(const CBlockIndex &block) const EXCLUSIVE_LOCKS_REQUIRED(void UpdatePruneLock(const std::string &name, const PruneLockInfo &lock_info) EXCLUSIVE_LOCKS_REQUIRED(AutoFile OpenBlockFile(const FlatFilePos &pos, bool fReadOnly) const
Check whether the block associated with this index entry is pruned or not.
std::vector< CBlockFileInfo > m_blockfile_info
CBlockFileInfo * GetBlockFileInfo(size_t n)
Get block file info entry for one block file.
bool LoadBlockIndex(const std::optional< uint256 > &snapshot_blockhash) EXCLUSIVE_LOCKS_REQUIRED(cs_main)
Load the blocktree off disk and into memory.
bool ReadBlock(CBlock &block, const FlatFilePos &pos) const
Functions for disk access for blocks.
AutoFile OpenUndoFile(const FlatFilePos &pos, bool fReadOnly=false) const
Open an undo file (rev?????.dat)
std::optional< int > m_snapshot_height
The height of the base block of an assumeutxo snapshot, if one is in use.
ImportingNow(std::atomic< bool > &importing)
std::atomic< bool > & m_importing
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.
static bool exists(const path &p)
static std::string PathToString(const path &path)
Convert path object to a byte string.
std::string HexStr(const std::span< const uint8_t > s)
Convert a span of bytes to a lower-case hexadecimal string.
#define LogPrintLevel(category, level,...)
#define LogDebug(category,...)
std::array< uint8_t, 4 > MessageStartChars
FILE * fopen(const fs::path &p, const char *mode)
static constexpr uint8_t DB_REINDEX_FLAG
static constexpr uint8_t DB_FLAG
static constexpr uint8_t DB_BLOCK_INDEX
static constexpr uint8_t DB_LAST_BLOCK
static constexpr uint8_t DB_BLOCK_FILES
static const unsigned int UNDOFILE_CHUNK_SIZE
The pre-allocation chunk size for rev?????.dat files (since 0.8)
static auto InitBlocksdirXorKey(const BlockManager::Options &opts)
static const unsigned int BLOCKFILE_CHUNK_SIZE
The pre-allocation chunk size for blk?????.dat files (since 0.8)
static constexpr uint32_t STORAGE_HEADER_BYTES
Size of header written by WriteBlock before a serialized CBlock (8 bytes)
std::ostream & operator<<(std::ostream &os, const BlockfileType &type)
static constexpr uint32_t UNDO_DATA_DISK_OVERHEAD
Total overhead when writing undo data: header (8 bytes) plus checksum (32 bytes)
static const unsigned int MAX_BLOCKFILE_SIZE
The maximum size of a blk?????.dat file (since 0.8)
void ImportBlocks(ChainstateManager &chainman, std::span< const fs::path > import_paths)
std::string ToString(const T &t)
Locale-independent version of std::to_string.
bool CheckProofOfWork(uint256 hash, unsigned int nBits, const Consensus::Params ¶ms)
Check whether a block hash satisfies the proof-of-work requirement specified by nBits.
static constexpr TransactionSerParams TX_WITH_WITNESS
size_t GetSerializeSize(const T &t)
static constexpr uint64_t MAX_SIZE
The maximum size of a serialized object in bytes or number of elements (for eg vectors) when the size...
bool CheckSignetBlockSolution(const CBlock &block, const Consensus::Params &consensusParams)
Extract signature and check whether a block has a valid solution.
auto MakeWritableByteSpan(V &&v) noexcept
Holds configuration for use during UTXO snapshot load and validation.
uint64_t m_chain_tx_count
Used to populate the m_chain_tx_count value, which is used during BlockManager::LoadBlockIndex().
Parameters that influence chain consensus.
bool wipe_data
If true, remove all existing data.
std::string ToString() const
An options struct for BlockManager, more ergonomically referred to as BlockManager::Options due to th...
Notifications & notifications
const fs::path blocks_dir
DBParams block_tree_db_params
bool operator()(const CBlockIndex *pa, const CBlockIndex *pb) const
bool operator()(const CBlockIndex *pa, const CBlockIndex *pb) const
#define WITH_LOCK(cs, code)
Run code while locking a mutex.
#define EXCLUSIVE_LOCKS_REQUIRED(...)
consteval auto _(util::TranslatedLiteral str)
bool FatalError(Notifications ¬ifications, BlockValidationState &state, const bilingual_str &message)
static const uint64_t MIN_DISK_SPACE_FOR_BLOCK_FILES