10 #include <validation.h> 54 explicit DBHeightKey(
int height_in) : height(height_in) {}
56 template<
typename Stream>
63 template<
typename Stream>
68 throw std::ios_base::failure(
"Invalid format for block filter index DB height key");
77 explicit DBHashKey(
const uint256& hash_in) : hash(hash_in) {}
83 throw std::ios_base::failure(
"Invalid format for block filter index DB hash key");
95 size_t n_cache_size,
bool f_memory,
bool f_wipe)
96 : m_filter_type(filter_type)
99 if (filter_name.empty())
throw std::invalid_argument(
"unknown filter_type");
101 fs::path path =
GetDataDir() /
"indexes" /
"blockfilter" / filter_name;
102 fs::create_directories(path);
104 m_name = filter_name +
" block filter index";
105 m_db = MakeUnique<BaseIndex::DB>(path /
"db", n_cache_size, f_memory, f_wipe);
116 return error(
"%s: Cannot read current %s state; index may be corrupted",
134 return error(
"%s: Failed to open filter file %d", __func__, pos.
nFile);
137 return error(
"%s: Failed to commit filter file %d", __func__, pos.
nFile);
147 if (filein.IsNull()) {
152 std::vector<unsigned char> encoded_filter;
154 filein >> block_hash >> encoded_filter;
157 catch (
const std::exception& e) {
158 return error(
"%s: Failed to deserialize block filter from disk: %s", __func__, e.what());
175 if (last_file.IsNull()) {
176 LogPrintf(
"%s: Failed to open filter file %d\n", __func__, pos.
nFile);
180 LogPrintf(
"%s: Failed to truncate filter file %d\n", __func__, pos.
nFile);
184 LogPrintf(
"%s: Failed to commit filter file %d\n", __func__, pos.
nFile);
196 LogPrintf(
"%s: out of disk space\n", __func__);
201 if (fileout.IsNull()) {
202 LogPrintf(
"%s: Failed to open filter file %d\n", __func__, pos.
nFile);
220 std::pair<uint256, DBVal> read_out;
221 if (!
m_db->Read(DBHeightKey(pindex->
nHeight - 1), read_out)) {
226 if (read_out.first != expected_block_hash) {
227 return error(
"%s: previous block header belongs to unexpected block %s; expected %s",
228 __func__, read_out.first.ToString(), expected_block_hash.
ToString());
231 prev_header = read_out.second.header;
237 if (bytes_written == 0)
return false;
239 std::pair<uint256, DBVal> value;
241 value.second.hash = filter.
GetHash();
245 if (!
m_db->Write(DBHeightKey(pindex->
nHeight), value)) {
254 const std::string& index_name,
255 int start_height,
int stop_height)
257 DBHeightKey key(start_height);
260 for (
int height = start_height; height <= stop_height; ++height) {
261 if (!db_it.
GetKey(key) || key.height != height) {
262 return error(
"%s: unexpected key in %s: expected (%c, %d)",
266 std::pair<uint256, DBVal> value;
268 return error(
"%s: unable to read value in %s at key (%c, %d)",
272 batch.
Write(DBHashKey(value.first), std::move(value.second));
284 std::unique_ptr<CDBIterator> db_it(
m_db->NewIterator());
297 if (!
m_db->WriteBatch(batch))
return false;
306 std::pair<uint256, DBVal> read_out;
307 if (!db.
Read(DBHeightKey(block_index->
nHeight), read_out)) {
311 result = std::move(read_out.second);
321 const CBlockIndex* stop_index, std::vector<DBVal>& results)
323 if (start_height < 0) {
324 return error(
"%s: start height (%d) is negative", __func__, start_height);
326 if (start_height > stop_index->
nHeight) {
327 return error(
"%s: start height (%d) is greater than stop height (%d)",
328 __func__, start_height, stop_index->
nHeight);
331 size_t results_size =
static_cast<size_t>(stop_index->
nHeight - start_height + 1);
332 std::vector<std::pair<uint256, DBVal>> values(results_size);
334 DBHeightKey key(start_height);
335 std::unique_ptr<CDBIterator> db_it(db.
NewIterator());
336 db_it->Seek(DBHeightKey(start_height));
337 for (
int height = start_height; height <= stop_index->
nHeight; ++height) {
338 if (!db_it->Valid() || !db_it->GetKey(key) || key.height != height) {
342 size_t i =
static_cast<size_t>(height - start_height);
343 if (!db_it->GetValue(values[i])) {
344 return error(
"%s: unable to read value in %s at key (%c, %d)",
351 results.resize(results_size);
356 block_index && block_index->
nHeight >= start_height;
357 block_index = block_index->pprev) {
358 uint256 block_hash = block_index->GetBlockHash();
360 size_t i =
static_cast<size_t>(block_index->nHeight - start_height);
361 if (block_hash == values[i].first) {
362 results[i] = std::move(values[i].second);
366 if (!db.
Read(DBHashKey(block_hash), results[i])) {
367 return error(
"%s: unable to read value in %s at key (%c, %s)",
393 auto header = m_headers_cache.find(block_index->
GetBlockHash());
394 if (header != m_headers_cache.end()) {
395 header_out = header->second;
408 m_headers_cache.emplace(block_index->
GetBlockHash(), entry.header);
411 header_out = entry.header;
416 std::vector<BlockFilter>& filters_out)
const 418 std::vector<DBVal> entries;
423 filters_out.resize(entries.size());
424 auto filter_pos_it = filters_out.begin();
425 for (
const auto& entry : entries) {
436 std::vector<uint256>& hashes_out)
const 439 std::vector<DBVal> entries;
445 hashes_out.reserve(entries.size());
446 for (
const auto& entry : entries) {
447 hashes_out.push_back(entry.hash);
464 size_t n_cache_size,
bool f_memory,
bool f_wipe)
467 std::forward_as_tuple(filter_type),
468 std::forward_as_tuple(filter_type,
469 n_cache_size, f_memory, f_wipe));
470 return result.second;
bool LookupFilter(const CBlockIndex *block_index, BlockFilter &filter_out) const
Get a single filter by block.
BlockFilterIndex is used to store and retrieve block filters, hashes, and headers for a range of bloc...
constexpr char DB_BLOCK_HEIGHT
std::deque< CInv >::iterator it
bool FileCommit(FILE *file)
Ensure file contents are fully committed to disk, using a platform-specific feature analogous to fsyn...
constexpr char DB_BLOCK_HASH
virtual bool Init()
Initialize internal state from the database and block index.
uint8_t ser_readdata8(Stream &s)
CBlockIndex * pprev
pointer to the index of the predecessor of this block
Batch of changes queued to be written to a CDBWrapper.
static bool LookupRange(CDBWrapper &db, const std::string &index_name, int start_height, const CBlockIndex *stop_index, std::vector< DBVal > &results)
BlockFilterIndex * GetBlockFilterIndex(BlockFilterType filter_type)
Get a block filter index by type.
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 We have a limit to prevent a bug in filling this cache potentiall...
constexpr unsigned int MAX_FLTR_FILE_SIZE
bool Rewind(const CBlockIndex *current_tip, const CBlockIndex *new_tip) override
Rewind index to an earlier chain tip during a chain reorg.
static void LogPrintf(const char *fmt, const Args &... args)
bool WriteBlock(const CBlock &block, const CBlockIndex *pindex) override
Write update index entries for a newly connected block.
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. ...
virtual bool Rewind(const CBlockIndex *current_tip, const CBlockIndex *new_tip)
Rewind index to an earlier chain tip during a chain reorg.
std::unique_ptr< BaseIndex::DB > m_db
CDBIterator * NewIterator()
uint256 GetHash() const
Compute the filter hash.
size_t GetSerializeSize(const T &t, int nVersion=0)
void Serialize(Stream &s, char a)
constexpr char DB_FILTER_POS
uint256 GetBlockHash() const
static bool CopyHeightIndexToHashIndex(CDBIterator &db_it, CDBBatch &batch, const std::string &index_name, int start_height, int stop_height)
const std::vector< unsigned char > & GetEncodedFilter() const
bool ReadFilterFromDisk(const FlatFilePos &pos, BlockFilter &filter) const
size_t WriteFilterToDisk(FlatFilePos &pos, const BlockFilter &filter)
Complete block filter struct as defined in BIP 157.
bool UndoReadFromDisk(CBlockUndo &blockundo, const CBlockIndex *pindex)
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.
void DestroyAllBlockFilterIndexes()
Destroy all open block filter indexes.
const fs::path & GetDataDir(bool fNetSpecific)
constexpr unsigned int FLTR_FILE_CHUNK_SIZE
The pre-allocation chunk size for fltr?????.dat files.
void Write(const K &key, const V &value)
const uint256 & GetBlockHash() const
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.
virtual bool CommitInternal(CDBBatch &batch)
Virtual method called internally by Commit that can be overridden to atomically commit more index sta...
std::string ToString() const
void ser_writedata32be(Stream &s, uint32_t obj)
bool Read(const K &key, V &value) const
#define SERIALIZE_METHODS(cls, obj)
Implement the Serialize and Unserialize methods by delegating to a single templated static method tha...
BlockFilterType m_filter_type
static constexpr int CFCHECKPT_INTERVAL
Interval between compact filter checkpoints.
uint256 ComputeHeader(const uint256 &prev_header) const
Compute the filter header given the previous one.
bool TruncateFile(FILE *file, unsigned int length)
The block chain is a tree shaped structure starting with the genesis block at the root...
bool DestroyBlockFilterIndex(BlockFilterType filter_type)
Destroy the block filter index with the given type.
Undo information for a CBlock.
FlatFilePos m_next_filter_pos
BlockFilterType GetFilterType() const
bool LookupFilterHeader(const CBlockIndex *block_index, uint256 &header_out)
Get a single filter header by block.
static std::map< BlockFilterType, BlockFilterIndex > g_filter_indexes
uint32_t ser_readdata32be(Stream &s)
void Unserialize(Stream &s, char &a)
bool CommitInternal(CDBBatch &batch) override
Virtual method called internally by Commit that can be overridden to atomically commit more index sta...
std::unique_ptr< FlatFileSeq > m_filter_fileseq
int nHeight
height of the entry in the chain. The genesis block has height 0
CBlockIndex * GetAncestor(int height)
Efficiently find an ancestor of this block.
bool Init() override
Initialize internal state from the database and block index.
BlockFilterType GetFilterType() const
static const int CLIENT_VERSION
bitcoind-res.rc includes this file, but it cannot cope with real c++ code.
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.
bool error(const char *fmt, const Args &... args)
static bool LookupOne(const CDBWrapper &db, const CBlockIndex *block_index, DBVal &result)
Non-refcounted RAII wrapper for FILE*.
void ser_writedata8(Stream &s, uint8_t obj)
const char * GetName() const override
Get the name of the index for display in logs.
const std::string & BlockFilterTypeName(BlockFilterType filter_type)
Get the human-readable name for a filter type.