From 7ea9257e6ec812ef98558c57731ed0a45cfc5082 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 dd3824fb1c..7a7ab22403 100644
--- a/src/blockfilter.cpp
+++ b/src/blockfilter.cpp
@@ -10,6 +10,7 @@
 #include <hash.h>
 #include <primitives/block.h>
 #include <primitives/transaction.h>
+#include <script/interpreter.h>
 #include <script/script.h>
 #include <streams.h>
 #include <undo.h>
@@ -21,6 +22,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
@@ -207,6 +209,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)
@@ -225,7 +255,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
@@ -237,6 +275,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 8eab4afa76..3f441f45e3 100644
--- a/src/blockfilter.h
+++ b/src/blockfilter.h
@@ -92,6 +92,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 629e0ee2da20627925141afc80cf5a4f048f75a7 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 7b84747a3f..290611b44a 100644
--- a/src/rpc/blockchain.cpp
+++ b/src/rpc/blockchain.cpp
@@ -2492,7 +2492,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 72aa6d56a3c92c74f60272b7a733f61a16b3443e 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 7a7ab22403..190bad75d4 100644
--- a/src/blockfilter.cpp
+++ b/src/blockfilter.cpp
@@ -278,7 +278,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 3f441f45e3..f63734df99 100644
--- a/src/blockfilter.h
+++ b/src/blockfilter.h
@@ -92,7 +92,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 5533f9c7a6c653eb605c5f0ee48af4fb8df3fe6d 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 | 81 ++++++++++++++++++++++++++++++++--
 1 file changed, 77 insertions(+), 4 deletions(-)

diff --git a/src/test/blockfilter_tests.cpp b/src/test/blockfilter_tests.cpp
index b372f25ea9..f8159e3708 100644
--- a/src/test/blockfilter_tests.cpp
+++ b/src/test/blockfilter_tests.cpp
@@ -5,6 +5,7 @@
 #include <test/data/blockfilters.json.h>
 #include <test/util/setup_common.h>
 
+#include <addresstype.h>
 #include <blockfilter.h>
 #include <core_io.h>
 #include <primitives/block.h>
@@ -127,6 +128,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 +249,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 3d324b962e636fe073b1f1473c9f1257a0663d21 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 190bad75d4..01f2bbcc54 100644
--- a/src/blockfilter.cpp
+++ b/src/blockfilter.cpp
@@ -22,7 +22,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
@@ -209,7 +209,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;
@@ -217,9 +217,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());
         }
     }
@@ -227,9 +228,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());
         }
     }
@@ -260,8 +262,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;
     }
 }
@@ -275,7 +277,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 f63734df99..fb3cbe3208 100644
--- a/src/blockfilter.h
+++ b/src/blockfilter.h
@@ -93,7 +93,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 f8159e3708..2433d874c3 100644
--- a/src/test/blockfilter_tests.cpp
+++ b/src/test/blockfilter_tests.cpp
@@ -128,12 +128,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 
@@ -141,20 +144,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));
@@ -163,10 +166,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) {
@@ -249,16 +252,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 88d7454b0b357961f0d7a4a4587da0f2a2ef4b65 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 01f2bbcc54..4161fea3bb 100644
--- a/src/blockfilter.cpp
+++ b/src/blockfilter.cpp
@@ -265,25 +265,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 2433d874c3..a65d5665b1 100644
--- a/src/test/blockfilter_tests.cpp
+++ b/src/test/blockfilter_tests.cpp
@@ -132,18 +132,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 705954ba4d4bf9d9a908ad0e60721106d8f3c356 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 4161fea3bb..6d058279be 100644
--- a/src/blockfilter.cpp
+++ b/src/blockfilter.cpp
@@ -185,8 +185,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;
 
@@ -194,6 +196,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());
         }
     }
@@ -201,7 +210,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());
         }
     }
@@ -209,36 +225,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)
@@ -260,10 +246,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 36ef6af918baf9263cd974ccfb55def429c3fdef 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 6d058279be..d7bcfb8b7f 100644
--- a/src/blockfilter.cpp
+++ b/src/blockfilter.cpp
@@ -187,7 +187,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;
@@ -246,10 +246,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 ff4282d9e70060b291e83215fa777a26945d60bc 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 d7bcfb8b7f..64d47618f0 100644
--- a/src/blockfilter.cpp
+++ b/src/blockfilter.cpp
@@ -210,7 +210,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;
@@ -251,15 +251,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 78620262bcdaed50058980ff6ff38e30a5433d9a 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 a65d5665b1..f6480f03e6 100644
--- a/src/test/blockfilter_tests.cpp
+++ b/src/test/blockfilter_tests.cpp
@@ -254,16 +254,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 921ddbf21ceedee64f63eeeb261520e3e794000d 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 42331d37e8..362a50a358 100644
--- a/src/init.cpp
+++ b/src/init.cpp
@@ -472,7 +472,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);
@@ -882,7 +882,7 @@ bool AppInitParameterInteraction(const ArgsManager& args)
     // 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) {