251    if (read_out.first != expected_block_hash) {
252        LogError("previous block header belongs to unexpected block %s; expected %s",
253                 read_out.first.ToString(), expected_block_hash.ToString());
254        return std::nullopt;
255    }
256
257    return read_out.second.header;
258}
259
260bool BlockFilterIndex::CustomAppend(const interfaces::BlockInfo& block)
261{
262    BlockFilter filter(m_filter_type, *Assert(block.data), *Assert(block.undo_data));
263    const uint256& header = filter.ComputeHeader(m_last_header);
264    bool res = Write(filter, block.height, header);
265    if (res) m_last_header = header; // update last header
266    return res;
267}
268
269bool BlockFilterIndex::Write(const BlockFilter& filter, uint32_t block_height, const uint256& filter_header)
270{
271    size_t bytes_written = WriteFilterToDisk(m_next_filter_pos, filter);
272    if (bytes_written == 0) return false;
273
274    std::pair<uint256, DBVal> value;
275    value.first = filter.GetBlockHash();
276    value.second.hash = filter.GetHash();
277    value.second.header = filter_header;
278    value.second.pos = m_next_filter_pos;
279
280    m_db->Write(index_util::DBHeightKey(block_height), value);
281
282    m_next_filter_pos.nPos += bytes_written;
283    return true;
284}
285
286bool BlockFilterIndex::CustomRemove(const interfaces::BlockInfo& block)
287{
288    CDBBatch batch(*m_db);
289    std::unique_ptr<CDBIterator> db_it(m_db->NewIterator());
290
291    // During a reorg, we need to copy block filter that is getting disconnected from the
292    // height index to the hash index so we can still find it when the height index entry
293    // is overwritten.
294    if (!index_util::CopyHeightIndexToHashIndex<DBVal>(*db_it, batch, m_name, block.height)) {
295        return false;
296    }
297
298    // The latest filter position gets written in Commit by the call to the BaseIndex::Rewind.
299    // But since this creates new references to the filter, the position should get updated here
300    // atomically as well in case Commit fails.
301    batch.Write(DB_FILTER_POS, m_next_filter_pos);
302    m_db->WriteBatch(batch);
303
304    // Update cached header to the previous block hash
305    m_last_header = *Assert(ReadFilterHeader(block.height - 1, *Assert(block.prev_hash)));
306    return true;
307}
308
309static bool LookupRange(CDBWrapper& db, const std::string& index_name, int start_height,
310                        const CBlockIndex* stop_index, std::vector<DBVal>& results)
311{
312    if (start_height < 0) {
313        LogError("start height (%d) is negative", start_height);
314        return false;
315    }
316    if (start_height > stop_index->nHeight) {
317        LogError("start height (%d) is greater than stop height (%d)",
318                 start_height, stop_index->nHeight);
319        return false;
320    }
321
322    size_t results_size = static_cast<size_t>(stop_index->nHeight - start_height + 1);
323    std::vector<std::pair<uint256, DBVal>> values(results_size);
324
325    index_util::DBHeightKey key(start_height);
326    std::unique_ptr<CDBIterator> db_it(db.NewIterator());
327    db_it->Seek(index_util::DBHeightKey(start_height));
328    for (int height = start_height; height <= stop_index->nHeight; ++height) {
329        if (!db_it->Valid() || !db_it->GetKey(key) || key.height != height) {
330            return false;
331        }
332
333        size_t i = static_cast<size_t>(height - start_height);
334        if (!db_it->GetValue(values[i])) {
335            LogError("unable to read value in %s at key (%c, %d)",
336                     index_name, index_util::DB_BLOCK_HEIGHT, height);
337            return false;
338        }
339
340        db_it->Next();
341    }
342
343    results.resize(results_size);
344
345    // Iterate backwards through block indexes collecting results in order to access the block hash
346    // of each entry in case we need to look it up in the hash index.
347    for (const CBlockIndex* block_index = stop_index;
348         block_index && block_index->nHeight >= start_height;
349         block_index = block_index->pprev) {
350        uint256 block_hash = block_index->GetBlockHash();
351
352        size_t i = static_cast<size_t>(block_index->nHeight - start_height);
353        if (block_hash == values[i].first) {
354            results[i] = std::move(values[i].second);
355            continue;
356        }
357
358        if (!db.Read(index_util::DBHashKey(block_hash), results[i])) {
359            LogError("unable to read value in %s at key (%c, %s)",
360                     index_name, index_util::DB_BLOCK_HASH, block_hash.ToString());
361            return false;
362        }
363    }
364
365    return true;
366}
367
368bool BlockFilterIndex::LookupFilter(const CBlockIndex* block_index, BlockFilter& filter_out) const
369{
370    DBVal entry;
371    if (!index_util::LookUpOne(*m_db, {block_index->GetBlockHash(), block_index->nHeight}, entry)) {
372        return false;
373    }
374
375    return ReadFilterFromDisk(entry.pos, entry.hash, filter_out);
376}
377
378bool BlockFilterIndex::LookupFilterHeader(const CBlockIndex* block_index, uint256& header_out)
379{
380    LOCK(m_cs_headers_cache);
381
382    bool is_checkpoint{block_index->nHeight % CFCHECKPT_INTERVAL == 0};
383
384    if (is_checkpoint) {
385        // Try to find the block in the headers cache if this is a checkpoint height.
386        auto header = m_headers_cache.find(block_index->GetBlockHash());
387        if (header != m_headers_cache.end()) {
388            header_out = header->second;
389            return true;
390        }
391    }
392
393    DBVal entry;
394    if (!index_util::LookUpOne(*m_db, {block_index->GetBlockHash(), block_index->nHeight}, entry)) {
395        return false;
396    }
397
398    if (is_checkpoint &&
399        m_headers_cache.size() < CF_HEADERS_CACHE_MAX_SZ) {
400        // Add to the headers cache if this is a checkpoint height.
401        m_headers_cache.emplace(block_index->GetBlockHash(), entry.header);
402    }
403
404    header_out = entry.header;
405    return true;
406}
407
408bool BlockFilterIndex::LookupFilterRange(int start_height, const CBlockIndex* stop_index,
409                                         std::vector<BlockFilter>& filters_out) const
410{
411    std::vector<DBVal> entries;
412    if (!LookupRange(*m_db, m_name, start_height, stop_index, entries)) {
413        return false;
414    }
415
416    filters_out.resize(entries.size());
417    auto filter_pos_it = filters_out.begin();
418    for (const auto& entry : entries) {
419        if (!ReadFilterFromDisk(entry.pos, entry.hash, *filter_pos_it)) {
420            return false;
421        }
422        ++filter_pos_it;
423    }
424
425    return true;
426}
427
428bool BlockFilterIndex::LookupFilterHashRange(int start_height, const CBlockIndex* stop_index,
429                                             std::vector<uint256>& hashes_out) const
430
431{
432    std::vector<DBVal> entries;
433    if (!LookupRange(*m_db, m_name, start_height, stop_index, entries)) {
434        return false;
435    }
436
437    hashes_out.clear();
438    hashes_out.reserve(entries.size());
439    for (const auto& entry : entries) {
440        hashes_out.push_back(entry.hash);
441    }
442    return true;
443}
444
445BlockFilterIndex* GetBlockFilterIndex(BlockFilterType filter_type)
446{
447    auto it = g_filter_indexes.find(filter_type);
448    return it != g_filter_indexes.end() ? &it->second : nullptr;
449}
450
451void ForEachBlockFilterIndex(std::function<void (BlockFilterIndex&)> fn)
452{
453    for (auto& entry : g_filter_indexes) fn(entry.second);
454}
455
456bool InitBlockFilterIndex(std::function<std::unique_ptr<interfaces::Chain>()> make_chain, BlockFilterType filter_type,
457                          size_t n_cache_size, bool f_memory, bool f_wipe)
458{
459    auto result = g_filter_indexes.emplace(std::piecewise_construct,
460                                           std::forward_as_tuple(filter_type),
461                                           std::forward_as_tuple(make_chain(), filter_type,
462                                                                 n_cache_size, f_memory, f_wipe));
463    return result.second;
464}
465
466bool DestroyBlockFilterIndex(BlockFilterType filter_type)
467{
468    return g_filter_indexes.erase(filter_type);
469}
470
471void DestroyAllBlockFilterIndexes()
472{
473    g_filter_indexes.clear();
474}
475