66 DBHeightKey() : height(0) {}
67 explicit DBHeightKey(
int height_in) : height(height_in) {}
69 template <
typename Stream>
void Serialize(Stream &s)
const {
74 template <
typename Stream>
void Unserialize(Stream &s) {
77 throw std::ios_base::failure(
78 "Invalid format for block filter index DB height key");
87 explicit DBHashKey(
const BlockHash &hash_in) : hash(hash_in) {}
93 throw std::ios_base::failure(
94 "Invalid format for block filter index DB hash key");
106 size_t n_cache_size,
bool f_memory,
108 : m_filter_type(filter_type) {
110 if (filter_name.empty()) {
111 throw std::invalid_argument(
"unknown filter_type");
116 fs::create_directories(path);
118 m_name = filter_name +
" block filter index";
119 m_db = std::make_unique<BaseIndex::DB>(path /
"db", n_cache_size, f_memory,
132 "%s: Cannot read current %s state; index may be corrupted",
150 return error(
"%s: Failed to open filter file %d", __func__, pos.
nFile);
153 return error(
"%s: Failed to commit filter file %d", __func__,
170 std::vector<uint8_t> encoded_filter;
172 filein >> block_hash >> encoded_filter;
175 }
catch (
const std::exception &e) {
176 return error(
"%s: Failed to deserialize block filter from disk: %s",
197 LogPrintf(
"%s: Failed to open filter file %d\n", __func__,
202 LogPrintf(
"%s: Failed to truncate filter file %d\n", __func__,
207 LogPrintf(
"%s: Failed to commit filter file %d\n", __func__,
220 LogPrintf(
"%s: out of disk space\n", __func__);
226 LogPrintf(
"%s: Failed to open filter file %d\n", __func__, pos.
nFile);
244 std::pair<BlockHash, DBVal> read_out;
245 if (!
m_db->Read(DBHeightKey(pindex->
nHeight - 1), read_out)) {
250 if (read_out.first != expected_block_hash) {
251 return error(
"%s: previous block header belongs to unexpected "
252 "block %s; expected %s",
253 __func__, read_out.first.ToString(),
257 prev_header = read_out.second.header;
263 if (bytes_written == 0) {
267 std::pair<BlockHash, DBVal> value;
269 value.second.hash = filter.
GetHash();
273 if (!
m_db->Write(DBHeightKey(pindex->
nHeight), value)) {
282 const std::string &index_name,
283 int start_height,
int stop_height) {
284 DBHeightKey key(start_height);
287 for (
int height = start_height; height <= stop_height; ++height) {
288 if (!db_it.
GetKey(key) || key.height != height) {
289 return error(
"%s: unexpected key in %s: expected (%c, %d)",
293 std::pair<BlockHash, DBVal> value;
295 return error(
"%s: unable to read value in %s at key (%c, %d)",
299 batch.
Write(DBHashKey(value.first), std::move(value.second));
311 std::unique_ptr<CDBIterator> db_it(
m_db->NewIterator());
326 if (!
m_db->WriteBatch(batch)) {
338 std::pair<BlockHash, DBVal> read_out;
339 if (!
db.Read(DBHeightKey(block_index->
nHeight), read_out)) {
343 result = std::move(read_out.second);
354 std::vector<DBVal> &results) {
355 if (start_height < 0) {
356 return error(
"%s: start height (%d) is negative", __func__,
359 if (start_height > stop_index->
nHeight) {
360 return error(
"%s: start height (%d) is greater than stop height (%d)",
361 __func__, start_height, stop_index->
nHeight);
364 size_t results_size =
365 static_cast<size_t>(stop_index->
nHeight - start_height + 1);
366 std::vector<std::pair<BlockHash, DBVal>> values(results_size);
368 DBHeightKey key(start_height);
369 std::unique_ptr<CDBIterator> db_it(
db.NewIterator());
370 db_it->Seek(DBHeightKey(start_height));
371 for (
int height = start_height; height <= stop_index->
nHeight; ++height) {
372 if (!db_it->Valid() || !db_it->GetKey(key) || key.height != height) {
376 size_t i =
static_cast<size_t>(height - start_height);
377 if (!db_it->GetValue(values[i])) {
378 return error(
"%s: unable to read value in %s at key (%c, %d)",
385 results.resize(results_size);
391 block_index && block_index->
nHeight >= start_height;
392 block_index = block_index->pprev) {
393 BlockHash block_hash = block_index->GetBlockHash();
395 size_t i =
static_cast<size_t>(block_index->nHeight - start_height);
396 if (block_hash == values[i].first) {
397 results[i] = std::move(values[i].second);
401 if (!
db.Read(DBHashKey(block_hash), results[i])) {
402 return error(
"%s: unable to read value in %s at key (%c, %s)",
430 auto header = m_headers_cache.find(block_index->
GetBlockHash());
431 if (header != m_headers_cache.end()) {
432 header_out = header->second;
444 m_headers_cache.emplace(block_index->
GetBlockHash(), entry.header);
447 header_out = entry.header;
453 std::vector<BlockFilter> &filters_out)
const {
454 std::vector<DBVal> entries;
459 filters_out.resize(entries.size());
460 auto filter_pos_it = filters_out.begin();
461 for (
const auto &entry : entries) {
473 std::vector<uint256> &hashes_out)
const
476 std::vector<DBVal> entries;
482 hashes_out.reserve(entries.size());
483 for (
const auto &entry : entries) {
484 hashes_out.push_back(entry.hash);
501 bool f_memory,
bool f_wipe) {
503 std::piecewise_construct, std::forward_as_tuple(filter_type),
504 std::forward_as_tuple(filter_type, n_cache_size, f_memory, f_wipe));
505 return result.second;
const std::string & BlockFilterTypeName(BlockFilterType filter_type)
Get the human-readable name for a filter type.
constexpr char DB_BLOCK_HASH
The index database stores three items for each block: the disk location of the encoded filter,...
constexpr unsigned int FLTR_FILE_CHUNK_SIZE
The pre-allocation chunk size for fltr?????.dat files.
bool DestroyBlockFilterIndex(BlockFilterType filter_type)
Destroy the block filter index with the given type.
void DestroyAllBlockFilterIndexes()
Destroy all open block filter indexes.
constexpr char DB_BLOCK_HEIGHT
static bool CopyHeightIndexToHashIndex(CDBIterator &db_it, CDBBatch &batch, const std::string &index_name, int start_height, int stop_height)
static bool LookupOne(const CDBWrapper &db, const CBlockIndex *block_index, DBVal &result)
BlockFilterIndex * GetBlockFilterIndex(BlockFilterType filter_type)
Get a block filter index by type.
constexpr unsigned int MAX_FLTR_FILE_SIZE
void ForEachBlockFilterIndex(std::function< void(BlockFilterIndex &)> fn)
Iterate over all running block filter indexes, invoking fn on each.
constexpr size_t CF_HEADERS_CACHE_MAX_SZ
Maximum size of the cfheaders cache.
static bool LookupRange(CDBWrapper &db, const std::string &index_name, int start_height, const CBlockIndex *stop_index, std::vector< DBVal > &results)
constexpr char DB_FILTER_POS
bool InitBlockFilterIndex(BlockFilterType filter_type, size_t n_cache_size, bool f_memory, bool f_wipe)
Initialize a block filter index for the given type if one does not already exist.
static std::map< BlockFilterType, BlockFilterIndex > g_filter_indexes
static constexpr int CFCHECKPT_INTERVAL
Interval between compact filter checkpoints.
const fs::path & GetDataDirNet() const
Get data directory path with appended network identifier.
virtual bool Init()
Initialize internal state from the database and block index.
virtual bool CommitInternal(CDBBatch &batch)
Virtual method called internally by Commit that can be overridden to atomically commit more index sta...
virtual bool Rewind(const CBlockIndex *current_tip, const CBlockIndex *new_tip)
Rewind index to an earlier chain tip during a chain reorg.
Complete block filter struct as defined in BIP 157.
const BlockHash & GetBlockHash() const
uint256 ComputeHeader(const uint256 &prev_header) const
Compute the filter header given the previous one.
BlockFilterType GetFilterType() const
const std::vector< uint8_t > & GetEncodedFilter() const
uint256 GetHash() const
Compute the filter hash.
BlockFilterIndex is used to store and retrieve block filters, hashes, and headers for a range of bloc...
std::unique_ptr< BaseIndex::DB > m_db
bool CommitInternal(CDBBatch &batch) override
Virtual method called internally by Commit that can be overridden to atomically commit more index sta...
bool Rewind(const CBlockIndex *current_tip, const CBlockIndex *new_tip) override
Rewind index to an earlier chain tip during a chain reorg.
bool ReadFilterFromDisk(const FlatFilePos &pos, BlockFilter &filter) const
bool LookupFilterRange(int start_height, const CBlockIndex *stop_index, std::vector< BlockFilter > &filters_out) const
Get a range of filters between two heights on a chain.
BlockFilterType GetFilterType() const
bool LookupFilterHeader(const CBlockIndex *block_index, uint256 &header_out)
Get a single filter header by block.
BlockFilterType m_filter_type
bool Init() override
Initialize internal state from the database and block index.
bool WriteBlock(const CBlock &block, const CBlockIndex *pindex) override
Write update index entries for a newly connected block.
BlockFilterIndex(BlockFilterType filter_type, size_t n_cache_size, bool f_memory=false, bool f_wipe=false)
Constructs the index, which becomes available to be queried.
std::unique_ptr< FlatFileSeq > m_filter_fileseq
bool LookupFilter(const CBlockIndex *block_index, BlockFilter &filter_out) const
Get a single filter by block.
bool LookupFilterHashRange(int start_height, const CBlockIndex *stop_index, std::vector< uint256 > &hashes_out) const
Get a range of filter hashes between two heights on a chain.
const char * GetName() const override
Get the name of the index for display in logs.
size_t WriteFilterToDisk(FlatFilePos &pos, const BlockFilter &filter)
FlatFilePos m_next_filter_pos
Non-refcounted RAII wrapper for FILE*.
FILE * Get() const
Get wrapped FILE* without transfer of ownership.
bool IsNull() const
Return true if the wrapped FILE* is nullptr, false otherwise.
The block chain is a tree shaped structure starting with the genesis block at the root,...
CBlockIndex * pprev
pointer to the index of the predecessor of this block
CBlockIndex * GetAncestor(int height)
Efficiently find an ancestor of this block.
BlockHash GetBlockHash() const
int nHeight
height of the entry in the chain. The genesis block has height 0
Undo information for a CBlock.
Batch of changes queued to be written to a CDBWrapper.
void Write(const K &key, const V &value)
std::string ToString() const
Path class wrapper to prepare application code for transition from boost::filesystem library to std::...
static constexpr int CLIENT_VERSION
bitcoind-res.rc includes this file, but it cannot cope with real c++ code.
bool UndoReadFromDisk(CBlockUndo &blockundo, const CBlockIndex *pindex)
uint8_t ser_readdata8(Stream &s)
void ser_writedata32be(Stream &s, uint32_t obj)
#define SERIALIZE_METHODS(cls, obj)
Implement the Serialize and Unserialize methods by delegating to a single templated static method tha...
void Serialize(Stream &s, char a)
void Unserialize(Stream &s, char &a)
void ser_writedata8(Stream &s, uint8_t obj)
Lowest-level serialization and conversion.
size_t GetSerializeSize(const T &t, int nVersion=0)
uint32_t ser_readdata32be(Stream &s)
A BlockHash is a unqiue identifier for a block.
bool TruncateFile(FILE *file, unsigned int length)
bool FileCommit(FILE *file)
bool error(const char *fmt, const Args &...args)