diff --git a/src/blockfilter.cpp b/src/blockfilter.cpp
index 50f28f33c9..a1b0a97d0d 100644
--- a/src/blockfilter.cpp
+++ b/src/blockfilter.cpp
@@ -1,274 +1,276 @@
 // Copyright (c) 2018 The Bitcoin Core developers
 // Distributed under the MIT software license, see the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
 #include <blockfilter.h>
 #include <crypto/siphash.h>
 #include <hash.h>
 #include <primitives/transaction.h>
 #include <script/script.h>
 #include <streams.h>
 
 /// SerType used to serialize parameters in GCS filter encoding.
 static constexpr int GCS_SER_TYPE = SER_NETWORK;
 
 /// Protocol version used to serialize parameters in GCS filter encoding.
 static constexpr int GCS_SER_VERSION = 0;
 
 template <typename OStream>
 static void GolombRiceEncode(BitStreamWriter<OStream> &bitwriter, uint8_t P,
                              uint64_t x) {
     // Write quotient as unary-encoded: q 1's followed by one 0.
     uint64_t q = x >> P;
     while (q > 0) {
         int nbits = q <= 64 ? static_cast<int>(q) : 64;
         bitwriter.Write(~0ULL, nbits);
         q -= nbits;
     }
     bitwriter.Write(0, 1);
 
     // Write the remainder in P bits. Since the remainder is just the bottom
     // P bits of x, there is no need to mask first.
     bitwriter.Write(x, P);
 }
 
 template <typename IStream>
 static uint64_t GolombRiceDecode(BitStreamReader<IStream> &bitreader,
                                  uint8_t P) {
     // Read unary-encoded quotient: q 1's followed by one 0.
     uint64_t q = 0;
     while (bitreader.Read(1) == 1) {
         ++q;
     }
 
     uint64_t r = bitreader.Read(P);
 
     return (q << P) + r;
 }
 
 // Map a value x that is uniformly distributed in the range [0, 2^64) to a
 // value uniformly distributed in [0, n) by returning the upper 64 bits of
 // x * n.
 //
 // See:
 // https://lemire.me/blog/2016/06/27/a-fast-alternative-to-the-modulo-reduction/
 static uint64_t MapIntoRange(uint64_t x, uint64_t n) {
 #ifdef __SIZEOF_INT128__
     return (static_cast<unsigned __int128>(x) *
             static_cast<unsigned __int128>(n)) >>
            64;
 #else
     // To perform the calculation on 64-bit numbers without losing the
     // result to overflow, split the numbers into the most significant and
     // least significant 32 bits and perform multiplication piece-wise.
     //
     // See: https://stackoverflow.com/a/26855440
     uint64_t x_hi = x >> 32;
     uint64_t x_lo = x & 0xFFFFFFFF;
     uint64_t n_hi = n >> 32;
     uint64_t n_lo = n & 0xFFFFFFFF;
 
     uint64_t ac = x_hi * n_hi;
     uint64_t ad = x_hi * n_lo;
     uint64_t bc = x_lo * n_hi;
     uint64_t bd = x_lo * n_lo;
 
     uint64_t mid34 = (bd >> 32) + (bc & 0xFFFFFFFF) + (ad & 0xFFFFFFFF);
     uint64_t upper64 = ac + (bc >> 32) + (ad >> 32) + (mid34 >> 32);
     return upper64;
 #endif
 }
 
 uint64_t GCSFilter::HashToRange(const Element &element) const {
     uint64_t hash = CSipHasher(m_params.m_siphash_k0, m_params.m_siphash_k1)
                         .Write(element.data(), element.size())
                         .Finalize();
     return MapIntoRange(hash, m_F);
 }
 
 std::vector<uint64_t>
 GCSFilter::BuildHashedSet(const ElementSet &elements) const {
     std::vector<uint64_t> hashed_elements;
     hashed_elements.reserve(elements.size());
     for (const Element &element : elements) {
         hashed_elements.push_back(HashToRange(element));
     }
     std::sort(hashed_elements.begin(), hashed_elements.end());
     return hashed_elements;
 }
 
 GCSFilter::GCSFilter(const Params &params)
     : m_params(params), m_N(0), m_F(0), m_encoded{0} {}
 
 GCSFilter::GCSFilter(const Params &params, std::vector<uint8_t> encoded_filter)
     : m_params(params), m_encoded(std::move(encoded_filter)) {
     VectorReader stream(GCS_SER_TYPE, GCS_SER_VERSION, m_encoded, 0);
 
     uint64_t N = ReadCompactSize(stream);
     m_N = static_cast<uint32_t>(N);
     if (m_N != N) {
         throw std::ios_base::failure("N must be <2^32");
     }
     m_F = static_cast<uint64_t>(m_N) * static_cast<uint64_t>(m_params.m_M);
 
     // Verify that the encoded filter contains exactly N elements. If it has too
     // much or too little data, a std::ios_base::failure exception will be
     // raised.
     BitStreamReader<VectorReader> bitreader(stream);
     for (uint64_t i = 0; i < m_N; ++i) {
         GolombRiceDecode(bitreader, m_params.m_P);
     }
     if (!stream.empty()) {
         throw std::ios_base::failure("encoded_filter contains excess data");
     }
 }
 
 GCSFilter::GCSFilter(const Params &params, const ElementSet &elements)
     : m_params(params) {
     size_t N = elements.size();
     m_N = static_cast<uint32_t>(N);
     if (m_N != N) {
         throw std::invalid_argument("N must be <2^32");
     }
     m_F = static_cast<uint64_t>(m_N) * static_cast<uint64_t>(m_params.m_M);
 
     CVectorWriter stream(GCS_SER_TYPE, GCS_SER_VERSION, m_encoded, 0);
 
     WriteCompactSize(stream, m_N);
 
     if (elements.empty()) {
         return;
     }
 
     BitStreamWriter<CVectorWriter> bitwriter(stream);
 
     uint64_t last_value = 0;
     for (uint64_t value : BuildHashedSet(elements)) {
         uint64_t delta = value - last_value;
         GolombRiceEncode(bitwriter, m_params.m_P, delta);
         last_value = value;
     }
 
     bitwriter.Flush();
 }
 
 bool GCSFilter::MatchInternal(const uint64_t *element_hashes,
                               size_t size) const {
     VectorReader stream(GCS_SER_TYPE, GCS_SER_VERSION, m_encoded, 0);
 
     // Seek forward by size of N
     uint64_t N = ReadCompactSize(stream);
     assert(N == m_N);
 
     BitStreamReader<VectorReader> bitreader(stream);
 
     uint64_t value = 0;
     size_t hashes_index = 0;
     for (uint32_t i = 0; i < m_N; ++i) {
         uint64_t delta = GolombRiceDecode(bitreader, m_params.m_P);
         value += delta;
 
         while (true) {
             if (hashes_index == size) {
                 return false;
             } else if (element_hashes[hashes_index] == value) {
                 return true;
             } else if (element_hashes[hashes_index] > value) {
                 break;
             }
 
             hashes_index++;
         }
     }
 
     return false;
 }
 
 bool GCSFilter::Match(const Element &element) const {
     uint64_t query = HashToRange(element);
     return MatchInternal(&query, 1);
 }
 
 bool GCSFilter::MatchAny(const ElementSet &elements) const {
     const std::vector<uint64_t> queries = BuildHashedSet(elements);
     return MatchInternal(queries.data(), queries.size());
 }
 
 static GCSFilter::ElementSet BasicFilterElements(const CBlock &block,
                                                  const CBlockUndo &block_undo) {
     GCSFilter::ElementSet elements;
 
     for (const CTransactionRef &tx : block.vtx) {
         for (const CTxOut &txout : tx->vout) {
             const CScript &script = txout.scriptPubKey;
             if (script.empty() || script[0] == OP_RETURN) {
                 continue;
             }
             elements.emplace(script.begin(), script.end());
         }
     }
 
     for (const CTxUndo &tx_undo : block_undo.vtxundo) {
         for (const Coin &prevout : tx_undo.vprevout) {
             const CScript &script = prevout.GetTxOut().scriptPubKey;
             if (script.empty()) {
                 continue;
             }
             elements.emplace(script.begin(), script.end());
         }
     }
 
     return elements;
 }
 
 BlockFilter::BlockFilter(BlockFilterType filter_type, const uint256 &block_hash,
                          std::vector<uint8_t> filter)
     : m_filter_type(filter_type), m_block_hash(block_hash) {
     GCSFilter::Params params;
     if (!BuildParams(params)) {
         throw std::invalid_argument("unknown filter_type");
     }
     m_filter = GCSFilter(params, std::move(filter));
 }
 
 BlockFilter::BlockFilter(BlockFilterType filter_type, const CBlock &block,
                          const CBlockUndo &block_undo)
     : m_filter_type(filter_type), m_block_hash(block.GetHash()) {
     GCSFilter::Params params;
     if (!BuildParams(params)) {
         throw std::invalid_argument("unknown filter_type");
     }
     m_filter = GCSFilter(params, BasicFilterElements(block, block_undo));
 }
 
 bool BlockFilter::BuildParams(GCSFilter::Params &params) const {
     switch (m_filter_type) {
         case BlockFilterType::BASIC:
             params.m_siphash_k0 = m_block_hash.GetUint64(0);
             params.m_siphash_k1 = m_block_hash.GetUint64(1);
             params.m_P = BASIC_FILTER_P;
             params.m_M = BASIC_FILTER_M;
             return true;
+        case BlockFilterType::INVALID:
+            return false;
     }
 
     return false;
 }
 
 uint256 BlockFilter::GetHash() const {
     const std::vector<uint8_t> &data = GetEncodedFilter();
 
     uint256 result;
     CHash256().Write(data.data(), data.size()).Finalize(result.begin());
     return result;
 }
 
 uint256 BlockFilter::ComputeHeader(const uint256 &prev_header) const {
     const uint256 &filter_hash = GetHash();
 
     uint256 result;
     CHash256()
         .Write(filter_hash.begin(), filter_hash.size())
         .Write(prev_header.begin(), prev_header.size())
         .Finalize(result.begin());
     return result;
 }
diff --git a/src/blockfilter.h b/src/blockfilter.h
index 95f1ae6aeb..5c710a0ac3 100644
--- a/src/blockfilter.h
+++ b/src/blockfilter.h
@@ -1,146 +1,147 @@
 // Copyright (c) 2018 The Bitcoin Core developers
 // Distributed under the MIT software license, see the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
 #ifndef BITCOIN_BLOCKFILTER_H
 #define BITCOIN_BLOCKFILTER_H
 
 #include <primitives/block.h>
 #include <serialize.h>
 #include <uint256.h>
 #include <undo.h>
 
 #include <cstdint>
 #include <set>
 #include <vector>
 
 /**
  * This implements a Golomb-coded set as defined in BIP 158. It is a
  * compact, probabilistic data structure for testing set membership.
  */
 class GCSFilter {
 public:
     typedef std::vector<uint8_t> Element;
     typedef std::set<Element> ElementSet;
 
     struct Params {
         uint64_t m_siphash_k0;
         uint64_t m_siphash_k1;
         uint8_t m_P;  //!< Golomb-Rice coding parameter
         uint32_t m_M; //!< Inverse false positive rate
 
         Params(uint64_t siphash_k0 = 0, uint64_t siphash_k1 = 0, uint8_t P = 0,
                uint32_t M = 1)
             : m_siphash_k0(siphash_k0), m_siphash_k1(siphash_k1), m_P(P),
               m_M(M) {}
     };
 
 private:
     Params m_params;
     uint32_t m_N; //!< Number of elements in the filter
     uint64_t m_F; //!< Range of element hashes, F = N * M
     std::vector<uint8_t> m_encoded;
 
     /** Hash a data element to an integer in the range [0, N * M). */
     uint64_t HashToRange(const Element &element) const;
 
     std::vector<uint64_t> BuildHashedSet(const ElementSet &elements) const;
 
     /** Helper method used to implement Match and MatchAny */
     bool MatchInternal(const uint64_t *sorted_element_hashes,
                        size_t size) const;
 
 public:
     /** Constructs an empty filter. */
     explicit GCSFilter(const Params &params = Params());
 
     /** Reconstructs an already-created filter from an encoding. */
     GCSFilter(const Params &params, std::vector<uint8_t> encoded_filter);
 
     /** Builds a new filter from the params and set of elements. */
     GCSFilter(const Params &params, const ElementSet &elements);
 
     uint32_t GetN() const { return m_N; }
     const Params &GetParams() const { return m_params; }
     const std::vector<uint8_t> &GetEncoded() const { return m_encoded; }
 
     /**
      * Checks if the element may be in the set. False positives are possible
      * with probability 1/M.
      */
     bool Match(const Element &element) const;
 
     /**
      * Checks if any of the given elements may be in the set. False positives
      * are possible with probability 1/M per element checked. This is more
      * efficient that checking Match on multiple elements separately.
      */
     bool MatchAny(const ElementSet &elements) const;
 };
 
 constexpr uint8_t BASIC_FILTER_P = 19;
 constexpr uint32_t BASIC_FILTER_M = 784931;
 
-enum BlockFilterType : uint8_t {
+enum class BlockFilterType : uint8_t {
     BASIC = 0,
+    INVALID = 255,
 };
 
 /**
  * Complete block filter struct as defined in BIP 157. Serialization matches
  * payload of "cfilter" messages.
  */
 class BlockFilter {
 private:
-    BlockFilterType m_filter_type;
+    BlockFilterType m_filter_type = BlockFilterType::INVALID;
     uint256 m_block_hash;
     GCSFilter m_filter;
 
     bool BuildParams(GCSFilter::Params &params) const;
 
 public:
     BlockFilter() = default;
 
     //! Reconstruct a BlockFilter from parts.
     BlockFilter(BlockFilterType filter_type, const uint256 &block_hash,
                 std::vector<uint8_t> filter);
 
     //! Construct a new BlockFilter of the specified type from a block.
     BlockFilter(BlockFilterType filter_type, const CBlock &block,
                 const CBlockUndo &block_undo);
 
     BlockFilterType GetFilterType() const { return m_filter_type; }
     const uint256 &GetBlockHash() const { return m_block_hash; }
     const GCSFilter &GetFilter() const { return m_filter; }
 
     const std::vector<uint8_t> &GetEncodedFilter() const {
         return m_filter.GetEncoded();
     }
 
     //! Compute the filter hash.
     uint256 GetHash() const;
 
     //! Compute the filter header given the previous one.
     uint256 ComputeHeader(const uint256 &prev_header) const;
 
     template <typename Stream> void Serialize(Stream &s) const {
         s << m_block_hash << static_cast<uint8_t>(m_filter_type)
           << m_filter.GetEncoded();
     }
 
     template <typename Stream> void Unserialize(Stream &s) {
         std::vector<uint8_t> encoded_filter;
         uint8_t filter_type;
 
         s >> m_block_hash >> filter_type >> encoded_filter;
 
         m_filter_type = static_cast<BlockFilterType>(filter_type);
 
         GCSFilter::Params params;
         if (!BuildParams(params)) {
             throw std::ios_base::failure("unknown filter_type");
         }
         m_filter = GCSFilter(params, std::move(encoded_filter));
     }
 };
 
 #endif // BITCOIN_BLOCKFILTER_H
diff --git a/src/test/blockfilter_tests.cpp b/src/test/blockfilter_tests.cpp
index aaef57aa22..95fe2f2aad 100644
--- a/src/test/blockfilter_tests.cpp
+++ b/src/test/blockfilter_tests.cpp
@@ -1,185 +1,193 @@
 // Copyright (c) 2018 The Bitcoin Core developers
 // Distributed under the MIT software license, see the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
 #include <blockfilter.h>
 
 #include <core_io.h>
 #include <serialize.h>
 #include <streams.h>
 #include <utilstrencodings.h>
 
 #include <test/data/blockfilters.json.h>
 #include <test/test_bitcoin.h>
 
 #include <boost/test/unit_test.hpp>
 
 #include <univalue.h>
 
 BOOST_AUTO_TEST_SUITE(blockfilter_tests)
 
 BOOST_AUTO_TEST_CASE(gcsfilter_test) {
     GCSFilter::ElementSet included_elements, excluded_elements;
     for (int i = 0; i < 100; ++i) {
         GCSFilter::Element element1(32);
         element1[0] = i;
         included_elements.insert(std::move(element1));
 
         GCSFilter::Element element2(32);
         element2[1] = i;
         excluded_elements.insert(std::move(element2));
     }
 
     GCSFilter filter({0, 0, 10, 1 << 10}, included_elements);
     for (const auto &element : included_elements) {
         BOOST_CHECK(filter.Match(element));
 
         auto insertion = excluded_elements.insert(element);
         BOOST_CHECK(filter.MatchAny(excluded_elements));
         excluded_elements.erase(insertion.first);
     }
 }
 
 BOOST_AUTO_TEST_CASE(gcsfilter_default_constructor) {
     GCSFilter filter;
     BOOST_CHECK_EQUAL(filter.GetN(), 0);
     BOOST_CHECK_EQUAL(filter.GetEncoded().size(), 1);
 
     const GCSFilter::Params &params = filter.GetParams();
     BOOST_CHECK_EQUAL(params.m_siphash_k0, 0);
     BOOST_CHECK_EQUAL(params.m_siphash_k1, 0);
     BOOST_CHECK_EQUAL(params.m_P, 0);
     BOOST_CHECK_EQUAL(params.m_M, 1);
 }
 
 BOOST_AUTO_TEST_CASE(blockfilter_basic_test) {
     CScript included_scripts[5], excluded_scripts[3];
 
     // First two are outputs on a single transaction.
     included_scripts[0] << std::vector<uint8_t>(0, 65) << OP_CHECKSIG;
     included_scripts[1] << OP_DUP << OP_HASH160 << std::vector<uint8_t>(1, 20)
                         << OP_EQUALVERIFY << OP_CHECKSIG;
 
     // Third is an output on in a second transaction.
     included_scripts[2] << OP_1 << std::vector<uint8_t>(2, 33) << OP_1
                         << OP_CHECKMULTISIG;
 
     // Last two are spent by a single transaction.
     included_scripts[3] << OP_0 << std::vector<uint8_t>(3, 32);
     included_scripts[4] << OP_4 << OP_ADD << OP_8 << OP_EQUAL;
 
     // OP_RETURN output is an output on the second transaction.
     excluded_scripts[0] << OP_RETURN << std::vector<uint8_t>(4, 40);
 
     // This script is not related to the block at all.
     excluded_scripts[1] << std::vector<uint8_t>(5, 33) << OP_CHECKSIG;
 
     CMutableTransaction tx_1;
     tx_1.vout.emplace_back(100 * SATOSHI, included_scripts[0]);
     tx_1.vout.emplace_back(200 * SATOSHI, included_scripts[1]);
 
     CMutableTransaction tx_2;
     tx_2.vout.emplace_back(300 * SATOSHI, included_scripts[2]);
     tx_2.vout.emplace_back(0 * SATOSHI, excluded_scripts[0]);
     // Script is empty
     tx_2.vout.emplace_back(400 * SATOSHI, excluded_scripts[2]);
 
     CBlock block;
     block.vtx.push_back(MakeTransactionRef(tx_1));
     block.vtx.push_back(MakeTransactionRef(tx_2));
 
     CBlockUndo block_undo;
     block_undo.vtxundo.emplace_back();
     block_undo.vtxundo.back().vprevout.emplace_back(
         CTxOut(500 * SATOSHI, included_scripts[3]), 1000, true);
     block_undo.vtxundo.back().vprevout.emplace_back(
         CTxOut(600 * SATOSHI, included_scripts[4]), 10000, false);
     block_undo.vtxundo.back().vprevout.emplace_back(
         CTxOut(700 * SATOSHI, excluded_scripts[2]), 100000, false);
 
     BlockFilter block_filter(BlockFilterType::BASIC, block, block_undo);
     const GCSFilter &filter = block_filter.GetFilter();
 
     for (const CScript &script : included_scripts) {
         BOOST_CHECK(
             filter.Match(GCSFilter::Element(script.begin(), script.end())));
     }
     for (const CScript &script : excluded_scripts) {
         BOOST_CHECK(
             !filter.Match(GCSFilter::Element(script.begin(), script.end())));
     }
 
     // Test serialization/unserialization.
     BlockFilter block_filter2;
 
     CDataStream stream(SER_NETWORK, PROTOCOL_VERSION);
     stream << block_filter;
     stream >> block_filter2;
 
-    BOOST_CHECK_EQUAL(block_filter.GetFilterType(),
-                      block_filter2.GetFilterType());
+    BOOST_CHECK(block_filter.GetFilterType() == block_filter2.GetFilterType());
     BOOST_CHECK(block_filter.GetBlockHash() == block_filter2.GetBlockHash());
     BOOST_CHECK(block_filter.GetEncodedFilter() ==
                 block_filter2.GetEncodedFilter());
+
+    BlockFilter default_ctor_block_filter_1;
+    BlockFilter default_ctor_block_filter_2;
+    BOOST_CHECK(default_ctor_block_filter_1.GetFilterType() ==
+                default_ctor_block_filter_2.GetFilterType());
+    BOOST_CHECK(default_ctor_block_filter_1.GetBlockHash() ==
+                default_ctor_block_filter_2.GetBlockHash());
+    BOOST_CHECK(default_ctor_block_filter_1.GetEncodedFilter() ==
+                default_ctor_block_filter_2.GetEncodedFilter());
 }
 
 BOOST_AUTO_TEST_CASE(blockfilters_json_test) {
     UniValue json;
     std::string json_data(json_tests::blockfilters,
                           json_tests::blockfilters +
                               sizeof(json_tests::blockfilters));
     if (!json.read(json_data) || !json.isArray()) {
         BOOST_ERROR("Parse error.");
         return;
     }
 
     const UniValue &tests = json.get_array();
     for (size_t i = 0; i < tests.size(); i++) {
         UniValue test = tests[i];
         std::string strTest = test.write();
 
         if (test.size() == 1) {
             continue;
         } else if (test.size() < 7) {
             BOOST_ERROR("Bad test: " << strTest);
             continue;
         }
 
         size_t pos = 0;
         /*int block_height =*/test[pos++].get_int();
         /*uint256 block_hash =*/ParseHashStr(test[pos++].get_str(),
                                              "block_hash");
 
         CBlock block;
         BOOST_REQUIRE(DecodeHexBlk(block, test[pos++].get_str()));
 
         CBlockUndo block_undo;
         block_undo.vtxundo.emplace_back();
         CTxUndo &tx_undo = block_undo.vtxundo.back();
         const UniValue &prev_scripts = test[pos++].get_array();
         for (size_t ii = 0; ii < prev_scripts.size(); ii++) {
             std::vector<uint8_t> raw_script =
                 ParseHex(prev_scripts[ii].get_str());
             CTxOut txout(0 * SATOSHI,
                          CScript(raw_script.begin(), raw_script.end()));
             tx_undo.vprevout.emplace_back(txout, 0, false);
         }
 
         uint256 prev_filter_header_basic =
             ParseHashStr(test[pos++].get_str(), "prev_filter_header_basic");
         std::vector<uint8_t> filter_basic = ParseHex(test[pos++].get_str());
         uint256 filter_header_basic =
             ParseHashStr(test[pos++].get_str(), "filter_header_basic");
 
         BlockFilter computed_filter_basic(BlockFilterType::BASIC, block,
                                           block_undo);
         BOOST_CHECK(computed_filter_basic.GetFilter().GetEncoded() ==
                     filter_basic);
 
         uint256 computed_header_basic =
             computed_filter_basic.ComputeHeader(prev_filter_header_basic);
         BOOST_CHECK(computed_header_basic == filter_header_basic);
     }
 }
 
 BOOST_AUTO_TEST_SUITE_END()