From 71454dd0a0a057928ef367ba661f160200ecb126 Mon Sep 17 00:00:00 2001
From: dangershony <dan.gershony@gmail.com>
Date: Thu, 27 Feb 2020 19:07:58 +0100
Subject: [PATCH 01/11] Add Neutrino filter for p2wpkh script types

Github-Pull: #18223
Rebased-From: 42a93bba786f3ea81e48dd89466dc9bfb7e63645
---
 src/blockfilter.cpp | 47 ++++++++++++++++++++++++++++++++++++++++++++-
 src/blockfilter.h   |  2 ++
 2 files changed, 48 insertions(+), 1 deletion(-)

diff --git a/src/blockfilter.cpp b/src/blockfilter.cpp
index 88c7526b9e..975eb1dc46 100644
--- a/src/blockfilter.cpp
+++ b/src/blockfilter.cpp
@@ -10,6 +10,7 @@
 #include <hash.h>
 #include <primitives/transaction.h>
 #include <script/script.h>
+#include <script/standard.h>
 #include <streams.h>
 #include <util/golombrice.h>
 #include <util/string.h>
@@ -22,6 +23,7 @@ static constexpr int GCS_SER_VERSION = 0;
 
 static const std::map<BlockFilterType, std::string> g_filter_types = {
     {BlockFilterType::BASIC, "basic"},
+    {BlockFilterType::P2WPKH, "p2wpkh"},
 };
 
 uint64_t GCSFilter::HashToRange(const Element& element) const
@@ -208,6 +210,34 @@ static GCSFilter::ElementSet BasicFilterElements(const CBlock& block,
     return elements;
 }
 
+static GCSFilter::ElementSet P2WPKHFilterElements(const CBlock& block,
+    const CBlockUndo& block_undo)
+{
+    GCSFilter::ElementSet elements;
+
+    for (const CTransactionRef& tx : block.vtx) {
+        for (const CTxOut& txout : tx->vout) {
+            const CScript& scriptPubKey = txout.scriptPubKey;
+            std::vector<std::vector<unsigned char>> solutions;
+            TxoutType script_type = Solver(txout.scriptPubKey, solutions);
+            if (scriptPubKey.empty() || script_type != TxoutType::WITNESS_V0_KEYHASH) continue;
+            elements.emplace(scriptPubKey.begin(), scriptPubKey.end());
+        }
+    }
+
+    for (const CTxUndo& tx_undo : block_undo.vtxundo) {
+        for (const Coin& prevout : tx_undo.vprevout) {
+            const CScript& scriptPubKey = prevout.out.scriptPubKey;
+            std::vector<std::vector<unsigned char>> solutions;
+            TxoutType script_type = Solver(scriptPubKey, solutions);
+            if (scriptPubKey.empty() || script_type != TxoutType::WITNESS_V0_KEYHASH) continue;
+            elements.emplace(scriptPubKey.begin(), scriptPubKey.end());
+        }
+    }
+
+    return elements;
+}
+
 BlockFilter::BlockFilter(BlockFilterType filter_type, const uint256& block_hash,
                          std::vector<unsigned char> filter, bool skip_decode_check)
     : m_filter_type(filter_type), m_block_hash(block_hash)
@@ -226,7 +256,15 @@ BlockFilter::BlockFilter(BlockFilterType filter_type, const CBlock& block, const
     if (!BuildParams(params)) {
         throw std::invalid_argument("unknown filter_type");
     }
-    m_filter = GCSFilter(params, BasicFilterElements(block, block_undo));
+
+    switch (m_filter_type) {
+    case BlockFilterType::BASIC:
+        m_filter = GCSFilter(params, BasicFilterElements(block, block_undo));
+        break;
+    case BlockFilterType::P2WPKH:
+        m_filter = GCSFilter(params, P2WPKHFilterElements(block, block_undo));
+        break;
+    }
 }
 
 bool BlockFilter::BuildParams(GCSFilter::Params& params) const
@@ -238,6 +276,13 @@ bool BlockFilter::BuildParams(GCSFilter::Params& params) const
         params.m_P = BASIC_FILTER_P;
         params.m_M = BASIC_FILTER_M;
         return true;
+    case BlockFilterType::P2WPKH:
+        params.m_siphash_k0 = m_block_hash.GetUint64(0);
+        params.m_siphash_k1 = m_block_hash.GetUint64(1);
+        // using the same filter params as basic type
+        params.m_P = BASIC_FILTER_P;
+        params.m_M = BASIC_FILTER_M;
+        return true;
     case BlockFilterType::INVALID:
         return false;
     }
diff --git a/src/blockfilter.h b/src/blockfilter.h
index fb5114edb3..9d5afa7d18 100644
--- a/src/blockfilter.h
+++ b/src/blockfilter.h
@@ -89,6 +89,8 @@ constexpr uint32_t BASIC_FILTER_M = 784931;
 enum class BlockFilterType : uint8_t
 {
     BASIC = 0,
+    // Floter 1 is reserved as option to include all filters
+    P2WPKH = 2,
     INVALID = 255,
 };
 

From 2f81131d3584f66c7131d87f6702457b04b94760 Mon Sep 17 00:00:00 2001
From: Luke Dashjr <luke-jr+git@utopios.org>
Date: Thu, 30 Sep 2021 19:40:28 +0000
Subject: [PATCH 02/11] Add possible values to cli description

Github-Pull: #18223
Rebased-From: 19b9959a3c02dc9cb98740d5740e709b971e0c03
---
 src/rpc/blockchain.cpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/rpc/blockchain.cpp b/src/rpc/blockchain.cpp
index fb22321d90..257e272ccb 100644
--- a/src/rpc/blockchain.cpp
+++ b/src/rpc/blockchain.cpp
@@ -2493,7 +2493,7 @@ static RPCHelpMan getblockfilter()
                 "\nRetrieve a BIP 157 content filter for a particular block.\n",
                 {
                     {"blockhash", RPCArg::Type::STR_HEX, RPCArg::Optional::NO, "The hash of the block"},
-                    {"filtertype", RPCArg::Type::STR, RPCArg::Default{BlockFilterTypeName(BlockFilterType::BASIC)}, "The type name of the filter"},
+                    {"filtertype", RPCArg::Type::STR, RPCArg::Default{BlockFilterTypeName(BlockFilterType::BASIC)}, "The type name of the filter, values: " + ListBlockFilterTypes()},
                 },
                 RPCResult{
                     RPCResult::Type::OBJ, "", "",

From 10060b121c999c7da9446e22149c23629e21c933 Mon Sep 17 00:00:00 2001
From: Dan Gershony <dan.gershony@gmail.com>
Date: Fri, 28 Feb 2020 15:49:23 +0100
Subject: [PATCH 03/11] Apply suggestions from code review
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Co-Authored-By: Dávid Molnár <molnardavid84@gmail.com>

Github-Pull: #18223
Rebased-From: 70448154c9a5d2d37916703d745ca2373afee730
---
 src/blockfilter.cpp | 2 +-
 src/blockfilter.h   | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/blockfilter.cpp b/src/blockfilter.cpp
index 975eb1dc46..8543c42d80 100644
--- a/src/blockfilter.cpp
+++ b/src/blockfilter.cpp
@@ -279,7 +279,7 @@ bool BlockFilter::BuildParams(GCSFilter::Params& params) const
     case BlockFilterType::P2WPKH:
         params.m_siphash_k0 = m_block_hash.GetUint64(0);
         params.m_siphash_k1 = m_block_hash.GetUint64(1);
-        // using the same filter params as basic type
+        // Using the same filter params as basic type.
         params.m_P = BASIC_FILTER_P;
         params.m_M = BASIC_FILTER_M;
         return true;
diff --git a/src/blockfilter.h b/src/blockfilter.h
index 9d5afa7d18..fff860cd6e 100644
--- a/src/blockfilter.h
+++ b/src/blockfilter.h
@@ -89,7 +89,7 @@ constexpr uint32_t BASIC_FILTER_M = 784931;
 enum class BlockFilterType : uint8_t
 {
     BASIC = 0,
-    // Floter 1 is reserved as option to include all filters
+    // Filter 1 is reserved as an option to include all filters.
     P2WPKH = 2,
     INVALID = 255,
 };

From 59def198b584c0da34e73c9d58f07a82258e9864 Mon Sep 17 00:00:00 2001
From: dangershony <dan.gershony@gmail.com>
Date: Fri, 28 Feb 2020 17:21:48 +0100
Subject: [PATCH 04/11] Adding tests for p2wpkh filter type

Github-Pull: #18223
Rebased-From: fcb3690581c8aef3044d8527fc5a3c0e60b06933
---
 src/test/blockfilter_tests.cpp | 82 ++++++++++++++++++++++++++++++++--
 1 file changed, 78 insertions(+), 4 deletions(-)

diff --git a/src/test/blockfilter_tests.cpp b/src/test/blockfilter_tests.cpp
index 9388b4c96a..f1ada076b2 100644
--- a/src/test/blockfilter_tests.cpp
+++ b/src/test/blockfilter_tests.cpp
@@ -14,6 +14,8 @@
 
 #include <boost/test/unit_test.hpp>
 
+#include <script/standard.h>
+
 BOOST_AUTO_TEST_SUITE(blockfilter_tests)
 
 BOOST_AUTO_TEST_CASE(gcsfilter_test)
@@ -125,6 +127,72 @@ BOOST_AUTO_TEST_CASE(blockfilter_basic_test)
     BOOST_CHECK(default_ctor_block_filter_1.GetEncodedFilter() == default_ctor_block_filter_2.GetEncodedFilter());
 }
 
+BOOST_AUTO_TEST_CASE(blockfilter_p2wpkh_test)
+{
+    CScript included_scripts[2], excluded_scripts[9];
+
+    included_scripts[0] = GetScriptForDestination(WitnessV0KeyHash());  // p2wpkh 
+    included_scripts[1] = GetScriptForDestination(WitnessV0KeyHash()); // p2wpkh 
+
+    excluded_scripts[0] << std::vector<unsigned char>(0, 65) << OP_CHECKSIG; // p2pk 
+    excluded_scripts[1] << OP_0 << OP_HASH160 << std::vector<unsigned char>(1, 20) << OP_EQUALVERIFY << OP_CHECKSIG; // p2pkh 
+    excluded_scripts[2] << OP_1 << std::vector<unsigned char>(2, 33) << OP_1 << OP_CHECKMULTISIG; // multisig 
+    excluded_scripts[3] << OP_0 << std::vector<unsigned char>(3, 32); // push data 
+    excluded_scripts[4] << OP_4 << OP_ADD << OP_8 << OP_EQUAL; // random script 
+    excluded_scripts[5] << OP_RETURN << std::vector<unsigned char>(4, 40); // opreturn 
+    excluded_scripts[6] = GetScriptForDestination(WitnessV0ScriptHash()); // p2wsh
+    excluded_scripts[7] << OP_RETURN << OP_4 << OP_ADD << OP_8 << OP_EQUAL; // none standard opreturn
+
+    CMutableTransaction tx_1;
+    tx_1.vout.emplace_back(100, included_scripts[0]);
+    tx_1.vout.emplace_back(200, excluded_scripts[0]);
+    tx_1.vout.emplace_back(300, excluded_scripts[1]);
+    tx_1.vout.emplace_back(400, excluded_scripts[2]);
+
+    CMutableTransaction tx_2;
+    tx_2.vout.emplace_back(100, excluded_scripts[3]);
+    tx_2.vout.emplace_back(0, excluded_scripts[4]);
+    tx_2.vout.emplace_back(400, excluded_scripts[5]);
+    tx_2.vout.emplace_back(400, excluded_scripts[8]); // Script is empty
+
+    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, included_scripts[1]), 1000, true);
+    block_undo.vtxundo.back().vprevout.emplace_back(CTxOut(600, excluded_scripts[6]), 10000, false);
+    block_undo.vtxundo.back().vprevout.emplace_back(CTxOut(700, excluded_scripts[7]), 100000, false);
+
+    BlockFilter block_filter(BlockFilterType::P2WPKH, 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_EQUAL(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_EQUAL(default_ctor_block_filter_1.GetFilterType(), default_ctor_block_filter_2.GetFilterType());
+    BOOST_CHECK_EQUAL(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;
@@ -182,13 +250,19 @@ BOOST_AUTO_TEST_CASE(blockfilters_json_test)
 BOOST_AUTO_TEST_CASE(blockfilter_type_names)
 {
     BOOST_CHECK_EQUAL(BlockFilterTypeName(BlockFilterType::BASIC), "basic");
+    BOOST_CHECK_EQUAL(BlockFilterTypeName(BlockFilterType::P2WPKH), "p2wpkh");
     BOOST_CHECK_EQUAL(BlockFilterTypeName(static_cast<BlockFilterType>(255)), "");
 
-    BlockFilterType filter_type;
-    BOOST_CHECK(BlockFilterTypeByName("basic", filter_type));
-    BOOST_CHECK_EQUAL(filter_type, BlockFilterType::BASIC);
+    BlockFilterType filter_type_basic;
+    BOOST_CHECK(BlockFilterTypeByName("basic", filter_type_basic));
+    BOOST_CHECK_EQUAL(filter_type_basic, BlockFilterType::BASIC);
 
-    BOOST_CHECK(!BlockFilterTypeByName("unknown", filter_type));
+    BlockFilterType filter_type_p2wpkh;
+    BOOST_CHECK(BlockFilterTypeByName("p2wpkh", filter_type_p2wpkh));
+    BOOST_CHECK_EQUAL(filter_type_p2wpkh, BlockFilterType::P2WPKH);
+
+    BlockFilterType filter_type_unknown;
+    BOOST_CHECK(!BlockFilterTypeByName("unknown", filter_type_unknown));
 }
 
 BOOST_AUTO_TEST_SUITE_END()

From d0a114bbe6f0e65a2d6afeee97db6d9bc3980125 Mon Sep 17 00:00:00 2001
From: Luke Dashjr <luke-jr+git@utopios.org>
Date: Thu, 30 Sep 2021 19:49:26 +0000
Subject: [PATCH 05/11] Make the filter element for witness ver0

Github-Pull: #18223
Rebased-From: 22b2ac6c38a870d59d18e8d2d7a0337dc63c86a5
---
 src/blockfilter.cpp            | 24 +++++++++++++-----------
 src/blockfilter.h              |  2 +-
 src/test/blockfilter_tests.cpp | 29 ++++++++++++++++-------------
 3 files changed, 30 insertions(+), 25 deletions(-)

diff --git a/src/blockfilter.cpp b/src/blockfilter.cpp
index 8543c42d80..173a2e81c5 100644
--- a/src/blockfilter.cpp
+++ b/src/blockfilter.cpp
@@ -23,7 +23,7 @@ static constexpr int GCS_SER_VERSION = 0;
 
 static const std::map<BlockFilterType, std::string> g_filter_types = {
     {BlockFilterType::BASIC, "basic"},
-    {BlockFilterType::P2WPKH, "p2wpkh"},
+    {BlockFilterType::V0, "v0"},
 };
 
 uint64_t GCSFilter::HashToRange(const Element& element) const
@@ -210,7 +210,7 @@ static GCSFilter::ElementSet BasicFilterElements(const CBlock& block,
     return elements;
 }
 
-static GCSFilter::ElementSet P2WPKHFilterElements(const CBlock& block,
+static GCSFilter::ElementSet V0FilterElements(const CBlock& block,
     const CBlockUndo& block_undo)
 {
     GCSFilter::ElementSet elements;
@@ -218,9 +218,10 @@ static GCSFilter::ElementSet P2WPKHFilterElements(const CBlock& block,
     for (const CTransactionRef& tx : block.vtx) {
         for (const CTxOut& txout : tx->vout) {
             const CScript& scriptPubKey = txout.scriptPubKey;
-            std::vector<std::vector<unsigned char>> solutions;
-            TxoutType script_type = Solver(txout.scriptPubKey, solutions);
-            if (scriptPubKey.empty() || script_type != TxoutType::WITNESS_V0_KEYHASH) continue;
+            int witnessversion;
+            std::vector<unsigned char> witnessprogram;
+            if (scriptPubKey.empty() || !scriptPubKey.IsWitnessProgram(witnessversion, witnessprogram)) continue;
+            if (!(witnessversion == 0 && (witnessprogram.size() == WITNESS_V0_KEYHASH_SIZE || witnessprogram.size() == WITNESS_V0_SCRIPTHASH_SIZE)))  continue;
             elements.emplace(scriptPubKey.begin(), scriptPubKey.end());
         }
     }
@@ -228,9 +229,10 @@ static GCSFilter::ElementSet P2WPKHFilterElements(const CBlock& block,
     for (const CTxUndo& tx_undo : block_undo.vtxundo) {
         for (const Coin& prevout : tx_undo.vprevout) {
             const CScript& scriptPubKey = prevout.out.scriptPubKey;
-            std::vector<std::vector<unsigned char>> solutions;
-            TxoutType script_type = Solver(scriptPubKey, solutions);
-            if (scriptPubKey.empty() || script_type != TxoutType::WITNESS_V0_KEYHASH) continue;
+            int witnessversion;
+            std::vector<unsigned char> witnessprogram;
+            if (scriptPubKey.empty() || !scriptPubKey.IsWitnessProgram(witnessversion, witnessprogram)) continue;
+            if (!(witnessversion == 0 && (witnessprogram.size() == WITNESS_V0_KEYHASH_SIZE || witnessprogram.size() == WITNESS_V0_SCRIPTHASH_SIZE))) continue;
             elements.emplace(scriptPubKey.begin(), scriptPubKey.end());
         }
     }
@@ -261,8 +263,8 @@ BlockFilter::BlockFilter(BlockFilterType filter_type, const CBlock& block, const
     case BlockFilterType::BASIC:
         m_filter = GCSFilter(params, BasicFilterElements(block, block_undo));
         break;
-    case BlockFilterType::P2WPKH:
-        m_filter = GCSFilter(params, P2WPKHFilterElements(block, block_undo));
+    case BlockFilterType::V0:
+        m_filter = GCSFilter(params, V0FilterElements(block, block_undo));
         break;
     }
 }
@@ -276,7 +278,7 @@ bool BlockFilter::BuildParams(GCSFilter::Params& params) const
         params.m_P = BASIC_FILTER_P;
         params.m_M = BASIC_FILTER_M;
         return true;
-    case BlockFilterType::P2WPKH:
+    case BlockFilterType::V0:
         params.m_siphash_k0 = m_block_hash.GetUint64(0);
         params.m_siphash_k1 = m_block_hash.GetUint64(1);
         // Using the same filter params as basic type.
diff --git a/src/blockfilter.h b/src/blockfilter.h
index fff860cd6e..c4bf86edec 100644
--- a/src/blockfilter.h
+++ b/src/blockfilter.h
@@ -90,7 +90,7 @@ enum class BlockFilterType : uint8_t
 {
     BASIC = 0,
     // Filter 1 is reserved as an option to include all filters.
-    P2WPKH = 2,
+    V0 = 2,
     INVALID = 255,
 };
 
diff --git a/src/test/blockfilter_tests.cpp b/src/test/blockfilter_tests.cpp
index f1ada076b2..87b1e130a1 100644
--- a/src/test/blockfilter_tests.cpp
+++ b/src/test/blockfilter_tests.cpp
@@ -127,12 +127,15 @@ BOOST_AUTO_TEST_CASE(blockfilter_basic_test)
     BOOST_CHECK(default_ctor_block_filter_1.GetEncodedFilter() == default_ctor_block_filter_2.GetEncodedFilter());
 }
 
-BOOST_AUTO_TEST_CASE(blockfilter_p2wpkh_test)
+BOOST_AUTO_TEST_CASE(blockfilter_v0_test)
 {
-    CScript included_scripts[2], excluded_scripts[9];
+    CScript included_scripts[4], excluded_scripts[8];
 
     included_scripts[0] = GetScriptForDestination(WitnessV0KeyHash());  // p2wpkh 
     included_scripts[1] = GetScriptForDestination(WitnessV0KeyHash()); // p2wpkh 
+    included_scripts[2] = GetScriptForDestination(WitnessV0ScriptHash()); // p2wsh
+    included_scripts[3] = GetScriptForDestination(WitnessV0ScriptHash()); // p2wsh
+
 
     excluded_scripts[0] << std::vector<unsigned char>(0, 65) << OP_CHECKSIG; // p2pk 
     excluded_scripts[1] << OP_0 << OP_HASH160 << std::vector<unsigned char>(1, 20) << OP_EQUALVERIFY << OP_CHECKSIG; // p2pkh 
@@ -140,20 +143,20 @@ BOOST_AUTO_TEST_CASE(blockfilter_p2wpkh_test)
     excluded_scripts[3] << OP_0 << std::vector<unsigned char>(3, 32); // push data 
     excluded_scripts[4] << OP_4 << OP_ADD << OP_8 << OP_EQUAL; // random script 
     excluded_scripts[5] << OP_RETURN << std::vector<unsigned char>(4, 40); // opreturn 
-    excluded_scripts[6] = GetScriptForDestination(WitnessV0ScriptHash()); // p2wsh
-    excluded_scripts[7] << OP_RETURN << OP_4 << OP_ADD << OP_8 << OP_EQUAL; // none standard opreturn
+    excluded_scripts[6] << OP_RETURN << OP_4 << OP_ADD << OP_8 << OP_EQUAL; // none standard opreturn
 
     CMutableTransaction tx_1;
     tx_1.vout.emplace_back(100, included_scripts[0]);
+    tx_1.vout.emplace_back(100, included_scripts[2]);
     tx_1.vout.emplace_back(200, excluded_scripts[0]);
     tx_1.vout.emplace_back(300, excluded_scripts[1]);
     tx_1.vout.emplace_back(400, excluded_scripts[2]);
 
     CMutableTransaction tx_2;
+    tx_2.vout.emplace_back(100, included_scripts[3]);
     tx_2.vout.emplace_back(100, excluded_scripts[3]);
     tx_2.vout.emplace_back(0, excluded_scripts[4]);
-    tx_2.vout.emplace_back(400, excluded_scripts[5]);
-    tx_2.vout.emplace_back(400, excluded_scripts[8]); // Script is empty
+    tx_2.vout.emplace_back(400, excluded_scripts[7]); // Script is empty
 
     CBlock block;
     block.vtx.push_back(MakeTransactionRef(tx_1));
@@ -162,10 +165,10 @@ BOOST_AUTO_TEST_CASE(blockfilter_p2wpkh_test)
     CBlockUndo block_undo;
     block_undo.vtxundo.emplace_back();
     block_undo.vtxundo.back().vprevout.emplace_back(CTxOut(500, included_scripts[1]), 1000, true);
-    block_undo.vtxundo.back().vprevout.emplace_back(CTxOut(600, excluded_scripts[6]), 10000, false);
-    block_undo.vtxundo.back().vprevout.emplace_back(CTxOut(700, excluded_scripts[7]), 100000, false);
+    block_undo.vtxundo.back().vprevout.emplace_back(CTxOut(600, excluded_scripts[5]), 10000, false);
+    block_undo.vtxundo.back().vprevout.emplace_back(CTxOut(700, excluded_scripts[6]), 100000, false);
 
-    BlockFilter block_filter(BlockFilterType::P2WPKH, block, block_undo);
+    BlockFilter block_filter(BlockFilterType::V0, block, block_undo);
     const GCSFilter& filter = block_filter.GetFilter();
 
     for (const CScript& script : included_scripts) {
@@ -250,16 +253,16 @@ BOOST_AUTO_TEST_CASE(blockfilters_json_test)
 BOOST_AUTO_TEST_CASE(blockfilter_type_names)
 {
     BOOST_CHECK_EQUAL(BlockFilterTypeName(BlockFilterType::BASIC), "basic");
-    BOOST_CHECK_EQUAL(BlockFilterTypeName(BlockFilterType::P2WPKH), "p2wpkh");
+    BOOST_CHECK_EQUAL(BlockFilterTypeName(BlockFilterType::V0), "v0");
     BOOST_CHECK_EQUAL(BlockFilterTypeName(static_cast<BlockFilterType>(255)), "");
 
     BlockFilterType filter_type_basic;
     BOOST_CHECK(BlockFilterTypeByName("basic", filter_type_basic));
     BOOST_CHECK_EQUAL(filter_type_basic, BlockFilterType::BASIC);
 
-    BlockFilterType filter_type_p2wpkh;
-    BOOST_CHECK(BlockFilterTypeByName("p2wpkh", filter_type_p2wpkh));
-    BOOST_CHECK_EQUAL(filter_type_p2wpkh, BlockFilterType::P2WPKH);
+    BlockFilterType filter_type_v0;
+    BOOST_CHECK(BlockFilterTypeByName("v0", filter_type_v0));
+    BOOST_CHECK_EQUAL(filter_type_v0, BlockFilterType::V0);
 
     BlockFilterType filter_type_unknown;
     BOOST_CHECK(!BlockFilterTypeByName("unknown", filter_type_unknown));

From 7375c7b000ac2e347f16ab52abc2ee677a6276bc Mon Sep 17 00:00:00 2001
From: Luke Dashjr <luke-jr+git@utopios.org>
Date: Thu, 30 Sep 2021 19:51:35 +0000
Subject: [PATCH 06/11] Act on review

Github-Pull: #18223
Rebased-From: dac4d5a74fa42c3b4efa21ffa019a3ff75375510
---
 src/blockfilter.cpp            |  9 ++-------
 src/test/blockfilter_tests.cpp | 17 ++++++++---------
 2 files changed, 10 insertions(+), 16 deletions(-)

diff --git a/src/blockfilter.cpp b/src/blockfilter.cpp
index 173a2e81c5..5dfc50b683 100644
--- a/src/blockfilter.cpp
+++ b/src/blockfilter.cpp
@@ -266,25 +266,20 @@ BlockFilter::BlockFilter(BlockFilterType filter_type, const CBlock& block, const
     case BlockFilterType::V0:
         m_filter = GCSFilter(params, V0FilterElements(block, block_undo));
         break;
+    default: assert(false);
     }
 }
 
 bool BlockFilter::BuildParams(GCSFilter::Params& params) const
 {
     switch (m_filter_type) {
+    case BlockFilterType::V0:
     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::V0:
-        params.m_siphash_k0 = m_block_hash.GetUint64(0);
-        params.m_siphash_k1 = m_block_hash.GetUint64(1);
-        // Using the same filter params as basic type.
-        params.m_P = BASIC_FILTER_P;
-        params.m_M = BASIC_FILTER_M;
-        return true;
     case BlockFilterType::INVALID:
         return false;
     }
diff --git a/src/test/blockfilter_tests.cpp b/src/test/blockfilter_tests.cpp
index 87b1e130a1..43bb5d19b2 100644
--- a/src/test/blockfilter_tests.cpp
+++ b/src/test/blockfilter_tests.cpp
@@ -131,18 +131,17 @@ BOOST_AUTO_TEST_CASE(blockfilter_v0_test)
 {
     CScript included_scripts[4], excluded_scripts[8];
 
-    included_scripts[0] = GetScriptForDestination(WitnessV0KeyHash());  // p2wpkh 
-    included_scripts[1] = GetScriptForDestination(WitnessV0KeyHash()); // p2wpkh 
+    included_scripts[0] = GetScriptForDestination(WitnessV0KeyHash());  // p2wpkh
+    included_scripts[1] = GetScriptForDestination(WitnessV0KeyHash()); // p2wpkh
     included_scripts[2] = GetScriptForDestination(WitnessV0ScriptHash()); // p2wsh
     included_scripts[3] = GetScriptForDestination(WitnessV0ScriptHash()); // p2wsh
 
-
-    excluded_scripts[0] << std::vector<unsigned char>(0, 65) << OP_CHECKSIG; // p2pk 
-    excluded_scripts[1] << OP_0 << OP_HASH160 << std::vector<unsigned char>(1, 20) << OP_EQUALVERIFY << OP_CHECKSIG; // p2pkh 
-    excluded_scripts[2] << OP_1 << std::vector<unsigned char>(2, 33) << OP_1 << OP_CHECKMULTISIG; // multisig 
-    excluded_scripts[3] << OP_0 << std::vector<unsigned char>(3, 32); // push data 
-    excluded_scripts[4] << OP_4 << OP_ADD << OP_8 << OP_EQUAL; // random script 
-    excluded_scripts[5] << OP_RETURN << std::vector<unsigned char>(4, 40); // opreturn 
+    excluded_scripts[0] << std::vector<unsigned char>(0, 65) << OP_CHECKSIG; // p2pk
+    excluded_scripts[1] << OP_0 << OP_HASH160 << std::vector<unsigned char>(1, 20) << OP_EQUALVERIFY << OP_CHECKSIG; // p2pkh
+    excluded_scripts[2] << OP_1 << std::vector<unsigned char>(2, 33) << OP_1 << OP_CHECKMULTISIG; // multisig
+    excluded_scripts[3] << OP_0 << std::vector<unsigned char>(3, 32); // push data
+    excluded_scripts[4] << OP_4 << OP_ADD << OP_8 << OP_EQUAL; // random script
+    excluded_scripts[5] << OP_RETURN << std::vector<unsigned char>(4, 40); // opreturn
     excluded_scripts[6] << OP_RETURN << OP_4 << OP_ADD << OP_8 << OP_EQUAL; // none standard opreturn
 
     CMutableTransaction tx_1;

From 0a4ff2875a567641dd411cb50ed1927099db14de Mon Sep 17 00:00:00 2001
From: dangershony <dan.gershony@gmail.com>
Date: Mon, 2 Mar 2020 13:28:44 +0000
Subject: [PATCH 07/11] Move the filter logic to a single method named
 BuildFilterElements

Github-Pull: #18223
Rebased-From: 3055ac89c1032c2e9f35e4894d6f61ef960a3ef8
---
 src/blockfilter.cpp | 56 +++++++++++++++++----------------------------
 1 file changed, 21 insertions(+), 35 deletions(-)

diff --git a/src/blockfilter.cpp b/src/blockfilter.cpp
index 5dfc50b683..81e02ebf2e 100644
--- a/src/blockfilter.cpp
+++ b/src/blockfilter.cpp
@@ -186,8 +186,10 @@ const std::string& ListBlockFilterTypes()
     return type_list;
 }
 
-static GCSFilter::ElementSet BasicFilterElements(const CBlock& block,
-                                                 const CBlockUndo& block_undo)
+static GCSFilter::ElementSet BuildFilterElements(const CBlock& block,
+                                                 const CBlockUndo& block_undo,
+                                                 bool only_segwit = true,
+                                                 int witness_version = 0)
 {
     GCSFilter::ElementSet elements;
 
@@ -195,6 +197,13 @@ static GCSFilter::ElementSet BasicFilterElements(const CBlock& block,
         for (const CTxOut& txout : tx->vout) {
             const CScript& script = txout.scriptPubKey;
             if (script.empty() || script[0] == OP_RETURN) continue;
+            if (only_segwit) {
+                int witnessversion;
+                std::vector<unsigned char> witnessprogram;
+                if (!script.IsWitnessProgram(witnessversion, witnessprogram)) continue;
+                if (witnessversion != witness_version) continue;
+                if (!(witnessversion == 0 && (witnessprogram.size() == WITNESS_V0_KEYHASH_SIZE || witnessprogram.size() == WITNESS_V0_SCRIPTHASH_SIZE))) continue; // specific v0 checks
+            }
             elements.emplace(script.begin(), script.end());
         }
     }
@@ -202,7 +211,14 @@ static GCSFilter::ElementSet BasicFilterElements(const CBlock& block,
     for (const CTxUndo& tx_undo : block_undo.vtxundo) {
         for (const Coin& prevout : tx_undo.vprevout) {
             const CScript& script = prevout.out.scriptPubKey;
-            if (script.empty()) continue;
+            if (script.empty() || script[0] == OP_RETURN) continue;
+            if (only_segwit) {
+                int witnessversion;
+                std::vector<unsigned char> witnessprogram;
+                if (!script.IsWitnessProgram(witnessversion, witnessprogram)) continue;
+                if (witnessversion != witness_version) continue;
+                if (!(witnessversion == 0 && (witnessprogram.size() == WITNESS_V0_KEYHASH_SIZE || witnessprogram.size() == WITNESS_V0_SCRIPTHASH_SIZE))) continue; // specific v0 checks
+            }
             elements.emplace(script.begin(), script.end());
         }
     }
@@ -210,36 +226,6 @@ static GCSFilter::ElementSet BasicFilterElements(const CBlock& block,
     return elements;
 }
 
-static GCSFilter::ElementSet V0FilterElements(const CBlock& block,
-    const CBlockUndo& block_undo)
-{
-    GCSFilter::ElementSet elements;
-
-    for (const CTransactionRef& tx : block.vtx) {
-        for (const CTxOut& txout : tx->vout) {
-            const CScript& scriptPubKey = txout.scriptPubKey;
-            int witnessversion;
-            std::vector<unsigned char> witnessprogram;
-            if (scriptPubKey.empty() || !scriptPubKey.IsWitnessProgram(witnessversion, witnessprogram)) continue;
-            if (!(witnessversion == 0 && (witnessprogram.size() == WITNESS_V0_KEYHASH_SIZE || witnessprogram.size() == WITNESS_V0_SCRIPTHASH_SIZE)))  continue;
-            elements.emplace(scriptPubKey.begin(), scriptPubKey.end());
-        }
-    }
-
-    for (const CTxUndo& tx_undo : block_undo.vtxundo) {
-        for (const Coin& prevout : tx_undo.vprevout) {
-            const CScript& scriptPubKey = prevout.out.scriptPubKey;
-            int witnessversion;
-            std::vector<unsigned char> witnessprogram;
-            if (scriptPubKey.empty() || !scriptPubKey.IsWitnessProgram(witnessversion, witnessprogram)) continue;
-            if (!(witnessversion == 0 && (witnessprogram.size() == WITNESS_V0_KEYHASH_SIZE || witnessprogram.size() == WITNESS_V0_SCRIPTHASH_SIZE))) continue;
-            elements.emplace(scriptPubKey.begin(), scriptPubKey.end());
-        }
-    }
-
-    return elements;
-}
-
 BlockFilter::BlockFilter(BlockFilterType filter_type, const uint256& block_hash,
                          std::vector<unsigned char> filter, bool skip_decode_check)
     : m_filter_type(filter_type), m_block_hash(block_hash)
@@ -261,10 +247,10 @@ BlockFilter::BlockFilter(BlockFilterType filter_type, const CBlock& block, const
 
     switch (m_filter_type) {
     case BlockFilterType::BASIC:
-        m_filter = GCSFilter(params, BasicFilterElements(block, block_undo));
+        m_filter = GCSFilter(params, BuildFilterElements(block, block_undo, false));
         break;
     case BlockFilterType::V0:
-        m_filter = GCSFilter(params, V0FilterElements(block, block_undo));
+        m_filter = GCSFilter(params, BuildFilterElements(block, block_undo));
         break;
     default: assert(false);
     }

From 47a835005bfbaf55afd5443d745938d7d2d07e55 Mon Sep 17 00:00:00 2001
From: dangershony <dan.gershony@gmail.com>
Date: Mon, 2 Mar 2020 21:38:56 +0000
Subject: [PATCH 08/11] Change the BuildFilterElements default args

Github-Pull: #18223
Rebased-From: dc1fe756fc5148b467932fb76888393270134c1d
---
 src/blockfilter.cpp | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/src/blockfilter.cpp b/src/blockfilter.cpp
index 81e02ebf2e..3fc9cfc1c7 100644
--- a/src/blockfilter.cpp
+++ b/src/blockfilter.cpp
@@ -188,7 +188,7 @@ const std::string& ListBlockFilterTypes()
 
 static GCSFilter::ElementSet BuildFilterElements(const CBlock& block,
                                                  const CBlockUndo& block_undo,
-                                                 bool only_segwit = true,
+                                                 bool only_segwit = false,
                                                  int witness_version = 0)
 {
     GCSFilter::ElementSet elements;
@@ -247,10 +247,10 @@ BlockFilter::BlockFilter(BlockFilterType filter_type, const CBlock& block, const
 
     switch (m_filter_type) {
     case BlockFilterType::BASIC:
-        m_filter = GCSFilter(params, BuildFilterElements(block, block_undo, false));
+        m_filter = GCSFilter(params, BuildFilterElements(block, block_undo));
         break;
     case BlockFilterType::V0:
-        m_filter = GCSFilter(params, BuildFilterElements(block, block_undo));
+        m_filter = GCSFilter(params, BuildFilterElements(block, block_undo, true));
         break;
     default: assert(false);
     }

From c723b1dc15b5f64976c8d1239f656983321992f1 Mon Sep 17 00:00:00 2001
From: dangershony <dan.gershony@gmail.com>
Date: Wed, 4 Mar 2020 21:10:07 +0000
Subject: [PATCH 09/11] Act on review

Github-Pull: #18223
Rebased-From: 5561e7a0c79606e555ea9b986a9065d14ec40118
---
 src/blockfilter.cpp | 7 ++++---
 1 file changed, 4 insertions(+), 3 deletions(-)

diff --git a/src/blockfilter.cpp b/src/blockfilter.cpp
index 3fc9cfc1c7..bf1a4b7add 100644
--- a/src/blockfilter.cpp
+++ b/src/blockfilter.cpp
@@ -211,7 +211,7 @@ static GCSFilter::ElementSet BuildFilterElements(const CBlock& block,
     for (const CTxUndo& tx_undo : block_undo.vtxundo) {
         for (const Coin& prevout : tx_undo.vprevout) {
             const CScript& script = prevout.out.scriptPubKey;
-            if (script.empty() || script[0] == OP_RETURN) continue;
+            if (script.empty()) continue;
             if (only_segwit) {
                 int witnessversion;
                 std::vector<unsigned char> witnessprogram;
@@ -252,15 +252,16 @@ BlockFilter::BlockFilter(BlockFilterType filter_type, const CBlock& block, const
     case BlockFilterType::V0:
         m_filter = GCSFilter(params, BuildFilterElements(block, block_undo, true));
         break;
-    default: assert(false);
+    case BlockFilterType::INVALID:
+        assert(false);
     }
 }
 
 bool BlockFilter::BuildParams(GCSFilter::Params& params) const
 {
     switch (m_filter_type) {
-    case BlockFilterType::V0:
     case BlockFilterType::BASIC:
+    case BlockFilterType::V0:
         params.m_siphash_k0 = m_block_hash.GetUint64(0);
         params.m_siphash_k1 = m_block_hash.GetUint64(1);
         params.m_P = BASIC_FILTER_P;

From a00e65a4d2dd9af3bc1cad22e99486f00c0b7ae6 Mon Sep 17 00:00:00 2001
From: Luke Dashjr <luke-jr+git@utopios.org>
Date: Wed, 4 Mar 2020 19:07:11 +0000
Subject: [PATCH 10/11] QA: blockfilter_tests: Diff-minimise

---
 src/test/blockfilter_tests.cpp | 9 ++++-----
 1 file changed, 4 insertions(+), 5 deletions(-)

diff --git a/src/test/blockfilter_tests.cpp b/src/test/blockfilter_tests.cpp
index 43bb5d19b2..14f996e7c6 100644
--- a/src/test/blockfilter_tests.cpp
+++ b/src/test/blockfilter_tests.cpp
@@ -255,16 +255,15 @@ BOOST_AUTO_TEST_CASE(blockfilter_type_names)
     BOOST_CHECK_EQUAL(BlockFilterTypeName(BlockFilterType::V0), "v0");
     BOOST_CHECK_EQUAL(BlockFilterTypeName(static_cast<BlockFilterType>(255)), "");
 
-    BlockFilterType filter_type_basic;
-    BOOST_CHECK(BlockFilterTypeByName("basic", filter_type_basic));
-    BOOST_CHECK_EQUAL(filter_type_basic, BlockFilterType::BASIC);
+    BlockFilterType filter_type;
+    BOOST_CHECK(BlockFilterTypeByName("basic", filter_type));
+    BOOST_CHECK_EQUAL(filter_type, BlockFilterType::BASIC);
 
     BlockFilterType filter_type_v0;
     BOOST_CHECK(BlockFilterTypeByName("v0", filter_type_v0));
     BOOST_CHECK_EQUAL(filter_type_v0, BlockFilterType::V0);
 
-    BlockFilterType filter_type_unknown;
-    BOOST_CHECK(!BlockFilterTypeByName("unknown", filter_type_unknown));
+    BOOST_CHECK(!BlockFilterTypeByName("unknown", filter_type));
 }
 
 BOOST_AUTO_TEST_SUITE_END()

From 27827c9b8926aac0b1ae5d553509f79c9ea65a7b Mon Sep 17 00:00:00 2001
From: Luke Dashjr <luke-jr+git@utopios.org>
Date: Wed, 4 Mar 2020 19:17:15 +0000
Subject: [PATCH 11/11] Only enable basic blockfilterindex if enabled with type
 omitted

---
 src/init.cpp | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/init.cpp b/src/init.cpp
index 1122496539..014efc78a8 100644
--- a/src/init.cpp
+++ b/src/init.cpp
@@ -462,7 +462,7 @@ void SetupServerArgs(ArgsManager& argsman)
     argsman.AddArg("-txindex", strprintf("Maintain a full transaction index, used by the getrawtransaction rpc call (default: %u)", DEFAULT_TXINDEX), ArgsManager::ALLOW_ANY, OptionsCategory::OPTIONS);
     argsman.AddArg("-blockfilterindex=<type>",
                  strprintf("Maintain an index of compact filters by block (default: %s, values: %s).", DEFAULT_BLOCKFILTERINDEX, ListBlockFilterTypes()) +
-                 " If <type> is not supplied or if <type> = 1, indexes for all known types are enabled.",
+                 " If <type> is not supplied or if <type> = 1, certain indexes are enabled (currently just basic).",
                  ArgsManager::ALLOW_ANY, OptionsCategory::OPTIONS);
 
     argsman.AddArg("-addnode=<ip>", strprintf("Add a node to connect to and attempt to keep the connection open (see the addnode RPC help for more info). This option can be specified multiple times to add multiple nodes; connections are limited to %u at a time and are counted separately from the -maxconnections limit.", MAX_ADDNODE_CONNECTIONS), ArgsManager::ALLOW_ANY | ArgsManager::NETWORK_ONLY, OptionsCategory::CONNECTION);
@@ -874,7 +874,7 @@ bool AppInitParameterInteraction(const ArgsManager& args, bool use_syscall_sandb
     // parse and validate enabled filter types
     std::string blockfilterindex_value = args.GetArg("-blockfilterindex", DEFAULT_BLOCKFILTERINDEX);
     if (blockfilterindex_value == "" || blockfilterindex_value == "1") {
-        g_enabled_filter_types = AllBlockFilterTypes();
+        g_enabled_filter_types = {BlockFilterType::BASIC};
     } else if (blockfilterindex_value != "0") {
         const std::vector<std::string> names = args.GetArgs("-blockfilterindex");
         for (const auto& name : names) {