Abstract filter with base class

Author: rustaceanrob

src/blockfilter.cpp

@@ -254,3 +254,63 @@ uint256 BlockFilter::ComputeHeader(const uint256& prev_header) const
 {
     return Hash(GetHash(), prev_header);
 }
+
+// --- BlockFilterBase implementation ---
+
+/**
+ * GCS-based implementation of BlockFilterBase.
+ * Wraps the existing BlockFilter class, exposing a clean interface
+ * that operates on scripts rather than GCS internal elements.
+ */
+class GCSBlockFilter : public BlockFilterBase {
+public:
+    explicit GCSBlockFilter(BlockFilter filter) : m_filter(std::move(filter)) {}
+
+    BlockFilterType GetFilterType() const override { return m_filter.GetFilterType(); }
+    const uint256& GetBlockHash() const override { return m_filter.GetBlockHash(); }
+
+    bool Match(const CScript& script) const override {
+        GCSFilter::Element element(script.begin(), script.end());
+        return m_filter.GetFilter().Match(element);
+    }
+
+    bool MatchAny(const std::vector<CScript>& scripts) const override {
+        GCSFilter::ElementSet elements;
+        for (const CScript& script : scripts) {
+            elements.emplace(script.begin(), script.end());
+        }
+        return m_filter.GetFilter().MatchAny(elements);
+    }
+
+    const std::vector<unsigned char>& GetEncodedFilter() const override {
+        return m_filter.GetEncodedFilter();
+    }
+
+    uint256 GetHash() const override { return m_filter.GetHash(); }
+
+    uint256 ComputeHeader(const uint256& prev_header) const override {
+        return m_filter.ComputeHeader(prev_header);
+    }
+
+private:
+    BlockFilter m_filter;
+};
+
+// --- Factory functions ---
+
+std::unique_ptr<BlockFilterBase> CreateBlockFilter(BlockFilterType type, const CBlock& block, const CBlockUndo& block_undo)
+{
+    return std::make_unique<GCSBlockFilter>(BlockFilter(type, block, block_undo));
+}
+
+std::unique_ptr<BlockFilterBase> CreateBlockFilter(BlockFilterType type, const uint256& block_hash, std::vector<unsigned char> encoded)
+{
+    return std::make_unique<GCSBlockFilter>(BlockFilter(type, block_hash, std::move(encoded), /*skip_decode_check=*/false));
+}
+
+std::unique_ptr<BlockFilterBase> CreateBlockFilter(BlockFilterType type, SpanReader& stream)
+{
+    BlockFilter filter;
+    filter.Unserialize(stream);
+    return std::make_unique<GCSBlockFilter>(std::move(filter));
+}

src/blockfilter.h

@@ -8,6 +8,7 @@
 #include <cstddef>
 #include <cstdint>
 #include <ios>
+#include <memory>
 #include <set>
 #include <string>
 #include <string_view>
@@ -21,6 +22,8 @@
 
 class CBlock;
 class CBlockUndo;
+class CScript;
+template<typename T> class Span;
 
 /**
  * This implements a Golomb-coded set as defined in BIP 158. It is a
@@ -173,4 +176,45 @@ class BlockFilter
     }
 };
 
+/**
+ * Abstract interface for block filters.
+ * Callers can query filters by script without knowing the internal encoding.
+ */
+class BlockFilterBase {
+public:
+    virtual ~BlockFilterBase() = default;
+
+    //! Filter type
+    virtual BlockFilterType GetFilterType() const = 0;
+
+    //! Block this filter is for
+    virtual const uint256& GetBlockHash() const = 0;
+
+    //! Query: does the filter possibly contain this script?
+    virtual bool Match(const CScript& script) const = 0;
+
+    //! Query: does the filter possibly contain any of these scripts?
+    virtual bool MatchAny(const std::vector<CScript>& scripts) const = 0;
+
+    //! Serialized filter data (for P2P/storage)
+    virtual const std::vector<unsigned char>& GetEncodedFilter() const = 0;
+
+    //! Filter hash (BIP 157)
+    virtual uint256 GetHash() const = 0;
+
+    //! Filter header (BIP 157)
+    virtual uint256 ComputeHeader(const uint256& prev_header) const = 0;
+};
+
+/**
+ * Create a block filter from a block and its undo data.
+ * The filter type determines the encoding algorithm used internally.
+ */
+std::unique_ptr<BlockFilterBase> CreateBlockFilter(BlockFilterType type, const CBlock& block, const CBlockUndo& block_undo);
+
+/**
+ * Create a block filter from serialized data.
+ */
+std::unique_ptr<BlockFilterBase> CreateBlockFilter(BlockFilterType type, const uint256& block_hash, std::vector<unsigned char> encoded);
+
 #endif // BITCOIN_BLOCKFILTER_H

src/index/blockfilterindex.cpp

@@ -174,7 +174,7 @@ bool BlockFilterIndex::ReadFilterFromDisk(const FlatFilePos& pos, const uint256&
     return true;
 }
 
-size_t BlockFilterIndex::WriteFilterToDisk(FlatFilePos& pos, const BlockFilter& filter)
+size_t BlockFilterIndex::WriteFilterToDisk(FlatFilePos& pos, const BlockFilterBase& filter)
 {
     assert(filter.GetFilterType() == GetFilterType());
 
@@ -249,14 +249,14 @@ std::optional<uint256> BlockFilterIndex::ReadFilterHeader(int height, const uint
 
 bool BlockFilterIndex::CustomAppend(const interfaces::BlockInfo& block)
 {
-    BlockFilter filter(m_filter_type, *Assert(block.data), *Assert(block.undo_data));
-    const uint256& header = filter.ComputeHeader(m_last_header);
-    bool res = Write(filter, block.height, header);
+    std::unique_ptr<BlockFilterBase> filter = CreateBlockFilter(m_filter_type, *Assert(block.data), *Assert(block.undo_data));
+    const uint256& header = filter->ComputeHeader(m_last_header);
+    bool res = Write(*filter, block.height, header);
     if (res) m_last_header = header; // update last header
     return res;
 }
 
-bool BlockFilterIndex::Write(const BlockFilter& filter, uint32_t block_height, const uint256& filter_header)
+bool BlockFilterIndex::Write(const BlockFilterBase& filter, uint32_t block_height, const uint256& filter_header)
 {
     size_t bytes_written = WriteFilterToDisk(m_next_filter_pos, filter);
     if (bytes_written == 0) return false;
@@ -365,6 +365,21 @@ bool BlockFilterIndex::LookupFilter(const CBlockIndex* block_index, BlockFilter&
     return ReadFilterFromDisk(entry.pos, entry.hash, filter_out);
 }
 
+std::unique_ptr<BlockFilterBase> BlockFilterIndex::LookupFilter(const CBlockIndex* block_index) const
+{
+    DBVal entry;
+    if (!index_util::LookUpOne(*m_db, {block_index->GetBlockHash(), block_index->nHeight}, entry)) {
+        return nullptr;
+    }
+
+    BlockFilter filter;
+    if (!ReadFilterFromDisk(entry.pos, entry.hash, filter)) {
+        return nullptr;
+    }
+
+    return CreateBlockFilter(filter.GetFilterType(), filter.GetBlockHash(), filter.GetEncodedFilter());
+}
+
 bool BlockFilterIndex::LookupFilterHeader(const CBlockIndex* block_index, uint256& header_out)
 {
     LOCK(m_cs_headers_cache);

src/index/blockfilterindex.h

@@ -47,7 +47,7 @@ class BlockFilterIndex final : public BaseIndex
     std::unique_ptr<FlatFileSeq> m_filter_fileseq;
 
     bool ReadFilterFromDisk(const FlatFilePos& pos, const uint256& hash, BlockFilter& filter) const;
-    size_t WriteFilterToDisk(FlatFilePos& pos, const BlockFilter& filter);
+    size_t WriteFilterToDisk(FlatFilePos& pos, const BlockFilterBase& filter);
 
     Mutex m_cs_headers_cache;
     /** cache of block hash to filter header, to avoid disk access when responding to getcfcheckpt. */
@@ -58,7 +58,7 @@ class BlockFilterIndex final : public BaseIndex
 
     bool AllowPrune() const override { return true; }
 
-    bool Write(const BlockFilter& filter, uint32_t block_height, const uint256& filter_header);
+    bool Write(const BlockFilterBase& filter, uint32_t block_height, const uint256& filter_header);
 
     std::optional<uint256> ReadFilterHeader(int height, const uint256& expected_block_hash);
 
@@ -85,6 +85,9 @@ class BlockFilterIndex final : public BaseIndex
     /** Get a single filter by block. */
     bool LookupFilter(const CBlockIndex* block_index, BlockFilter& filter_out) const;
 
+    /** Get a single filter by block (returns interface pointer). */
+    std::unique_ptr<BlockFilterBase> LookupFilter(const CBlockIndex* block_index) const;
+
     /** Get a single filter header by block. */
     bool LookupFilterHeader(const CBlockIndex* block_index, uint256& header_out) EXCLUSIVE_LOCKS_REQUIRED(!m_cs_headers_cache);
 

src/interfaces/chain.h

@@ -139,9 +139,9 @@ class Chain
     //! Returns whether a block filter index is available.
     virtual bool hasBlockFilterIndex(BlockFilterType filter_type) = 0;
 
-    //! Returns whether any of the elements match the block via a BIP 157 block filter
+    //! Returns whether any of the scripts match the block via a BIP 157 block filter
     //! or std::nullopt if the block filter for this block couldn't be found.
-    virtual std::optional<bool> blockFilterMatchesAny(BlockFilterType filter_type, const uint256& block_hash, const GCSFilter::ElementSet& filter_set) = 0;
+    virtual std::optional<bool> blockFilterMatchesAny(BlockFilterType filter_type, const uint256& block_hash, const std::vector<CScript>& scripts) = 0;
 
     //! Return whether node has the block and optionally return block metadata
     //! or contents.

src/node/interfaces.cpp

@@ -32,6 +32,7 @@
 #include <net_processing.h>
 #include <netaddress.h>
 #include <netbase.h>
+#include <script/script.h>
 #include <node/blockstorage.h>
 #include <node/coin.h>
 #include <node/context.h>
@@ -576,15 +577,17 @@ class ChainImpl : public Chain
     {
         return GetBlockFilterIndex(filter_type) != nullptr;
     }
-    std::optional<bool> blockFilterMatchesAny(BlockFilterType filter_type, const uint256& block_hash, const GCSFilter::ElementSet& filter_set) override
+    std::optional<bool> blockFilterMatchesAny(BlockFilterType filter_type, const uint256& block_hash, const std::vector<CScript>& scripts) override
     {
         const BlockFilterIndex* block_filter_index{GetBlockFilterIndex(filter_type)};
         if (!block_filter_index) return std::nullopt;
 
-        BlockFilter filter;
         const CBlockIndex* index{WITH_LOCK(::cs_main, return chainman().m_blockman.LookupBlockIndex(block_hash))};
-        if (index == nullptr || !block_filter_index->LookupFilter(index, filter)) return std::nullopt;
-        return filter.GetFilter().MatchAny(filter_set);
+        if (!index) return std::nullopt;
+
+        std::unique_ptr<BlockFilterBase> filter = block_filter_index->LookupFilter(index);
+        if (!filter) return std::nullopt;
+        return filter->MatchAny(scripts);
     }
     bool findBlock(const uint256& hash, const FoundBlock& block) override
     {

src/wallet/wallet.cpp

@@ -338,7 +338,7 @@ class FastWalletRescanFilter
 
     std::optional<bool> MatchesBlock(const uint256& block_hash) const
     {
-        return m_wallet.chain().blockFilterMatchesAny(BlockFilterType::BASIC, block_hash, m_filter_set);
+        return m_wallet.chain().blockFilterMatchesAny(BlockFilterType::BASIC, block_hash, m_scripts);
     }
 
 private:
@@ -350,12 +350,12 @@ class FastWalletRescanFilter
       * take possible keypool top-ups into account.
       */
     std::map<uint256, int32_t> m_last_range_ends;
-    GCSFilter::ElementSet m_filter_set;
+    std::vector<CScript> m_scripts;
 
     void AddScriptPubKeys(const DescriptorScriptPubKeyMan* desc_spkm, int32_t last_range_end = 0)
     {
         for (const auto& script_pub_key : desc_spkm->GetScriptPubKeys(last_range_end)) {
-            m_filter_set.emplace(script_pub_key.begin(), script_pub_key.end());
+            m_scripts.push_back(script_pub_key);
         }
     }
 };