diff --git a/doc/REST-interface.md b/doc/REST-interface.md
index ed46e22262bb..8f38238f60bb 100644
--- a/doc/REST-interface.md
+++ b/doc/REST-interface.md
@@ -33,8 +33,7 @@ Supported API
 Given a transaction hash: returns a transaction in binary, hex-encoded binary, or JSON formats.
 Responds with 404 if the transaction doesn't exist.
 
-By default, this endpoint will only search the mempool.
-To query for a confirmed transaction, enable the transaction index via "txindex=1" command line / configuration option.
+This endpoint only searches the mempool.
 
 #### Blocks
 - `GET /rest/block/<BLOCK-HASH>.<bin|hex|json>`
@@ -61,23 +60,6 @@ Returns empty if the block doesn't exist or it isn't in the active chain.
 *Deprecated (but not removed) since 24.0:*
 `GET /rest/headers/<COUNT>/<BLOCK-HASH>.<bin|hex|json>`
 
-#### Blockfilter Headers
-`GET /rest/blockfilterheaders/<FILTERTYPE>/<BLOCK-HASH>.<bin|hex|json>?count=<COUNT=5>`
-
-Given a block hash: returns <COUNT> amount of blockfilter headers in upward
-direction for the filter type <FILTERTYPE>.
-Returns empty if the block doesn't exist or it isn't in the active chain.
-
-*Deprecated (but not removed) since 24.0:*
-`GET /rest/blockfilterheaders/<FILTERTYPE>/<COUNT>/<BLOCK-HASH>.<bin|hex|json>`
-
-#### Blockfilters
-`GET /rest/blockfilter/<FILTERTYPE>/<BLOCK-HASH>.<bin|hex|json>`
-
-Given a block hash: returns the block filter of the given block of type
-<FILTERTYPE>.
-Responds with 404 if the block doesn't exist.
-
 #### Blockhash by height
 `GET /rest/blockhashbyheight/<HEIGHT>.<bin|hex|json>`
 
diff --git a/doc/bips.md b/doc/bips.md
index eb35ca2d6ac0..03ddf085cc02 100644
--- a/doc/bips.md
+++ b/doc/bips.md
@@ -38,8 +38,6 @@ BIPs that are implemented by Bitcoin Core:
 * [`BIP 147`](https://github.com/bitcoin/bips/blob/master/bip-0147.mediawiki): NULLDUMMY softfork as of **v0.13.1** ([PR 8636](https://github.com/bitcoin/bitcoin/pull/8636) and [PR 8937](https://github.com/bitcoin/bitcoin/pull/8937)), *buried* since **v0.19.0** ([PR #16060](https://github.com/bitcoin/bitcoin/pull/16060)).
 * [`BIP 152`](https://github.com/bitcoin/bips/blob/master/bip-0152.mediawiki): Compact block transfer and related optimizations are used as of **v0.13.0** ([PR 8068](https://github.com/bitcoin/bitcoin/pull/8068)).
 * [`BIP 155`](https://github.com/bitcoin/bips/blob/master/bip-0155.mediawiki): The 'addrv2' and 'sendaddrv2' messages which enable relay of Tor V3 addresses (and other networks) are supported as of **v0.21.0** ([PR 19954](https://github.com/bitcoin/bitcoin/pull/19954)).
-* [`BIP 157`](https://github.com/bitcoin/bips/blob/master/bip-0157.mediawiki)
-  [`158`](https://github.com/bitcoin/bips/blob/master/bip-0158.mediawiki): Compact Block Filters for Light Clients can be indexed as of **v0.19.0** ([PR #14121](https://github.com/bitcoin/bitcoin/pull/14121)) and served to peers on the P2P network as of **v0.21.0** ([PR #16442](https://github.com/bitcoin/bitcoin/pull/16442)).
 * [`BIP 159`](https://github.com/bitcoin/bips/blob/master/bip-0159.mediawiki): The `NODE_NETWORK_LIMITED` service bit is signalled as of **v0.16.0** ([PR 11740](https://github.com/bitcoin/bitcoin/pull/11740)), and such nodes are connected to as of **v0.17.0** ([PR 10387](https://github.com/bitcoin/bitcoin/pull/10387)).
 * [`BIP 173`](https://github.com/bitcoin/bips/blob/master/bip-0173.mediawiki): Bech32 addresses for native Segregated Witness outputs are supported as of **v0.16.0** ([PR 11167](https://github.com/bitcoin/bitcoin/pull/11167)). Bech32 addresses are generated by default as of **v0.20.0** ([PR 16884](https://github.com/bitcoin/bitcoin/pull/16884)).
 * [`BIP 324`](https://github.com/bitcoin/bips/blob/master/bip-0324.mediawiki): The v2 transport protocol specified by BIP324 and the associated `NODE_P2P_V2` service bit are supported as of **v26.0**, but off by default ([PR 28331](https://github.com/bitcoin/bitcoin/pull/28331)). On by default as of **v27.0** ([PR 29347](https://github.com/bitcoin/bitcoin/pull/29347)).
diff --git a/doc/developer-notes.md b/doc/developer-notes.md
index fdd6824e1f73..edd0e940105d 100644
--- a/doc/developer-notes.md
+++ b/doc/developer-notes.md
@@ -695,9 +695,6 @@ done by the components.
 - [HTTP worker threads (`b-http_pool_x`)](https://doxygen.bitcoincore.org/httpserver_8cpp.html#a2ad0a49dc9b5e8117c0dee98c24187d8)
   : Threads to service RPC and REST requests.
 
-- [Indexer threads (`b-txindex`, etc)](https://doxygen.bitcoincore.org/class_base_index.html#a96a7407421fbf877509248bbe64f8d87)
-  : One thread per indexer.
-
 - [SchedulerThread (`b-scheduler`)](https://doxygen.bitcoincore.org/class_c_scheduler.html#a14d2800815da93577858ea078aed1fba)
   : Does asynchronous background tasks like dumping addrman and running
   asynchronous validationinterface callbacks.
diff --git a/doc/files.md b/doc/files.md
index e3f4f1b4e1b0..760e2664bc47 100644
--- a/doc/files.md
+++ b/doc/files.md
@@ -46,11 +46,6 @@ Subdirectory       | File(s)               | Description
 `blocks/`          | `revNNNNN.dat`<sup>[\[2\]](#note2)</sup> | Block undo data (custom format)
 `blocks/`          | `xor.dat`             | Rolling XOR pattern for block and undo data files
 `chainstate/`      | LevelDB database      | Blockchain state (a compact representation of all currently unspent transaction outputs (UTXOs) and metadata about the transactions they are from)
-`indexes/txindex/` | LevelDB database      | Transaction index; *optional*, used if `-txindex=1`
-`indexes/txospenderindex/` | LevelDB database      | Transaction spender index; *optional*, used if `-txospenderindex=1`
-`indexes/blockfilter/basic/db/` | LevelDB database      | Blockfilter index LevelDB database for the basic filtertype; *optional*, used if `-blockfilterindex=basic`
-`indexes/blockfilter/basic/`    | `fltrNNNNN.dat`<sup>[\[2\]](#note2)</sup> | Blockfilter index filters for the basic filtertype; *optional*, used if `-blockfilterindex=basic`
-`indexes/coinstatsindex/db/` | LevelDB database | Coinstats index; *optional*, used if `-coinstatsindex=1`
 `./`               | `anchors.dat`         | Anchor IP address database, created on shutdown and deleted at startup. Anchors are last known outgoing block-relay-only peers that are tried to re-connect to on startup
 `./`               | `banlist.json`        | Stores the addresses/subnets of banned nodes.
 `./`               | `bitcoin.conf`        | User-defined [configuration settings](bitcoin-conf.md) for `bitcoind`. File is not written to by the software and must be created manually. Path can be specified by `-conf` option
diff --git a/src/CMakeLists.txt b/src/CMakeLists.txt
index 67ec63c18940..ed4d9d83ddb6 100644
--- a/src/CMakeLists.txt
+++ b/src/CMakeLists.txt
@@ -158,7 +158,6 @@ add_library(bitcoin_node STATIC EXCLUDE_FROM_ALL
   banman.cpp
   bip324.cpp
   blockencodings.cpp
-  blockfilter.cpp
   consensus/tx_verify.cpp
   dbwrapper.cpp
   deploymentstatus.cpp
@@ -167,11 +166,6 @@ add_library(bitcoin_node STATIC EXCLUDE_FROM_ALL
   httprpc.cpp
   httpserver.cpp
   i2p.cpp
-  index/base.cpp
-  index/blockfilterindex.cpp
-  index/coinstatsindex.cpp
-  index/txindex.cpp
-  index/txospenderindex.cpp
   init.cpp
   kernel/chain.cpp
   kernel/checks.cpp
diff --git a/src/bench/CMakeLists.txt b/src/bench/CMakeLists.txt
index 9bb0cc886f12..f930702a7038 100644
--- a/src/bench/CMakeLists.txt
+++ b/src/bench/CMakeLists.txt
@@ -26,9 +26,7 @@ add_executable(bench_bitcoin
   duplicate_inputs.cpp
   ellswift.cpp
   examples.cpp
-  gcs_filter.cpp
   hashpadding.cpp
-  index_blockfilter.cpp
   load_external.cpp
   lockedpool.cpp
   logging.cpp
diff --git a/src/bench/gcs_filter.cpp b/src/bench/gcs_filter.cpp
deleted file mode 100644
index ea48592ac8fc..000000000000
--- a/src/bench/gcs_filter.cpp
+++ /dev/null
@@ -1,93 +0,0 @@
-// Copyright (c) 2018-present 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 <bench/bench.h>
-#include <blockfilter.h>
-#include <uint256.h>
-
-#include <cstdint>
-#include <utility>
-#include <vector>
-
-static GCSFilter::ElementSet GenerateGCSTestElements()
-{
-    GCSFilter::ElementSet elements;
-
-    // Testing the benchmarks with different number of elements show that a filter
-    // with at least 100,000 elements results in benchmarks that have the same
-    // ns/op. This makes it easy to reason about how long (in nanoseconds) a single
-    // filter element takes to process.
-    for (int i = 0; i < 100000; ++i) {
-        GCSFilter::Element element(32);
-        element[0] = static_cast<unsigned char>(i);
-        element[1] = static_cast<unsigned char>(i >> 8);
-        elements.insert(std::move(element));
-    }
-
-    return elements;
-}
-
-static void GCSBlockFilterGetHash(benchmark::Bench& bench)
-{
-    auto elements = GenerateGCSTestElements();
-
-    GCSFilter filter({0, 0, BASIC_FILTER_P, BASIC_FILTER_M}, elements);
-    BlockFilter block_filter(BlockFilterType::BASIC, {}, filter.GetEncoded(), /*skip_decode_check=*/false);
-
-    bench.run([&] {
-        block_filter.GetHash();
-    });
-}
-
-static void GCSFilterConstruct(benchmark::Bench& bench)
-{
-    auto elements = GenerateGCSTestElements();
-
-    uint64_t siphash_k0 = 0;
-    bench.run([&]{
-        GCSFilter filter({siphash_k0, 0, BASIC_FILTER_P, BASIC_FILTER_M}, elements);
-
-        siphash_k0++;
-    });
-}
-
-static void GCSFilterDecode(benchmark::Bench& bench)
-{
-    auto elements = GenerateGCSTestElements();
-
-    GCSFilter filter({0, 0, BASIC_FILTER_P, BASIC_FILTER_M}, elements);
-    auto encoded = filter.GetEncoded();
-
-    bench.run([&] {
-        GCSFilter filter({0, 0, BASIC_FILTER_P, BASIC_FILTER_M}, encoded, /*skip_decode_check=*/false);
-    });
-}
-
-static void GCSFilterDecodeSkipCheck(benchmark::Bench& bench)
-{
-    auto elements = GenerateGCSTestElements();
-
-    GCSFilter filter({0, 0, BASIC_FILTER_P, BASIC_FILTER_M}, elements);
-    auto encoded = filter.GetEncoded();
-
-    bench.run([&] {
-        GCSFilter filter({0, 0, BASIC_FILTER_P, BASIC_FILTER_M}, encoded, /*skip_decode_check=*/true);
-    });
-}
-
-static void GCSFilterMatch(benchmark::Bench& bench)
-{
-    auto elements = GenerateGCSTestElements();
-
-    GCSFilter filter({0, 0, BASIC_FILTER_P, BASIC_FILTER_M}, elements);
-
-    bench.run([&] {
-        filter.Match(GCSFilter::Element());
-    });
-}
-BENCHMARK(GCSBlockFilterGetHash);
-BENCHMARK(GCSFilterConstruct);
-BENCHMARK(GCSFilterDecode);
-BENCHMARK(GCSFilterDecodeSkipCheck);
-BENCHMARK(GCSFilterMatch);
diff --git a/src/bench/index_blockfilter.cpp b/src/bench/index_blockfilter.cpp
deleted file mode 100644
index 805ad050bfcc..000000000000
--- a/src/bench/index_blockfilter.cpp
+++ /dev/null
@@ -1,62 +0,0 @@
-// Copyright (c) 2023-present The Bitcoin Core developers
-// Distributed under the MIT software license, see the accompanying
-// file COPYING or https://www.opensource.org/licenses/mit-license.php.
-
-#include <addresstype.h>
-#include <bench/bench.h>
-#include <blockfilter.h>
-#include <chain.h>
-#include <index/base.h>
-#include <index/blockfilterindex.h>
-#include <interfaces/chain.h>
-#include <primitives/block.h>
-#include <primitives/transaction.h>
-#include <pubkey.h>
-#include <script/script.h>
-#include <span.h>
-#include <sync.h>
-#include <test/util/setup_common.h>
-#include <uint256.h>
-#include <util/strencodings.h>
-#include <util/time.h>
-#include <validation.h>
-
-#include <cassert>
-#include <memory>
-#include <vector>
-
-using namespace util::hex_literals;
-
-// Very simple block filter index sync benchmark, only using coinbase outputs.
-static void BlockFilterIndexSync(benchmark::Bench& bench)
-{
-    const auto test_setup = MakeNoLogFileContext<TestChain100Setup>();
-
-    // Create more blocks
-    int CHAIN_SIZE = 600;
-    CPubKey pubkey{"02ed26169896db86ced4cbb7b3ecef9859b5952825adbeab998fb5b307e54949c9"_hex_u8};
-    CScript script = GetScriptForDestination(WitnessV0KeyHash(pubkey));
-    std::vector<CMutableTransaction> noTxns;
-    for (int i = 0; i < CHAIN_SIZE - 100; i++) {
-        test_setup->CreateAndProcessBlock(noTxns, script);
-        SetMockTime(GetTime() + 1);
-    }
-    assert(WITH_LOCK(::cs_main, return test_setup->m_node.chainman->ActiveHeight() == CHAIN_SIZE));
-
-    bench.minEpochIterations(5).run([&] {
-        BlockFilterIndex filter_index(interfaces::MakeChain(test_setup->m_node), BlockFilterType::BASIC,
-                                      /*n_cache_size=*/0, /*f_memory=*/false, /*f_wipe=*/true);
-        assert(filter_index.Init());
-        assert(!filter_index.BlockUntilSyncedToCurrentChain());
-        filter_index.Sync();
-
-        IndexSummary summary = filter_index.GetSummary();
-        assert(summary.synced);
-        assert(summary.best_block_hash == WITH_LOCK(::cs_main, return test_setup->m_node.chainman->ActiveTip()->GetBlockHash()));
-
-        // Shutdown sequence (c.f. Shutdown() in init.cpp)
-        filter_index.Stop();
-    });
-}
-
-BENCHMARK(BlockFilterIndexSync);
diff --git a/src/bitcoin-cli.cpp b/src/bitcoin-cli.cpp
index 25f31d36bc16..ee6f29c4513f 100644
--- a/src/bitcoin-cli.cpp
+++ b/src/bitcoin-cli.cpp
@@ -681,7 +681,6 @@ class NetinfoRequestHandler : public BaseRequestHandler
         "           \"n\" - NETWORK: peer can serve the full block chain\n"
         "           \"b\" - BLOOM: peer can handle bloom-filtered connections (see BIP 111)\n"
         "           \"w\" - WITNESS: peer can be asked for blocks and transactions with witness data (SegWit)\n"
-        "           \"c\" - COMPACT_FILTERS: peer can handle basic block filter requests (see BIPs 157 and 158)\n"
         "           \"l\" - NETWORK_LIMITED: peer limited to serving only the last 288 blocks (~2 days)\n"
         "           \"2\" - P2P_V2: peer supports version 2 P2P transport protocol, as defined in BIP 324\n"
         "           \"u\" - UNKNOWN: unrecognized bit flag\n"
diff --git a/src/blockfilter.cpp b/src/blockfilter.cpp
deleted file mode 100644
index 44d08440d136..000000000000
--- a/src/blockfilter.cpp
+++ /dev/null
@@ -1,256 +0,0 @@
-// Copyright (c) 2018-present 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 <mutex>
-#include <set>
-#include <string_view>
-
-#include <blockfilter.h>
-#include <crypto/siphash.h>
-#include <hash.h>
-#include <primitives/block.h>
-#include <primitives/transaction.h>
-#include <script/script.h>
-#include <streams.h>
-#include <undo.h>
-#include <util/golombrice.h>
-#include <util/string.h>
-
-using util::Join;
-
-static const std::map<BlockFilterType, std::string> g_filter_types = {
-    {BlockFilterType::BASIC, "basic"},
-};
-
-uint64_t GCSFilter::HashToRange(const Element& element) const
-{
-    uint64_t hash = CSipHasher(m_params.m_siphash_k0, m_params.m_siphash_k1)
-        .Write(element)
-        .Finalize();
-    return FastRange64(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<unsigned char> encoded_filter, bool skip_decode_check)
-    : m_params(params), m_encoded(std::move(encoded_filter))
-{
-    SpanReader stream{m_encoded};
-
-    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);
-
-    if (skip_decode_check) return;
-
-    // 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 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);
-
-    VectorWriter stream{m_encoded, 0};
-
-    WriteCompactSize(stream, m_N);
-
-    if (elements.empty()) {
-        return;
-    }
-
-    BitStreamWriter 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
-{
-    SpanReader stream{m_encoded};
-
-    // Seek forward by size of N
-    uint64_t N = ReadCompactSize(stream);
-    assert(N == m_N);
-
-    BitStreamReader 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());
-}
-
-const std::string& BlockFilterTypeName(BlockFilterType filter_type)
-{
-    static std::string unknown_retval;
-    auto it = g_filter_types.find(filter_type);
-    return it != g_filter_types.end() ? it->second : unknown_retval;
-}
-
-bool BlockFilterTypeByName(std::string_view name, BlockFilterType& filter_type)
-{
-    for (const auto& entry : g_filter_types) {
-        if (entry.second == name) {
-            filter_type = entry.first;
-            return true;
-        }
-    }
-    return false;
-}
-
-const std::set<BlockFilterType>& AllBlockFilterTypes()
-{
-    static std::set<BlockFilterType> types;
-
-    static std::once_flag flag;
-    std::call_once(flag, []() {
-            for (const auto& entry : g_filter_types) {
-                types.insert(entry.first);
-            }
-        });
-
-    return types;
-}
-
-const std::string& ListBlockFilterTypes()
-{
-    static std::string type_list{Join(g_filter_types, ", ", [](const auto& entry) { return entry.second; })};
-
-    return type_list;
-}
-
-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.out.scriptPubKey;
-            if (script.empty()) continue;
-            elements.emplace(script.begin(), script.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)
-{
-    GCSFilter::Params params;
-    if (!BuildParams(params)) {
-        throw std::invalid_argument("unknown filter_type");
-    }
-    m_filter = GCSFilter(params, std::move(filter), skip_decode_check);
-}
-
-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
-{
-    return Hash(GetEncodedFilter());
-}
-
-uint256 BlockFilter::ComputeHeader(const uint256& prev_header) const
-{
-    return Hash(GetHash(), prev_header);
-}
diff --git a/src/blockfilter.h b/src/blockfilter.h
deleted file mode 100644
index 225d3b16bede..000000000000
--- a/src/blockfilter.h
+++ /dev/null
@@ -1,176 +0,0 @@
-// Copyright (c) 2018-present 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 <cstddef>
-#include <cstdint>
-#include <ios>
-#include <set>
-#include <string>
-#include <string_view>
-#include <unordered_set>
-#include <utility>
-#include <vector>
-
-#include <attributes.h>
-#include <uint256.h>
-#include <util/bytevectorhash.h>
-
-class CBlock;
-class CBlockUndo;
-
-/**
- * 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<unsigned char> Element;
-    typedef std::unordered_set<Element, ByteVectorHash> 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<unsigned char> 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<unsigned char> encoded_filter, bool skip_decode_check);
-
-    /** 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 LIFETIMEBOUND { return m_params; }
-    const std::vector<unsigned char>& GetEncoded() const LIFETIMEBOUND { 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 class BlockFilterType : uint8_t
-{
-    BASIC = 0,
-    INVALID = 255,
-};
-
-/** Get the human-readable name for a filter type. Returns empty string for unknown types. */
-const std::string& BlockFilterTypeName(BlockFilterType filter_type);
-
-/** Find a filter type by its human-readable name. */
-bool BlockFilterTypeByName(std::string_view name, BlockFilterType& filter_type);
-
-/** Get a list of known filter types. */
-const std::set<BlockFilterType>& AllBlockFilterTypes();
-
-/** Get a comma-separated list of known filter type names. */
-const std::string& ListBlockFilterTypes();
-
-/**
- * Complete block filter struct as defined in BIP 157. Serialization matches
- * payload of "cfilter" messages.
- */
-class BlockFilter
-{
-private:
-    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<unsigned char> filter, bool skip_decode_check);
-
-    //! 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 LIFETIMEBOUND { return m_block_hash; }
-    const GCSFilter& GetFilter() const LIFETIMEBOUND { return m_filter; }
-
-    const std::vector<unsigned char>& GetEncodedFilter() const LIFETIMEBOUND
-    {
-        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 << static_cast<uint8_t>(m_filter_type)
-          << m_block_hash
-          << m_filter.GetEncoded();
-    }
-
-    template <typename Stream>
-    void Unserialize(Stream& s) {
-        std::vector<unsigned char> encoded_filter;
-        uint8_t filter_type;
-
-        s >> filter_type
-          >> m_block_hash
-          >> 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), /*skip_decode_check=*/false);
-    }
-};
-
-#endif // BITCOIN_BLOCKFILTER_H
diff --git a/src/index/base.cpp b/src/index/base.cpp
deleted file mode 100644
index bb41cc2a632a..000000000000
--- a/src/index/base.cpp
+++ /dev/null
@@ -1,510 +0,0 @@
-// Copyright (c) 2017-present 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 <index/base.h>
-
-#include <chain.h>
-#include <common/args.h>
-#include <dbwrapper.h>
-#include <interfaces/chain.h>
-#include <interfaces/types.h>
-#include <kernel/types.h>
-#include <node/abort.h>
-#include <node/blockstorage.h>
-#include <node/context.h>
-#include <node/database_args.h>
-#include <node/interface_ui.h>
-#include <primitives/block.h>
-#include <sync.h>
-#include <tinyformat.h>
-#include <uint256.h>
-#include <undo.h>
-#include <util/check.h>
-#include <util/fs.h>
-#include <util/log.h>
-#include <util/string.h>
-#include <util/thread.h>
-#include <util/threadinterrupt.h>
-#include <util/time.h>
-#include <util/translation.h>
-#include <validation.h>
-#include <validationinterface.h>
-
-#include <compare>
-#include <cstdint>
-#include <functional>
-#include <memory>
-#include <optional>
-#include <stdexcept>
-#include <string>
-#include <thread>
-#include <utility>
-#include <vector>
-
-using kernel::ChainstateRole;
-
-constexpr uint8_t DB_BEST_BLOCK{'B'};
-
-constexpr auto SYNC_LOG_INTERVAL{30s};
-constexpr auto SYNC_LOCATOR_WRITE_INTERVAL{30s};
-
-template <typename... Args>
-void BaseIndex::FatalErrorf(util::ConstevalFormatString<sizeof...(Args)> fmt, const Args&... args)
-{
-    auto message = tfm::format(fmt, args...);
-    node::AbortNode(m_chain->context()->shutdown_request, m_chain->context()->exit_status, Untranslated(message), m_chain->context()->warnings.get());
-}
-
-CBlockLocator GetLocator(interfaces::Chain& chain, const uint256& block_hash)
-{
-    CBlockLocator locator;
-    bool found = chain.findBlock(block_hash, interfaces::FoundBlock().locator(locator));
-    assert(found);
-    assert(!locator.IsNull());
-    return locator;
-}
-
-BaseIndex::DB::DB(const fs::path& path, size_t n_cache_size, bool f_memory, bool f_wipe, bool f_obfuscate) :
-    CDBWrapper{DBParams{
-        .path = path,
-        .cache_bytes = n_cache_size,
-        .memory_only = f_memory,
-        .wipe_data = f_wipe,
-        .obfuscate = f_obfuscate,
-        .options = [] { DBOptions options; node::ReadDatabaseArgs(gArgs, options); return options; }()}}
-{}
-
-CBlockLocator BaseIndex::DB::ReadBestBlock() const
-{
-    CBlockLocator locator;
-
-    bool success = Read(DB_BEST_BLOCK, locator);
-    if (!success) {
-        locator.SetNull();
-    }
-
-    return locator;
-}
-
-void BaseIndex::DB::WriteBestBlock(CDBBatch& batch, const CBlockLocator& locator)
-{
-    batch.Write(DB_BEST_BLOCK, locator);
-}
-
-BaseIndex::BaseIndex(std::unique_ptr<interfaces::Chain> chain, std::string name)
-    : m_chain{std::move(chain)}, m_name{std::move(name)} {}
-
-BaseIndex::~BaseIndex()
-{
-    Interrupt();
-    Stop();
-}
-
-bool BaseIndex::Init()
-{
-    AssertLockNotHeld(cs_main);
-
-    // May need reset if index is being restarted.
-    m_interrupt.reset();
-
-    // m_chainstate member gives indexing code access to node internals. It is
-    // removed in followup https://github.com/bitcoin/bitcoin/pull/24230
-    m_chainstate = WITH_LOCK(::cs_main,
-                             return &m_chain->context()->chainman->ValidatedChainstate());
-    // Register to validation interface before setting the 'm_synced' flag, so that
-    // callbacks are not missed once m_synced is true.
-    m_chain->context()->validation_signals->RegisterValidationInterface(this);
-
-    const auto locator{GetDB().ReadBestBlock()};
-
-    LOCK(cs_main);
-    CChain& index_chain = m_chainstate->m_chain;
-
-    if (locator.IsNull()) {
-        SetBestBlockIndex(nullptr);
-    } else {
-        // Setting the best block to the locator's top block. If it is not part of the
-        // best chain, we will rewind to the fork point during index sync
-        const CBlockIndex* locator_index{m_chainstate->m_blockman.LookupBlockIndex(locator.vHave.at(0))};
-        if (!locator_index) {
-            return InitError(Untranslated(strprintf("best block of %s not found. Please rebuild the index.", GetName())));
-        }
-        SetBestBlockIndex(locator_index);
-    }
-
-    // Child init
-    const CBlockIndex* start_block = m_best_block_index.load();
-    if (!CustomInit(start_block ? std::make_optional(interfaces::BlockRef{start_block->GetBlockHash(), start_block->nHeight}) : std::nullopt)) {
-        return false;
-    }
-
-    // Note: this will latch to true immediately if the user starts up with an empty
-    // datadir and an index enabled. If this is the case, indexation will happen solely
-    // via `BlockConnected` signals until, possibly, the next restart.
-    m_synced = start_block == index_chain.Tip();
-    m_init = true;
-    return true;
-}
-
-static const CBlockIndex* NextSyncBlock(const CBlockIndex* const pindex_prev, CChain& chain) EXCLUSIVE_LOCKS_REQUIRED(cs_main)
-{
-    AssertLockHeld(cs_main);
-
-    if (!pindex_prev) {
-        return chain.Genesis();
-    }
-
-    if (const auto* pindex{chain.Next(*pindex_prev)}) {
-        return pindex;
-    }
-
-    // If there is no next block, we might be synced
-    if (pindex_prev == chain.Tip()) {
-        return nullptr;
-    }
-
-    // Since block is not in the chain, return the next block in the chain AFTER the last common ancestor.
-    // Caller will be responsible for rewinding back to the common ancestor.
-    const auto* fork{chain.FindFork(*pindex_prev)};
-    // Common ancestor must exist (genesis).
-    return chain.Next(*Assert(fork));
-}
-
-bool BaseIndex::ProcessBlock(const CBlockIndex* pindex, const CBlock* block_data)
-{
-    interfaces::BlockInfo block_info = kernel::MakeBlockInfo(pindex, block_data);
-
-    CBlock block;
-    if (!block_data) { // disk lookup if block data wasn't provided
-        if (!m_chainstate->m_blockman.ReadBlock(block, *pindex)) {
-            FatalErrorf("Failed to read block %s from disk",
-                        pindex->GetBlockHash().ToString());
-            return false;
-        }
-        block_info.data = &block;
-    }
-
-    CBlockUndo block_undo;
-    if (CustomOptions().connect_undo_data) {
-        if (pindex->nHeight > 0 && !m_chainstate->m_blockman.ReadBlockUndo(block_undo, *pindex)) {
-            FatalErrorf("Failed to read undo block data %s from disk",
-                        pindex->GetBlockHash().ToString());
-            return false;
-        }
-        block_info.undo_data = &block_undo;
-    }
-
-    if (!CustomAppend(block_info)) {
-        FatalErrorf("Failed to write block %s to index database",
-                    pindex->GetBlockHash().ToString());
-        return false;
-    }
-
-    return true;
-}
-
-void BaseIndex::Sync()
-{
-    const CBlockIndex* pindex = m_best_block_index.load();
-    if (!m_synced) {
-        auto last_log_time{NodeClock::now()};
-        auto last_locator_write_time{last_log_time};
-        while (true) {
-            if (m_interrupt) {
-                LogInfo("%s: m_interrupt set; exiting ThreadSync", GetName());
-
-                SetBestBlockIndex(pindex);
-                // No need to handle errors in Commit. If it fails, the error will be already be
-                // logged. The best way to recover is to continue, as index cannot be corrupted by
-                // a missed commit to disk for an advanced index state.
-                Commit();
-                return;
-            }
-
-            const CBlockIndex* pindex_next = WITH_LOCK(cs_main, return NextSyncBlock(pindex, m_chainstate->m_chain));
-            // If pindex_next is null, it means pindex is the chain tip, so
-            // commit data indexed so far.
-            if (!pindex_next) {
-                SetBestBlockIndex(pindex);
-                // No need to handle errors in Commit. See rationale above.
-                Commit();
-
-                // If pindex is still the chain tip after committing, exit the
-                // sync loop. It is important for cs_main to be locked while
-                // setting m_synced = true, otherwise a new block could be
-                // attached while m_synced is still false, and it would not be
-                // indexed.
-                LOCK(::cs_main);
-                pindex_next = NextSyncBlock(pindex, m_chainstate->m_chain);
-                if (!pindex_next) {
-                    m_synced = true;
-                    break;
-                }
-            }
-            if (pindex_next->pprev != pindex && !Rewind(pindex, pindex_next->pprev)) {
-                FatalErrorf("Failed to rewind %s to a previous chain tip", GetName());
-                return;
-            }
-            pindex = pindex_next;
-
-
-            if (!ProcessBlock(pindex)) return; // error logged internally
-
-            auto current_time{NodeClock::now()};
-            if (current_time - last_log_time >= SYNC_LOG_INTERVAL) {
-                LogInfo("Syncing %s with block chain from height %d", GetName(), pindex->nHeight);
-                last_log_time = current_time;
-            }
-
-            if (current_time - last_locator_write_time >= SYNC_LOCATOR_WRITE_INTERVAL) {
-                SetBestBlockIndex(pindex);
-                last_locator_write_time = current_time;
-                // No need to handle errors in Commit. See rationale above.
-                Commit();
-            }
-        }
-    }
-
-    if (pindex) {
-        LogInfo("%s is enabled at height %d", GetName(), pindex->nHeight);
-    } else {
-        LogInfo("%s is enabled", GetName());
-    }
-}
-
-bool BaseIndex::Commit()
-{
-    // Don't commit anything if we haven't indexed any block yet
-    // (this could happen if init is interrupted).
-    bool ok = m_best_block_index != nullptr;
-    if (ok) {
-        CDBBatch batch(GetDB());
-        ok = CustomCommit(batch);
-        if (ok) {
-            GetDB().WriteBestBlock(batch, GetLocator(*m_chain, m_best_block_index.load()->GetBlockHash()));
-            GetDB().WriteBatch(batch);
-        }
-    }
-    if (!ok) {
-        LogError("Failed to commit latest %s state", GetName());
-        return false;
-    }
-    return true;
-}
-
-bool BaseIndex::Rewind(const CBlockIndex* current_tip, const CBlockIndex* new_tip)
-{
-    assert(current_tip->GetAncestor(new_tip->nHeight) == new_tip);
-
-    CBlock block;
-    CBlockUndo block_undo;
-
-    for (const CBlockIndex* iter_tip = current_tip; iter_tip != new_tip; iter_tip = iter_tip->pprev) {
-        interfaces::BlockInfo block_info = kernel::MakeBlockInfo(iter_tip);
-        if (CustomOptions().disconnect_data) {
-            if (!m_chainstate->m_blockman.ReadBlock(block, *iter_tip)) {
-                LogError("Failed to read block %s from disk",
-                         iter_tip->GetBlockHash().ToString());
-                return false;
-            }
-            block_info.data = &block;
-        }
-        if (CustomOptions().disconnect_undo_data && iter_tip->nHeight > 0) {
-            if (!m_chainstate->m_blockman.ReadBlockUndo(block_undo, *iter_tip)) {
-                return false;
-            }
-            block_info.undo_data = &block_undo;
-        }
-        if (!CustomRemove(block_info)) {
-            return false;
-        }
-    }
-
-    // Don't commit here - the committed index state must never be ahead of the
-    // flushed chainstate, otherwise unclean restarts would lead to index corruption.
-    // Pruning has a minimum of 288 blocks-to-keep and getting the index
-    // out of sync may be possible but a users fault.
-    // In case we reorg beyond the pruned depth, ReadBlock would
-    // throw and lead to a graceful shutdown
-    SetBestBlockIndex(new_tip);
-    return true;
-}
-
-void BaseIndex::BlockConnected(const ChainstateRole& role, const std::shared_ptr<const CBlock>& block, const CBlockIndex* pindex)
-{
-    // Ignore events from not fully validated chains to avoid out-of-order indexing.
-    //
-    // TODO at some point we could parameterize whether a particular index can be
-    // built out of order, but for now just do the conservative simple thing.
-    if (!role.validated) {
-        return;
-    }
-
-    // Ignore BlockConnected signals until we have fully indexed the chain.
-    if (!m_synced) {
-        return;
-    }
-
-    const CBlockIndex* best_block_index = m_best_block_index.load();
-    if (!best_block_index) {
-        if (pindex->nHeight != 0) {
-            FatalErrorf("First block connected is not the genesis block (height=%d)",
-                       pindex->nHeight);
-            return;
-        }
-    } else {
-        // Ensure block connects to an ancestor of the current best block. This should be the case
-        // most of the time, but may not be immediately after the sync thread catches up and sets
-        // m_synced. Consider the case where there is a reorg and the blocks on the stale branch are
-        // in the ValidationInterface queue backlog even after the sync thread has caught up to the
-        // new chain tip. In this unlikely event, log a warning and let the queue clear.
-        if (best_block_index->GetAncestor(pindex->nHeight - 1) != pindex->pprev) {
-            LogWarning("Block %s does not connect to an ancestor of "
-                      "known best chain (tip=%s); not updating index",
-                      pindex->GetBlockHash().ToString(),
-                      best_block_index->GetBlockHash().ToString());
-            return;
-        }
-        if (best_block_index != pindex->pprev && !Rewind(best_block_index, pindex->pprev)) {
-            FatalErrorf("Failed to rewind %s to a previous chain tip",
-                       GetName());
-            return;
-        }
-    }
-
-    // Dispatch block to child class; errors are logged internally and abort the node.
-    if (ProcessBlock(pindex, block.get())) {
-        // Setting the best block index is intentionally the last step of this
-        // function, so BlockUntilSyncedToCurrentChain callers waiting for the
-        // best block index to be updated can rely on the block being fully
-        // processed, and the index object being safe to delete.
-        SetBestBlockIndex(pindex);
-    }
-}
-
-void BaseIndex::ChainStateFlushed(const ChainstateRole& role, const CBlockLocator& locator)
-{
-    // Ignore events from not fully validated chains to avoid out-of-order indexing.
-    if (!role.validated) {
-        return;
-    }
-
-    if (!m_synced) {
-        return;
-    }
-
-    const uint256& locator_tip_hash = locator.vHave.front();
-    const CBlockIndex* locator_tip_index;
-    {
-        LOCK(cs_main);
-        locator_tip_index = m_chainstate->m_blockman.LookupBlockIndex(locator_tip_hash);
-    }
-
-    if (!locator_tip_index) {
-        FatalErrorf("First block (hash=%s) in locator was not found",
-                   locator_tip_hash.ToString());
-        return;
-    }
-
-    // This checks that ChainStateFlushed callbacks are received after BlockConnected. The check may fail
-    // immediately after the sync thread catches up and sets m_synced. Consider the case where
-    // there is a reorg and the blocks on the stale branch are in the ValidationInterface queue
-    // backlog even after the sync thread has caught up to the new chain tip. In this unlikely
-    // event, log a warning and let the queue clear.
-    const CBlockIndex* best_block_index = m_best_block_index.load();
-    if (best_block_index->GetAncestor(locator_tip_index->nHeight) != locator_tip_index) {
-        LogWarning("Locator contains block (hash=%s) not on known best "
-                  "chain (tip=%s); not writing index locator",
-                  locator_tip_hash.ToString(),
-                  best_block_index->GetBlockHash().ToString());
-        return;
-    }
-
-    // No need to handle errors in Commit. If it fails, the error will be already be logged. The
-    // best way to recover is to continue, as index cannot be corrupted by a missed commit to disk
-    // for an advanced index state.
-    Commit();
-}
-
-bool BaseIndex::BlockUntilSyncedToCurrentChain() const
-{
-    AssertLockNotHeld(cs_main);
-
-    if (!m_synced) {
-        return false;
-    }
-
-    {
-        // Skip the queue-draining stuff if we know we're caught up with
-        // m_chain.Tip().
-        LOCK(cs_main);
-        const CBlockIndex* chain_tip = m_chainstate->m_chain.Tip();
-        const CBlockIndex* best_block_index = m_best_block_index.load();
-        if (best_block_index->GetAncestor(chain_tip->nHeight) == chain_tip) {
-            return true;
-        }
-    }
-
-    LogInfo("%s is catching up on block notifications", GetName());
-    m_chain->context()->validation_signals->SyncWithValidationInterfaceQueue();
-    return true;
-}
-
-void BaseIndex::Interrupt()
-{
-    m_interrupt();
-}
-
-bool BaseIndex::StartBackgroundSync()
-{
-    if (!m_init) throw std::logic_error("Error: Cannot start a non-initialized index");
-
-    m_thread_sync = std::thread(&util::TraceThread, GetName(), [this] { Sync(); });
-    return true;
-}
-
-void BaseIndex::Stop()
-{
-    if (m_chain->context()->validation_signals) {
-        m_chain->context()->validation_signals->UnregisterValidationInterface(this);
-    }
-
-    if (m_thread_sync.joinable()) {
-        m_thread_sync.join();
-    }
-}
-
-IndexSummary BaseIndex::GetSummary() const
-{
-    IndexSummary summary{};
-    summary.name = GetName();
-    summary.synced = m_synced;
-    if (const auto& pindex = m_best_block_index.load()) {
-        summary.best_block_height = pindex->nHeight;
-        summary.best_block_hash = pindex->GetBlockHash();
-    } else {
-        summary.best_block_height = 0;
-        summary.best_block_hash = m_chain->getBlockHash(0);
-    }
-    return summary;
-}
-
-void BaseIndex::SetBestBlockIndex(const CBlockIndex* block)
-{
-    assert(!m_chainstate->m_blockman.IsPruneMode() || AllowPrune());
-
-    if (AllowPrune() && block) {
-        node::PruneLockInfo prune_lock;
-        prune_lock.height_first = block->nHeight;
-        WITH_LOCK(::cs_main, m_chainstate->m_blockman.UpdatePruneLock(GetName(), prune_lock));
-    }
-
-    // Intentionally set m_best_block_index as the last step in this function,
-    // after updating prune locks above, and after making any other references
-    // to *this, so the BlockUntilSyncedToCurrentChain function (which checks
-    // m_best_block_index as an optimization) can be used to wait for the last
-    // BlockConnected notification and safely assume that prune locks are
-    // updated and that the index object is safe to delete.
-    m_best_block_index = block;
-}
diff --git a/src/index/base.h b/src/index/base.h
deleted file mode 100644
index 63f60be0349a..000000000000
--- a/src/index/base.h
+++ /dev/null
@@ -1,184 +0,0 @@
-// Copyright (c) 2017-present 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_INDEX_BASE_H
-#define BITCOIN_INDEX_BASE_H
-
-#include <attributes.h>
-#include <dbwrapper.h>
-#include <interfaces/chain.h>
-#include <kernel/cs_main.h>
-#include <sync.h>
-#include <uint256.h>
-#include <util/fs.h>
-#include <util/threadinterrupt.h>
-#include <validationinterface.h>
-
-#include <atomic>
-#include <cstddef>
-#include <memory>
-#include <optional>
-#include <string>
-#include <thread>
-
-class CBlock;
-class CBlockIndex;
-class Chainstate;
-
-struct CBlockLocator;
-struct IndexSummary {
-    std::string name;
-    bool synced{false};
-    int best_block_height{0};
-    uint256 best_block_hash;
-};
-namespace interfaces {
-struct BlockRef;
-}
-namespace util {
-template <unsigned int num_params>
-struct ConstevalFormatString;
-}
-
-/**
- * Base class for indices of blockchain data. This implements
- * CValidationInterface and ensures blocks are indexed sequentially according
- * to their position in the active chain.
- *
- * In the presence of multiple chainstates (i.e. if a UTXO snapshot is loaded),
- * only the background "IBD" chainstate will be indexed to avoid building the
- * index out of order. When the background chainstate completes validation, the
- * index will be reinitialized and indexing will continue.
- */
-class BaseIndex : public CValidationInterface
-{
-protected:
-    /**
-     * The database stores a block locator of the chain the database is synced to
-     * so that the index can efficiently determine the point it last stopped at.
-     * A locator is used instead of a simple hash of the chain tip because blocks
-     * and block index entries may not be flushed to disk until after this database
-     * is updated.
-    */
-    class DB : public CDBWrapper
-    {
-    public:
-        DB(const fs::path& path, size_t n_cache_size,
-           bool f_memory = false, bool f_wipe = false, bool f_obfuscate = false);
-
-        /// Read block locator of the chain that the index is in sync with.
-        /// Note, the returned locator will be empty if no record exists.
-        CBlockLocator ReadBestBlock() const;
-
-        /// Write block locator of the chain that the index is in sync with.
-        void WriteBestBlock(CDBBatch& batch, const CBlockLocator& locator);
-    };
-
-private:
-    /// Whether the index has been initialized or not.
-    std::atomic<bool> m_init{false};
-    /// Whether the index is in sync with the main chain. The flag is flipped
-    /// from false to true once, after which point this starts processing
-    /// ValidationInterface notifications to stay in sync.
-    ///
-    /// Note that this will latch to true *immediately* upon startup if
-    /// `m_chainstate->m_chain` is empty, which will be the case upon startup
-    /// with an empty datadir if, e.g., `-txindex=1` is specified.
-    std::atomic<bool> m_synced{false};
-
-    /// The last block in the chain that the index is in sync with.
-    std::atomic<const CBlockIndex*> m_best_block_index{nullptr};
-
-    std::thread m_thread_sync;
-    CThreadInterrupt m_interrupt;
-
-    /// Write the current index state (eg. chain block locator and subclass-specific items) to disk.
-    ///
-    /// Recommendations for error handling:
-    /// If called on a successor of the previous committed best block in the index, the index can
-    /// continue processing without risk of corruption, though the index state will need to catch up
-    /// from further behind on reboot. If the new state is not a successor of the previous state (due
-    /// to a chain reorganization), the index must halt until Commit succeeds or else it could end up
-    /// getting corrupted.
-    bool Commit();
-
-    /// Loop over disconnected blocks and call CustomRemove.
-    bool Rewind(const CBlockIndex* current_tip, const CBlockIndex* new_tip);
-
-    bool ProcessBlock(const CBlockIndex* pindex, const CBlock* block_data = nullptr);
-
-    virtual bool AllowPrune() const = 0;
-
-    template <typename... Args>
-    void FatalErrorf(util::ConstevalFormatString<sizeof...(Args)> fmt, const Args&... args);
-
-protected:
-    std::unique_ptr<interfaces::Chain> m_chain;
-    Chainstate* m_chainstate{nullptr};
-    const std::string m_name;
-
-    void BlockConnected(const kernel::ChainstateRole& role, const std::shared_ptr<const CBlock>& block, const CBlockIndex* pindex) override;
-
-    void ChainStateFlushed(const kernel::ChainstateRole& role, const CBlockLocator& locator) override;
-
-    /// Initialize internal state from the database and block index.
-    [[nodiscard]] virtual bool CustomInit(const std::optional<interfaces::BlockRef>& block) { return true; }
-
-    /// Write update index entries for a newly connected block.
-    [[nodiscard]] virtual bool CustomAppend(const interfaces::BlockInfo& block) { return true; }
-
-    /// Virtual method called internally by Commit that can be overridden to atomically
-    /// commit more index state.
-    virtual bool CustomCommit(CDBBatch& batch) { return true; }
-
-    /// Rewind index by one block during a chain reorg.
-    [[nodiscard]] virtual bool CustomRemove(const interfaces::BlockInfo& block) { return true; }
-
-    virtual DB& GetDB() const = 0;
-
-    /// Update the internal best block index as well as the prune lock.
-    void SetBestBlockIndex(const CBlockIndex* block);
-
-public:
-    BaseIndex(std::unique_ptr<interfaces::Chain> chain, std::string name);
-    /// Destructor interrupts sync thread if running and blocks until it exits.
-    virtual ~BaseIndex();
-
-    /// Get the name of the index for display in logs.
-    const std::string& GetName() const LIFETIMEBOUND { return m_name; }
-
-    /// Return custom notification options for index.
-    [[nodiscard]] virtual interfaces::Chain::NotifyOptions CustomOptions() { return {}; }
-
-    /// Blocks the current thread until the index is caught up to the current
-    /// state of the block chain. This only blocks if the index has gotten in
-    /// sync once and only needs to process blocks in the ValidationInterface
-    /// queue. If the index is catching up from far behind, this method does
-    /// not block and immediately returns false.
-    bool BlockUntilSyncedToCurrentChain() const LOCKS_EXCLUDED(::cs_main);
-
-    void Interrupt();
-
-    /// Initializes the sync state and registers the instance to the
-    /// validation interface so that it stays in sync with blockchain updates.
-    [[nodiscard]] bool Init();
-
-    /// Starts the initial sync process on a background thread.
-    [[nodiscard]] bool StartBackgroundSync();
-
-    /// Sync the index with the block index starting from the current best block.
-    /// Intended to be run in its own thread, m_thread_sync, and can be
-    /// interrupted with m_interrupt. Once the index gets in sync, the m_synced
-    /// flag is set and the BlockConnected ValidationInterface callback takes
-    /// over and the sync thread exits.
-    void Sync();
-
-    /// Stops the instance from staying in sync with blockchain updates.
-    void Stop();
-
-    /// Get a summary of the index and its state.
-    IndexSummary GetSummary() const;
-};
-
-#endif // BITCOIN_INDEX_BASE_H
diff --git a/src/index/blockfilterindex.cpp b/src/index/blockfilterindex.cpp
deleted file mode 100644
index d4fd70259817..000000000000
--- a/src/index/blockfilterindex.cpp
+++ /dev/null
@@ -1,464 +0,0 @@
-// Copyright (c) 2018-present 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 <index/blockfilterindex.h>
-
-#include <blockfilter.h>
-#include <chain.h>
-#include <common/args.h>
-#include <dbwrapper.h>
-#include <flatfile.h>
-#include <hash.h>
-#include <index/base.h>
-#include <index/db_key.h>
-#include <interfaces/chain.h>
-#include <interfaces/types.h>
-#include <serialize.h>
-#include <streams.h>
-#include <sync.h>
-#include <uint256.h>
-#include <util/check.h>
-#include <util/fs.h>
-#include <util/hasher.h>
-#include <util/log.h>
-#include <util/syserror.h>
-
-#include <cerrno>
-#include <exception>
-#include <map>
-#include <optional>
-#include <stdexcept>
-#include <string>
-#include <tuple>
-#include <utility>
-#include <vector>
-
-/* The index database stores three items for each block: the disk location of the encoded filter,
- * its dSHA256 hash, and the header. Those belonging to blocks on the active chain are indexed by
- * height, and those belonging to blocks that have been reorganized out of the active chain are
- * indexed by block hash. This ensures that filter data for any block that becomes part of the
- * active chain can always be retrieved, alleviating timing concerns.
- *
- * The filters themselves are stored in flat files and referenced by the LevelDB entries. This
- * minimizes the amount of data written to LevelDB and keeps the database values constant size. The
- * disk location of the next block filter to be written (represented as a FlatFilePos) is stored
- * under the DB_FILTER_POS key.
- *
- * The logic for keys is shared with other indexes, see index/db_key.h.
- */
-constexpr uint8_t DB_FILTER_POS{'P'};
-
-constexpr unsigned int MAX_FLTR_FILE_SIZE{16_MiB};
-/** The pre-allocation chunk size for fltr?????.dat files */
-constexpr unsigned int FLTR_FILE_CHUNK_SIZE{1_MiB};
-/** Maximum size of the cfheaders cache
- *  We have a limit to prevent a bug in filling this cache
- *  potentially turning into an OOM. At 2000 entries, this cache
- *  is big enough for a 2,000,000 length block chain, which
- *  we should be enough until ~2047. */
-constexpr size_t CF_HEADERS_CACHE_MAX_SZ{2000};
-
-namespace {
-
-struct DBVal {
-    uint256 hash;
-    uint256 header;
-    FlatFilePos pos;
-
-    SERIALIZE_METHODS(DBVal, obj) { READWRITE(obj.hash, obj.header, obj.pos); }
-};
-
-}; // namespace
-
-static std::map<BlockFilterType, BlockFilterIndex> g_filter_indexes;
-
-BlockFilterIndex::BlockFilterIndex(std::unique_ptr<interfaces::Chain> chain, BlockFilterType filter_type,
-                                   size_t n_cache_size, bool f_memory, bool f_wipe)
-    : BaseIndex(std::move(chain), BlockFilterTypeName(filter_type) + " block filter index")
-    , m_filter_type(filter_type)
-{
-    const std::string& filter_name = BlockFilterTypeName(filter_type);
-    if (filter_name.empty()) throw std::invalid_argument("unknown filter_type");
-
-    fs::path path = gArgs.GetDataDirNet() / "indexes" / "blockfilter" / fs::u8path(filter_name);
-    fs::create_directories(path);
-
-    m_db = std::make_unique<BaseIndex::DB>(path / "db", n_cache_size, f_memory, f_wipe);
-    m_filter_fileseq = std::make_unique<FlatFileSeq>(std::move(path), "fltr", FLTR_FILE_CHUNK_SIZE);
-}
-
-interfaces::Chain::NotifyOptions BlockFilterIndex::CustomOptions()
-{
-    interfaces::Chain::NotifyOptions options;
-    options.connect_undo_data = true;
-    return options;
-}
-
-bool BlockFilterIndex::CustomInit(const std::optional<interfaces::BlockRef>& block)
-{
-    if (!m_db->Read(DB_FILTER_POS, m_next_filter_pos)) {
-        // Check that the cause of the read failure is that the key does not exist. Any other errors
-        // indicate database corruption or a disk failure, and starting the index would cause
-        // further corruption.
-        if (m_db->Exists(DB_FILTER_POS)) {
-            LogError("Cannot read current %s state; index may be corrupted",
-                      GetName());
-            return false;
-        }
-
-        // If the DB_FILTER_POS is not set, then initialize to the first location.
-        m_next_filter_pos.nFile = 0;
-        m_next_filter_pos.nPos = 0;
-    }
-
-    if (block) {
-        auto op_last_header = ReadFilterHeader(block->height, block->hash);
-        if (!op_last_header) {
-            LogError("Cannot read last block filter header; index may be corrupted");
-            return false;
-        }
-        m_last_header = *op_last_header;
-    }
-
-    return true;
-}
-
-bool BlockFilterIndex::CustomCommit(CDBBatch& batch)
-{
-    const FlatFilePos& pos = m_next_filter_pos;
-
-    // Flush current filter file to disk.
-    AutoFile file{m_filter_fileseq->Open(pos)};
-    if (file.IsNull()) {
-        LogError("Failed to open filter file %d", pos.nFile);
-        return false;
-    }
-    if (!file.Commit()) {
-        LogError("Failed to commit filter file %d", pos.nFile);
-        (void)file.fclose();
-        return false;
-    }
-    if (file.fclose() != 0) {
-        LogError("Failed to close filter file %d after commit: %s", pos.nFile, SysErrorString(errno));
-        return false;
-    }
-
-    batch.Write(DB_FILTER_POS, pos);
-    return true;
-}
-
-bool BlockFilterIndex::ReadFilterFromDisk(const FlatFilePos& pos, const uint256& hash, BlockFilter& filter) const
-{
-    AutoFile filein{m_filter_fileseq->Open(pos, true)};
-    if (filein.IsNull()) {
-        return false;
-    }
-
-    // Check that the hash of the encoded_filter matches the one stored in the db.
-    uint256 block_hash;
-    std::vector<uint8_t> encoded_filter;
-    try {
-        filein >> block_hash >> encoded_filter;
-        if (Hash(encoded_filter) != hash) {
-            LogError("Checksum mismatch in filter decode.");
-            return false;
-        }
-        filter = BlockFilter(GetFilterType(), block_hash, std::move(encoded_filter), /*skip_decode_check=*/true);
-    }
-    catch (const std::exception& e) {
-        LogError("Failed to deserialize block filter from disk: %s", e.what());
-        return false;
-    }
-
-    return true;
-}
-
-size_t BlockFilterIndex::WriteFilterToDisk(FlatFilePos& pos, const BlockFilter& filter)
-{
-    assert(filter.GetFilterType() == GetFilterType());
-
-    uint64_t data_size{
-        GetSerializeSize(filter.GetBlockHash()) +
-        GetSerializeSize(filter.GetEncodedFilter())};
-
-    // If writing the filter would overflow the file, flush and move to the next one.
-    if (pos.nPos + data_size > MAX_FLTR_FILE_SIZE) {
-        AutoFile last_file{m_filter_fileseq->Open(pos)};
-        if (last_file.IsNull()) {
-            LogError("Failed to open filter file %d", pos.nFile);
-            return 0;
-        }
-        if (!last_file.Truncate(pos.nPos)) {
-            LogError("Failed to truncate filter file %d", pos.nFile);
-            return 0;
-        }
-        if (!last_file.Commit()) {
-            LogError("Failed to commit filter file %d", pos.nFile);
-            (void)last_file.fclose();
-            return 0;
-        }
-        if (last_file.fclose() != 0) {
-            LogError("Failed to close filter file %d after commit: %s", pos.nFile, SysErrorString(errno));
-            return 0;
-        }
-
-        pos.nFile++;
-        pos.nPos = 0;
-    }
-
-    // Pre-allocate sufficient space for filter data.
-    bool out_of_space;
-    m_filter_fileseq->Allocate(pos, data_size, out_of_space);
-    if (out_of_space) {
-        LogError("out of disk space");
-        return 0;
-    }
-
-    AutoFile fileout{m_filter_fileseq->Open(pos)};
-    if (fileout.IsNull()) {
-        LogError("Failed to open filter file %d", pos.nFile);
-        return 0;
-    }
-
-    fileout << filter.GetBlockHash() << filter.GetEncodedFilter();
-
-    if (fileout.fclose() != 0) {
-        LogError("Failed to close filter file %d: %s", pos.nFile, SysErrorString(errno));
-        return 0;
-    }
-
-    return data_size;
-}
-
-std::optional<uint256> BlockFilterIndex::ReadFilterHeader(int height, const uint256& expected_block_hash)
-{
-    std::pair<uint256, DBVal> read_out;
-    if (!m_db->Read(index_util::DBHeightKey(height), read_out)) {
-        return std::nullopt;
-    }
-
-    if (read_out.first != expected_block_hash) {
-        LogError("previous block header belongs to unexpected block %s; expected %s",
-                 read_out.first.ToString(), expected_block_hash.ToString());
-        return std::nullopt;
-    }
-
-    return read_out.second.header;
-}
-
-bool BlockFilterIndex::CustomAppend(const interfaces::BlockInfo& block)
-{
-    BlockFilter filter(m_filter_type, *Assert(block.data), *Assert(block.undo_data));
-    const uint256& header = filter.ComputeHeader(m_last_header);
-    bool res = Write(filter, block.height, header);
-    if (res) m_last_header = header; // update last header
-    return res;
-}
-
-bool BlockFilterIndex::Write(const BlockFilter& filter, uint32_t block_height, const uint256& filter_header)
-{
-    size_t bytes_written = WriteFilterToDisk(m_next_filter_pos, filter);
-    if (bytes_written == 0) return false;
-
-    std::pair<uint256, DBVal> value;
-    value.first = filter.GetBlockHash();
-    value.second.hash = filter.GetHash();
-    value.second.header = filter_header;
-    value.second.pos = m_next_filter_pos;
-
-    m_db->Write(index_util::DBHeightKey(block_height), value);
-
-    m_next_filter_pos.nPos += bytes_written;
-    return true;
-}
-
-bool BlockFilterIndex::CustomRemove(const interfaces::BlockInfo& block)
-{
-    CDBBatch batch(*m_db);
-    std::unique_ptr<CDBIterator> db_it(m_db->NewIterator());
-
-    // During a reorg, we need to copy block filter that is getting disconnected from the
-    // height index to the hash index so we can still find it when the height index entry
-    // is overwritten.
-    if (!index_util::CopyHeightIndexToHashIndex<DBVal>(*db_it, batch, m_name, block.height)) {
-        return false;
-    }
-
-    // The latest filter position gets written in Commit by the call to the BaseIndex::Rewind.
-    // But since this creates new references to the filter, the position should get updated here
-    // atomically as well in case Commit fails.
-    batch.Write(DB_FILTER_POS, m_next_filter_pos);
-    m_db->WriteBatch(batch);
-
-    // Update cached header to the previous block hash
-    m_last_header = *Assert(ReadFilterHeader(block.height - 1, *Assert(block.prev_hash)));
-    return true;
-}
-
-static bool LookupRange(CDBWrapper& db, const std::string& index_name, int start_height,
-                        const CBlockIndex* stop_index, std::vector<DBVal>& results)
-{
-    if (start_height < 0) {
-        LogError("start height (%d) is negative", start_height);
-        return false;
-    }
-    if (start_height > stop_index->nHeight) {
-        LogError("start height (%d) is greater than stop height (%d)",
-                 start_height, stop_index->nHeight);
-        return false;
-    }
-
-    size_t results_size = static_cast<size_t>(stop_index->nHeight - start_height + 1);
-    std::vector<std::pair<uint256, DBVal>> values(results_size);
-
-    index_util::DBHeightKey key(start_height);
-    std::unique_ptr<CDBIterator> db_it(db.NewIterator());
-    db_it->Seek(index_util::DBHeightKey(start_height));
-    for (int height = start_height; height <= stop_index->nHeight; ++height) {
-        if (!db_it->Valid() || !db_it->GetKey(key) || key.height != height) {
-            return false;
-        }
-
-        size_t i = static_cast<size_t>(height - start_height);
-        if (!db_it->GetValue(values[i])) {
-            LogError("unable to read value in %s at key (%c, %d)",
-                     index_name, index_util::DB_BLOCK_HEIGHT, height);
-            return false;
-        }
-
-        db_it->Next();
-    }
-
-    results.resize(results_size);
-
-    // Iterate backwards through block indexes collecting results in order to access the block hash
-    // of each entry in case we need to look it up in the hash index.
-    for (const CBlockIndex* block_index = stop_index;
-         block_index && block_index->nHeight >= start_height;
-         block_index = block_index->pprev) {
-        uint256 block_hash = block_index->GetBlockHash();
-
-        size_t i = static_cast<size_t>(block_index->nHeight - start_height);
-        if (block_hash == values[i].first) {
-            results[i] = std::move(values[i].second);
-            continue;
-        }
-
-        if (!db.Read(index_util::DBHashKey(block_hash), results[i])) {
-            LogError("unable to read value in %s at key (%c, %s)",
-                     index_name, index_util::DB_BLOCK_HASH, block_hash.ToString());
-            return false;
-        }
-    }
-
-    return true;
-}
-
-bool BlockFilterIndex::LookupFilter(const CBlockIndex* block_index, BlockFilter& filter_out) const
-{
-    DBVal entry;
-    if (!index_util::LookUpOne(*m_db, {block_index->GetBlockHash(), block_index->nHeight}, entry)) {
-        return false;
-    }
-
-    return ReadFilterFromDisk(entry.pos, entry.hash, filter_out);
-}
-
-bool BlockFilterIndex::LookupFilterHeader(const CBlockIndex* block_index, uint256& header_out)
-{
-    LOCK(m_cs_headers_cache);
-
-    bool is_checkpoint{block_index->nHeight % CFCHECKPT_INTERVAL == 0};
-
-    if (is_checkpoint) {
-        // Try to find the block in the headers cache if this is a checkpoint height.
-        auto header = m_headers_cache.find(block_index->GetBlockHash());
-        if (header != m_headers_cache.end()) {
-            header_out = header->second;
-            return true;
-        }
-    }
-
-    DBVal entry;
-    if (!index_util::LookUpOne(*m_db, {block_index->GetBlockHash(), block_index->nHeight}, entry)) {
-        return false;
-    }
-
-    if (is_checkpoint &&
-        m_headers_cache.size() < CF_HEADERS_CACHE_MAX_SZ) {
-        // Add to the headers cache if this is a checkpoint height.
-        m_headers_cache.emplace(block_index->GetBlockHash(), entry.header);
-    }
-
-    header_out = entry.header;
-    return true;
-}
-
-bool BlockFilterIndex::LookupFilterRange(int start_height, const CBlockIndex* stop_index,
-                                         std::vector<BlockFilter>& filters_out) const
-{
-    std::vector<DBVal> entries;
-    if (!LookupRange(*m_db, m_name, start_height, stop_index, entries)) {
-        return false;
-    }
-
-    filters_out.resize(entries.size());
-    auto filter_pos_it = filters_out.begin();
-    for (const auto& entry : entries) {
-        if (!ReadFilterFromDisk(entry.pos, entry.hash, *filter_pos_it)) {
-            return false;
-        }
-        ++filter_pos_it;
-    }
-
-    return true;
-}
-
-bool BlockFilterIndex::LookupFilterHashRange(int start_height, const CBlockIndex* stop_index,
-                                             std::vector<uint256>& hashes_out) const
-
-{
-    std::vector<DBVal> entries;
-    if (!LookupRange(*m_db, m_name, start_height, stop_index, entries)) {
-        return false;
-    }
-
-    hashes_out.clear();
-    hashes_out.reserve(entries.size());
-    for (const auto& entry : entries) {
-        hashes_out.push_back(entry.hash);
-    }
-    return true;
-}
-
-BlockFilterIndex* GetBlockFilterIndex(BlockFilterType filter_type)
-{
-    auto it = g_filter_indexes.find(filter_type);
-    return it != g_filter_indexes.end() ? &it->second : nullptr;
-}
-
-void ForEachBlockFilterIndex(std::function<void (BlockFilterIndex&)> fn)
-{
-    for (auto& entry : g_filter_indexes) fn(entry.second);
-}
-
-bool InitBlockFilterIndex(std::function<std::unique_ptr<interfaces::Chain>()> make_chain, BlockFilterType filter_type,
-                          size_t n_cache_size, bool f_memory, bool f_wipe)
-{
-    auto result = g_filter_indexes.emplace(std::piecewise_construct,
-                                           std::forward_as_tuple(filter_type),
-                                           std::forward_as_tuple(make_chain(), filter_type,
-                                                                 n_cache_size, f_memory, f_wipe));
-    return result.second;
-}
-
-bool DestroyBlockFilterIndex(BlockFilterType filter_type)
-{
-    return g_filter_indexes.erase(filter_type);
-}
-
-void DestroyAllBlockFilterIndexes()
-{
-    g_filter_indexes.clear();
-}
diff --git a/src/index/blockfilterindex.h b/src/index/blockfilterindex.h
deleted file mode 100644
index 0bb4a74e1256..000000000000
--- a/src/index/blockfilterindex.h
+++ /dev/null
@@ -1,126 +0,0 @@
-// Copyright (c) 2018-present 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_INDEX_BLOCKFILTERINDEX_H
-#define BITCOIN_INDEX_BLOCKFILTERINDEX_H
-
-#include <attributes.h>
-#include <flatfile.h>
-#include <index/base.h>
-#include <interfaces/chain.h>
-#include <sync.h>
-#include <uint256.h>
-#include <util/hasher.h>
-
-#include <cstddef>
-#include <cstdint>
-#include <functional>
-#include <memory>
-#include <optional>
-#include <unordered_map>
-#include <vector>
-
-class BlockFilter;
-class CBlockIndex;
-enum class BlockFilterType : uint8_t;
-
-static const char* const DEFAULT_BLOCKFILTERINDEX = "0";
-
-/** Interval between compact filter checkpoints. See BIP 157. */
-static constexpr int CFCHECKPT_INTERVAL = 1000;
-
-/**
- * BlockFilterIndex is used to store and retrieve block filters, hashes, and headers for a range of
- * blocks by height. An index is constructed for each supported filter type with its own database
- * (ie. filter data for different types are stored in separate databases).
- *
- * This index is used to serve BIP 157 net requests.
- */
-class BlockFilterIndex final : public BaseIndex
-{
-private:
-    BlockFilterType m_filter_type;
-    std::unique_ptr<BaseIndex::DB> m_db;
-
-    FlatFilePos m_next_filter_pos;
-    std::unique_ptr<FlatFileSeq> m_filter_fileseq;
-
-    bool ReadFilterFromDisk(const FlatFilePos& pos, const uint256& hash, BlockFilter& filter) const;
-    size_t WriteFilterToDisk(FlatFilePos& pos, const BlockFilter& filter);
-
-    Mutex m_cs_headers_cache;
-    /** cache of block hash to filter header, to avoid disk access when responding to getcfcheckpt. */
-    std::unordered_map<uint256, uint256, BlockHasher> m_headers_cache GUARDED_BY(m_cs_headers_cache);
-
-    // Last computed header to avoid disk reads on every new block.
-    uint256 m_last_header{};
-
-    bool AllowPrune() const override { return true; }
-
-    bool Write(const BlockFilter& filter, uint32_t block_height, const uint256& filter_header);
-
-    std::optional<uint256> ReadFilterHeader(int height, const uint256& expected_block_hash);
-
-protected:
-    bool CustomInit(const std::optional<interfaces::BlockRef>& block) override;
-
-    bool CustomCommit(CDBBatch& batch) override;
-
-    bool CustomAppend(const interfaces::BlockInfo& block) override;
-
-    bool CustomRemove(const interfaces::BlockInfo& block) override;
-
-    BaseIndex::DB& GetDB() const LIFETIMEBOUND override { return *m_db; }
-
-public:
-    /** Constructs the index, which becomes available to be queried. */
-    explicit BlockFilterIndex(std::unique_ptr<interfaces::Chain> chain, BlockFilterType filter_type,
-                              size_t n_cache_size, bool f_memory = false, bool f_wipe = false);
-
-    interfaces::Chain::NotifyOptions CustomOptions() override;
-
-    BlockFilterType GetFilterType() const { return m_filter_type; }
-
-    /** Get a single filter by block. */
-    bool LookupFilter(const CBlockIndex* block_index, BlockFilter& filter_out) const;
-
-    /** Get a single filter header by block. */
-    bool LookupFilterHeader(const CBlockIndex* block_index, uint256& header_out) EXCLUSIVE_LOCKS_REQUIRED(!m_cs_headers_cache);
-
-    /** Get a range of filters between two heights on a chain. */
-    bool LookupFilterRange(int start_height, const CBlockIndex* stop_index,
-                           std::vector<BlockFilter>& filters_out) const;
-
-    /** Get a range of filter hashes between two heights on a chain. */
-    bool LookupFilterHashRange(int start_height, const CBlockIndex* stop_index,
-                               std::vector<uint256>& hashes_out) const;
-};
-
-/**
- * Get a block filter index by type. Returns nullptr if index has not been initialized or was
- * already destroyed.
- */
-BlockFilterIndex* GetBlockFilterIndex(BlockFilterType filter_type);
-
-/** Iterate over all running block filter indexes, invoking fn on each. */
-void ForEachBlockFilterIndex(std::function<void (BlockFilterIndex&)> fn);
-
-/**
- * Initialize a block filter index for the given type if one does not already exist. Returns true if
- * a new index is created and false if one has already been initialized.
- */
-bool InitBlockFilterIndex(std::function<std::unique_ptr<interfaces::Chain>()> make_chain, BlockFilterType filter_type,
-                          size_t n_cache_size, bool f_memory = false, bool f_wipe = false);
-
-/**
- * Destroy the block filter index with the given type. Returns false if no such index exists. This
- * just releases the allocated memory and closes the database connection, it does not delete the
- * index data.
- */
-bool DestroyBlockFilterIndex(BlockFilterType filter_type);
-
-/** Destroy all open block filter indexes. */
-void DestroyAllBlockFilterIndexes();
-
-#endif // BITCOIN_INDEX_BLOCKFILTERINDEX_H
diff --git a/src/index/coinstatsindex.cpp b/src/index/coinstatsindex.cpp
deleted file mode 100644
index 80a6d8dfd2b3..000000000000
--- a/src/index/coinstatsindex.cpp
+++ /dev/null
@@ -1,403 +0,0 @@
-// Copyright (c) 2020-present 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 <index/coinstatsindex.h>
-
-#include <arith_uint256.h>
-#include <chain.h>
-#include <chainparams.h>
-#include <coins.h>
-#include <common/args.h>
-#include <consensus/amount.h>
-#include <crypto/muhash.h>
-#include <dbwrapper.h>
-#include <index/base.h>
-#include <index/db_key.h>
-#include <interfaces/chain.h>
-#include <interfaces/types.h>
-#include <kernel/coinstats.h>
-#include <primitives/block.h>
-#include <primitives/transaction.h>
-#include <script/script.h>
-#include <serialize.h>
-#include <uint256.h>
-#include <undo.h>
-#include <util/check.h>
-#include <util/fs.h>
-#include <util/log.h>
-#include <validation.h>
-
-#include <compare>
-#include <limits>
-#include <string>
-#include <utility>
-#include <vector>
-
-using kernel::ApplyCoinHash;
-using kernel::CCoinsStats;
-using kernel::GetBogoSize;
-using kernel::RemoveCoinHash;
-
-static constexpr uint8_t DB_MUHASH{'M'};
-
-namespace {
-
-struct DBVal {
-    uint256 muhash{uint256::ZERO};
-    uint64_t transaction_output_count{0};
-    uint64_t bogo_size{0};
-    CAmount total_amount{0};
-    CAmount total_subsidy{0};
-    arith_uint256 total_prevout_spent_amount{0};
-    arith_uint256 total_new_outputs_ex_coinbase_amount{0};
-    arith_uint256 total_coinbase_amount{0};
-    CAmount total_unspendables_genesis_block{0};
-    CAmount total_unspendables_bip30{0};
-    CAmount total_unspendables_scripts{0};
-    CAmount total_unspendables_unclaimed_rewards{0};
-
-    SERIALIZE_METHODS(DBVal, obj)
-    {
-        uint256 prevout_spent, new_outputs, coinbase;
-        SER_WRITE(obj, prevout_spent = ArithToUint256(obj.total_prevout_spent_amount));
-        SER_WRITE(obj, new_outputs = ArithToUint256(obj.total_new_outputs_ex_coinbase_amount));
-        SER_WRITE(obj, coinbase = ArithToUint256(obj.total_coinbase_amount));
-
-        READWRITE(obj.muhash);
-        READWRITE(obj.transaction_output_count);
-        READWRITE(obj.bogo_size);
-        READWRITE(obj.total_amount);
-        READWRITE(obj.total_subsidy);
-        READWRITE(prevout_spent);
-        READWRITE(new_outputs);
-        READWRITE(coinbase);
-        READWRITE(obj.total_unspendables_genesis_block);
-        READWRITE(obj.total_unspendables_bip30);
-        READWRITE(obj.total_unspendables_scripts);
-        READWRITE(obj.total_unspendables_unclaimed_rewards);
-
-        SER_READ(obj, obj.total_prevout_spent_amount = UintToArith256(prevout_spent));
-        SER_READ(obj, obj.total_new_outputs_ex_coinbase_amount = UintToArith256(new_outputs));
-        SER_READ(obj, obj.total_coinbase_amount = UintToArith256(coinbase));
-    }
-};
-}; // namespace
-
-std::unique_ptr<CoinStatsIndex> g_coin_stats_index;
-
-CoinStatsIndex::CoinStatsIndex(std::unique_ptr<interfaces::Chain> chain, size_t n_cache_size, bool f_memory, bool f_wipe)
-    : BaseIndex(std::move(chain), "coinstatsindex")
-{
-    // An earlier version of the index used "indexes/coinstats" but it contained
-    // a bug and is superseded by a fixed version at "indexes/coinstatsindex".
-    // The original index is kept around until the next release in case users
-    // decide to downgrade their node.
-    auto old_path = gArgs.GetDataDirNet() / "indexes" / "coinstats";
-    if (fs::exists(old_path)) {
-        // TODO: Change this to deleting the old index with v31.
-        LogWarning("Old version of coinstatsindex found at %s. This folder can be safely deleted unless you " \
-            "plan to downgrade your node to version 29 or lower.", fs::PathToString(old_path));
-    }
-    fs::path path{gArgs.GetDataDirNet() / "indexes" / "coinstatsindex"};
-    fs::create_directories(path);
-
-    m_db = std::make_unique<CoinStatsIndex::DB>(path / "db", n_cache_size, f_memory, f_wipe);
-}
-
-bool CoinStatsIndex::CustomAppend(const interfaces::BlockInfo& block)
-{
-    const CAmount block_subsidy{GetBlockSubsidy(block.height, Params().GetConsensus())};
-    m_total_subsidy += block_subsidy;
-
-    // Ignore genesis block
-    if (block.height > 0) {
-        uint256 expected_block_hash{*Assert(block.prev_hash)};
-        if (m_current_block_hash != expected_block_hash) {
-            LogError("previous block header belongs to unexpected block %s; expected %s",
-                      m_current_block_hash.ToString(), expected_block_hash.ToString());
-            return false;
-        }
-
-        // Add the new utxos created from the block
-        assert(block.data);
-        for (size_t i = 0; i < block.data->vtx.size(); ++i) {
-            const auto& tx{block.data->vtx.at(i)};
-            const bool is_coinbase{tx->IsCoinBase()};
-
-            // Skip duplicate txid coinbase transactions (BIP30).
-            if (is_coinbase && IsBIP30Unspendable(block.hash, block.height)) {
-                m_total_unspendables_bip30 += block_subsidy;
-                continue;
-            }
-
-            for (uint32_t j = 0; j < tx->vout.size(); ++j) {
-                const CTxOut& out{tx->vout[j]};
-                const Coin coin{out, block.height, is_coinbase};
-                const COutPoint outpoint{tx->GetHash(), j};
-
-                // Skip unspendable coins
-                if (coin.out.scriptPubKey.IsUnspendable()) {
-                    m_total_unspendables_scripts += coin.out.nValue;
-                    continue;
-                }
-
-                ApplyCoinHash(m_muhash, outpoint, coin);
-
-                if (is_coinbase) {
-                    m_total_coinbase_amount += coin.out.nValue;
-                } else {
-                    m_total_new_outputs_ex_coinbase_amount += coin.out.nValue;
-                }
-
-                ++m_transaction_output_count;
-                m_total_amount += coin.out.nValue;
-                m_bogo_size += GetBogoSize(coin.out.scriptPubKey);
-            }
-
-            // The coinbase tx has no undo data since no former output is spent
-            if (!is_coinbase) {
-                const auto& tx_undo{Assert(block.undo_data)->vtxundo.at(i - 1)};
-
-                for (size_t j = 0; j < tx_undo.vprevout.size(); ++j) {
-                    const Coin& coin{tx_undo.vprevout[j]};
-                    const COutPoint outpoint{tx->vin[j].prevout.hash, tx->vin[j].prevout.n};
-
-                    RemoveCoinHash(m_muhash, outpoint, coin);
-
-                    m_total_prevout_spent_amount += coin.out.nValue;
-
-                    --m_transaction_output_count;
-                    m_total_amount -= coin.out.nValue;
-                    m_bogo_size -= GetBogoSize(coin.out.scriptPubKey);
-                }
-            }
-        }
-    } else {
-        // genesis block
-        m_total_unspendables_genesis_block += block_subsidy;
-    }
-
-    // If spent prevouts + block subsidy are still a higher amount than
-    // new outputs + coinbase + current unspendable amount this means
-    // the miner did not claim the full block reward. Unclaimed block
-    // rewards are also unspendable.
-    const CAmount temp_total_unspendable_amount{m_total_unspendables_genesis_block + m_total_unspendables_bip30 + m_total_unspendables_scripts + m_total_unspendables_unclaimed_rewards};
-    const arith_uint256 unclaimed_rewards{(m_total_prevout_spent_amount + m_total_subsidy) - (m_total_new_outputs_ex_coinbase_amount + m_total_coinbase_amount + temp_total_unspendable_amount)};
-    assert(unclaimed_rewards <= arith_uint256(std::numeric_limits<CAmount>::max()));
-    m_total_unspendables_unclaimed_rewards += static_cast<CAmount>(unclaimed_rewards.GetLow64());
-
-    std::pair<uint256, DBVal> value;
-    value.first = block.hash;
-    value.second.transaction_output_count = m_transaction_output_count;
-    value.second.bogo_size = m_bogo_size;
-    value.second.total_amount = m_total_amount;
-    value.second.total_subsidy = m_total_subsidy;
-    value.second.total_prevout_spent_amount = m_total_prevout_spent_amount;
-    value.second.total_new_outputs_ex_coinbase_amount = m_total_new_outputs_ex_coinbase_amount;
-    value.second.total_coinbase_amount = m_total_coinbase_amount;
-    value.second.total_unspendables_genesis_block = m_total_unspendables_genesis_block;
-    value.second.total_unspendables_bip30 = m_total_unspendables_bip30;
-    value.second.total_unspendables_scripts = m_total_unspendables_scripts;
-    value.second.total_unspendables_unclaimed_rewards = m_total_unspendables_unclaimed_rewards;
-
-    uint256 out;
-    m_muhash.Finalize(out);
-    value.second.muhash = out;
-
-    m_current_block_hash = block.hash;
-
-    // Intentionally do not update DB_MUHASH here so it stays in sync with
-    // DB_BEST_BLOCK, and the index is not corrupted if there is an unclean shutdown.
-    m_db->Write(index_util::DBHeightKey(block.height), value);
-    return true;
-}
-
-bool CoinStatsIndex::CustomRemove(const interfaces::BlockInfo& block)
-{
-    CDBBatch batch(*m_db);
-    std::unique_ptr<CDBIterator> db_it(m_db->NewIterator());
-
-    // During a reorg, copy the block's hash digest from the height index to the hash index,
-    // ensuring it's still accessible after the height index entry is overwritten.
-    if (!index_util::CopyHeightIndexToHashIndex<DBVal>(*db_it, batch, m_name, block.height)) {
-        return false;
-    }
-
-    m_db->WriteBatch(batch);
-
-    if (!RevertBlock(block)) {
-        return false; // failure cause logged internally
-    }
-
-    return true;
-}
-
-std::optional<CCoinsStats> CoinStatsIndex::LookUpStats(const CBlockIndex& block_index) const
-{
-    CCoinsStats stats{block_index.nHeight, block_index.GetBlockHash()};
-    stats.index_used = true;
-
-    DBVal entry;
-    if (!index_util::LookUpOne(*m_db, {block_index.GetBlockHash(), block_index.nHeight}, entry)) {
-        return std::nullopt;
-    }
-
-    stats.hashSerialized = entry.muhash;
-    stats.nTransactionOutputs = entry.transaction_output_count;
-    stats.nBogoSize = entry.bogo_size;
-    stats.total_amount = entry.total_amount;
-    stats.total_subsidy = entry.total_subsidy;
-    stats.total_prevout_spent_amount = entry.total_prevout_spent_amount;
-    stats.total_new_outputs_ex_coinbase_amount = entry.total_new_outputs_ex_coinbase_amount;
-    stats.total_coinbase_amount = entry.total_coinbase_amount;
-    stats.total_unspendables_genesis_block = entry.total_unspendables_genesis_block;
-    stats.total_unspendables_bip30 = entry.total_unspendables_bip30;
-    stats.total_unspendables_scripts = entry.total_unspendables_scripts;
-    stats.total_unspendables_unclaimed_rewards = entry.total_unspendables_unclaimed_rewards;
-
-    return stats;
-}
-
-bool CoinStatsIndex::CustomInit(const std::optional<interfaces::BlockRef>& block)
-{
-    if (!m_db->Read(DB_MUHASH, m_muhash)) {
-        // Check that the cause of the read failure is that the key does not
-        // exist. Any other errors indicate database corruption or a disk
-        // failure, and starting the index would cause further corruption.
-        if (m_db->Exists(DB_MUHASH)) {
-            LogError("Cannot read current %s state; index may be corrupted",
-                      GetName());
-            return false;
-        }
-    }
-
-    if (block) {
-        DBVal entry;
-        if (!index_util::LookUpOne(*m_db, *block, entry)) {
-            LogError("Cannot read current %s state; index may be corrupted",
-                      GetName());
-            return false;
-        }
-
-        uint256 out;
-        m_muhash.Finalize(out);
-        if (entry.muhash != out) {
-            LogError("Cannot read current %s state; index may be corrupted",
-                      GetName());
-            return false;
-        }
-
-        m_transaction_output_count = entry.transaction_output_count;
-        m_bogo_size = entry.bogo_size;
-        m_total_amount = entry.total_amount;
-        m_total_subsidy = entry.total_subsidy;
-        m_total_prevout_spent_amount = entry.total_prevout_spent_amount;
-        m_total_new_outputs_ex_coinbase_amount = entry.total_new_outputs_ex_coinbase_amount;
-        m_total_coinbase_amount = entry.total_coinbase_amount;
-        m_total_unspendables_genesis_block = entry.total_unspendables_genesis_block;
-        m_total_unspendables_bip30 = entry.total_unspendables_bip30;
-        m_total_unspendables_scripts = entry.total_unspendables_scripts;
-        m_total_unspendables_unclaimed_rewards = entry.total_unspendables_unclaimed_rewards;
-        m_current_block_hash = block->hash;
-    }
-
-    return true;
-}
-
-bool CoinStatsIndex::CustomCommit(CDBBatch& batch)
-{
-    // DB_MUHASH should always be committed in a batch together with DB_BEST_BLOCK
-    // to prevent an inconsistent state of the DB.
-    batch.Write(DB_MUHASH, m_muhash);
-    return true;
-}
-
-interfaces::Chain::NotifyOptions CoinStatsIndex::CustomOptions()
-{
-    interfaces::Chain::NotifyOptions options;
-    options.connect_undo_data = true;
-    options.disconnect_data = true;
-    options.disconnect_undo_data = true;
-    return options;
-}
-
-// Revert a single block as part of a reorg
-bool CoinStatsIndex::RevertBlock(const interfaces::BlockInfo& block)
-{
-    std::pair<uint256, DBVal> read_out;
-
-    // Ignore genesis block
-    if (block.height > 0) {
-        if (!m_db->Read(index_util::DBHeightKey(block.height - 1), read_out)) {
-            return false;
-        }
-
-        uint256 expected_block_hash{*block.prev_hash};
-        if (read_out.first != expected_block_hash) {
-            LogWarning("previous block header belongs to unexpected block %s; expected %s",
-                      read_out.first.ToString(), expected_block_hash.ToString());
-
-            if (!m_db->Read(index_util::DBHashKey(expected_block_hash), read_out)) {
-                LogError("previous block header not found; expected %s",
-                          expected_block_hash.ToString());
-                return false;
-            }
-        }
-    }
-
-    // Roll back muhash by removing the new UTXOs that were created by the
-    // block and reapplying the old UTXOs that were spent by the block
-    assert(block.data);
-    assert(block.undo_data);
-    for (size_t i = 0; i < block.data->vtx.size(); ++i) {
-        const auto& tx{block.data->vtx.at(i)};
-        const bool is_coinbase{tx->IsCoinBase()};
-
-        if (is_coinbase && IsBIP30Unspendable(block.hash, block.height)) {
-            continue;
-        }
-
-        for (uint32_t j = 0; j < tx->vout.size(); ++j) {
-            const CTxOut& out{tx->vout[j]};
-            const COutPoint outpoint{tx->GetHash(), j};
-            const Coin coin{out, block.height, is_coinbase};
-
-            if (!coin.out.scriptPubKey.IsUnspendable()) {
-                RemoveCoinHash(m_muhash, outpoint, coin);
-            }
-        }
-
-        // The coinbase tx has no undo data since no former output is spent
-        if (!is_coinbase) {
-            const auto& tx_undo{block.undo_data->vtxundo.at(i - 1)};
-
-            for (size_t j = 0; j < tx_undo.vprevout.size(); ++j) {
-                const Coin& coin{tx_undo.vprevout[j]};
-                const COutPoint outpoint{tx->vin[j].prevout.hash, tx->vin[j].prevout.n};
-                ApplyCoinHash(m_muhash, outpoint, coin);
-            }
-        }
-    }
-
-    // Check that the rolled back muhash is consistent with the DB read out
-    uint256 out;
-    m_muhash.Finalize(out);
-    Assert(read_out.second.muhash == out);
-
-    // Apply the other values from the DB to the member variables
-    m_transaction_output_count = read_out.second.transaction_output_count;
-    m_total_amount = read_out.second.total_amount;
-    m_bogo_size = read_out.second.bogo_size;
-    m_total_subsidy = read_out.second.total_subsidy;
-    m_total_prevout_spent_amount = read_out.second.total_prevout_spent_amount;
-    m_total_new_outputs_ex_coinbase_amount = read_out.second.total_new_outputs_ex_coinbase_amount;
-    m_total_coinbase_amount = read_out.second.total_coinbase_amount;
-    m_total_unspendables_genesis_block = read_out.second.total_unspendables_genesis_block;
-    m_total_unspendables_bip30 = read_out.second.total_unspendables_bip30;
-    m_total_unspendables_scripts = read_out.second.total_unspendables_scripts;
-    m_total_unspendables_unclaimed_rewards = read_out.second.total_unspendables_unclaimed_rewards;
-    m_current_block_hash = *block.prev_hash;
-
-    return true;
-}
diff --git a/src/index/coinstatsindex.h b/src/index/coinstatsindex.h
deleted file mode 100644
index 0e26fba56d95..000000000000
--- a/src/index/coinstatsindex.h
+++ /dev/null
@@ -1,78 +0,0 @@
-// Copyright (c) 2020-present 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_INDEX_COINSTATSINDEX_H
-#define BITCOIN_INDEX_COINSTATSINDEX_H
-
-#include <arith_uint256.h>
-#include <consensus/amount.h>
-#include <crypto/muhash.h>
-#include <index/base.h>
-#include <interfaces/chain.h>
-#include <uint256.h>
-
-#include <cstddef>
-#include <cstdint>
-#include <memory>
-#include <optional>
-
-class CBlockIndex;
-namespace kernel {
-struct CCoinsStats;
-}
-
-static constexpr bool DEFAULT_COINSTATSINDEX{false};
-
-/**
- * CoinStatsIndex maintains statistics on the UTXO set.
- */
-class CoinStatsIndex final : public BaseIndex
-{
-private:
-    std::unique_ptr<BaseIndex::DB> m_db;
-
-    MuHash3072 m_muhash;
-    uint64_t m_transaction_output_count{0};
-    uint64_t m_bogo_size{0};
-    CAmount m_total_amount{0};
-    CAmount m_total_subsidy{0};
-    arith_uint256 m_total_prevout_spent_amount{0};
-    arith_uint256 m_total_new_outputs_ex_coinbase_amount{0};
-    arith_uint256 m_total_coinbase_amount{0};
-    CAmount m_total_unspendables_genesis_block{0};
-    CAmount m_total_unspendables_bip30{0};
-    CAmount m_total_unspendables_scripts{0};
-    CAmount m_total_unspendables_unclaimed_rewards{0};
-
-    uint256 m_current_block_hash{};
-
-    [[nodiscard]] bool RevertBlock(const interfaces::BlockInfo& block);
-
-    bool AllowPrune() const override { return true; }
-
-protected:
-    bool CustomInit(const std::optional<interfaces::BlockRef>& block) override;
-
-    bool CustomCommit(CDBBatch& batch) override;
-
-    bool CustomAppend(const interfaces::BlockInfo& block) override;
-
-    bool CustomRemove(const interfaces::BlockInfo& block) override;
-
-    BaseIndex::DB& GetDB() const override { return *m_db; }
-
-public:
-    // Constructs the index, which becomes available to be queried.
-    explicit CoinStatsIndex(std::unique_ptr<interfaces::Chain> chain, size_t n_cache_size, bool f_memory = false, bool f_wipe = false);
-
-    interfaces::Chain::NotifyOptions CustomOptions() override;
-
-    // Look up stats for a specific block using CBlockIndex
-    std::optional<kernel::CCoinsStats> LookUpStats(const CBlockIndex& block_index) const;
-};
-
-/// The global UTXO set hash object.
-extern std::unique_ptr<CoinStatsIndex> g_coin_stats_index;
-
-#endif // BITCOIN_INDEX_COINSTATSINDEX_H
diff --git a/src/index/db_key.h b/src/index/db_key.h
deleted file mode 100644
index b7334c81e41f..000000000000
--- a/src/index/db_key.h
+++ /dev/null
@@ -1,116 +0,0 @@
-// Copyright (c) 2025-present 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_INDEX_DB_KEY_H
-#define BITCOIN_INDEX_DB_KEY_H
-
-#include <dbwrapper.h>
-#include <interfaces/types.h>
-#include <logging.h>
-#include <serialize.h>
-#include <uint256.h>
-
-#include <cstdint>
-#include <ios>
-#include <string>
-#include <utility>
-
-namespace index_util {
-/*
- * This file includes the logic for the db keys used by blockfilterindex and coinstatsindex.
- * Index data is usually indexed by height, but in case of a reorg, entries of blocks no
- * longer in the main chain will be copied to a hash index by which they can still be queried.
- * Keys for the height index have the type [DB_BLOCK_HEIGHT, uint32 (BE)]. The height is represented
- * as big-endian so that sequential reads of filters by height are fast.
- * Keys for the hash index have the type [DB_BLOCK_HASH, uint256].
- */
-
-static constexpr uint8_t DB_BLOCK_HASH{'s'};
-static constexpr uint8_t DB_BLOCK_HEIGHT{'t'};
-
-struct DBHeightKey {
-    int height;
-
-    explicit DBHeightKey(int height_in) : height(height_in) {}
-
-    template<typename Stream>
-    void Serialize(Stream& s) const
-    {
-        ser_writedata8(s, DB_BLOCK_HEIGHT);
-        ser_writedata32be(s, height);
-    }
-
-    template<typename Stream>
-    void Unserialize(Stream& s)
-    {
-        const uint8_t prefix{ser_readdata8(s)};
-        if (prefix != DB_BLOCK_HEIGHT) {
-            throw std::ios_base::failure("Invalid format for index DB height key");
-        }
-        height = ser_readdata32be(s);
-    }
-};
-
-struct DBHashKey {
-    uint256 hash;
-
-    explicit DBHashKey(const uint256& hash_in) : hash(hash_in) {}
-
-    SERIALIZE_METHODS(DBHashKey, obj) {
-        uint8_t prefix{DB_BLOCK_HASH};
-        READWRITE(prefix);
-        if (prefix != DB_BLOCK_HASH) {
-            throw std::ios_base::failure("Invalid format for index DB hash key");
-        }
-
-        READWRITE(obj.hash);
-    }
-};
-
-template <typename DBVal>
-[[nodiscard]] static bool CopyHeightIndexToHashIndex(CDBIterator& db_it, CDBBatch& batch,
-                                                     const std::string& index_name, int height)
-{
-    DBHeightKey key(height);
-    db_it.Seek(key);
-
-    if (!db_it.GetKey(key) || key.height != height) {
-        LogError("unexpected key in %s: expected (%c, %d)",
-                  index_name, DB_BLOCK_HEIGHT, height);
-        return false;
-    }
-
-    std::pair<uint256, DBVal> value;
-    if (!db_it.GetValue(value)) {
-        LogError("unable to read value in %s at key (%c, %d)",
-                 index_name, DB_BLOCK_HEIGHT, height);
-        return false;
-    }
-
-    batch.Write(DBHashKey(value.first), value.second);
-    return true;
-}
-
-template <typename DBVal>
-static bool LookUpOne(const CDBWrapper& db, const interfaces::BlockRef& block, DBVal& result)
-{
-    // First check if the result is stored under the height index and the value
-    // there matches the block hash. This should be the case if the block is on
-    // the active chain.
-    std::pair<uint256, DBVal> read_out;
-    if (!db.Read(DBHeightKey(block.height), read_out)) {
-        return false;
-    }
-    if (read_out.first == block.hash) {
-        result = std::move(read_out.second);
-        return true;
-    }
-
-    // If value at the height index corresponds to an different block, the
-    // result will be stored in the hash index.
-    return db.Read(DBHashKey(block.hash), result);
-}
-} // namespace index_util
-
-#endif // BITCOIN_INDEX_DB_KEY_H
diff --git a/src/index/disktxpos.h b/src/index/disktxpos.h
deleted file mode 100644
index ce5cc77b2d05..000000000000
--- a/src/index/disktxpos.h
+++ /dev/null
@@ -1,26 +0,0 @@
-// Copyright (c) 2019-present 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_INDEX_DISKTXPOS_H
-#define BITCOIN_INDEX_DISKTXPOS_H
-
-#include <flatfile.h>
-#include <serialize.h>
-
-struct CDiskTxPos : public FlatFilePos
-{
-    uint32_t nTxOffset{0}; // after header
-
-    SERIALIZE_METHODS(CDiskTxPos, obj)
-    {
-        READWRITE(AsBase<FlatFilePos>(obj), VARINT(obj.nTxOffset));
-    }
-
-    CDiskTxPos(const FlatFilePos& blockIn, uint32_t nTxOffsetIn) : FlatFilePos{blockIn.nFile, blockIn.nPos}, nTxOffset{nTxOffsetIn} {
-    }
-
-    CDiskTxPos() = default;
-};
-
-#endif // BITCOIN_INDEX_DISKTXPOS_H
diff --git a/src/index/txindex.cpp b/src/index/txindex.cpp
deleted file mode 100644
index 4b0c82877ab2..000000000000
--- a/src/index/txindex.cpp
+++ /dev/null
@@ -1,120 +0,0 @@
-// Copyright (c) 2017-present 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 <index/txindex.h>
-
-#include <common/args.h>
-#include <dbwrapper.h>
-#include <flatfile.h>
-#include <index/base.h>
-#include <index/disktxpos.h>
-#include <interfaces/chain.h>
-#include <node/blockstorage.h>
-#include <primitives/block.h>
-#include <primitives/transaction.h>
-#include <serialize.h>
-#include <streams.h>
-#include <uint256.h>
-#include <util/fs.h>
-#include <util/log.h>
-#include <validation.h>
-
-#include <cassert>
-#include <cstdint>
-#include <cstdio>
-#include <exception>
-#include <string>
-#include <utility>
-#include <vector>
-
-constexpr uint8_t DB_TXINDEX{'t'};
-
-std::unique_ptr<TxIndex> g_txindex;
-
-
-/** Access to the txindex database (indexes/txindex/) */
-class TxIndex::DB : public BaseIndex::DB
-{
-public:
-    explicit DB(size_t n_cache_size, bool f_memory = false, bool f_wipe = false);
-
-    /// Read the disk location of the transaction data with the given hash. Returns false if the
-    /// transaction hash is not indexed.
-    bool ReadTxPos(const Txid& txid, CDiskTxPos& pos) const;
-
-    /// Write a batch of transaction positions to the DB.
-    void WriteTxs(const std::vector<std::pair<Txid, CDiskTxPos>>& v_pos);
-};
-
-TxIndex::DB::DB(size_t n_cache_size, bool f_memory, bool f_wipe) :
-    BaseIndex::DB(gArgs.GetDataDirNet() / "indexes" / "txindex", n_cache_size, f_memory, f_wipe)
-{}
-
-bool TxIndex::DB::ReadTxPos(const Txid& txid, CDiskTxPos& pos) const
-{
-    return Read(std::make_pair(DB_TXINDEX, txid.ToUint256()), pos);
-}
-
-void TxIndex::DB::WriteTxs(const std::vector<std::pair<Txid, CDiskTxPos>>& v_pos)
-{
-    CDBBatch batch(*this);
-    for (const auto& [txid, pos] : v_pos) {
-        batch.Write(std::make_pair(DB_TXINDEX, txid.ToUint256()), pos);
-    }
-    WriteBatch(batch);
-}
-
-TxIndex::TxIndex(std::unique_ptr<interfaces::Chain> chain, size_t n_cache_size, bool f_memory, bool f_wipe)
-    : BaseIndex(std::move(chain), "txindex"), m_db(std::make_unique<TxIndex::DB>(n_cache_size, f_memory, f_wipe))
-{}
-
-TxIndex::~TxIndex() = default;
-
-bool TxIndex::CustomAppend(const interfaces::BlockInfo& block)
-{
-    // Exclude genesis block transaction because outputs are not spendable.
-    if (block.height == 0) return true;
-
-    assert(block.data);
-    CDiskTxPos pos({block.file_number, block.data_pos}, GetSizeOfCompactSize(block.data->vtx.size()));
-    std::vector<std::pair<Txid, CDiskTxPos>> vPos;
-    vPos.reserve(block.data->vtx.size());
-    for (const auto& tx : block.data->vtx) {
-        vPos.emplace_back(tx->GetHash(), pos);
-        pos.nTxOffset += ::GetSerializeSize(TX_WITH_WITNESS(*tx));
-    }
-    m_db->WriteTxs(vPos);
-    return true;
-}
-
-BaseIndex::DB& TxIndex::GetDB() const { return *m_db; }
-
-bool TxIndex::FindTx(const Txid& tx_hash, uint256& block_hash, CTransactionRef& tx) const
-{
-    CDiskTxPos postx;
-    if (!m_db->ReadTxPos(tx_hash, postx)) {
-        return false;
-    }
-
-    AutoFile file{m_chainstate->m_blockman.OpenBlockFile(postx, true)};
-    if (file.IsNull()) {
-        LogError("OpenBlockFile failed");
-        return false;
-    }
-    CBlockHeader header;
-    try {
-        file >> header;
-        file.seek(postx.nTxOffset, SEEK_CUR);
-        file >> TX_WITH_WITNESS(tx);
-    } catch (const std::exception& e) {
-        LogError("Deserialize or I/O error - %s", e.what());
-        return false;
-    }
-    if (tx->GetHash() != tx_hash) {
-        LogError("txid mismatch");
-        return false;
-    }
-    block_hash = header.GetHash();
-    return true;
-}
diff --git a/src/index/txindex.h b/src/index/txindex.h
deleted file mode 100644
index 0358e0ae49f9..000000000000
--- a/src/index/txindex.h
+++ /dev/null
@@ -1,60 +0,0 @@
-// Copyright (c) 2017-present 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_INDEX_TXINDEX_H
-#define BITCOIN_INDEX_TXINDEX_H
-
-#include <index/base.h>
-#include <primitives/transaction.h>
-
-#include <cstddef>
-#include <memory>
-
-class uint256;
-namespace interfaces {
-class Chain;
-}
-
-static constexpr bool DEFAULT_TXINDEX{false};
-
-/**
- * TxIndex is used to look up transactions included in the blockchain by hash.
- * The index is written to a LevelDB database and records the filesystem
- * location of each transaction by transaction hash.
- */
-class TxIndex final : public BaseIndex
-{
-protected:
-    class DB;
-
-private:
-    const std::unique_ptr<DB> m_db;
-
-    bool AllowPrune() const override { return false; }
-
-protected:
-    bool CustomAppend(const interfaces::BlockInfo& block) override;
-
-    BaseIndex::DB& GetDB() const override;
-
-public:
-    /// Constructs the index, which becomes available to be queried.
-    explicit TxIndex(std::unique_ptr<interfaces::Chain> chain, size_t n_cache_size, bool f_memory = false, bool f_wipe = false);
-
-    // Destructor is declared because this class contains a unique_ptr to an incomplete type.
-    virtual ~TxIndex() override;
-
-    /// Look up a transaction by hash.
-    ///
-    /// @param[in]   tx_hash  The hash of the transaction to be returned.
-    /// @param[out]  block_hash  The hash of the block the transaction is found in.
-    /// @param[out]  tx  The transaction itself.
-    /// @return  true if transaction is found, false otherwise
-    bool FindTx(const Txid& tx_hash, uint256& block_hash, CTransactionRef& tx) const;
-};
-
-/// The global transaction index, used in GetTransaction. May be null.
-extern std::unique_ptr<TxIndex> g_txindex;
-
-#endif // BITCOIN_INDEX_TXINDEX_H
diff --git a/src/index/txospenderindex.cpp b/src/index/txospenderindex.cpp
deleted file mode 100644
index f0d559a958f5..000000000000
--- a/src/index/txospenderindex.cpp
+++ /dev/null
@@ -1,183 +0,0 @@
-// Copyright (c) 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 <index/txospenderindex.h>
-
-#include <common/args.h>
-#include <crypto/siphash.h>
-#include <dbwrapper.h>
-#include <flatfile.h>
-#include <index/base.h>
-#include <index/disktxpos.h>
-#include <interfaces/chain.h>
-#include <logging.h>
-#include <node/blockstorage.h>
-#include <primitives/block.h>
-#include <primitives/transaction.h>
-#include <random.h>
-#include <serialize.h>
-#include <streams.h>
-#include <tinyformat.h>
-#include <uint256.h>
-#include <util/fs.h>
-#include <validation.h>
-
-#include <cstdio>
-#include <exception>
-#include <ios>
-#include <string>
-#include <utility>
-#include <vector>
-
-/* The database is used to find the spending transaction of a given utxo.
- * For every input of every transaction it stores a key that is a pair(siphash(input outpoint), transaction location on disk) and an empty value.
- * To find the spending transaction of an outpoint, we perform a range query on siphash(outpoint), and for each returned key load the transaction
- * and return it if it does spend the provided outpoint.
- */
-
-// LevelDB key prefix. We only have one key for now but it will make it easier to add others if needed.
-constexpr uint8_t DB_TXOSPENDERINDEX{'s'};
-
-std::unique_ptr<TxoSpenderIndex> g_txospenderindex;
-
-struct DBKey {
-    uint64_t hash;
-    CDiskTxPos pos;
-
-    explicit DBKey(const uint64_t& hash_in, const CDiskTxPos& pos_in) : hash(hash_in), pos(pos_in) {}
-
-    SERIALIZE_METHODS(DBKey, obj)
-    {
-        uint8_t prefix{DB_TXOSPENDERINDEX};
-        READWRITE(prefix);
-        if (prefix != DB_TXOSPENDERINDEX) {
-            throw std::ios_base::failure("Invalid format for spender index DB key");
-        }
-        READWRITE(obj.hash);
-        READWRITE(obj.pos);
-    }
-};
-
-TxoSpenderIndex::TxoSpenderIndex(std::unique_ptr<interfaces::Chain> chain, size_t n_cache_size, bool f_memory, bool f_wipe)
-    : BaseIndex(std::move(chain), "txospenderindex"), m_db{std::make_unique<DB>(gArgs.GetDataDirNet() / "indexes" / "txospenderindex" / "db", n_cache_size, f_memory, f_wipe)}
-{
-    if (!m_db->Read("siphash_key", m_siphash_key)) {
-        FastRandomContext rng(false);
-        m_siphash_key = {rng.rand64(), rng.rand64()};
-        m_db->Write("siphash_key", m_siphash_key, /*fSync=*/ true);
-    }
-}
-
-interfaces::Chain::NotifyOptions TxoSpenderIndex::CustomOptions()
-{
-    interfaces::Chain::NotifyOptions options;
-    options.disconnect_data = true;
-    return options;
-}
-
-static uint64_t CreateKeyPrefix(std::pair<uint64_t, uint64_t> siphash_key, const COutPoint& vout)
-{
-    return PresaltedSipHasher(siphash_key.first, siphash_key.second)(vout.hash.ToUint256(), vout.n);
-}
-
-static DBKey CreateKey(std::pair<uint64_t, uint64_t> siphash_key, const COutPoint& vout, const CDiskTxPos& pos)
-{
-    return DBKey(CreateKeyPrefix(siphash_key, vout), pos);
-}
-
-void TxoSpenderIndex::WriteSpenderInfos(const std::vector<std::pair<COutPoint, CDiskTxPos>>& items)
-{
-    CDBBatch batch(*m_db);
-    for (const auto& [outpoint, pos] : items) {
-        DBKey key(CreateKey(m_siphash_key, outpoint, pos));
-        // key is hash(spent outpoint) | disk pos, value is empty
-        batch.Write(key, "");
-    }
-    m_db->WriteBatch(batch);
-}
-
-
-void TxoSpenderIndex::EraseSpenderInfos(const std::vector<std::pair<COutPoint, CDiskTxPos>>& items)
-{
-    CDBBatch batch(*m_db);
-    for (const auto& [outpoint, pos] : items) {
-        batch.Erase(CreateKey(m_siphash_key, outpoint, pos));
-    }
-    m_db->WriteBatch(batch);
-}
-
-static std::vector<std::pair<COutPoint, CDiskTxPos>> BuildSpenderPositions(const interfaces::BlockInfo& block)
-{
-    std::vector<std::pair<COutPoint, CDiskTxPos>> items;
-    items.reserve(block.data->vtx.size());
-
-    CDiskTxPos pos({block.file_number, block.data_pos}, GetSizeOfCompactSize(block.data->vtx.size()));
-    for (const auto& tx : block.data->vtx) {
-        if (!tx->IsCoinBase()) {
-            for (const auto& input : tx->vin) {
-                items.emplace_back(input.prevout, pos);
-            }
-        }
-        pos.nTxOffset += ::GetSerializeSize(TX_WITH_WITNESS(*tx));
-    }
-
-    return items;
-}
-
-
-bool TxoSpenderIndex::CustomAppend(const interfaces::BlockInfo& block)
-{
-    WriteSpenderInfos(BuildSpenderPositions(block));
-    return true;
-}
-
-bool TxoSpenderIndex::CustomRemove(const interfaces::BlockInfo& block)
-{
-    EraseSpenderInfos(BuildSpenderPositions(block));
-    return true;
-}
-
-util::Expected<TxoSpender, std::string> TxoSpenderIndex::ReadTransaction(const CDiskTxPos& tx_pos) const
-{
-    AutoFile file{m_chainstate->m_blockman.OpenBlockFile(tx_pos, /*fReadOnly=*/true)};
-    if (file.IsNull()) {
-        return util::Unexpected("cannot open block");
-    }
-    CBlockHeader header;
-    TxoSpender spender;
-    try {
-        file >> header;
-        file.seek(tx_pos.nTxOffset, SEEK_CUR);
-        file >> TX_WITH_WITNESS(spender.tx);
-        spender.block_hash = header.GetHash();
-        return spender;
-    } catch (const std::exception& e) {
-        return util::Unexpected(e.what());
-    }
-}
-
-util::Expected<std::optional<TxoSpender>, std::string> TxoSpenderIndex::FindSpender(const COutPoint& txo) const
-{
-    const uint64_t prefix{CreateKeyPrefix(m_siphash_key, txo)};
-    std::unique_ptr<CDBIterator> it(m_db->NewIterator());
-    DBKey key(prefix, CDiskTxPos());
-
-    // find all keys that start with the outpoint hash, load the transaction at the location specified in the key
-    // and return it if it does spend the provided outpoint
-    for (it->Seek(std::pair{DB_TXOSPENDERINDEX, prefix}); it->Valid() && it->GetKey(key) && key.hash == prefix; it->Next()) {
-        if (const auto spender{ReadTransaction(key.pos)}) {
-            for (const auto& input : spender->tx->vin) {
-                if (input.prevout == txo) {
-                    return std::optional{*spender};
-                }
-            }
-        } else {
-            LogError("Deserialize or I/O error - %s", spender.error());
-            return util::Unexpected{strprintf("IO error finding spending tx for outpoint %s:%d.", txo.hash.GetHex(), txo.n)};
-        }
-    }
-    return util::Expected<std::optional<TxoSpender>, std::string>(std::nullopt);
-}
-
-BaseIndex::DB& TxoSpenderIndex::GetDB() const { return *m_db; }
diff --git a/src/index/txospenderindex.h b/src/index/txospenderindex.h
deleted file mode 100644
index 35ca30d8b31b..000000000000
--- a/src/index/txospenderindex.h
+++ /dev/null
@@ -1,75 +0,0 @@
-// Copyright (c) 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_INDEX_TXOSPENDERINDEX_H
-#define BITCOIN_INDEX_TXOSPENDERINDEX_H
-
-#include <index/base.h>
-#include <interfaces/chain.h>
-#include <primitives/transaction.h>
-#include <uint256.h>
-#include <util/expected.h>
-
-#include <cstddef>
-#include <cstdint>
-#include <memory>
-#include <optional>
-#include <string>
-#include <utility>
-#include <vector>
-
-struct CDiskTxPos;
-
-static constexpr bool DEFAULT_TXOSPENDERINDEX{false};
-
-struct TxoSpender {
-    CTransactionRef tx;
-    uint256 block_hash;
-};
-
-/**
- * TxoSpenderIndex is used to look up which transaction spent a given output.
- * The index is written to a LevelDB database and, for each input of each transaction in a block,
- * records the outpoint that is spent and the hash of the spending transaction.
- */
-class TxoSpenderIndex final : public BaseIndex
-{
-private:
-    std::unique_ptr<BaseIndex::DB> m_db;
-    std::pair<uint64_t, uint64_t> m_siphash_key;
-    bool AllowPrune() const override { return false; }
-    void WriteSpenderInfos(const std::vector<std::pair<COutPoint, CDiskTxPos>>& items);
-    void EraseSpenderInfos(const std::vector<std::pair<COutPoint, CDiskTxPos>>& items);
-    util::Expected<TxoSpender, std::string> ReadTransaction(const CDiskTxPos& pos) const;
-
-protected:
-    interfaces::Chain::NotifyOptions CustomOptions() override;
-
-    bool CustomAppend(const interfaces::BlockInfo& block) override;
-
-    bool CustomRemove(const interfaces::BlockInfo& block) override;
-
-    BaseIndex::DB& GetDB() const override;
-
-public:
-    explicit TxoSpenderIndex(std::unique_ptr<interfaces::Chain> chain, size_t n_cache_size, bool f_memory = false, bool f_wipe = false);
-
-    /**
-     * Search the index for a transaction that spends the given outpoint.
-     *
-     * @param[in] txo  The outpoint to search for.
-     *
-     * @return  std::nullopt               if the outpoint has not been spent on-chain.
-     *          std::optional{TxoSpender}  if the output has been spent on-chain. Contains the spending transaction
-     *                                     and the block it was confirmed in.
-     *          util::Unexpected{error}    if something unexpected happened (i.e. disk or deserialization error).
-     */
-    util::Expected<std::optional<TxoSpender>, std::string> FindSpender(const COutPoint& txo) const;
-};
-
-/// The global txo spender index. May be null.
-extern std::unique_ptr<TxoSpenderIndex> g_txospenderindex;
-
-
-#endif // BITCOIN_INDEX_TXOSPENDERINDEX_H
diff --git a/src/init.cpp b/src/init.cpp
index 15b8b9516238..d3ebb2c84717 100644
--- a/src/init.cpp
+++ b/src/init.cpp
@@ -11,7 +11,6 @@
 
 #include <addrman.h>
 #include <banman.h>
-#include <blockfilter.h>
 #include <btcsignals.h>
 #include <chain.h>
 #include <chainparams.h>
@@ -25,10 +24,6 @@
 #include <hash.h>
 #include <httprpc.h>
 #include <httpserver.h>
-#include <index/blockfilterindex.h>
-#include <index/coinstatsindex.h>
-#include <index/txindex.h>
-#include <index/txospenderindex.h>
 #include <init/common.h>
 #include <interfaces/chain.h>
 #include <interfaces/init.h>
@@ -281,9 +276,6 @@ void Interrupt(NodeContext& node)
     InterruptMapPort();
     if (node.connman)
         node.connman->Interrupt();
-    for (auto* index : node.indexes) {
-        index->Interrupt();
-    }
 }
 
 void Shutdown(NodeContext& node)
@@ -358,14 +350,6 @@ void Shutdown(NodeContext& node)
     // CValidationInterface callbacks, flush them...
     if (node.validation_signals) node.validation_signals->FlushBackgroundCallbacks();
 
-    // Stop and delete all indexes only after flushing background callbacks.
-    for (auto* index : node.indexes) index->Stop();
-    if (g_txindex) g_txindex.reset();
-    if (g_txospenderindex) g_txospenderindex.reset();
-    if (g_coin_stats_index) g_coin_stats_index.reset();
-    DestroyAllBlockFilterIndexes();
-    node.indexes.clear(); // all instances are nullptr now
-
     // Any future callbacks will be dropped. This should absolutely be safe - if
     // missing a callback results in an unrecoverable situation, unclean shutdown
     // would too. The only reason to do the above flushes is to let the wallet catch
@@ -494,7 +478,6 @@ void SetupServerArgs(ArgsManager& argsman, bool can_listen_ipc)
 #endif
     argsman.AddArg("-blockreconstructionextratxn=<n>", strprintf("Extra transactions to keep in memory for compact block reconstructions (default: %u)", DEFAULT_BLOCK_RECONSTRUCTION_EXTRA_TXN), ArgsManager::ALLOW_ANY, OptionsCategory::OPTIONS);
     argsman.AddArg("-blocksonly", strprintf("Whether to reject transactions from network peers. Disables automatic broadcast and rebroadcast of transactions, unless the source peer has the 'forcerelay' permission. RPC transactions are not affected. (default: %u)", DEFAULT_BLOCKSONLY), ArgsManager::ALLOW_ANY, OptionsCategory::OPTIONS);
-    argsman.AddArg("-coinstatsindex", strprintf("Maintain coinstats index used by the gettxoutsetinfo RPC (default: %u)", DEFAULT_COINSTATSINDEX), ArgsManager::ALLOW_ANY, OptionsCategory::OPTIONS);
     argsman.AddArg("-conf=<file>", strprintf("Specify path to read-only configuration file. Relative paths will be prefixed by datadir location (only useable from command line, not configuration file) (default: %s)", BITCOIN_CONF_FILENAME), ArgsManager::ALLOW_ANY, OptionsCategory::OPTIONS);
     argsman.AddArg("-datadir=<dir>", "Specify data directory", ArgsManager::ALLOW_ANY | ArgsManager::DISALLOW_NEGATION, OptionsCategory::OPTIONS);
     argsman.AddArg("-dbbatchsize", strprintf("Maximum database write batch size in bytes (default: %u)", DEFAULT_DB_CACHE_BATCH), ArgsManager::ALLOW_ANY | ArgsManager::DEBUG_ONLY, OptionsCategory::OPTIONS);
@@ -514,23 +497,16 @@ void SetupServerArgs(ArgsManager& argsman, bool can_listen_ipc)
                              DEFAULT_PERSIST_V1_DAT),
                    ArgsManager::ALLOW_ANY, OptionsCategory::OPTIONS);
     argsman.AddArg("-pid=<file>", strprintf("Specify pid file. Relative paths will be prefixed by a net-specific datadir location. (default: %s)", BITCOIN_PID_FILENAME), ArgsManager::ALLOW_ANY, OptionsCategory::OPTIONS);
-    argsman.AddArg("-prune=<n>", strprintf("Reduce storage requirements by enabling pruning (deleting) of old blocks. This allows the pruneblockchain RPC to be called to delete specific blocks and enables automatic pruning of old blocks if a target size in MiB is provided. This mode is incompatible with -txindex. "
+    argsman.AddArg("-prune=<n>", strprintf("Reduce storage requirements by enabling pruning (deleting) of old blocks. This allows the pruneblockchain RPC to be called to delete specific blocks and enables automatic pruning of old blocks if a target size in MiB is provided. "
             "Warning: Reverting this setting requires re-downloading the entire blockchain. "
             "(default: 0 = disable pruning blocks, 1 = allow manual pruning via RPC, >=%u = automatically prune block files to stay under the specified target size in MiB)", MIN_DISK_SPACE_FOR_BLOCK_FILES / 1_MiB), ArgsManager::ALLOW_ANY, OptionsCategory::OPTIONS);
-    argsman.AddArg("-reindex", "If enabled, wipe chain state and block index, and rebuild them from blk*.dat files on disk. Also wipe and rebuild other optional indexes that are active. If an assumeutxo snapshot was loaded, its chainstate will be wiped as well. The snapshot can then be reloaded via RPC.", ArgsManager::ALLOW_ANY, OptionsCategory::OPTIONS);
+    argsman.AddArg("-reindex", "If enabled, wipe chain state and block index, and rebuild them from blk*.dat files on disk. If an assumeutxo snapshot was loaded, its chainstate will be wiped as well. The snapshot can then be reloaded via RPC.", ArgsManager::ALLOW_ANY, OptionsCategory::OPTIONS);
     argsman.AddArg("-reindex-chainstate", "If enabled, wipe chain state, and rebuild it from blk*.dat files on disk. If an assumeutxo snapshot was loaded, its chainstate will be wiped as well. The snapshot can then be reloaded via RPC.", ArgsManager::ALLOW_ANY, OptionsCategory::OPTIONS);
     argsman.AddArg("-settings=<file>", strprintf("Specify path to dynamic settings data file. Can be disabled with -nosettings. File is written at runtime and not meant to be edited by users (use %s instead for custom settings). Relative paths will be prefixed by datadir location. (default: %s)", BITCOIN_CONF_FILENAME, BITCOIN_SETTINGS_FILENAME), ArgsManager::ALLOW_ANY, OptionsCategory::OPTIONS);
 #if HAVE_SYSTEM
     argsman.AddArg("-startupnotify=<cmd>", "Execute command on startup.", ArgsManager::ALLOW_ANY, OptionsCategory::OPTIONS);
     argsman.AddArg("-shutdownnotify=<cmd>", "Execute command immediately before beginning shutdown. The need for shutdown may be urgent, so be careful not to delay it long (if the command doesn't require interaction with the server, consider having it fork into the background).", ArgsManager::ALLOW_ANY, OptionsCategory::OPTIONS);
 #endif
-    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("-txospenderindex", strprintf("Maintain a transaction output spender index, used by the gettxspendingprevout rpc call (default: %u)", DEFAULT_TXOSPENDERINDEX), 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.",
-                 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);
     argsman.AddArg("-asmap=<file>", strprintf("Specify asn mapping used for bucketing of the peers. Relative paths will be prefixed by the net-specific datadir location.%s",
                 #ifdef ENABLE_EMBEDDED_ASMAP
@@ -565,7 +541,6 @@ void SetupServerArgs(ArgsManager& argsman, bool can_listen_ipc)
     argsman.AddArg("-onlynet=<net>", "Make automatic outbound connections only to network <net> (" + Join(GetNetworkNames(), ", ") + "). Inbound and manual connections are not affected by this option. It can be specified multiple times to allow multiple networks.", ArgsManager::ALLOW_ANY, OptionsCategory::CONNECTION);
     argsman.AddArg("-v2transport", strprintf("Support v2 transport (default: %u)", DEFAULT_V2_TRANSPORT), ArgsManager::ALLOW_ANY, OptionsCategory::CONNECTION);
     argsman.AddArg("-peerbloomfilters", strprintf("Support filtering of blocks and transaction with bloom filters (default: %u)", DEFAULT_PEERBLOOMFILTERS), ArgsManager::ALLOW_ANY, OptionsCategory::CONNECTION);
-    argsman.AddArg("-peerblockfilters", strprintf("Serve compact block filters to peers per BIP 157 (default: %u)", DEFAULT_PEERBLOCKFILTERS), ArgsManager::ALLOW_ANY, OptionsCategory::CONNECTION);
     argsman.AddArg("-txreconciliation", strprintf("Enable transaction reconciliations per BIP 330 (default: %d)", DEFAULT_TXRECONCILIATION_ENABLE), ArgsManager::ALLOW_ANY | ArgsManager::DEBUG_ONLY, OptionsCategory::CONNECTION);
     argsman.AddArg("-port=<port>", strprintf("Listen for connections on <port> (default: %u, testnet3: %u, testnet4: %u, signet: %u, regtest: %u). Not relevant for I2P (see doc/i2p.md). If set to a value x, the default onion listening port will be set to x+1.", defaultChainParams->GetDefaultPort(), testnetChainParams->GetDefaultPort(), testnet4ChainParams->GetDefaultPort(), signetChainParams->GetDefaultPort(), regtestChainParams->GetDefaultPort()), ArgsManager::ALLOW_ANY | ArgsManager::NETWORK_ONLY, OptionsCategory::CONNECTION);
     const std::string proxy_doc_for_value =
@@ -855,7 +830,6 @@ int nMaxConnections;
 int available_fds;
 ServiceFlags g_local_services = ServiceFlags(NODE_NETWORK_LIMITED | NODE_WITNESS);
 int64_t peer_connect_timeout;
-std::set<BlockFilterType> g_enabled_filter_types;
 
 } // namespace
 
@@ -962,40 +936,12 @@ bool AppInitParameterInteraction(const ArgsManager& args)
         return InitError(strprintf(_("Specified blocks directory \"%s\" does not exist."), args.GetArg("-blocksdir", "")));
     }
 
-    // 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();
-    } else if (blockfilterindex_value != "0") {
-        const std::vector<std::string> names = args.GetArgs("-blockfilterindex");
-        for (const auto& name : names) {
-            BlockFilterType filter_type;
-            if (!BlockFilterTypeByName(name, filter_type)) {
-                return InitError(strprintf(_("Unknown -blockfilterindex value %s."), name));
-            }
-            g_enabled_filter_types.insert(filter_type);
-        }
-    }
-
     // Signal NODE_P2P_V2 if BIP324 v2 transport is enabled.
     if (args.GetBoolArg("-v2transport", DEFAULT_V2_TRANSPORT)) {
         g_local_services = ServiceFlags(g_local_services | NODE_P2P_V2);
     }
 
-    // Signal NODE_COMPACT_FILTERS if peerblockfilters and basic filters index are both enabled.
-    if (args.GetBoolArg("-peerblockfilters", DEFAULT_PEERBLOCKFILTERS)) {
-        if (!g_enabled_filter_types.contains(BlockFilterType::BASIC)) {
-            return InitError(_("Cannot set -peerblockfilters without -blockfilterindex."));
-        }
-
-        g_local_services = ServiceFlags(g_local_services | NODE_COMPACT_FILTERS);
-    }
-
     if (args.GetIntArg("-prune", 0)) {
-        if (args.GetBoolArg("-txindex", DEFAULT_TXINDEX))
-            return InitError(_("Prune mode is incompatible with -txindex."));
-        if (args.GetBoolArg("-txospenderindex", DEFAULT_TXOSPENDERINDEX))
-            return InitError(_("Prune mode is incompatible with -txospenderindex."));
         if (args.GetBoolArg("-reindex-chainstate", false)) {
             return InitError(_("Prune mode is incompatible with -reindex-chainstate. Use full -reindex instead."));
         }
@@ -1352,25 +1298,11 @@ static ChainstateLoadResult InitAndLoadChainstate(
     ChainstateManager& chainman = *node.chainman;
     if (chainman.m_interrupt) return {ChainstateLoadStatus::INTERRUPTED, {}};
 
-    // This is defined and set here instead of inline in validation.h to avoid a hard
-    // dependency between validation and index/base, since the latter is not in
-    // libbitcoinkernel.
     chainman.snapshot_download_completed = [&node]() {
         if (!node.chainman->m_blockman.IsPruneMode()) {
             LogInfo("[snapshot] re-enabling NODE_NETWORK services");
             node.connman->AddLocalServices(NODE_NETWORK);
         }
-        LogInfo("[snapshot] restarting indexes");
-        // Drain the validation interface queue to ensure that the old indexes
-        // don't have any pending work.
-        Assert(node.validation_signals)->SyncWithValidationInterfaceQueue();
-        for (auto* index : node.indexes) {
-            index->Interrupt();
-            index->Stop();
-            if (!(index->Init() && index->StartBackgroundSync())) {
-                LogWarning("[snapshot] Failed to restart index %s on snapshot chain", index->GetName());
-            }
-        }
     };
     node::ChainstateLoadOptions options;
     options.mempool = Assert(node.mempool.get());
@@ -1802,20 +1734,11 @@ bool AppInitMain(NodeContext& node, interfaces::BlockAndHeaderTipInfo* tip_info)
 
     // cache size calculations
     node::LogOversizedDbCache(args);
-    const auto [index_cache_sizes, kernel_cache_sizes] = CalculateCacheSizes(args, g_enabled_filter_types.size());
+    const auto cache_sizes = CalculateCacheSizes(args);
+    const auto& kernel_cache_sizes = cache_sizes.kernel;
 
     LogInfo("Cache configuration:");
     LogInfo("* Using %.1f MiB for block index database", kernel_cache_sizes.block_tree_db / double(1_MiB));
-    if (args.GetBoolArg("-txindex", DEFAULT_TXINDEX)) {
-        LogInfo("* Using %.1f MiB for transaction index database", index_cache_sizes.tx_index / double(1_MiB));
-    }
-    if (args.GetBoolArg("-txospenderindex", DEFAULT_TXOSPENDERINDEX)) {
-        LogInfo("* Using %.1f MiB for transaction output spender index database", index_cache_sizes.txospender_index / double(1_MiB));
-    }
-    for (BlockFilterType filter_type : g_enabled_filter_types) {
-        LogInfo("* Using %.1f MiB for %s block filter index database",
-                  index_cache_sizes.filter_index / double(1_MiB), BlockFilterTypeName(filter_type));
-    }
     LogInfo("* Using %.1f MiB for chain state database", kernel_cache_sizes.coins_db / double(1_MiB));
 
     assert(!node.mempool);
@@ -1873,31 +1796,6 @@ bool AppInitMain(NodeContext& node, interfaces::BlockAndHeaderTipInfo* tip_info)
                                      peerman_opts);
     validation_signals.RegisterValidationInterface(node.peerman.get());
 
-    // ********************************************************* Step 8: start indexers
-
-    if (args.GetBoolArg("-txindex", DEFAULT_TXINDEX)) {
-        g_txindex = std::make_unique<TxIndex>(interfaces::MakeChain(node), index_cache_sizes.tx_index, false, do_reindex);
-        node.indexes.emplace_back(g_txindex.get());
-    }
-
-    if (args.GetBoolArg("-txospenderindex", DEFAULT_TXOSPENDERINDEX)) {
-        g_txospenderindex = std::make_unique<TxoSpenderIndex>(interfaces::MakeChain(node), index_cache_sizes.txospender_index, false, do_reindex);
-        node.indexes.emplace_back(g_txospenderindex.get());
-    }
-
-    for (const auto& filter_type : g_enabled_filter_types) {
-        InitBlockFilterIndex([&]{ return interfaces::MakeChain(node); }, filter_type, index_cache_sizes.filter_index, false, do_reindex);
-        node.indexes.emplace_back(GetBlockFilterIndex(filter_type));
-    }
-
-    if (args.GetBoolArg("-coinstatsindex", DEFAULT_COINSTATSINDEX)) {
-        g_coin_stats_index = std::make_unique<CoinStatsIndex>(interfaces::MakeChain(node), /*cache_size=*/0, false, do_reindex);
-        node.indexes.emplace_back(g_coin_stats_index.get());
-    }
-
-    // Init indexes
-    for (auto index : node.indexes) if (!index->Init()) return false;
-
     // ********************************************************* Step 10: data directory maintenance
 
     // if pruning, perform the initial blockstore prune
@@ -2003,12 +1901,6 @@ bool AppInitMain(NodeContext& node, interfaces::BlockAndHeaderTipInfo* tip_info)
             return;
         }
 
-        // Start indexes initial sync
-        if (!StartIndexBackgroundSync(node)) {
-            bilingual_str err_str = _("Failed to start indexes, shutting down…");
-            chainman.GetNotifications().fatalError(err_str);
-            return;
-        }
         // Load mempool from disk
         if (auto* pool{chainman.ActiveChainstate().GetMempool()}) {
             LoadMempool(*pool, ShouldPersistMempool(args) ? MempoolPath(args) : fs::path{}, chainman.ActiveChainstate(), {});
@@ -2293,80 +2185,3 @@ bool AppInitMain(NodeContext& node, interfaces::BlockAndHeaderTipInfo* tip_info)
 
     return true;
 }
-
-bool StartIndexBackgroundSync(NodeContext& node)
-{
-    ChainstateManager& chainman = *Assert(node.chainman);
-    const Chainstate& chainstate = WITH_LOCK(::cs_main, return chainman.ValidatedChainstate());
-    const CChain& index_chain = chainstate.m_chain;
-    const int current_height = WITH_LOCK(::cs_main, return index_chain.Height());
-
-    // Skip checking data availability if we have not synced any blocks yet
-    if (current_height > 0) {
-        // Before starting index sync, verify that all required block data is available
-        // on disk from each index's current sync position up to the chain tip.
-        //
-        // This is done separately for undo and block data: First we verify block + undo
-        // data existence from tip down to the lowest height required by any index that
-        // needs undo data (e.g., coinstatsindex, blockfilterindex). Then, if any
-        // block-only index needs to sync from a lower height than previously covered,
-        // verify block data existence down to that lower height.
-        //
-        // This avoids checking undo data for blocks where no index requires it,
-        // though currently block and undo data availability are synchronized on disk
-        // under normal circumstances.
-        std::optional<const CBlockIndex*> block_start;
-        std::string block_start_name;
-        std::optional<const CBlockIndex*> undo_start;
-        std::string undo_start_name;
-
-        for (const auto& index : node.indexes) {
-            const IndexSummary& summary = index->GetSummary();
-            if (summary.synced) continue;
-
-            // Get the last common block between the index best block and the active chain
-            const CBlockIndex* pindex = nullptr;
-            {
-                LOCK(::cs_main);
-                pindex = chainman.m_blockman.LookupBlockIndex(summary.best_block_hash);
-                if (!pindex) {
-                    LogWarning("Failed to find block manager entry for best block %s from %s, falling back to genesis for index sync",
-                        summary.best_block_hash.ToString(), summary.name);
-                } else if (!index_chain.Contains(*pindex)) {
-                    pindex = index_chain.FindFork(*pindex);
-                }
-            }
-            if (!pindex) {
-                pindex = index_chain.Genesis();
-            }
-
-            bool need_undo = index->CustomOptions().connect_undo_data;
-            auto& op_start_index = need_undo ? undo_start : block_start;
-            auto& name_index = need_undo ? undo_start_name : block_start_name;
-
-            if (op_start_index && pindex->nHeight >= op_start_index.value()->nHeight) continue;
-            op_start_index = pindex;
-            name_index = summary.name;
-        }
-
-        // Verify all blocks needed to sync to current tip are present including undo data.
-        if (undo_start) {
-            LOCK(::cs_main);
-            if (!chainman.m_blockman.CheckBlockDataAvailability(*index_chain.Tip(), *Assert(undo_start.value()), BlockStatus{BLOCK_HAVE_DATA | BLOCK_HAVE_UNDO})) {
-                return InitError(Untranslated(strprintf("%s best block of the index goes beyond pruned data (including undo data). Please disable the index or reindex (which will download the whole blockchain again)", undo_start_name)));
-            }
-        }
-
-        // Verify all blocks needed to sync to current tip are present unless we already checked all of them above.
-        if (block_start && !(undo_start && undo_start.value()->nHeight <= block_start.value()->nHeight)) {
-            LOCK(::cs_main);
-            if (!chainman.m_blockman.CheckBlockDataAvailability(*index_chain.Tip(), *Assert(block_start.value()), BlockStatus{BLOCK_HAVE_DATA})) {
-                return InitError(Untranslated(strprintf("%s best block of the index goes beyond pruned data. Please disable the index or reindex (which will download the whole blockchain again)", block_start_name)));
-            }
-        }
-    }
-
-    // Start threads
-    for (auto index : node.indexes) if (!index->StartBackgroundSync()) return false;
-    return true;
-}
diff --git a/src/init.h b/src/init.h
index f3a55da35eee..f16386d89026 100644
--- a/src/init.h
+++ b/src/init.h
@@ -76,7 +76,4 @@ bool AppInitMain(node::NodeContext& node, interfaces::BlockAndHeaderTipInfo* tip
  */
 void SetupServerArgs(ArgsManager& argsman, bool can_listen_ipc=false);
 
-/** Validates requirements to run the indexes and spawns each index initial sync thread */
-bool StartIndexBackgroundSync(node::NodeContext& node);
-
 #endif // BITCOIN_INIT_H
diff --git a/src/interfaces/chain.h b/src/interfaces/chain.h
index 7c725e24a5d1..b04f11890689 100644
--- a/src/interfaces/chain.h
+++ b/src/interfaces/chain.h
@@ -5,7 +5,6 @@
 #ifndef BITCOIN_INTERFACES_CHAIN_H
 #define BITCOIN_INTERFACES_CHAIN_H
 
-#include <blockfilter.h>
 #include <common/settings.h>
 #include <kernel/chain.h> // IWYU pragma: export
 #include <node/types.h>
@@ -135,13 +134,6 @@ class Chain
     //! or one of its ancestors.
     virtual std::optional<int> findLocatorFork(const CBlockLocator& locator) = 0;
 
-    //! Returns whether a block filter index is available.
-    virtual bool hasBlockFilterIndex(BlockFilterType filter_type) = 0;
-
-    //! Returns whether any of the elements match the block via a BIP 157 block filter
-    //! or std::nullopt if the block filter for this block couldn't be found.
-    virtual std::optional<bool> blockFilterMatchesAny(BlockFilterType filter_type, const uint256& block_hash, const GCSFilter::ElementSet& filter_set) = 0;
-
     //! Return whether node has the block and optionally return block metadata
     //! or contents.
     virtual bool findBlock(const uint256& hash, const FoundBlock& block={}) = 0;
diff --git a/src/kernel/coinstats.h b/src/kernel/coinstats.h
index 92ace06ba5d2..51e069b441a4 100644
--- a/src/kernel/coinstats.h
+++ b/src/kernel/coinstats.h
@@ -5,7 +5,6 @@
 #ifndef BITCOIN_KERNEL_COINSTATS_H
 #define BITCOIN_KERNEL_COINSTATS_H
 
-#include <arith_uint256.h>
 #include <consensus/amount.h>
 #include <uint256.h>
 
@@ -43,31 +42,6 @@ struct CCoinsStats {
     //! The number of coins contained.
     uint64_t coins_count{0};
 
-    //! Signals if the coinstatsindex was used to retrieve the statistics.
-    bool index_used{false};
-
-    // Following values are only available from coinstats index
-
-    //! Total cumulative amount of block subsidies up to and including this block
-    CAmount total_subsidy{0};
-    //! The unspendable coinbase amount from the genesis block
-    CAmount total_unspendables_genesis_block{0};
-    //! The two unspendable coinbase outputs total amount caused by BIP30
-    CAmount total_unspendables_bip30{0};
-    //! Total cumulative amount of outputs sent to unspendable scripts (OP_RETURN for example) up to and including this block
-    CAmount total_unspendables_scripts{0};
-    //! Total cumulative amount of coins lost due to unclaimed miner rewards up to and including this block
-    CAmount total_unspendables_unclaimed_rewards{0};
-
-    // Despite containing amounts the following values use a uint256 type to prevent overflowing
-
-    //! Total cumulative amount of prevouts spent up to and including this block
-    arith_uint256 total_prevout_spent_amount{0};
-    //! Total cumulative amount of outputs created up to and including this block
-    arith_uint256 total_new_outputs_ex_coinbase_amount{0};
-    //! Total cumulative amount of coinbase outputs up to and including this block
-    arith_uint256 total_coinbase_amount{0};
-
     CCoinsStats() = default;
     CCoinsStats(int block_height, const uint256& block_hash);
 };
diff --git a/src/net.cpp b/src/net.cpp
index f8149ef309d1..1e610f984029 100644
--- a/src/net.cpp
+++ b/src/net.cpp
@@ -940,12 +940,12 @@ const std::array<std::string, 33> V2_MESSAGE_IDS = {
     NetMsgType::PONG,
     NetMsgType::SENDCMPCT,
     NetMsgType::TX,
-    NetMsgType::GETCFILTERS,
-    NetMsgType::CFILTER,
-    NetMsgType::GETCFHEADERS,
-    NetMsgType::CFHEADERS,
-    NetMsgType::GETCFCHECKPT,
-    NetMsgType::CFCHECKPT,
+    "", // formerly NetMsgType::GETCFILTERS
+    "", // formerly NetMsgType::CFILTER
+    "", // formerly NetMsgType::GETCFHEADERS
+    "", // formerly NetMsgType::CFHEADERS
+    "", // formerly NetMsgType::GETCFCHECKPT
+    "", // formerly NetMsgType::CFCHECKPT
     NetMsgType::ADDRV2,
     // Unimplemented message types that are assigned in BIP324:
     "",
diff --git a/src/net_processing.cpp b/src/net_processing.cpp
index 631e968da7f0..a972af790bbf 100644
--- a/src/net_processing.cpp
+++ b/src/net_processing.cpp
@@ -9,7 +9,6 @@
 #include <arith_uint256.h>
 #include <banman.h>
 #include <blockencodings.h>
-#include <blockfilter.h>
 #include <chain.h>
 #include <chainparams.h>
 #include <common/bloom.h>
@@ -21,7 +20,6 @@
 #include <deploymentstatus.h>
 #include <flatfile.h>
 #include <headerssync.h>
-#include <index/blockfilterindex.h>
 #include <kernel/types.h>
 #include <logging.h>
 #include <merkleblock.h>
@@ -180,10 +178,6 @@ static_assert(INVENTORY_BROADCAST_MAX <= node::MAX_PEER_TX_ANNOUNCEMENTS, "INVEN
 static constexpr auto AVG_FEEFILTER_BROADCAST_INTERVAL{10min};
 /** Maximum feefilter broadcast delay after significant change. */
 static constexpr auto MAX_FEEFILTER_CHANGE_DELAY{5min};
-/** Maximum number of compact filters that may be requested with one getcfilters. See BIP 157. */
-static constexpr uint32_t MAX_GETCFILTERS_SIZE = 1000;
-/** Maximum number of cf hashes that may be requested with one getcfheaders. See BIP 157. */
-static constexpr uint32_t MAX_GETCFHEADERS_SIZE = 2000;
 /** the maximum percentage of addresses from our addrman to return in response to a getaddr message. */
 static constexpr size_t MAX_PCT_ADDR_TO_SEND = 23;
 /** The maximum number of address records permitted in an ADDR message. */
@@ -1019,60 +1013,6 @@ class PeerManagerImpl final : public PeerManager
     void ProcessGetBlockData(CNode& pfrom, Peer& peer, const CInv& inv)
         EXCLUSIVE_LOCKS_REQUIRED(g_msgproc_mutex, !m_most_recent_block_mutex);
 
-    /**
-     * Validation logic for compact filters request handling.
-     *
-     * May disconnect from the peer in the case of a bad request.
-     *
-     * @param[in]   node            The node that we received the request from
-     * @param[in]   peer            The peer that we received the request from
-     * @param[in]   filter_type     The filter type the request is for. Must be basic filters.
-     * @param[in]   start_height    The start height for the request
-     * @param[in]   stop_hash       The stop_hash for the request
-     * @param[in]   max_height_diff The maximum number of items permitted to request, as specified in BIP 157
-     * @param[out]  stop_index      The CBlockIndex for the stop_hash block, if the request can be serviced.
-     * @param[out]  filter_index    The filter index, if the request can be serviced.
-     * @return                      True if the request can be serviced.
-     */
-    bool PrepareBlockFilterRequest(CNode& node, Peer& peer,
-                                   BlockFilterType filter_type, uint32_t start_height,
-                                   const uint256& stop_hash, uint32_t max_height_diff,
-                                   const CBlockIndex*& stop_index,
-                                   BlockFilterIndex*& filter_index);
-
-    /**
-     * Handle a cfilters request.
-     *
-     * May disconnect from the peer in the case of a bad request.
-     *
-     * @param[in]   node            The node that we received the request from
-     * @param[in]   peer            The peer that we received the request from
-     * @param[in]   vRecv           The raw message received
-     */
-    void ProcessGetCFilters(CNode& node, Peer& peer, DataStream& vRecv);
-
-    /**
-     * Handle a cfheaders request.
-     *
-     * May disconnect from the peer in the case of a bad request.
-     *
-     * @param[in]   node            The node that we received the request from
-     * @param[in]   peer            The peer that we received the request from
-     * @param[in]   vRecv           The raw message received
-     */
-    void ProcessGetCFHeaders(CNode& node, Peer& peer, DataStream& vRecv);
-
-    /**
-     * Handle a getcfcheckpt request.
-     *
-     * May disconnect from the peer in the case of a bad request.
-     *
-     * @param[in]   node            The node that we received the request from
-     * @param[in]   peer            The peer that we received the request from
-     * @param[in]   vRecv           The raw message received
-     */
-    void ProcessGetCFCheckPt(CNode& node, Peer& peer, DataStream& vRecv);
-
     void ProcessPong(CNode& pfrom, Peer& peer, NodeClock::time_point ping_end, DataStream& vRecv);
 
     /** Checks if address relay is permitted with peer. If needed, initializes
@@ -3261,168 +3201,6 @@ bool PeerManagerImpl::ProcessOrphanTx(Peer& peer)
     return false;
 }
 
-bool PeerManagerImpl::PrepareBlockFilterRequest(CNode& node, Peer& peer,
-                                                BlockFilterType filter_type, uint32_t start_height,
-                                                const uint256& stop_hash, uint32_t max_height_diff,
-                                                const CBlockIndex*& stop_index,
-                                                BlockFilterIndex*& filter_index)
-{
-    const bool supported_filter_type =
-        (filter_type == BlockFilterType::BASIC &&
-         (peer.m_our_services & NODE_COMPACT_FILTERS));
-    if (!supported_filter_type) {
-        LogDebug(BCLog::NET, "peer requested unsupported block filter type: %d, %s",
-                 static_cast<uint8_t>(filter_type), node.DisconnectMsg());
-        node.fDisconnect = true;
-        return false;
-    }
-
-    {
-        LOCK(cs_main);
-        stop_index = m_chainman.m_blockman.LookupBlockIndex(stop_hash);
-
-        // Check that the stop block exists and the peer would be allowed to fetch it.
-        if (!stop_index || !BlockRequestAllowed(*stop_index)) {
-            LogDebug(BCLog::NET, "peer requested invalid block hash: %s, %s",
-                     stop_hash.ToString(), node.DisconnectMsg());
-            node.fDisconnect = true;
-            return false;
-        }
-    }
-
-    uint32_t stop_height = stop_index->nHeight;
-    if (start_height > stop_height) {
-        LogDebug(BCLog::NET, "peer sent invalid getcfilters/getcfheaders with "
-                 "start height %d and stop height %d, %s",
-                 start_height, stop_height, node.DisconnectMsg());
-        node.fDisconnect = true;
-        return false;
-    }
-    if (stop_height - start_height >= max_height_diff) {
-        LogDebug(BCLog::NET, "peer requested too many cfilters/cfheaders: %d / %d, %s",
-                 stop_height - start_height + 1, max_height_diff, node.DisconnectMsg());
-        node.fDisconnect = true;
-        return false;
-    }
-
-    filter_index = GetBlockFilterIndex(filter_type);
-    if (!filter_index) {
-        LogDebug(BCLog::NET, "Filter index for supported type %s not found\n", BlockFilterTypeName(filter_type));
-        return false;
-    }
-
-    return true;
-}
-
-void PeerManagerImpl::ProcessGetCFilters(CNode& node, Peer& peer, DataStream& vRecv)
-{
-    uint8_t filter_type_ser;
-    uint32_t start_height;
-    uint256 stop_hash;
-
-    vRecv >> filter_type_ser >> start_height >> stop_hash;
-
-    const BlockFilterType filter_type = static_cast<BlockFilterType>(filter_type_ser);
-
-    const CBlockIndex* stop_index;
-    BlockFilterIndex* filter_index;
-    if (!PrepareBlockFilterRequest(node, peer, filter_type, start_height, stop_hash,
-                                   MAX_GETCFILTERS_SIZE, stop_index, filter_index)) {
-        return;
-    }
-
-    std::vector<BlockFilter> filters;
-    if (!filter_index->LookupFilterRange(start_height, stop_index, filters)) {
-        LogDebug(BCLog::NET, "Failed to find block filter in index: filter_type=%s, start_height=%d, stop_hash=%s\n",
-                     BlockFilterTypeName(filter_type), start_height, stop_hash.ToString());
-        return;
-    }
-
-    for (const auto& filter : filters) {
-        MakeAndPushMessage(node, NetMsgType::CFILTER, filter);
-    }
-}
-
-void PeerManagerImpl::ProcessGetCFHeaders(CNode& node, Peer& peer, DataStream& vRecv)
-{
-    uint8_t filter_type_ser;
-    uint32_t start_height;
-    uint256 stop_hash;
-
-    vRecv >> filter_type_ser >> start_height >> stop_hash;
-
-    const BlockFilterType filter_type = static_cast<BlockFilterType>(filter_type_ser);
-
-    const CBlockIndex* stop_index;
-    BlockFilterIndex* filter_index;
-    if (!PrepareBlockFilterRequest(node, peer, filter_type, start_height, stop_hash,
-                                   MAX_GETCFHEADERS_SIZE, stop_index, filter_index)) {
-        return;
-    }
-
-    uint256 prev_header;
-    if (start_height > 0) {
-        const CBlockIndex* const prev_block =
-            stop_index->GetAncestor(static_cast<int>(start_height - 1));
-        if (!filter_index->LookupFilterHeader(prev_block, prev_header)) {
-            LogDebug(BCLog::NET, "Failed to find block filter header in index: filter_type=%s, block_hash=%s\n",
-                         BlockFilterTypeName(filter_type), prev_block->GetBlockHash().ToString());
-            return;
-        }
-    }
-
-    std::vector<uint256> filter_hashes;
-    if (!filter_index->LookupFilterHashRange(start_height, stop_index, filter_hashes)) {
-        LogDebug(BCLog::NET, "Failed to find block filter hashes in index: filter_type=%s, start_height=%d, stop_hash=%s\n",
-                     BlockFilterTypeName(filter_type), start_height, stop_hash.ToString());
-        return;
-    }
-
-    MakeAndPushMessage(node, NetMsgType::CFHEADERS,
-              filter_type_ser,
-              stop_index->GetBlockHash(),
-              prev_header,
-              filter_hashes);
-}
-
-void PeerManagerImpl::ProcessGetCFCheckPt(CNode& node, Peer& peer, DataStream& vRecv)
-{
-    uint8_t filter_type_ser;
-    uint256 stop_hash;
-
-    vRecv >> filter_type_ser >> stop_hash;
-
-    const BlockFilterType filter_type = static_cast<BlockFilterType>(filter_type_ser);
-
-    const CBlockIndex* stop_index;
-    BlockFilterIndex* filter_index;
-    if (!PrepareBlockFilterRequest(node, peer, filter_type, /*start_height=*/0, stop_hash,
-                                   /*max_height_diff=*/std::numeric_limits<uint32_t>::max(),
-                                   stop_index, filter_index)) {
-        return;
-    }
-
-    std::vector<uint256> headers(stop_index->nHeight / CFCHECKPT_INTERVAL);
-
-    // Populate headers.
-    const CBlockIndex* block_index = stop_index;
-    for (int i = headers.size() - 1; i >= 0; i--) {
-        int height = (i + 1) * CFCHECKPT_INTERVAL;
-        block_index = block_index->GetAncestor(height);
-
-        if (!filter_index->LookupFilterHeader(block_index, headers[i])) {
-            LogDebug(BCLog::NET, "Failed to find block filter header in index: filter_type=%s, block_hash=%s\n",
-                         BlockFilterTypeName(filter_type), block_index->GetBlockHash().ToString());
-            return;
-        }
-    }
-
-    MakeAndPushMessage(node, NetMsgType::CFCHECKPT,
-              filter_type_ser,
-              stop_index->GetBlockHash(),
-              headers);
-}
-
 void PeerManagerImpl::ProcessBlock(CNode& node, const std::shared_ptr<const CBlock>& block, bool force_processing, bool min_pow_checked)
 {
     bool new_block{false};
@@ -4990,21 +4768,6 @@ void PeerManagerImpl::ProcessMessage(Peer& peer, CNode& pfrom, const std::string
         return;
     }
 
-    if (msg_type == NetMsgType::GETCFILTERS) {
-        ProcessGetCFilters(pfrom, peer, vRecv);
-        return;
-    }
-
-    if (msg_type == NetMsgType::GETCFHEADERS) {
-        ProcessGetCFHeaders(pfrom, peer, vRecv);
-        return;
-    }
-
-    if (msg_type == NetMsgType::GETCFCHECKPT) {
-        ProcessGetCFCheckPt(pfrom, peer, vRecv);
-        return;
-    }
-
     if (msg_type == NetMsgType::NOTFOUND) {
         std::vector<CInv> vInv;
         vRecv >> vInv;
diff --git a/src/net_processing.h b/src/net_processing.h
index 4ae48f84e4b9..08c929075ba0 100644
--- a/src/net_processing.h
+++ b/src/net_processing.h
@@ -42,7 +42,6 @@ static constexpr bool DEFAULT_TXRECONCILIATION_ENABLE{false};
     orphan, replaced, and rejected transactions. */
 static const uint32_t DEFAULT_BLOCK_RECONSTRUCTION_EXTRA_TXN{100};
 static const bool DEFAULT_PEERBLOOMFILTERS = false;
-static const bool DEFAULT_PEERBLOCKFILTERS = false;
 /** Maximum number of outstanding CMPCTBLOCK requests for the same block. */
 static const unsigned int MAX_CMPCTBLOCKS_INFLIGHT_PER_BLOCK = 3;
 /** Number of headers sent in one getheaders result. We rely on the assumption that if a peer sends
diff --git a/src/node/caches.cpp b/src/node/caches.cpp
index 3250c51a8c20..397f56fc8e77 100644
--- a/src/node/caches.cpp
+++ b/src/node/caches.cpp
@@ -6,25 +6,16 @@
 
 #include <common/args.h>
 #include <common/system.h>
-#include <index/txindex.h>
-#include <index/txospenderindex.h>
 #include <kernel/caches.h>
 #include <logging.h>
 #include <node/interface_ui.h>
 #include <tinyformat.h>
 #include <util/byte_units.h>
+#include <util/translation.h>
 
 #include <algorithm>
 #include <string>
 
-// Unlike for the UTXO database, for the txindex scenario the leveldb cache make
-// a meaningful difference: https://github.com/bitcoin/bitcoin/pull/8273#issuecomment-229601991
-//! Max memory allocated to tx index DB specific cache in bytes.
-static constexpr size_t MAX_TX_INDEX_CACHE{1_GiB};
-//! Max memory allocated to all block filter index caches combined in bytes.
-static constexpr size_t MAX_FILTER_INDEX_CACHE{1_GiB};
-//! Max memory allocated to tx spenderindex DB specific cache in bytes.
-static constexpr size_t MAX_TXOSPENDER_INDEX_CACHE{1_GiB};
 //! Maximum dbcache size on 32-bit systems.
 static constexpr size_t MAX_32BIT_DBCACHE{1_GiB};
 //! Larger default dbcache on 64-bit systems with enough RAM.
@@ -54,21 +45,10 @@ size_t CalculateDbCacheBytes(const ArgsManager& args)
     return GetDefaultDBCache();
 }
 
-CacheSizes CalculateCacheSizes(const ArgsManager& args, size_t n_indexes)
+CacheSizes CalculateCacheSizes(const ArgsManager& args)
 {
     size_t total_cache{CalculateDbCacheBytes(args)};
-
-    IndexCacheSizes index_sizes;
-    index_sizes.tx_index = std::min(total_cache / 8, args.GetBoolArg("-txindex", DEFAULT_TXINDEX) ? MAX_TX_INDEX_CACHE : 0);
-    total_cache -= index_sizes.tx_index;
-    index_sizes.txospender_index = std::min(total_cache / 8, args.GetBoolArg("-txospenderindex", DEFAULT_TXOSPENDERINDEX) ? MAX_TXOSPENDER_INDEX_CACHE : 0);
-    total_cache -= index_sizes.txospender_index;
-    if (n_indexes > 0) {
-        size_t max_cache = std::min(total_cache / 8, MAX_FILTER_INDEX_CACHE);
-        index_sizes.filter_index = max_cache / n_indexes;
-        total_cache -= index_sizes.filter_index * n_indexes;
-    }
-    return {index_sizes, kernel::CacheSizes{total_cache}};
+    return {kernel::CacheSizes{total_cache}};
 }
 
 void LogOversizedDbCache(const ArgsManager& args) noexcept
diff --git a/src/node/caches.h b/src/node/caches.h
index f4143bed44f1..90baa9e1ca97 100644
--- a/src/node/caches.h
+++ b/src/node/caches.h
@@ -19,16 +19,10 @@ static constexpr size_t DEFAULT_DB_CACHE{DEFAULT_KERNEL_CACHE};
 
 namespace node {
 size_t GetDefaultDBCache();
-struct IndexCacheSizes {
-    size_t tx_index{0};
-    size_t filter_index{0};
-    size_t txospender_index{0};
-};
 struct CacheSizes {
-    IndexCacheSizes index;
     kernel::CacheSizes kernel;
 };
-CacheSizes CalculateCacheSizes(const ArgsManager& args, size_t n_indexes = 0);
+CacheSizes CalculateCacheSizes(const ArgsManager& args);
 constexpr bool ShouldWarnOversizedDbCache(uint64_t dbcache, uint64_t total_ram) noexcept
 {
     const uint64_t cap{(total_ram < 2_GiB) ? DEFAULT_DB_CACHE : (total_ram / 100) * 75};
diff --git a/src/node/context.h b/src/node/context.h
index 7cd9e4a74876..36e0b05e291d 100644
--- a/src/node/context.h
+++ b/src/node/context.h
@@ -15,7 +15,6 @@
 class ArgsManager;
 class AddrMan;
 class BanMan;
-class BaseIndex;
 class CBlockPolicyEstimator;
 class CConnman;
 class ValidationSignals;
@@ -72,7 +71,6 @@ struct NodeContext {
     std::unique_ptr<ChainstateManager> chainman;
     std::unique_ptr<BanMan> banman;
     ArgsManager* args{nullptr}; // Currently a raw pointer because the memory is not managed by this struct
-    std::vector<BaseIndex*> indexes; // raw pointers because memory is not managed by this struct
     std::unique_ptr<interfaces::Chain> chain;
     std::unique_ptr<interfaces::Mining> mining;
     std::unique_ptr<CScheduler> scheduler;
diff --git a/src/node/interfaces.cpp b/src/node/interfaces.cpp
index 11a714ecdca1..347147f37a68 100644
--- a/src/node/interfaces.cpp
+++ b/src/node/interfaces.cpp
@@ -4,7 +4,6 @@
 
 #include <addrdb.h>
 #include <banman.h>
-#include <blockfilter.h>
 #include <btcsignals.h>
 #include <chain.h>
 #include <chainparams.h>
@@ -13,7 +12,6 @@
 #include <consensus/validation.h>
 #include <deploymentstatus.h>
 #include <httprpc.h>
-#include <index/blockfilterindex.h>
 #include <init.h>
 #include <interfaces/chain.h>
 #include <interfaces/handler.h>
@@ -515,20 +513,6 @@ class ChainImpl : public Chain
         }
         return std::nullopt;
     }
-    bool hasBlockFilterIndex(BlockFilterType filter_type) override
-    {
-        return GetBlockFilterIndex(filter_type) != nullptr;
-    }
-    std::optional<bool> blockFilterMatchesAny(BlockFilterType filter_type, const uint256& block_hash, const GCSFilter::ElementSet& filter_set) override
-    {
-        const BlockFilterIndex* block_filter_index{GetBlockFilterIndex(filter_type)};
-        if (!block_filter_index) return std::nullopt;
-
-        BlockFilter filter;
-        const CBlockIndex* index{WITH_LOCK(::cs_main, return chainman().m_blockman.LookupBlockIndex(block_hash))};
-        if (index == nullptr || !block_filter_index->LookupFilter(index, filter)) return std::nullopt;
-        return filter.GetFilter().MatchAny(filter_set);
-    }
     bool findBlock(const uint256& hash, const FoundBlock& block) override
     {
         WAIT_LOCK(cs_main, lock);
diff --git a/src/node/transaction.cpp b/src/node/transaction.cpp
index bff82f215605..97a1857cbef7 100644
--- a/src/node/transaction.cpp
+++ b/src/node/transaction.cpp
@@ -4,7 +4,6 @@
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
 #include <consensus/validation.h>
-#include <index/txindex.h>
 #include <net.h>
 #include <net_processing.h>
 #include <node/blockstorage.h>
@@ -146,19 +145,6 @@ CTransactionRef GetTransaction(const CBlockIndex* const block_index, const CTxMe
         CTransactionRef ptx = mempool->get(hash);
         if (ptx) return ptx;
     }
-    if (g_txindex) {
-        CTransactionRef tx;
-        uint256 block_hash;
-        if (g_txindex->FindTx(hash, block_hash, tx)) {
-            if (!block_index || block_index->GetBlockHash() == block_hash) {
-                // Don't return the transaction if the provided block hash doesn't match.
-                // The case where a transaction appears in multiple blocks (e.g. reorgs or
-                // BIP30) is handled by the block lookup below.
-                hashBlock = block_hash;
-                return tx;
-            }
-        }
-    }
     if (block_index) {
         CBlock block;
         if (blockman.ReadBlock(block, *block_index)) {
diff --git a/src/node/transaction.h b/src/node/transaction.h
index 952657bc2129..b9d8b56b1251 100644
--- a/src/node/transaction.h
+++ b/src/node/transaction.h
@@ -59,14 +59,13 @@ static const CAmount DEFAULT_MAX_BURN_AMOUNT{0};
 /**
  * Return transaction with a given hash.
  * If mempool is provided and block_index is not provided, check it first for the tx.
- * If -txindex is available, check it next for the tx.
- * Finally, if block_index is provided, check for tx by reading entire block from disk.
+ * If block_index is provided, check for tx by reading entire block from disk.
  *
  * @param[in]  block_index     The block to read from disk, or nullptr
  * @param[in]  mempool         If provided, check mempool for tx
  * @param[in]  hash            The txid
  * @param[in]  blockman        Used to access and read blocks from disk
- * @param[out] hashBlock       The block hash, if the tx was found via -txindex or block_index
+ * @param[out] hashBlock       The block hash, if the tx was found via block_index
  * @returns                    The tx if found, otherwise nullptr
  */
 CTransactionRef GetTransaction(const CBlockIndex* block_index, const CTxMemPool* mempool, const Txid& hash, const BlockManager& blockman, uint256& hashBlock);
diff --git a/src/protocol.cpp b/src/protocol.cpp
index 5f0b76e39449..fdde4ef35dde 100644
--- a/src/protocol.cpp
+++ b/src/protocol.cpp
@@ -96,7 +96,6 @@ static std::string serviceFlagToStr(size_t bit)
     case NODE_NETWORK:         return "NETWORK";
     case NODE_BLOOM:           return "BLOOM";
     case NODE_WITNESS:         return "WITNESS";
-    case NODE_COMPACT_FILTERS: return "COMPACT_FILTERS";
     case NODE_NETWORK_LIMITED: return "NETWORK_LIMITED";
     case NODE_P2P_V2:          return "P2P_V2";
     // Not using default, so we get warned when a case is missing
diff --git a/src/protocol.h b/src/protocol.h
index 8ed90dd3f8ef..69038cb6a295 100644
--- a/src/protocol.h
+++ b/src/protocol.h
@@ -216,42 +216,6 @@ inline constexpr const char* GETBLOCKTXN{"getblocktxn"};
  * @since protocol version 70014 as described by BIP 152
  */
 inline constexpr const char* BLOCKTXN{"blocktxn"};
-/**
- * getcfilters requests compact filters for a range of blocks.
- * Only available with service bit NODE_COMPACT_FILTERS as described by
- * BIP 157 & 158.
- */
-inline constexpr const char* GETCFILTERS{"getcfilters"};
-/**
- * cfilter is a response to a getcfilters request containing a single compact
- * filter.
- */
-inline constexpr const char* CFILTER{"cfilter"};
-/**
- * getcfheaders requests a compact filter header and the filter hashes for a
- * range of blocks, which can then be used to reconstruct the filter headers
- * for those blocks.
- * Only available with service bit NODE_COMPACT_FILTERS as described by
- * BIP 157 & 158.
- */
-inline constexpr const char* GETCFHEADERS{"getcfheaders"};
-/**
- * cfheaders is a response to a getcfheaders request containing a filter header
- * and a vector of filter hashes for each subsequent block in the requested range.
- */
-inline constexpr const char* CFHEADERS{"cfheaders"};
-/**
- * getcfcheckpt requests evenly spaced compact filter headers, enabling
- * parallelized download and validation of the headers between them.
- * Only available with service bit NODE_COMPACT_FILTERS as described by
- * BIP 157 & 158.
- */
-inline constexpr const char* GETCFCHECKPT{"getcfcheckpt"};
-/**
- * cfcheckpt is a response to a getcfcheckpt request containing a vector of
- * evenly spaced filter headers for blocks on the requested chain.
- */
-inline constexpr const char* CFCHECKPT{"cfcheckpt"};
 /**
  * Indicates that a node prefers to relay transactions via wtxid, rather than
  * txid.
@@ -295,12 +259,6 @@ inline const std::array ALL_NET_MESSAGE_TYPES{std::to_array<std::string>({
     NetMsgType::CMPCTBLOCK,
     NetMsgType::GETBLOCKTXN,
     NetMsgType::BLOCKTXN,
-    NetMsgType::GETCFILTERS,
-    NetMsgType::CFILTER,
-    NetMsgType::GETCFHEADERS,
-    NetMsgType::CFHEADERS,
-    NetMsgType::GETCFCHECKPT,
-    NetMsgType::CFCHECKPT,
     NetMsgType::WTXIDRELAY,
     NetMsgType::SENDTXRCNCL,
 })};
@@ -318,9 +276,6 @@ enum ServiceFlags : uint64_t {
     // NODE_WITNESS indicates that a node can be asked for blocks and transactions including
     // witness data.
     NODE_WITNESS = (1 << 3),
-    // NODE_COMPACT_FILTERS means the node will service basic block filter requests.
-    // See BIP157 and BIP158 for details on how this is implemented.
-    NODE_COMPACT_FILTERS = (1 << 6),
     // NODE_NETWORK_LIMITED means the same as NODE_NETWORK with the limitation of only
     // serving the last 288 (2 day) blocks
     // See BIP159 for details on how this is implemented.
diff --git a/src/rest.cpp b/src/rest.cpp
index d2c5a9b4899d..251a0ade6cee 100644
--- a/src/rest.cpp
+++ b/src/rest.cpp
@@ -5,14 +5,11 @@
 
 #include <rest.h>
 
-#include <blockfilter.h>
 #include <chain.h>
 #include <chainparams.h>
 #include <core_io.h>
 #include <flatfile.h>
 #include <httpserver.h>
-#include <index/blockfilterindex.h>
-#include <index/txindex.h>
 #include <node/blockstorage.h>
 #include <node/context.h>
 #include <primitives/block.h>
@@ -497,219 +494,6 @@ static bool rest_block_part(const std::any& context, HTTPRequest* req, const std
     }
 }
 
-static bool rest_filter_header(const std::any& context, HTTPRequest* req, const std::string& uri_part)
-{
-    if (!CheckWarmup(req)) return false;
-
-    std::string param;
-    const RESTResponseFormat rf = ParseDataFormat(param, uri_part);
-
-    std::vector<std::string> uri_parts = SplitString(param, '/');
-    std::string raw_count;
-    std::string raw_blockhash;
-    if (uri_parts.size() == 3) {
-        // deprecated path: /rest/blockfilterheaders/<filtertype>/<count>/<blockhash>
-        raw_blockhash = uri_parts[2];
-        raw_count = uri_parts[1];
-    } else if (uri_parts.size() == 2) {
-        // new path with query parameter: /rest/blockfilterheaders/<filtertype>/<blockhash>?count=<count>
-        raw_blockhash = uri_parts[1];
-        try {
-            raw_count = req->GetQueryParameter("count").value_or("5");
-        } catch (const std::runtime_error& e) {
-            return RESTERR(req, HTTP_BAD_REQUEST, e.what());
-        }
-    } else {
-        return RESTERR(req, HTTP_BAD_REQUEST, "Invalid URI format. Expected /rest/blockfilterheaders/<filtertype>/<blockhash>.<ext>?count=<count>");
-    }
-
-    const auto parsed_count{ToIntegral<size_t>(raw_count)};
-    if (!parsed_count.has_value() || *parsed_count < 1 || *parsed_count > MAX_REST_HEADERS_RESULTS) {
-        return RESTERR(req, HTTP_BAD_REQUEST, strprintf("Header count is invalid or out of acceptable range (1-%u): %s", MAX_REST_HEADERS_RESULTS, raw_count));
-    }
-
-    auto block_hash{uint256::FromHex(raw_blockhash)};
-    if (!block_hash) {
-        return RESTERR(req, HTTP_BAD_REQUEST, "Invalid hash: " + raw_blockhash);
-    }
-
-    BlockFilterType filtertype;
-    if (!BlockFilterTypeByName(uri_parts[0], filtertype)) {
-        return RESTERR(req, HTTP_BAD_REQUEST, "Unknown filtertype " + uri_parts[0]);
-    }
-
-    BlockFilterIndex* index = GetBlockFilterIndex(filtertype);
-    if (!index) {
-        return RESTERR(req, HTTP_BAD_REQUEST, "Index is not enabled for filtertype " + uri_parts[0]);
-    }
-
-    std::vector<const CBlockIndex*> headers;
-    headers.reserve(*parsed_count);
-    {
-        ChainstateManager* maybe_chainman = GetChainman(context, req);
-        if (!maybe_chainman) return false;
-        ChainstateManager& chainman = *maybe_chainman;
-        LOCK(cs_main);
-        CChain& active_chain = chainman.ActiveChain();
-        const CBlockIndex* pindex{chainman.m_blockman.LookupBlockIndex(*block_hash)};
-        while (pindex != nullptr && active_chain.Contains(*pindex)) {
-            headers.push_back(pindex);
-            if (headers.size() == *parsed_count)
-                break;
-            pindex = active_chain.Next(*pindex);
-        }
-    }
-
-    bool index_ready = index->BlockUntilSyncedToCurrentChain();
-
-    std::vector<uint256> filter_headers;
-    filter_headers.reserve(*parsed_count);
-    for (const CBlockIndex* pindex : headers) {
-        uint256 filter_header;
-        if (!index->LookupFilterHeader(pindex, filter_header)) {
-            std::string errmsg = "Filter not found.";
-
-            if (!index_ready) {
-                errmsg += " Block filters are still in the process of being indexed.";
-            } else {
-                errmsg += " This error is unexpected and indicates index corruption.";
-            }
-
-            return RESTERR(req, HTTP_NOT_FOUND, errmsg);
-        }
-        filter_headers.push_back(filter_header);
-    }
-
-    switch (rf) {
-    case RESTResponseFormat::BINARY: {
-        DataStream ssHeader{};
-        for (const uint256& header : filter_headers) {
-            ssHeader << header;
-        }
-
-        req->WriteHeader("Content-Type", "application/octet-stream");
-        req->WriteReply(HTTP_OK, ssHeader);
-        return true;
-    }
-    case RESTResponseFormat::HEX: {
-        DataStream ssHeader{};
-        for (const uint256& header : filter_headers) {
-            ssHeader << header;
-        }
-
-        std::string strHex = HexStr(ssHeader) + "\n";
-        req->WriteHeader("Content-Type", "text/plain");
-        req->WriteReply(HTTP_OK, strHex);
-        return true;
-    }
-    case RESTResponseFormat::JSON: {
-        UniValue jsonHeaders(UniValue::VARR);
-        for (const uint256& header : filter_headers) {
-            jsonHeaders.push_back(header.GetHex());
-        }
-
-        std::string strJSON = jsonHeaders.write() + "\n";
-        req->WriteHeader("Content-Type", "application/json");
-        req->WriteReply(HTTP_OK, strJSON);
-        return true;
-    }
-    default: {
-        return RESTERR(req, HTTP_NOT_FOUND, "output format not found (available: " + AvailableDataFormatsString() + ")");
-    }
-    }
-}
-
-static bool rest_block_filter(const std::any& context, HTTPRequest* req, const std::string& uri_part)
-{
-    if (!CheckWarmup(req)) return false;
-
-    std::string param;
-    const RESTResponseFormat rf = ParseDataFormat(param, uri_part);
-
-    // request is sent over URI scheme /rest/blockfilter/filtertype/blockhash
-    std::vector<std::string> uri_parts = SplitString(param, '/');
-    if (uri_parts.size() != 2) {
-        return RESTERR(req, HTTP_BAD_REQUEST, "Invalid URI format. Expected /rest/blockfilter/<filtertype>/<blockhash>");
-    }
-
-    auto block_hash{uint256::FromHex(uri_parts[1])};
-    if (!block_hash) {
-        return RESTERR(req, HTTP_BAD_REQUEST, "Invalid hash: " + uri_parts[1]);
-    }
-
-    BlockFilterType filtertype;
-    if (!BlockFilterTypeByName(uri_parts[0], filtertype)) {
-        return RESTERR(req, HTTP_BAD_REQUEST, "Unknown filtertype " + uri_parts[0]);
-    }
-
-    BlockFilterIndex* index = GetBlockFilterIndex(filtertype);
-    if (!index) {
-        return RESTERR(req, HTTP_BAD_REQUEST, "Index is not enabled for filtertype " + uri_parts[0]);
-    }
-
-    const CBlockIndex* block_index;
-    bool block_was_connected;
-    {
-        ChainstateManager* maybe_chainman = GetChainman(context, req);
-        if (!maybe_chainman) return false;
-        ChainstateManager& chainman = *maybe_chainman;
-        LOCK(cs_main);
-        block_index = chainman.m_blockman.LookupBlockIndex(*block_hash);
-        if (!block_index) {
-            return RESTERR(req, HTTP_NOT_FOUND, uri_parts[1] + " not found");
-        }
-        block_was_connected = block_index->IsValid(BLOCK_VALID_SCRIPTS);
-    }
-
-    bool index_ready = index->BlockUntilSyncedToCurrentChain();
-
-    BlockFilter filter;
-    if (!index->LookupFilter(block_index, filter)) {
-        std::string errmsg = "Filter not found.";
-
-        if (!block_was_connected) {
-            errmsg += " Block was not connected to active chain.";
-        } else if (!index_ready) {
-            errmsg += " Block filters are still in the process of being indexed.";
-        } else {
-            errmsg += " This error is unexpected and indicates index corruption.";
-        }
-
-        return RESTERR(req, HTTP_NOT_FOUND, errmsg);
-    }
-
-    switch (rf) {
-    case RESTResponseFormat::BINARY: {
-        DataStream ssResp{};
-        ssResp << filter;
-
-        req->WriteHeader("Content-Type", "application/octet-stream");
-        req->WriteReply(HTTP_OK, ssResp);
-        return true;
-    }
-    case RESTResponseFormat::HEX: {
-        DataStream ssResp{};
-        ssResp << filter;
-
-        std::string strHex = HexStr(ssResp) + "\n";
-        req->WriteHeader("Content-Type", "text/plain");
-        req->WriteReply(HTTP_OK, strHex);
-        return true;
-    }
-    case RESTResponseFormat::JSON: {
-        UniValue ret(UniValue::VOBJ);
-        ret.pushKV("filter", HexStr(filter.GetEncodedFilter()));
-        std::string strJSON = ret.write() + "\n";
-        req->WriteHeader("Content-Type", "application/json");
-        req->WriteReply(HTTP_OK, strJSON);
-        return true;
-    }
-    default: {
-        return RESTERR(req, HTTP_NOT_FOUND, "output format not found (available: " + AvailableDataFormatsString() + ")");
-    }
-    }
-}
-
 // A bit of a hack - dependency on a function defined in rpc/blockchain.cpp
 RPCMethod getblockchaininfo();
 
@@ -847,10 +631,6 @@ static bool rest_tx(const std::any& context, HTTPRequest* req, const std::string
         return RESTERR(req, HTTP_BAD_REQUEST, "Invalid hash: " + hashStr);
     }
 
-    if (g_txindex) {
-        g_txindex->BlockUntilSyncedToCurrentChain();
-    }
-
     const NodeContext* const node = GetNodeContext(context, req);
     if (!node) return false;
     uint256 hashBlock = uint256();
@@ -1146,8 +926,6 @@ static const struct {
     {"/rest/block/notxdetails/", rest_block_notxdetails},
     {"/rest/block/", rest_block_extended},
     {"/rest/blockpart/", rest_block_part},
-    {"/rest/blockfilter/", rest_block_filter},
-    {"/rest/blockfilterheaders/", rest_filter_header},
     {"/rest/chaininfo", rest_chaininfo},
     {"/rest/mempool/", rest_mempool},
     {"/rest/headers/", rest_headers},
diff --git a/src/rpc/blockchain.cpp b/src/rpc/blockchain.cpp
index 14412c90fcc9..35a94a2fbda5 100644
--- a/src/rpc/blockchain.cpp
+++ b/src/rpc/blockchain.cpp
@@ -5,7 +5,6 @@
 
 #include <rpc/blockchain.h>
 
-#include <blockfilter.h>
 #include <chain.h>
 #include <chainparams.h>
 #include <chainparamsbase.h>
@@ -20,8 +19,6 @@
 #include <deploymentstatus.h>
 #include <flatfile.h>
 #include <hash.h>
-#include <index/blockfilterindex.h>
-#include <index/coinstatsindex.h>
 #include <interfaces/mining.h>
 #include <kernel/coinstats.h>
 #include <logging/timer.h>
@@ -992,29 +989,13 @@ CoinStatsHashType ParseHashType(std::string_view hash_type_input)
 
 /**
  * Calculate statistics about the unspent transaction output set
- *
- * @param[in] index_requested Signals if the coinstatsindex should be used (when available).
  */
 static std::optional<kernel::CCoinsStats> GetUTXOStats(CCoinsView* view, node::BlockManager& blockman,
                                                        kernel::CoinStatsHashType hash_type,
                                                        const std::function<void()>& interruption_point = {},
-                                                       const CBlockIndex* pindex = nullptr,
-                                                       bool index_requested = true)
+                                                       const CBlockIndex* pindex = nullptr)
 {
-    // Use CoinStatsIndex if it is requested and available and a hash_type of Muhash or None was requested
-    if ((hash_type == kernel::CoinStatsHashType::MUHASH || hash_type == kernel::CoinStatsHashType::NONE) && g_coin_stats_index && index_requested) {
-        if (pindex) {
-            return g_coin_stats_index->LookUpStats(*pindex);
-        } else {
-            CBlockIndex& block_index = *CHECK_NONFATAL(WITH_LOCK(::cs_main, return blockman.LookupBlockIndex(view->GetBestBlock())));
-            return g_coin_stats_index->LookUpStats(block_index);
-        }
-    }
-
-    // If the coinstats index isn't requested or is otherwise not usable, the
-    // pindex should either be null or equal to the view's best block. This is
-    // because without the coinstats index we can only get coinstats about the
-    // best block.
+    // Without a coinstats index we can only get coinstats about the best block.
     CHECK_NONFATAL(!pindex || pindex->GetBlockHash() == view->GetBestBlock());
 
     return kernel::ComputeUTXOStats(hash_type, view, blockman, interruption_point);
@@ -1025,15 +1006,9 @@ static RPCMethod gettxoutsetinfo()
     return RPCMethod{
         "gettxoutsetinfo",
         "Returns statistics about the unspent transaction output set.\n"
-                "Note this call may take some time if you are not using coinstatsindex.\n",
+                "Note this call may take some time.\n",
                 {
                     {"hash_type", RPCArg::Type::STR, RPCArg::Default{"hash_serialized_3"}, "Which UTXO set hash should be calculated. Options: 'hash_serialized_3' (the legacy algorithm), 'muhash', 'none'."},
-                    {"hash_or_height", RPCArg::Type::NUM, RPCArg::DefaultHint{"the current best block"}, "The block hash or height of the target height (only available with coinstatsindex).",
-                     RPCArgOptions{
-                         .skip_type_check = true,
-                         .type_str = {"", "string or numeric"},
-                     }},
-                    {"use_index", RPCArg::Type::BOOL, RPCArg::Default{true}, "Use coinstatsindex, if available."},
                 },
                 RPCResult{
                     RPCResult::Type::OBJ, "", "",
@@ -1044,42 +1019,21 @@ static RPCMethod gettxoutsetinfo()
                         {RPCResult::Type::NUM, "bogosize", "Database-independent, meaningless metric indicating the UTXO set size"},
                         {RPCResult::Type::STR_HEX, "hash_serialized_3", /*optional=*/true, "The serialized hash (only present if 'hash_serialized_3' hash_type is chosen)"},
                         {RPCResult::Type::STR_HEX, "muhash", /*optional=*/true, "The serialized hash (only present if 'muhash' hash_type is chosen)"},
-                        {RPCResult::Type::NUM, "transactions", /*optional=*/true, "The number of transactions with unspent outputs (not available when coinstatsindex is used)"},
-                        {RPCResult::Type::NUM, "disk_size", /*optional=*/true, "The estimated size of the chainstate on disk (not available when coinstatsindex is used)"},
+                        {RPCResult::Type::NUM, "transactions", "The number of transactions with unspent outputs"},
+                        {RPCResult::Type::NUM, "disk_size", "The estimated size of the chainstate on disk"},
                         {RPCResult::Type::STR_AMOUNT, "total_amount", "The total amount of coins in the UTXO set"},
-                        {RPCResult::Type::STR_AMOUNT, "total_unspendable_amount", /*optional=*/true, "The total amount of coins permanently excluded from the UTXO set (only available if coinstatsindex is used)"},
-                        {RPCResult::Type::OBJ, "block_info", /*optional=*/true, "Info on amounts in the block at this block height (only available if coinstatsindex is used)",
-                        {
-                            {RPCResult::Type::STR_AMOUNT, "prevout_spent", "Total amount of all prevouts spent in this block"},
-                            {RPCResult::Type::STR_AMOUNT, "coinbase", "Coinbase subsidy amount of this block"},
-                            {RPCResult::Type::STR_AMOUNT, "new_outputs_ex_coinbase", "Total amount of new outputs created by this block"},
-                            {RPCResult::Type::STR_AMOUNT, "unspendable", "Total amount of unspendable outputs created in this block"},
-                            {RPCResult::Type::OBJ, "unspendables", "Detailed view of the unspendable categories",
-                            {
-                                {RPCResult::Type::STR_AMOUNT, "genesis_block", "The unspendable amount of the Genesis block subsidy"},
-                                {RPCResult::Type::STR_AMOUNT, "bip30", "Transactions overridden by duplicates (no longer possible with BIP30)"},
-                                {RPCResult::Type::STR_AMOUNT, "scripts", "Amounts sent to scripts that are unspendable (for example OP_RETURN outputs)"},
-                                {RPCResult::Type::STR_AMOUNT, "unclaimed_rewards", "Fee rewards that miners did not claim in their coinbase transaction"},
-                            }}
-                        }},
                     }},
                 RPCExamples{
                     HelpExampleCli("gettxoutsetinfo", "") +
                     HelpExampleCli("gettxoutsetinfo", R"("none")") +
-                    HelpExampleCli("gettxoutsetinfo", R"("none" 1000)") +
-                    HelpExampleCli("gettxoutsetinfo", R"("none" '"00000000c937983704a73af28acdec37b049d214adbda81d7e2a3dd146f6ed09"')") +
-                    HelpExampleCli("-named gettxoutsetinfo", R"(hash_type='muhash' use_index='false')") +
                     HelpExampleRpc("gettxoutsetinfo", "") +
-                    HelpExampleRpc("gettxoutsetinfo", R"("none")") +
-                    HelpExampleRpc("gettxoutsetinfo", R"("none", 1000)") +
-                    HelpExampleRpc("gettxoutsetinfo", R"("none", "00000000c937983704a73af28acdec37b049d214adbda81d7e2a3dd146f6ed09")")
+                    HelpExampleRpc("gettxoutsetinfo", R"("none")")
                 },
         [](const RPCMethod& self, const JSONRPCRequest& request) -> UniValue
 {
     UniValue ret(UniValue::VOBJ);
 
     const CoinStatsHashType hash_type{ParseHashType(self.Arg<std::string_view>("hash_type"))};
-    bool index_requested = request.params[2].isNull() || request.params[2].get_bool();
 
     NodeContext& node = EnsureAnyNodeContext(request.context);
     ChainstateManager& chainman = EnsureChainman(node);
@@ -1094,35 +1048,7 @@ static RPCMethod gettxoutsetinfo()
         blockman = &active_chainstate.m_blockman;
     }
 
-    const CBlockIndex* pindex{nullptr};
-    if (!request.params[1].isNull()) {
-        if (!g_coin_stats_index) {
-            throw JSONRPCError(RPC_INVALID_PARAMETER, "Querying specific block heights requires coinstatsindex");
-        }
-
-        if (hash_type == CoinStatsHashType::HASH_SERIALIZED) {
-            throw JSONRPCError(RPC_INVALID_PARAMETER, "hash_serialized_3 hash type cannot be queried for a specific block");
-        }
-
-        if (!index_requested) {
-            throw JSONRPCError(RPC_INVALID_PARAMETER, "Cannot set use_index to false when querying for a specific block");
-        }
-        pindex = ParseHashOrHeight(request.params[1], chainman);
-    }
-
-    if (index_requested && g_coin_stats_index) {
-        if (!g_coin_stats_index->BlockUntilSyncedToCurrentChain()) {
-            const IndexSummary summary{g_coin_stats_index->GetSummary()};
-
-            // If a specific block was requested and the index has already synced past that height, we can return the
-            // data already even though the index is not fully synced yet.
-            if (pindex && pindex->nHeight > summary.best_block_height) {
-                throw JSONRPCError(RPC_INTERNAL_ERROR, strprintf("Unable to get data because coinstatsindex is still syncing. Current height: %d", summary.best_block_height));
-            }
-        }
-    }
-
-    const std::optional<CCoinsStats> maybe_stats = GetUTXOStats(coins_view, *blockman, hash_type, node.rpc_interruption_point, pindex, index_requested);
+    const std::optional<CCoinsStats> maybe_stats = GetUTXOStats(coins_view, *blockman, hash_type, node.rpc_interruption_point);
     if (maybe_stats.has_value()) {
         const CCoinsStats& stats = maybe_stats.value();
         ret.pushKV("height", stats.nHeight);
@@ -1137,53 +1063,8 @@ static RPCMethod gettxoutsetinfo()
         }
         CHECK_NONFATAL(stats.total_amount.has_value());
         ret.pushKV("total_amount", ValueFromAmount(stats.total_amount.value()));
-        if (!stats.index_used) {
-            ret.pushKV("transactions", stats.nTransactions);
-            ret.pushKV("disk_size", stats.nDiskSize);
-        } else {
-            CCoinsStats prev_stats{};
-            if (stats.nHeight > 0) {
-                const CBlockIndex& block_index = *CHECK_NONFATAL(WITH_LOCK(::cs_main, return blockman->LookupBlockIndex(stats.hashBlock)));
-                const std::optional<CCoinsStats> maybe_prev_stats = GetUTXOStats(coins_view, *blockman, hash_type, node.rpc_interruption_point, block_index.pprev, index_requested);
-                if (!maybe_prev_stats) {
-                    throw JSONRPCError(RPC_INTERNAL_ERROR, "Unable to read UTXO set");
-                }
-                prev_stats = maybe_prev_stats.value();
-            }
-
-            CAmount block_total_unspendable_amount = stats.total_unspendables_genesis_block +
-                                                     stats.total_unspendables_bip30 +
-                                                     stats.total_unspendables_scripts +
-                                                     stats.total_unspendables_unclaimed_rewards;
-            CAmount prev_block_total_unspendable_amount = prev_stats.total_unspendables_genesis_block +
-                                                          prev_stats.total_unspendables_bip30 +
-                                                          prev_stats.total_unspendables_scripts +
-                                                          prev_stats.total_unspendables_unclaimed_rewards;
-
-            ret.pushKV("total_unspendable_amount", ValueFromAmount(block_total_unspendable_amount));
-
-            UniValue block_info(UniValue::VOBJ);
-            // These per-block values should fit uint64 under normal circumstances
-            arith_uint256 diff_prevout = stats.total_prevout_spent_amount - prev_stats.total_prevout_spent_amount;
-            arith_uint256 diff_coinbase = stats.total_coinbase_amount - prev_stats.total_coinbase_amount;
-            arith_uint256 diff_outputs = stats.total_new_outputs_ex_coinbase_amount - prev_stats.total_new_outputs_ex_coinbase_amount;
-            CAmount prevout_amount = static_cast<CAmount>(diff_prevout.GetLow64());
-            CAmount coinbase_amount = static_cast<CAmount>(diff_coinbase.GetLow64());
-            CAmount outputs_amount = static_cast<CAmount>(diff_outputs.GetLow64());
-            block_info.pushKV("prevout_spent", ValueFromAmount(prevout_amount));
-            block_info.pushKV("coinbase", ValueFromAmount(coinbase_amount));
-            block_info.pushKV("new_outputs_ex_coinbase", ValueFromAmount(outputs_amount));
-            block_info.pushKV("unspendable", ValueFromAmount(block_total_unspendable_amount - prev_block_total_unspendable_amount));
-
-            UniValue unspendables(UniValue::VOBJ);
-            unspendables.pushKV("genesis_block", ValueFromAmount(stats.total_unspendables_genesis_block - prev_stats.total_unspendables_genesis_block));
-            unspendables.pushKV("bip30", ValueFromAmount(stats.total_unspendables_bip30 - prev_stats.total_unspendables_bip30));
-            unspendables.pushKV("scripts", ValueFromAmount(stats.total_unspendables_scripts - prev_stats.total_unspendables_scripts));
-            unspendables.pushKV("unclaimed_rewards", ValueFromAmount(stats.total_unspendables_unclaimed_rewards - prev_stats.total_unspendables_unclaimed_rewards));
-            block_info.pushKV("unspendables", std::move(unspendables));
-
-            ret.pushKV("block_info", std::move(block_info));
-        }
+        ret.pushKV("transactions", stats.nTransactions);
+        ret.pushKV("disk_size", stats.nDiskSize);
     } else {
         throw JSONRPCError(RPC_INTERNAL_ERROR, "Unable to read UTXO set");
     }
@@ -2489,254 +2370,11 @@ static RPCMethod scantxoutset()
     };
 }
 
-/** RAII object to prevent concurrency issue when scanning blockfilters */
-static std::atomic<int> g_scanfilter_progress;
-static std::atomic<int> g_scanfilter_progress_height;
-static std::atomic<bool> g_scanfilter_in_progress;
-static std::atomic<bool> g_scanfilter_should_abort_scan;
-class BlockFiltersScanReserver
-{
-private:
-    bool m_could_reserve{false};
-public:
-    explicit BlockFiltersScanReserver() = default;
-
-    bool reserve() {
-        CHECK_NONFATAL(!m_could_reserve);
-        if (g_scanfilter_in_progress.exchange(true)) {
-            return false;
-        }
-        m_could_reserve = true;
-        return true;
-    }
-
-    ~BlockFiltersScanReserver() {
-        if (m_could_reserve) {
-            g_scanfilter_in_progress = false;
-        }
-    }
-};
-
-static bool CheckBlockFilterMatches(BlockManager& blockman, const CBlockIndex& blockindex, const GCSFilter::ElementSet& needles)
-{
-    const CBlock block{GetBlockChecked(blockman, blockindex)};
-    const CBlockUndo block_undo{GetUndoChecked(blockman, blockindex)};
-
-    // Check if any of the outputs match the scriptPubKey
-    for (const auto& tx : block.vtx) {
-        if (std::any_of(tx->vout.cbegin(), tx->vout.cend(), [&](const auto& txout) {
-                return needles.contains(std::vector<unsigned char>(txout.scriptPubKey.begin(), txout.scriptPubKey.end()));
-            })) {
-            return true;
-        }
-    }
-    // Check if any of the inputs match the scriptPubKey
-    for (const auto& txundo : block_undo.vtxundo) {
-        if (std::any_of(txundo.vprevout.cbegin(), txundo.vprevout.cend(), [&](const auto& coin) {
-                return needles.contains(std::vector<unsigned char>(coin.out.scriptPubKey.begin(), coin.out.scriptPubKey.end()));
-            })) {
-            return true;
-        }
-    }
-
-    return false;
-}
-
-static RPCMethod scanblocks()
-{
-    return RPCMethod{
-        "scanblocks",
-        "Return relevant blockhashes for given descriptors (requires blockfilterindex).\n"
-        "This call may take several minutes. Make sure to use no RPC timeout (bitcoin-cli -rpcclienttimeout=0)",
-        {
-            scan_action_arg_desc,
-            scan_objects_arg_desc,
-            RPCArg{"start_height", RPCArg::Type::NUM, RPCArg::Default{0}, "Height to start to scan from"},
-            RPCArg{"stop_height", RPCArg::Type::NUM, RPCArg::DefaultHint{"chain tip"}, "Height to stop to scan"},
-            RPCArg{"filtertype", RPCArg::Type::STR, RPCArg::Default{BlockFilterTypeName(BlockFilterType::BASIC)}, "The type name of the filter"},
-            RPCArg{"options", RPCArg::Type::OBJ_NAMED_PARAMS, RPCArg::Optional::OMITTED, "",
-                {
-                    {"filter_false_positives", RPCArg::Type::BOOL, RPCArg::Default{false}, "Filter false positives (slower and may fail on pruned nodes). Otherwise they may occur at a rate of 1/M"},
-                },
-                RPCArgOptions{.oneline_description="options"}},
-        },
-        {
-            scan_result_status_none,
-            RPCResult{"When action=='start'; only returns after scan completes", RPCResult::Type::OBJ, "", "", {
-                {RPCResult::Type::NUM, "from_height", "The height we started the scan from"},
-                {RPCResult::Type::NUM, "to_height", "The height we ended the scan at"},
-                {RPCResult::Type::ARR, "relevant_blocks", "Blocks that may have matched a scanobject.", {
-                    {RPCResult::Type::STR_HEX, "blockhash", "A relevant blockhash"},
-                }},
-                {RPCResult::Type::BOOL, "completed", "true if the scan process was not aborted"}
-            }},
-            RPCResult{"when action=='status' and a scan is currently in progress", RPCResult::Type::OBJ, "", "", {
-                    {RPCResult::Type::NUM, "progress", "Approximate percent complete"},
-                    {RPCResult::Type::NUM, "current_height", "Height of the block currently being scanned"},
-                },
-            },
-            scan_result_abort,
-        },
-        RPCExamples{
-            HelpExampleCli("scanblocks", "start '[\"addr(bcrt1q4u4nsgk6ug0sqz7r3rj9tykjxrsl0yy4d0wwte)\"]' 300000") +
-            HelpExampleCli("scanblocks", "start '[\"addr(bcrt1q4u4nsgk6ug0sqz7r3rj9tykjxrsl0yy4d0wwte)\"]' 100 150 basic") +
-            HelpExampleCli("scanblocks", "status") +
-            HelpExampleRpc("scanblocks", "\"start\", [\"addr(bcrt1q4u4nsgk6ug0sqz7r3rj9tykjxrsl0yy4d0wwte)\"], 300000") +
-            HelpExampleRpc("scanblocks", "\"start\", [\"addr(bcrt1q4u4nsgk6ug0sqz7r3rj9tykjxrsl0yy4d0wwte)\"], 100, 150, \"basic\"") +
-            HelpExampleRpc("scanblocks", "\"status\"")
-        },
-        [](const RPCMethod& self, const JSONRPCRequest& request) -> UniValue
-{
-    UniValue ret(UniValue::VOBJ);
-    auto action{self.Arg<std::string_view>("action")};
-    if (action == "status") {
-        BlockFiltersScanReserver reserver;
-        if (reserver.reserve()) {
-            // no scan in progress
-            return NullUniValue;
-        }
-        ret.pushKV("progress", g_scanfilter_progress.load());
-        ret.pushKV("current_height", g_scanfilter_progress_height.load());
-        return ret;
-    } else if (action == "abort") {
-        BlockFiltersScanReserver reserver;
-        if (reserver.reserve()) {
-            // reserve was possible which means no scan was running
-            return false;
-        }
-        // set the abort flag
-        g_scanfilter_should_abort_scan = true;
-        return true;
-    } else if (action == "start") {
-        BlockFiltersScanReserver reserver;
-        if (!reserver.reserve()) {
-            throw JSONRPCError(RPC_INVALID_PARAMETER, "Scan already in progress, use action \"abort\" or \"status\"");
-        }
-        auto filtertype_name{self.Arg<std::string_view>("filtertype")};
-
-        BlockFilterType filtertype;
-        if (!BlockFilterTypeByName(filtertype_name, filtertype)) {
-            throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, "Unknown filtertype");
-        }
-
-        UniValue options{request.params[5].isNull() ? UniValue::VOBJ : request.params[5]};
-        bool filter_false_positives{options.exists("filter_false_positives") ? options["filter_false_positives"].get_bool() : false};
-
-        BlockFilterIndex* index = GetBlockFilterIndex(filtertype);
-        if (!index) {
-            throw JSONRPCError(RPC_MISC_ERROR, tfm::format("Index is not enabled for filtertype %s", filtertype_name));
-        }
-
-        NodeContext& node = EnsureAnyNodeContext(request.context);
-        ChainstateManager& chainman = EnsureChainman(node);
-
-        // set the start-height
-        const CBlockIndex* start_index = nullptr;
-        const CBlockIndex* stop_block = nullptr;
-        {
-            LOCK(cs_main);
-            CChain& active_chain = chainman.ActiveChain();
-            start_index = active_chain.Genesis();
-            stop_block = active_chain.Tip(); // If no stop block is provided, stop at the chain tip.
-            if (!request.params[2].isNull()) {
-                start_index = active_chain[request.params[2].getInt<int>()];
-                if (!start_index) {
-                    throw JSONRPCError(RPC_MISC_ERROR, "Invalid start_height");
-                }
-            }
-            if (!request.params[3].isNull()) {
-                stop_block = active_chain[request.params[3].getInt<int>()];
-                if (!stop_block || stop_block->nHeight < start_index->nHeight) {
-                    throw JSONRPCError(RPC_MISC_ERROR, "Invalid stop_height");
-                }
-            }
-        }
-        CHECK_NONFATAL(start_index);
-        CHECK_NONFATAL(stop_block);
-
-        // loop through the scan objects, add scripts to the needle_set
-        GCSFilter::ElementSet needle_set;
-        for (const UniValue& scanobject : request.params[1].get_array().getValues()) {
-            FlatSigningProvider provider;
-            std::vector<CScript> scripts = EvalDescriptorStringOrObject(scanobject, provider);
-            for (const CScript& script : scripts) {
-                needle_set.emplace(script.begin(), script.end());
-            }
-        }
-        UniValue blocks(UniValue::VARR);
-        const int amount_per_chunk = 10000;
-        std::vector<BlockFilter> filters;
-        int start_block_height = start_index->nHeight; // for progress reporting
-        const int total_blocks_to_process = stop_block->nHeight - start_block_height;
-
-        g_scanfilter_should_abort_scan = false;
-        g_scanfilter_progress = 0;
-        g_scanfilter_progress_height = start_block_height;
-        bool completed = true;
-
-        const CBlockIndex* end_range = nullptr;
-        do {
-            node.rpc_interruption_point(); // allow a clean shutdown
-            if (g_scanfilter_should_abort_scan) {
-                completed = false;
-                break;
-            }
-
-            // split the lookup range in chunks if we are deeper than 'amount_per_chunk' blocks from the stopping block
-            int start_block = !end_range ? start_index->nHeight : start_index->nHeight + 1; // to not include the previous round 'end_range' block
-            end_range = (start_block + amount_per_chunk < stop_block->nHeight) ?
-                    WITH_LOCK(::cs_main, return chainman.ActiveChain()[start_block + amount_per_chunk]) :
-                    stop_block;
-
-            if (index->LookupFilterRange(start_block, end_range, filters)) {
-                for (const BlockFilter& filter : filters) {
-                    // compare the elements-set with each filter
-                    if (filter.GetFilter().MatchAny(needle_set)) {
-                        if (filter_false_positives) {
-                            // Double check the filter matches by scanning the block
-                            const CBlockIndex& blockindex = *CHECK_NONFATAL(WITH_LOCK(cs_main, return chainman.m_blockman.LookupBlockIndex(filter.GetBlockHash())));
-
-                            if (!CheckBlockFilterMatches(chainman.m_blockman, blockindex, needle_set)) {
-                                continue;
-                            }
-                        }
-
-                        blocks.push_back(filter.GetBlockHash().GetHex());
-                    }
-                }
-            }
-            start_index = end_range;
-
-            // update progress
-            int blocks_processed = end_range->nHeight - start_block_height;
-            if (total_blocks_to_process > 0) { // avoid division by zero
-                g_scanfilter_progress = (int)(100.0 / total_blocks_to_process * blocks_processed);
-            } else {
-                g_scanfilter_progress = 100;
-            }
-            g_scanfilter_progress_height = end_range->nHeight;
-
-        // Finish if we reached the stop block
-        } while (start_index != stop_block);
-
-        ret.pushKV("from_height", start_block_height);
-        ret.pushKV("to_height", start_index->nHeight); // start_index is always the last scanned block here
-        ret.pushKV("relevant_blocks", std::move(blocks));
-        ret.pushKV("completed", completed);
-    } else {
-        throw JSONRPCError(RPC_INVALID_PARAMETER, tfm::format("Invalid action '%s'", action));
-    }
-    return ret;
-},
-    };
-}
-
 static RPCMethod getdescriptoractivity()
 {
     return RPCMethod{
         "getdescriptoractivity",
         "Get spend and receive activity associated with a set of descriptors for a set of blocks. "
-        "This command pairs well with the `relevant_blocks` output of `scanblocks()`.\n"
         "This call may take several minutes. If you encounter timeouts, try specifying no RPC timeout (bitcoin-cli -rpcclienttimeout=0)",
         {
             RPCArg{"blockhashes", RPCArg::Type::ARR, RPCArg::Optional::NO, "The list of blockhashes to examine for activity. Order doesn't matter. Must be along main chain or an error is thrown.\n", {
@@ -2967,83 +2605,6 @@ static RPCMethod getdescriptoractivity()
     };
 }
 
-static RPCMethod getblockfilter()
-{
-    return RPCMethod{
-        "getblockfilter",
-        "Retrieve 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"},
-                },
-                RPCResult{
-                    RPCResult::Type::OBJ, "", "",
-                    {
-                        {RPCResult::Type::STR_HEX, "filter", "the hex-encoded filter data"},
-                        {RPCResult::Type::STR_HEX, "header", "the hex-encoded filter header"},
-                    }},
-                RPCExamples{
-                    HelpExampleCli("getblockfilter", "\"00000000c937983704a73af28acdec37b049d214adbda81d7e2a3dd146f6ed09\" \"basic\"") +
-                    HelpExampleRpc("getblockfilter", "\"00000000c937983704a73af28acdec37b049d214adbda81d7e2a3dd146f6ed09\", \"basic\"")
-                },
-        [](const RPCMethod& self, const JSONRPCRequest& request) -> UniValue
-{
-    uint256 block_hash = ParseHashV(request.params[0], "blockhash");
-    auto filtertype_name{self.Arg<std::string_view>("filtertype")};
-
-    BlockFilterType filtertype;
-    if (!BlockFilterTypeByName(filtertype_name, filtertype)) {
-        throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, "Unknown filtertype");
-    }
-
-    BlockFilterIndex* index = GetBlockFilterIndex(filtertype);
-    if (!index) {
-        throw JSONRPCError(RPC_MISC_ERROR, tfm::format("Index is not enabled for filtertype %s", filtertype_name));
-    }
-
-    const CBlockIndex* block_index;
-    bool block_was_connected;
-    {
-        ChainstateManager& chainman = EnsureAnyChainman(request.context);
-        LOCK(cs_main);
-        block_index = chainman.m_blockman.LookupBlockIndex(block_hash);
-        if (!block_index) {
-            throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, "Block not found");
-        }
-        block_was_connected = block_index->IsValid(BLOCK_VALID_SCRIPTS);
-    }
-
-    bool index_ready = index->BlockUntilSyncedToCurrentChain();
-
-    BlockFilter filter;
-    uint256 filter_header;
-    if (!index->LookupFilter(block_index, filter) ||
-        !index->LookupFilterHeader(block_index, filter_header)) {
-        int err_code;
-        std::string errmsg = "Filter not found.";
-
-        if (!block_was_connected) {
-            err_code = RPC_INVALID_ADDRESS_OR_KEY;
-            errmsg += " Block was not connected to active chain.";
-        } else if (!index_ready) {
-            err_code = RPC_MISC_ERROR;
-            errmsg += " Block filters are still in the process of being indexed.";
-        } else {
-            err_code = RPC_INTERNAL_ERROR;
-            errmsg += " This error is unexpected and indicates index corruption.";
-        }
-
-        throw JSONRPCError(err_code, errmsg);
-    }
-
-    UniValue ret(UniValue::VOBJ);
-    ret.pushKV("filter", HexStr(filter.GetEncodedFilter()));
-    ret.pushKV("header", filter_header.GetHex());
-    return ret;
-},
-    };
-}
-
 /**
  * RAII class that registers a prune lock in its constructor to prevent
  * block data from being pruned, and removes it in its destructor.
@@ -3661,9 +3222,7 @@ void RegisterBlockchainRPCCommands(CRPCTable& t)
         {"blockchain", &verifychain},
         {"blockchain", &preciousblock},
         {"blockchain", &scantxoutset},
-        {"blockchain", &scanblocks},
         {"blockchain", &getdescriptoractivity},
-        {"blockchain", &getblockfilter},
         {"blockchain", &dumptxoutset},
         {"blockchain", &loadtxoutset},
         {"blockchain", &getchainstates},
diff --git a/src/rpc/client.cpp b/src/rpc/client.cpp
index 6eb45a2525a1..a9449c9966be 100644
--- a/src/rpc/client.cpp
+++ b/src/rpc/client.cpp
@@ -74,11 +74,6 @@ static const CRPCConvertParam vRPCConvertParams[] =
     { "waitfornewblock", 0, "timeout" },
     { "getblocktemplate", 0, "template_request" },
     { "deriveaddresses", 1, "range" },
-    { "scanblocks", 1, "scanobjects" },
-    { "scanblocks", 2, "start_height" },
-    { "scanblocks", 3, "stop_height" },
-    { "scanblocks", 5, "options" },
-    { "scanblocks", 5, "filter_false_positives" },
     { "getdescriptoractivity", 0, "blockhashes" },
     { "getdescriptoractivity", 1, "scanobjects" },
     { "getdescriptoractivity", 2, "include_mempool" },
@@ -110,8 +105,6 @@ static const CRPCConvertParam vRPCConvertParams[] =
     { "gettxout", 1, "n" },
     { "gettxout", 2, "include_mempool" },
     { "gettxoutproof", 0, "txids" },
-    { "gettxoutsetinfo", 1, "hash_or_height", ParamFormat::JSON_OR_STRING },
-    { "gettxoutsetinfo", 2, "use_index"},
     { "dumptxoutset", 0, "path", ParamFormat::STRING },
     { "dumptxoutset", 1, "type", ParamFormat::STRING },
     { "dumptxoutset", 2, "options" },
@@ -143,10 +136,6 @@ static const CRPCConvertParam vRPCConvertParams[] =
     { "setnetworkactive", 0, "state" },
     { "getmempoolancestors", 1, "verbose" },
     { "getmempooldescendants", 1, "verbose" },
-    { "gettxspendingprevout", 0, "outputs" },
-    { "gettxspendingprevout", 1, "options" },
-    { "gettxspendingprevout", 1, "mempool_only" },
-    { "gettxspendingprevout", 1, "return_spending_tx" },
     { "logging", 0, "include" },
     { "logging", 1, "exclude" },
     { "disconnectnode", 1, "nodeid" },
diff --git a/src/rpc/mempool.cpp b/src/rpc/mempool.cpp
index 98450b907895..11720fa5cb31 100644
--- a/src/rpc/mempool.cpp
+++ b/src/rpc/mempool.cpp
@@ -11,7 +11,6 @@
 #include <common/args.h>
 #include <consensus/validation.h>
 #include <core_io.h>
-#include <index/txospenderindex.h>
 #include <kernel/mempool_entry.h>
 #include <net_processing.h>
 #include <netbase.h>
@@ -900,152 +899,6 @@ static RPCMethod getmempoolentry()
     };
 }
 
-static RPCMethod gettxspendingprevout()
-{
-    return RPCMethod{"gettxspendingprevout",
-        "Scans the mempool (and the txospenderindex, if available) to find transactions spending any of the given outputs",
-        {
-            {"outputs", RPCArg::Type::ARR, RPCArg::Optional::NO, "The transaction outputs that we want to check, and within each, the txid (string) vout (numeric).",
-                {
-                    {"", RPCArg::Type::OBJ, RPCArg::Optional::OMITTED, "",
-                        {
-                            {"txid", RPCArg::Type::STR_HEX, RPCArg::Optional::NO, "The transaction id"},
-                            {"vout", RPCArg::Type::NUM, RPCArg::Optional::NO, "The output number"},
-                        },
-                    },
-                },
-            },
-            {"options", RPCArg::Type::OBJ_NAMED_PARAMS, RPCArg::Optional::OMITTED, "",
-                {
-                    {"mempool_only", RPCArg::Type::BOOL, RPCArg::DefaultHint{"true if txospenderindex unavailable, otherwise false"}, "If false and mempool lacks a relevant spend, use txospenderindex (throws an exception if not available)."},
-                    {"return_spending_tx", RPCArg::Type::BOOL, RPCArg::DefaultHint{"false"}, "If true, return the full spending tx."},
-                },
-            },
-        },
-        RPCResult{
-            RPCResult::Type::ARR, "", "",
-            {
-                {RPCResult::Type::OBJ, "", "",
-                {
-                    {RPCResult::Type::STR_HEX, "txid", "the transaction id of the checked output"},
-                    {RPCResult::Type::NUM, "vout", "the vout value of the checked output"},
-                    {RPCResult::Type::STR_HEX, "spendingtxid", /*optional=*/true, "the transaction id of the mempool transaction spending this output (omitted if unspent)"},
-                    {RPCResult::Type::STR_HEX, "spendingtx", /*optional=*/true, "the transaction spending this output (only if return_spending_tx is set, omitted if unspent)"},
-                    {RPCResult::Type::STR_HEX, "blockhash", /*optional=*/true, "the hash of the spending block (omitted if unspent or the spending tx is not confirmed)"},
-                }},
-            }
-        },
-        RPCExamples{
-            HelpExampleCli("gettxspendingprevout", "\"[{\\\"txid\\\":\\\"a08e6907dbbd3d809776dbfc5d82e371b764ed838b5655e72f463568df1aadf0\\\",\\\"vout\\\":3}]\"")
-            + HelpExampleRpc("gettxspendingprevout", "\"[{\\\"txid\\\":\\\"a08e6907dbbd3d809776dbfc5d82e371b764ed838b5655e72f463568df1aadf0\\\",\\\"vout\\\":3}]\"")
-            + HelpExampleCliNamed("gettxspendingprevout", {{"outputs", "[{\"txid\":\"a08e6907dbbd3d809776dbfc5d82e371b764ed838b5655e72f463568df1aadf0\",\"vout\":3}]"}, {"return_spending_tx", true}})
-        },
-        [](const RPCMethod& self, const JSONRPCRequest& request) -> UniValue
-        {
-            const UniValue& output_params = request.params[0].get_array();
-            if (output_params.empty()) {
-                throw JSONRPCError(RPC_INVALID_PARAMETER, "Invalid parameter, outputs are missing");
-            }
-            const UniValue options{request.params[1].isNull() ? UniValue::VOBJ : request.params[1]};
-            RPCTypeCheckObj(options,
-                            {
-                                {"mempool_only", UniValueType(UniValue::VBOOL)},
-                                {"return_spending_tx", UniValueType(UniValue::VBOOL)},
-                            }, /*fAllowNull=*/true, /*fStrict=*/true);
-
-            const bool mempool_only{options.exists("mempool_only") ? options["mempool_only"].get_bool() : !g_txospenderindex};
-            const bool return_spending_tx{options.exists("return_spending_tx") ? options["return_spending_tx"].get_bool() : false};
-
-            // Worklist of outpoints to resolve
-            struct Entry {
-                COutPoint outpoint;
-                const UniValue* raw;
-            };
-            std::vector<Entry> prevouts_to_process;
-            prevouts_to_process.reserve(output_params.size());
-            for (unsigned int idx = 0; idx < output_params.size(); idx++) {
-                const UniValue& o = output_params[idx].get_obj();
-
-                RPCTypeCheckObj(o,
-                                {
-                                    {"txid", UniValueType(UniValue::VSTR)},
-                                    {"vout", UniValueType(UniValue::VNUM)},
-                                }, /*fAllowNull=*/false, /*fStrict=*/true);
-
-                const Txid txid = Txid::FromUint256(ParseHashO(o, "txid"));
-                const int nOutput{o.find_value("vout").getInt<int>()};
-                if (nOutput < 0) {
-                    throw JSONRPCError(RPC_INVALID_PARAMETER, "Invalid parameter, vout cannot be negative");
-                }
-                prevouts_to_process.emplace_back(COutPoint{txid, static_cast<uint32_t>(nOutput)}, &o);
-            }
-
-            auto make_output = [return_spending_tx](const Entry& prevout, const CTransaction* spending_tx = nullptr) {
-                UniValue o{*prevout.raw};
-                if (spending_tx) {
-                    o.pushKV("spendingtxid", spending_tx->GetHash().ToString());
-                    if (return_spending_tx) {
-                        o.pushKV("spendingtx", EncodeHexTx(*spending_tx));
-                    }
-                }
-                return o;
-            };
-
-            UniValue result{UniValue::VARR};
-
-            // Search the mempool first
-            {
-                const CTxMemPool& mempool = EnsureAnyMemPool(request.context);
-                LOCK(mempool.cs);
-
-                // Make the result if the spending tx appears in the mempool or this is a mempool_only request
-                for (auto it = prevouts_to_process.begin(); it != prevouts_to_process.end(); ) {
-                    const CTransaction* spending_tx{mempool.GetConflictTx(it->outpoint)};
-
-                    // If the outpoint is not spent in the mempool and this is not a mempool-only
-                    // request, we cannot answer it yet.
-                    if (!spending_tx && !mempool_only) {
-                        ++it;
-                        continue;
-                    }
-
-                    result.push_back(make_output(*it, spending_tx));
-                    it = prevouts_to_process.erase(it);
-                }
-            }
-
-            // Return early if all requests have been handled by the mempool search
-            if (prevouts_to_process.empty()) {
-                return result;
-            }
-
-            // At this point the request was not limited to the mempool and some outpoints remain
-            // unresolved. We now rely on the index to determine whether they were spent or not.
-            if (!g_txospenderindex || !g_txospenderindex->BlockUntilSyncedToCurrentChain()) {
-                throw JSONRPCError(RPC_MISC_ERROR, "Mempool lacks a relevant spend, and txospenderindex is unavailable.");
-            }
-
-            for (const auto& prevout : prevouts_to_process) {
-                const auto spender{g_txospenderindex->FindSpender(prevout.outpoint)};
-                if (!spender) {
-                    throw JSONRPCError(RPC_MISC_ERROR, spender.error());
-                }
-
-                if (const auto& spender_opt{spender.value()}) {
-                    UniValue o{make_output(prevout, spender_opt->tx.get())};
-                    o.pushKV("blockhash", spender_opt->block_hash.GetHex());
-                    result.push_back(std::move(o));
-                } else {
-                    // Only return the input outpoint itself, which indicates it is unspent.
-                    result.push_back(make_output(prevout));
-                }
-            }
-
-            return result;
-        },
-    };
-}
-
 UniValue MempoolInfoToJSON(const CTxMemPool& pool)
 {
     // Make sure this call is atomic in the pool.
@@ -1538,7 +1391,6 @@ void RegisterMempoolRPCCommands(CRPCTable& t)
         {"blockchain", &getmempooldescendants},
         {"blockchain", &getmempoolentry},
         {"blockchain", &getmempoolcluster},
-        {"blockchain", &gettxspendingprevout},
         {"blockchain", &getmempoolinfo},
         {"hidden", &getmempoolfeeratediagram},
         {"blockchain", &getrawmempool},
diff --git a/src/rpc/node.cpp b/src/rpc/node.cpp
index 92002a15010a..085ac328f6a1 100644
--- a/src/rpc/node.cpp
+++ b/src/rpc/node.cpp
@@ -7,10 +7,6 @@
 
 #include <chainparams.h>
 #include <httpserver.h>
-#include <index/blockfilterindex.h>
-#include <index/coinstatsindex.h>
-#include <index/txindex.h>
-#include <index/txospenderindex.h>
 #include <interfaces/chain.h>
 #include <interfaces/echo.h>
 #include <interfaces/init.h>
@@ -24,6 +20,7 @@
 #include <scheduler.h>
 #include <tinyformat.h>
 #include <univalue.h>
+#include <validationinterface.h>
 #include <util/any.h>
 #include <util/check.h>
 #include <util/time.h>
@@ -341,75 +338,11 @@ static RPCMethod echoipc()
     };
 }
 
-static UniValue SummaryToJSON(const IndexSummary&& summary, std::string index_name)
-{
-    UniValue ret_summary(UniValue::VOBJ);
-    if (!index_name.empty() && index_name != summary.name) return ret_summary;
-
-    UniValue entry(UniValue::VOBJ);
-    entry.pushKV("synced", summary.synced);
-    entry.pushKV("best_block_height", summary.best_block_height);
-    ret_summary.pushKV(summary.name, std::move(entry));
-    return ret_summary;
-}
-
-static RPCMethod getindexinfo()
-{
-    return RPCMethod{
-        "getindexinfo",
-        "Returns the status of one or all available indices currently running in the node.\n",
-                {
-                    {"index_name", RPCArg::Type::STR, RPCArg::Optional::OMITTED, "Filter results for an index with a specific name."},
-                },
-                RPCResult{
-                    RPCResult::Type::OBJ_DYN, "", "", {
-                        {
-                            RPCResult::Type::OBJ, "name", "The name of the index",
-                            {
-                                {RPCResult::Type::BOOL, "synced", "Whether the index is synced or not"},
-                                {RPCResult::Type::NUM, "best_block_height", "The block height to which the index is synced"},
-                            }
-                        },
-                    },
-                },
-                RPCExamples{
-                    HelpExampleCli("getindexinfo", "")
-                  + HelpExampleRpc("getindexinfo", "")
-                  + HelpExampleCli("getindexinfo", "txindex")
-                  + HelpExampleRpc("getindexinfo", "txindex")
-                },
-                [](const RPCMethod& self, const JSONRPCRequest& request) -> UniValue
-{
-    UniValue result(UniValue::VOBJ);
-    const std::string index_name{self.MaybeArg<std::string_view>("index_name").value_or("")};
-
-    if (g_txindex) {
-        result.pushKVs(SummaryToJSON(g_txindex->GetSummary(), index_name));
-    }
-
-    if (g_coin_stats_index) {
-        result.pushKVs(SummaryToJSON(g_coin_stats_index->GetSummary(), index_name));
-    }
-
-    if (g_txospenderindex) {
-        result.pushKVs(SummaryToJSON(g_txospenderindex->GetSummary(), index_name));
-    }
-
-    ForEachBlockFilterIndex([&result, &index_name](const BlockFilterIndex& index) {
-        result.pushKVs(SummaryToJSON(index.GetSummary(), index_name));
-    });
-
-    return result;
-},
-    };
-}
-
 void RegisterNodeRPCCommands(CRPCTable& t)
 {
     static const CRPCCommand commands[]{
         {"control", &getmemoryinfo},
         {"control", &logging},
-        {"util", &getindexinfo},
         {"hidden", &setmocktime},
         {"hidden", &mockscheduler},
         {"hidden", &echo},
diff --git a/src/rpc/rawtransaction.cpp b/src/rpc/rawtransaction.cpp
index e508c9d122b2..7bf088b60602 100644
--- a/src/rpc/rawtransaction.cpp
+++ b/src/rpc/rawtransaction.cpp
@@ -9,7 +9,6 @@
 #include <consensus/amount.h>
 #include <consensus/validation.h>
 #include <core_io.h>
-#include <index/txindex.h>
 #include <key_io.h>
 #include <node/blockstorage.h>
 #include <node/coin.h>
@@ -124,8 +123,7 @@ static RPCMethod getrawtransaction()
     return RPCMethod{
                 "getrawtransaction",
 
-                "By default, this call only returns a transaction if it is in the mempool. If -txindex is enabled\n"
-                "and no blockhash argument is passed, it will return the transaction if it is in the mempool or any block.\n"
+                "By default, this call only returns a transaction if it is in the mempool.\n"
                 "If a blockhash argument is passed, it will return the transaction if\n"
                 "the specified block is available and the transaction is in that block.\n\n"
                 "Hint: Use gettransaction for wallet transactions.\n\n"
@@ -210,11 +208,6 @@ static RPCMethod getrawtransaction()
         }
     }
 
-    bool f_txindex_ready = false;
-    if (g_txindex && !blockindex) {
-        f_txindex_ready = g_txindex->BlockUntilSyncedToCurrentChain();
-    }
-
     uint256 hash_block;
     const CTransactionRef tx = GetTransaction(blockindex, node.mempool.get(), txid, chainman.m_blockman, hash_block);
     if (!tx) {
@@ -225,12 +218,8 @@ static RPCMethod getrawtransaction()
                 throw JSONRPCError(RPC_MISC_ERROR, "Block not available");
             }
             errmsg = "No such transaction found in the provided block";
-        } else if (!g_txindex) {
-            errmsg = "No such mempool transaction. Use -txindex or provide a block hash to enable blockchain transaction queries";
-        } else if (!f_txindex_ready) {
-            errmsg = "No such mempool transaction. Blockchain transactions are still in the process of being indexed";
         } else {
-            errmsg = "No such mempool or blockchain transaction";
+            errmsg = "No such mempool transaction. Provide a block hash to look it up in a specific block";
         }
         throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, errmsg + ". Use gettransaction for wallet transactions.");
     }
diff --git a/src/rpc/txoutproof.cpp b/src/rpc/txoutproof.cpp
index 628825fc80e6..d031a9dbe364 100644
--- a/src/rpc/txoutproof.cpp
+++ b/src/rpc/txoutproof.cpp
@@ -6,7 +6,6 @@
 #include <chain.h>
 #include <chainparams.h>
 #include <coins.h>
-#include <index/txindex.h>
 #include <merkleblock.h>
 #include <node/blockstorage.h>
 #include <primitives/transaction.h>
@@ -27,7 +26,6 @@ static RPCMethod gettxoutproof()
         "Returns a hex-encoded proof that \"txid\" was included in a block.\n"
         "\nNOTE: By default this function only works sometimes. This is when there is an\n"
         "unspent output in the utxo for this transaction. To make it always work,\n"
-        "you need to maintain a transaction index, using the -txindex command line option or\n"
         "specify the block in which the transaction is included manually (by blockhash).\n",
         {
             {"txids", RPCArg::Type::ARR, RPCArg::Optional::NO, "The txids to filter",
@@ -80,11 +78,6 @@ static RPCMethod gettxoutproof()
             }
 
 
-            // Allow txindex to catch up if we need to query it and before we acquire cs_main.
-            if (g_txindex && !pblockindex) {
-                g_txindex->BlockUntilSyncedToCurrentChain();
-            }
-
             if (pblockindex == nullptr) {
                 const CTransactionRef tx = GetTransaction(/*block_index=*/nullptr, /*mempool=*/nullptr, *setTxids.begin(), chainman.m_blockman, hashBlock);
                 if (!tx || hashBlock.IsNull()) {
diff --git a/src/test/CMakeLists.txt b/src/test/CMakeLists.txt
index 79079c8faf82..e6a5286d8206 100644
--- a/src/test/CMakeLists.txt
+++ b/src/test/CMakeLists.txt
@@ -20,8 +20,6 @@ add_executable(test_bitcoin
   bip324_tests.cpp
   blockchain_tests.cpp
   blockencodings_tests.cpp
-  blockfilter_index_tests.cpp
-  blockfilter_tests.cpp
   blockmanager_tests.cpp
   bloom_tests.cpp
   bswap_tests.cpp
@@ -33,7 +31,6 @@ add_executable(test_bitcoin
   cluster_linearize_tests.cpp
   coins_tests.cpp
   coinscachepair_tests.cpp
-  coinstatsindex_tests.cpp
   coinsviewoverlay_tests.cpp
   common_url_tests.cpp
   compress_tests.cpp
@@ -117,8 +114,6 @@ add_executable(test_bitcoin
   translation_tests.cpp
   txdownload_tests.cpp
   txgraph_tests.cpp
-  txindex_tests.cpp
-  txospenderindex_tests.cpp
   txpackage_tests.cpp
   txreconciliation_tests.cpp
   txrequest_tests.cpp
@@ -144,7 +139,6 @@ include(TargetDataSources)
 target_json_data_sources(test_bitcoin
   data/base58_encode_decode.json
   data/bip341_wallet_vectors.json
-  data/blockfilters.json
   data/key_io_invalid.json
   data/key_io_valid.json
   data/script_tests.json
diff --git a/src/test/blockfilter_index_tests.cpp b/src/test/blockfilter_index_tests.cpp
deleted file mode 100644
index 10e4ffa4b089..000000000000
--- a/src/test/blockfilter_index_tests.cpp
+++ /dev/null
@@ -1,388 +0,0 @@
-// Copyright (c) 2017-present 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 <addresstype.h>
-#include <blockfilter.h>
-#include <chainparams.h>
-#include <consensus/merkle.h>
-#include <consensus/validation.h>
-#include <index/blockfilterindex.h>
-#include <interfaces/chain.h>
-#include <node/miner.h>
-#include <pow.h>
-#include <test/util/blockfilter.h>
-#include <test/util/common.h>
-#include <test/util/setup_common.h>
-#include <util/byte_units.h>
-#include <validation.h>
-
-#include <boost/test/unit_test.hpp>
-#include <future>
-
-using node::BlockAssembler;
-using node::BlockManager;
-using node::CBlockTemplate;
-
-BOOST_AUTO_TEST_SUITE(blockfilter_index_tests)
-
-struct BuildChainTestingSetup : public TestChain100Setup {
-    CBlock CreateBlock(const CBlockIndex* prev, const std::vector<CMutableTransaction>& txns, const CScript& scriptPubKey);
-    bool BuildChain(const CBlockIndex* pindex, const CScript& coinbase_script_pub_key, size_t length, std::vector<std::shared_ptr<CBlock>>& chain);
-};
-
-static bool CheckFilterLookups(BlockFilterIndex& filter_index, const CBlockIndex* block_index,
-                               uint256& last_header, const BlockManager& blockman)
-{
-    BlockFilter expected_filter;
-    if (!ComputeFilter(filter_index.GetFilterType(), *block_index, expected_filter, blockman)) {
-        BOOST_ERROR("ComputeFilter failed on block " << block_index->nHeight);
-        return false;
-    }
-
-    BlockFilter filter;
-    uint256 filter_header;
-    std::vector<BlockFilter> filters;
-    std::vector<uint256> filter_hashes;
-
-    BOOST_CHECK(filter_index.LookupFilter(block_index, filter));
-    BOOST_CHECK(filter_index.LookupFilterHeader(block_index, filter_header));
-    BOOST_CHECK(filter_index.LookupFilterRange(block_index->nHeight, block_index, filters));
-    BOOST_CHECK(filter_index.LookupFilterHashRange(block_index->nHeight, block_index,
-                                                   filter_hashes));
-
-    BOOST_CHECK_EQUAL(filters.size(), 1U);
-    BOOST_CHECK_EQUAL(filter_hashes.size(), 1U);
-
-    BOOST_CHECK_EQUAL(filter.GetHash(), expected_filter.GetHash());
-    BOOST_CHECK_EQUAL(filter_header, expected_filter.ComputeHeader(last_header));
-    BOOST_CHECK_EQUAL(filters[0].GetHash(), expected_filter.GetHash());
-    BOOST_CHECK_EQUAL(filter_hashes[0], expected_filter.GetHash());
-
-    filters.clear();
-    filter_hashes.clear();
-    last_header = filter_header;
-    return true;
-}
-
-CBlock BuildChainTestingSetup::CreateBlock(const CBlockIndex* prev,
-    const std::vector<CMutableTransaction>& txns,
-    const CScript& scriptPubKey)
-{
-    BlockAssembler::Options options;
-    options.coinbase_output_script = scriptPubKey;
-    options.include_dummy_extranonce = true;
-    std::unique_ptr<CBlockTemplate> pblocktemplate = BlockAssembler{m_node.chainman->ActiveChainstate(), m_node.mempool.get(), options}.CreateNewBlock();
-    CBlock& block = pblocktemplate->block;
-    block.hashPrevBlock = prev->GetBlockHash();
-    block.nTime = prev->nTime + 1;
-
-    // Replace mempool-selected txns with just coinbase plus passed-in txns:
-    block.vtx.resize(1);
-    for (const CMutableTransaction& tx : txns) {
-        block.vtx.push_back(MakeTransactionRef(tx));
-    }
-    {
-        CMutableTransaction tx_coinbase{*block.vtx.at(0)};
-        tx_coinbase.nLockTime = static_cast<uint32_t>(prev->nHeight);
-        tx_coinbase.vin.at(0).scriptSig = CScript{} << prev->nHeight + 1;
-        block.vtx.at(0) = MakeTransactionRef(std::move(tx_coinbase));
-        block.hashMerkleRoot = BlockMerkleRoot(block);
-    }
-
-    while (!CheckProofOfWork(block.GetHash(), block.nBits, m_node.chainman->GetConsensus())) ++block.nNonce;
-
-    return block;
-}
-
-bool BuildChainTestingSetup::BuildChain(const CBlockIndex* pindex,
-    const CScript& coinbase_script_pub_key,
-    size_t length,
-    std::vector<std::shared_ptr<CBlock>>& chain)
-{
-    std::vector<CMutableTransaction> no_txns;
-
-    chain.resize(length);
-    for (auto& block : chain) {
-        block = std::make_shared<CBlock>(CreateBlock(pindex, no_txns, coinbase_script_pub_key));
-
-        BlockValidationState state;
-        if (!Assert(m_node.chainman)->ProcessNewBlockHeaders({{*block}}, true, state, &pindex)) {
-            return false;
-        }
-    }
-
-    return true;
-}
-
-BOOST_FIXTURE_TEST_CASE(blockfilter_index_initial_sync, BuildChainTestingSetup)
-{
-    BlockFilterIndex filter_index(interfaces::MakeChain(m_node), BlockFilterType::BASIC, 1_MiB, true);
-    BOOST_REQUIRE(filter_index.Init());
-
-    uint256 last_header;
-
-    // Filter should not be found in the index before it is started.
-    {
-        LOCK(cs_main);
-
-        BlockFilter filter;
-        uint256 filter_header;
-        std::vector<BlockFilter> filters;
-        std::vector<uint256> filter_hashes;
-
-        for (const CBlockIndex* block_index = m_node.chainman->ActiveChain().Genesis();
-             block_index != nullptr;
-             block_index = m_node.chainman->ActiveChain().Next(*block_index)) {
-            BOOST_CHECK(!filter_index.LookupFilter(block_index, filter));
-            BOOST_CHECK(!filter_index.LookupFilterHeader(block_index, filter_header));
-            BOOST_CHECK(!filter_index.LookupFilterRange(block_index->nHeight, block_index, filters));
-            BOOST_CHECK(!filter_index.LookupFilterHashRange(block_index->nHeight, block_index,
-                                                            filter_hashes));
-        }
-    }
-
-    // BlockUntilSyncedToCurrentChain should return false before index is started.
-    BOOST_CHECK(!filter_index.BlockUntilSyncedToCurrentChain());
-
-    filter_index.Sync();
-
-    // Check that filter index has all blocks that were in the chain before it started.
-    {
-        LOCK(cs_main);
-        const CBlockIndex* block_index;
-        for (block_index = m_node.chainman->ActiveChain().Genesis();
-             block_index != nullptr;
-             block_index = m_node.chainman->ActiveChain().Next(*block_index)) {
-            CheckFilterLookups(filter_index, block_index, last_header, m_node.chainman->m_blockman);
-        }
-    }
-
-    // Create two forks.
-    const CBlockIndex* tip;
-    {
-        LOCK(cs_main);
-        tip = m_node.chainman->ActiveChain().Tip();
-    }
-    CKey coinbase_key_A = GenerateRandomKey();
-    CKey coinbase_key_B = GenerateRandomKey();
-    CScript coinbase_script_pub_key_A = GetScriptForDestination(PKHash(coinbase_key_A.GetPubKey()));
-    CScript coinbase_script_pub_key_B = GetScriptForDestination(PKHash(coinbase_key_B.GetPubKey()));
-    std::vector<std::shared_ptr<CBlock>> chainA, chainB;
-    BOOST_REQUIRE(BuildChain(tip, coinbase_script_pub_key_A, 10, chainA));
-    BOOST_REQUIRE(BuildChain(tip, coinbase_script_pub_key_B, 10, chainB));
-
-    // Check that new blocks on chain A get indexed.
-    uint256 chainA_last_header = last_header;
-    for (size_t i = 0; i < 2; i++) {
-        const auto& block = chainA[i];
-        BOOST_REQUIRE(Assert(m_node.chainman)->ProcessNewBlock(block, true, true, nullptr));
-    }
-    for (size_t i = 0; i < 2; i++) {
-        const auto& block = chainA[i];
-        const CBlockIndex* block_index;
-        {
-            LOCK(cs_main);
-            block_index = m_node.chainman->m_blockman.LookupBlockIndex(block->GetHash());
-        }
-
-        BOOST_CHECK(filter_index.BlockUntilSyncedToCurrentChain());
-        CheckFilterLookups(filter_index, block_index, chainA_last_header, m_node.chainman->m_blockman);
-    }
-
-    // Reorg to chain B.
-    uint256 chainB_last_header = last_header;
-    for (size_t i = 0; i < 3; i++) {
-        const auto& block = chainB[i];
-        BOOST_REQUIRE(Assert(m_node.chainman)->ProcessNewBlock(block, true, true, nullptr));
-    }
-    for (size_t i = 0; i < 3; i++) {
-        const auto& block = chainB[i];
-        const CBlockIndex* block_index;
-        {
-            LOCK(cs_main);
-            block_index = m_node.chainman->m_blockman.LookupBlockIndex(block->GetHash());
-        }
-
-        BOOST_CHECK(filter_index.BlockUntilSyncedToCurrentChain());
-        CheckFilterLookups(filter_index, block_index, chainB_last_header, m_node.chainman->m_blockman);
-    }
-
-    // Check that filters for stale blocks on A can be retrieved.
-    chainA_last_header = last_header;
-    for (size_t i = 0; i < 2; i++) {
-        const auto& block = chainA[i];
-        const CBlockIndex* block_index;
-        {
-            LOCK(cs_main);
-            block_index = m_node.chainman->m_blockman.LookupBlockIndex(block->GetHash());
-        }
-
-        BOOST_CHECK(filter_index.BlockUntilSyncedToCurrentChain());
-        CheckFilterLookups(filter_index, block_index, chainA_last_header, m_node.chainman->m_blockman);
-    }
-
-    // Reorg back to chain A.
-     for (size_t i = 2; i < 4; i++) {
-         const auto& block = chainA[i];
-         BOOST_REQUIRE(Assert(m_node.chainman)->ProcessNewBlock(block, true, true, nullptr));
-     }
-
-     // Check that chain A and B blocks can be retrieved.
-     chainA_last_header = last_header;
-     chainB_last_header = last_header;
-     for (size_t i = 0; i < 3; i++) {
-         const CBlockIndex* block_index;
-
-         {
-             LOCK(cs_main);
-             block_index = m_node.chainman->m_blockman.LookupBlockIndex(chainA[i]->GetHash());
-         }
-         BOOST_CHECK(filter_index.BlockUntilSyncedToCurrentChain());
-         CheckFilterLookups(filter_index, block_index, chainA_last_header, m_node.chainman->m_blockman);
-
-         {
-             LOCK(cs_main);
-             block_index = m_node.chainman->m_blockman.LookupBlockIndex(chainB[i]->GetHash());
-         }
-         BOOST_CHECK(filter_index.BlockUntilSyncedToCurrentChain());
-         CheckFilterLookups(filter_index, block_index, chainB_last_header, m_node.chainman->m_blockman);
-     }
-
-    // Test lookups for a range of filters/hashes.
-    std::vector<BlockFilter> filters;
-    std::vector<uint256> filter_hashes;
-
-    {
-        LOCK(cs_main);
-        tip = m_node.chainman->ActiveChain().Tip();
-    }
-    BOOST_CHECK(filter_index.LookupFilterRange(0, tip, filters));
-    BOOST_CHECK(filter_index.LookupFilterHashRange(0, tip, filter_hashes));
-
-    assert(tip->nHeight >= 0);
-    BOOST_CHECK_EQUAL(filters.size(), tip->nHeight + 1U);
-    BOOST_CHECK_EQUAL(filter_hashes.size(), tip->nHeight + 1U);
-
-    filters.clear();
-    filter_hashes.clear();
-
-    filter_index.Interrupt();
-    filter_index.Stop();
-}
-
-BOOST_FIXTURE_TEST_CASE(blockfilter_index_init_destroy, BasicTestingSetup)
-{
-    BlockFilterIndex* filter_index;
-
-    filter_index = GetBlockFilterIndex(BlockFilterType::BASIC);
-    BOOST_CHECK(filter_index == nullptr);
-
-    BOOST_CHECK(InitBlockFilterIndex([&]{ return interfaces::MakeChain(m_node); }, BlockFilterType::BASIC, 1_MiB, true, false));
-
-    filter_index = GetBlockFilterIndex(BlockFilterType::BASIC);
-    BOOST_CHECK(filter_index != nullptr);
-    BOOST_CHECK(filter_index->GetFilterType() == BlockFilterType::BASIC);
-
-    // Initialize returns false if index already exists.
-    BOOST_CHECK(!InitBlockFilterIndex([&]{ return interfaces::MakeChain(m_node); }, BlockFilterType::BASIC, 1_MiB, true, false));
-
-    int iter_count = 0;
-    ForEachBlockFilterIndex([&iter_count](BlockFilterIndex& _index) { iter_count++; });
-    BOOST_CHECK_EQUAL(iter_count, 1);
-
-    BOOST_CHECK(DestroyBlockFilterIndex(BlockFilterType::BASIC));
-
-    // Destroy returns false because index was already destroyed.
-    BOOST_CHECK(!DestroyBlockFilterIndex(BlockFilterType::BASIC));
-
-    filter_index = GetBlockFilterIndex(BlockFilterType::BASIC);
-    BOOST_CHECK(filter_index == nullptr);
-
-    // Reinitialize index.
-    BOOST_CHECK(InitBlockFilterIndex([&]{ return interfaces::MakeChain(m_node); }, BlockFilterType::BASIC, 1_MiB, true, false));
-
-    DestroyAllBlockFilterIndexes();
-
-    filter_index = GetBlockFilterIndex(BlockFilterType::BASIC);
-    BOOST_CHECK(filter_index == nullptr);
-}
-
-class IndexReorgCrash : public BaseIndex
-{
-private:
-    std::unique_ptr<BaseIndex::DB> m_db;
-    std::shared_future<void> m_blocker;
-    int m_blocking_height;
-
-public:
-    explicit IndexReorgCrash(std::unique_ptr<interfaces::Chain> chain, std::shared_future<void> blocker,
-                             int blocking_height) : BaseIndex(std::move(chain), "test index"), m_blocker(blocker),
-                                                    m_blocking_height(blocking_height)
-    {
-        const fs::path path = gArgs.GetDataDirNet() / "index";
-        fs::create_directories(path);
-        m_db = std::make_unique<BaseIndex::DB>(path / "db", /*n_cache_size=*/0, /*f_memory=*/true, /*f_wipe=*/false);
-    }
-
-    bool AllowPrune() const override { return false; }
-    BaseIndex::DB& GetDB() const override { return *m_db; }
-
-    bool CustomAppend(const interfaces::BlockInfo& block) override
-    {
-        // Simulate a delay so new blocks can get connected during the initial sync
-        if (block.height == m_blocking_height) m_blocker.wait();
-
-        // Move mock time forward so the best index gets updated only when we are not at the blocking height
-        if (block.height == m_blocking_height - 1 || block.height > m_blocking_height) {
-            SetMockTime(GetTime<std::chrono::seconds>() + 31s);
-        }
-
-        return true;
-    }
-};
-
-BOOST_FIXTURE_TEST_CASE(index_reorg_crash, BuildChainTestingSetup)
-{
-    // Enable mock time
-    SetMockTime(GetTime<std::chrono::minutes>());
-
-    std::promise<void> promise;
-    std::shared_future<void> blocker(promise.get_future());
-    int blocking_height = WITH_LOCK(cs_main, return m_node.chainman->ActiveChain().Tip()->nHeight);
-
-    IndexReorgCrash index(interfaces::MakeChain(m_node), blocker, blocking_height);
-    BOOST_REQUIRE(index.Init());
-    BOOST_REQUIRE(index.StartBackgroundSync());
-
-    auto func_wait_until = [&](int height, std::chrono::milliseconds timeout) {
-        auto deadline = std::chrono::steady_clock::now() + timeout;
-        while (index.GetSummary().best_block_height < height) {
-            if (std::chrono::steady_clock::now() > deadline) {
-                BOOST_FAIL(strprintf("Timeout waiting for index height %d (current: %d)", height, index.GetSummary().best_block_height));
-                return;
-            }
-            std::this_thread::sleep_for(100ms);
-        }
-    };
-
-    // Wait until the index is one block before the fork point
-    func_wait_until(blocking_height - 1, /*timeout=*/5s);
-
-    // Create a fork to trigger the reorg
-    std::vector<std::shared_ptr<CBlock>> fork;
-    const CBlockIndex* prev_tip = WITH_LOCK(cs_main, return m_node.chainman->ActiveChain().Tip()->pprev);
-    BOOST_REQUIRE(BuildChain(prev_tip, GetScriptForDestination(PKHash(GenerateRandomKey().GetPubKey())), 3, fork));
-
-    for (const auto& block : fork) {
-        BOOST_REQUIRE(m_node.chainman->ProcessNewBlock(block, /*force_processing=*/true, /*min_pow_checked=*/true, nullptr));
-    }
-
-    // Unblock the index thread so it can process the reorg
-    promise.set_value();
-    // Wait for the index to reach the new tip
-    func_wait_until(blocking_height + 2, 5s);
-    index.Stop();
-}
-
-BOOST_AUTO_TEST_SUITE_END()
diff --git a/src/test/blockfilter_tests.cpp b/src/test/blockfilter_tests.cpp
deleted file mode 100644
index 0fc7d5b29eee..000000000000
--- a/src/test/blockfilter_tests.cpp
+++ /dev/null
@@ -1,191 +0,0 @@
-// Copyright (c) 2018-present 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 <test/data/blockfilters.json.h>
-#include <test/util/common.h>
-
-#include <blockfilter.h>
-#include <core_io.h>
-#include <primitives/block.h>
-#include <serialize.h>
-#include <streams.h>
-#include <undo.h>
-#include <univalue.h>
-#include <util/strencodings.h>
-
-#include <boost/test/unit_test.hpp>
-
-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(), 0U);
-    BOOST_CHECK_EQUAL(filter.GetEncoded().size(), 1U);
-
-    const GCSFilter::Params& params = filter.GetParams();
-    BOOST_CHECK_EQUAL(params.m_siphash_k0, 0U);
-    BOOST_CHECK_EQUAL(params.m_siphash_k1, 0U);
-    BOOST_CHECK_EQUAL(params.m_P, 0);
-    BOOST_CHECK_EQUAL(params.m_M, 1U);
-}
-
-BOOST_AUTO_TEST_CASE(blockfilter_basic_test)
-{
-    CScript included_scripts[5], excluded_scripts[4];
-
-    // First two are outputs on a single transaction.
-    included_scripts[0] << std::vector<unsigned char>(65, 0) << OP_CHECKSIG;
-    included_scripts[1] << OP_DUP << OP_HASH160 << std::vector<unsigned char>(20, 1) << OP_EQUALVERIFY << OP_CHECKSIG;
-
-    // Third is an output on in a second transaction.
-    included_scripts[2] << OP_1 << std::vector<unsigned char>(33, 2) << OP_1 << OP_CHECKMULTISIG;
-
-    // Last two are spent by a single transaction.
-    included_scripts[3] << OP_0 << std::vector<unsigned char>(32, 3);
-    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<unsigned char>(40, 4);
-
-    // This script is not related to the block at all.
-    excluded_scripts[1] << std::vector<unsigned char>(33, 5) << OP_CHECKSIG;
-
-    // OP_RETURN is non-standard since it's not followed by a data push, but is still excluded from
-    // filter.
-    excluded_scripts[2] << OP_RETURN << OP_4 << OP_ADD << OP_8 << OP_EQUAL;
-
-    CMutableTransaction tx_1;
-    tx_1.vout.emplace_back(100, included_scripts[0]);
-    tx_1.vout.emplace_back(200, included_scripts[1]);
-    tx_1.vout.emplace_back(0, excluded_scripts[0]);
-
-    CMutableTransaction tx_2;
-    tx_2.vout.emplace_back(300, included_scripts[2]);
-    tx_2.vout.emplace_back(0, excluded_scripts[2]);
-    tx_2.vout.emplace_back(400, excluded_scripts[3]); // 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[3]), 1000, true);
-    block_undo.vtxundo.back().vprevout.emplace_back(CTxOut(600, included_scripts[4]), 10000, false);
-    block_undo.vtxundo.back().vprevout.emplace_back(CTxOut(700, excluded_scripts[3]), 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;
-
-    DataStream stream{};
-    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;
-    if (!json.read(json_tests::blockfilters) || !json.isArray()) {
-        BOOST_ERROR("Parse error.");
-        return;
-    }
-
-    const UniValue& tests = json.get_array();
-    for (unsigned int i = 0; i < tests.size(); i++) {
-        const 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;
-        }
-
-        unsigned int pos = 0;
-        /*int block_height =*/ test[pos++].getInt<int>();
-        BOOST_CHECK(uint256::FromHex(test[pos++].get_str()));
-
-        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 (unsigned int ii = 0; ii < prev_scripts.size(); ii++) {
-            std::vector<unsigned char> raw_script = ParseHex(prev_scripts[ii].get_str());
-            CTxOut txout(0, CScript(raw_script.begin(), raw_script.end()));
-            tx_undo.vprevout.emplace_back(txout, 0, false);
-        }
-
-        uint256 prev_filter_header_basic{*Assert(uint256::FromHex(test[pos++].get_str()))};
-        std::vector<unsigned char> filter_basic = ParseHex(test[pos++].get_str());
-        uint256 filter_header_basic{*Assert(uint256::FromHex(test[pos++].get_str()))};
-
-        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_CASE(blockfilter_type_names)
-{
-    BOOST_CHECK_EQUAL(BlockFilterTypeName(BlockFilterType::BASIC), "basic");
-    BOOST_CHECK_EQUAL(BlockFilterTypeName(static_cast<BlockFilterType>(255)), "");
-
-    BlockFilterType filter_type;
-    BOOST_CHECK(BlockFilterTypeByName("basic", filter_type));
-    BOOST_CHECK_EQUAL(filter_type, BlockFilterType::BASIC);
-
-    BOOST_CHECK(!BlockFilterTypeByName("unknown", filter_type));
-}
-
-BOOST_AUTO_TEST_SUITE_END()
diff --git a/src/test/coinstatsindex_tests.cpp b/src/test/coinstatsindex_tests.cpp
deleted file mode 100644
index f7f97c9b371a..000000000000
--- a/src/test/coinstatsindex_tests.cpp
+++ /dev/null
@@ -1,113 +0,0 @@
-// Copyright (c) 2020-present 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 <chainparams.h>
-#include <index/coinstatsindex.h>
-#include <interfaces/chain.h>
-#include <kernel/coinstats.h>
-#include <kernel/types.h>
-#include <test/util/setup_common.h>
-#include <test/util/validation.h>
-#include <util/byte_units.h>
-#include <validation.h>
-
-#include <boost/test/unit_test.hpp>
-
-using kernel::ChainstateRole;
-
-BOOST_AUTO_TEST_SUITE(coinstatsindex_tests)
-
-BOOST_FIXTURE_TEST_CASE(coinstatsindex_initial_sync, TestChain100Setup)
-{
-    CoinStatsIndex coin_stats_index{interfaces::MakeChain(m_node), 1_MiB, true};
-    BOOST_REQUIRE(coin_stats_index.Init());
-
-    const CBlockIndex* block_index;
-    {
-        LOCK(cs_main);
-        block_index = m_node.chainman->ActiveChain().Tip();
-    }
-
-    // CoinStatsIndex should not be found before it is started.
-    BOOST_CHECK(!coin_stats_index.LookUpStats(*block_index));
-
-    // BlockUntilSyncedToCurrentChain should return false before CoinStatsIndex
-    // is started.
-    BOOST_CHECK(!coin_stats_index.BlockUntilSyncedToCurrentChain());
-
-    coin_stats_index.Sync();
-
-    // Check that CoinStatsIndex works for genesis block.
-    const CBlockIndex* genesis_block_index;
-    {
-        LOCK(cs_main);
-        genesis_block_index = m_node.chainman->ActiveChain().Genesis();
-    }
-    BOOST_CHECK(coin_stats_index.LookUpStats(*genesis_block_index));
-
-    // Check that CoinStatsIndex updates with new blocks.
-    BOOST_CHECK(coin_stats_index.LookUpStats(*block_index));
-
-    const CScript script_pub_key{CScript() << ToByteVector(coinbaseKey.GetPubKey()) << OP_CHECKSIG};
-    std::vector<CMutableTransaction> noTxns;
-    CreateAndProcessBlock(noTxns, script_pub_key);
-
-    // Let the CoinStatsIndex to catch up again.
-    BOOST_CHECK(coin_stats_index.BlockUntilSyncedToCurrentChain());
-
-    const CBlockIndex* new_block_index;
-    {
-        LOCK(cs_main);
-        new_block_index = m_node.chainman->ActiveChain().Tip();
-    }
-    BOOST_CHECK(coin_stats_index.LookUpStats(*new_block_index));
-
-    BOOST_CHECK(block_index != new_block_index);
-
-    // Shutdown sequence (c.f. Shutdown() in init.cpp)
-    coin_stats_index.Stop();
-}
-
-// Test shutdown between BlockConnected and ChainStateFlushed notifications,
-// make sure index is not corrupted and is able to reload.
-BOOST_FIXTURE_TEST_CASE(coinstatsindex_unclean_shutdown, TestChain100Setup)
-{
-    Chainstate& chainstate = Assert(m_node.chainman)->ActiveChainstate();
-    const CChainParams& params = Params();
-    {
-        CoinStatsIndex index{interfaces::MakeChain(m_node), 1_MiB};
-        BOOST_REQUIRE(index.Init());
-        index.Sync();
-        std::shared_ptr<const CBlock> new_block;
-        CBlockIndex* new_block_index = nullptr;
-        {
-            const CScript script_pub_key{CScript() << ToByteVector(coinbaseKey.GetPubKey()) << OP_CHECKSIG};
-            const CBlock block = this->CreateBlock({}, script_pub_key, chainstate);
-
-            new_block = std::make_shared<CBlock>(block);
-
-            LOCK(cs_main);
-            BlockValidationState state;
-            BOOST_CHECK(CheckBlock(block, state, params.GetConsensus()));
-            BOOST_CHECK(m_node.chainman->AcceptBlock(new_block, state, &new_block_index, true, nullptr, nullptr, true));
-            CCoinsViewCache view(&chainstate.CoinsTip());
-            BOOST_CHECK(chainstate.ConnectBlock(block, state, new_block_index, view));
-        }
-        // Send block connected notification, then stop the index without
-        // sending a chainstate flushed notification. Prior to #24138, this
-        // would cause the index to be corrupted and fail to reload.
-        ValidationInterfaceTest::BlockConnected(ChainstateRole{}, index, new_block, new_block_index);
-        index.Stop();
-    }
-
-    {
-        CoinStatsIndex index{interfaces::MakeChain(m_node), 1_MiB};
-        BOOST_REQUIRE(index.Init());
-        // Make sure the index can be loaded.
-        BOOST_REQUIRE(index.StartBackgroundSync());
-        index.Stop();
-    }
-}
-
-BOOST_AUTO_TEST_SUITE_END()
diff --git a/src/test/data/blockfilters.json b/src/test/data/blockfilters.json
deleted file mode 100644
index 8945296a079b..000000000000
--- a/src/test/data/blockfilters.json
+++ /dev/null
@@ -1,13 +0,0 @@
-[
-["Block Height,Block Hash,Block,[Prev Output Scripts for Block],Previous Basic Header,Basic Filter,Basic Header,Notes"],
-[0,"000000000933ea01ad0ee984209779baaec3ced90fa3f408719526f8d77f4943","0100000000000000000000000000000000000000000000000000000000000000000000003ba3edfd7a7b12b27ac72c3e67768f617fc81bc3888a51323a9fb8aa4b1e5e4adae5494dffff001d1aa4ae180101000000010000000000000000000000000000000000000000000000000000000000000000ffffffff4d04ffff001d0104455468652054696d65732030332f4a616e2f32303039204368616e63656c6c6f72206f6e206272696e6b206f66207365636f6e64206261696c6f757420666f722062616e6b73ffffffff0100f2052a01000000434104678afdb0fe5548271967f1a67130b7105cd6a828e03909a67962e0ea1f61deb649f6bc3f4cef38c4f35504e51ec112de5c384df7ba0b8d578a4c702b6bf11d5fac00000000",[],"0000000000000000000000000000000000000000000000000000000000000000","019dfca8","21584579b7eb08997773e5aeff3a7f932700042d0ed2a6129012b7d7ae81b750","Genesis block"],
-[2,"000000006c02c8ea6e4ff69651f7fcde348fb9d557a06e6957b65552002a7820","0100000006128e87be8b1b4dea47a7247d5528d2702c96826c7a648497e773b800000000e241352e3bec0a95a6217e10c3abb54adfa05abb12c126695595580fb92e222032e7494dffff001d00d235340101000000010000000000000000000000000000000000000000000000000000000000000000ffffffff0e0432e7494d010e062f503253482fffffffff0100f2052a010000002321038a7f6ef1c8ca0c588aa53fa860128077c9e6c11e6830f4d7ee4e763a56b7718fac00000000",[],"d7bdac13a59d745b1add0d2ce852f1a0442e8945fc1bf3848d3cbffd88c24fe1","0174a170","186afd11ef2b5e7e3504f2e8cbf8df28a1fd251fe53d60dff8b1467d1b386cf0",""],
-[3,"000000008b896e272758da5297bcd98fdc6d97c9b765ecec401e286dc1fdbe10","0100000020782a005255b657696ea057d5b98f34defcf75196f64f6eeac8026c0000000041ba5afc532aae03151b8aa87b65e1594f97504a768e010c98c0add79216247186e7494dffff001d058dc2b60101000000010000000000000000000000000000000000000000000000000000000000000000ffffffff0e0486e7494d0151062f503253482fffffffff0100f2052a01000000232103f6d9ff4c12959445ca5549c811683bf9c88e637b222dd2e0311154c4c85cf423ac00000000",[],"186afd11ef2b5e7e3504f2e8cbf8df28a1fd251fe53d60dff8b1467d1b386cf0","016cf7a0","8d63aadf5ab7257cb6d2316a57b16f517bff1c6388f124ec4c04af1212729d2a",""],
-[15007,"0000000038c44c703bae0f98cdd6bf30922326340a5996cc692aaae8bacf47ad","0100000002394092aa378fe35d7e9ac79c869b975c4de4374cd75eb5484b0e1e00000000eb9b8670abd44ad6c55cee18e3020fb0c6519e7004b01a16e9164867531b67afc33bc94fffff001d123f10050101000000010000000000000000000000000000000000000000000000000000000000000000ffffffff0e04c33bc94f0115062f503253482fffffffff0100f2052a01000000232103f268e9ae07e0f8cb2f6e901d87c510d650b97230c0365b021df8f467363cafb1ac00000000",[],"18b5c2b0146d2d09d24fb00ff5b52bd0742f36c9e65527abdb9de30c027a4748","013c3710","07384b01311867949e0c046607c66b7a766d338474bb67f66c8ae9dbd454b20e","Tx has non-standard OP_RETURN output followed by opcodes"],
-[49291,"0000000018b07dca1b28b4b5a119f6d6e71698ce1ed96f143f54179ce177a19c","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",["5221033423007d8f263819a2e42becaaf5b06f34cb09919e06304349d950668209eaed21021d69e2b68c3960903b702af7829fadcd80bd89b158150c85c4a75b2c8cb9c39452ae","52210279be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f8179821021d69e2b68c3960903b702af7829fadcd80bd89b158150c85c4a75b2c8cb9c39452ae","522102a7ae1e0971fc1689bd66d2a7296da3a1662fd21a53c9e38979e0f090a375c12d21022adb62335f41eb4e27056ac37d462cda5ad783fa8e0e526ed79c752475db285d52ae","52210279be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f8179821022adb62335f41eb4e27056ac37d462cda5ad783fa8e0e526ed79c752475db285d52ae","512103b9d1d0e2b4355ec3cdef7c11a5c0beff9e8b8d8372ab4b4e0aaf30e80173001951ae","76a9149144761ebaccd5b4bbdc2a35453585b5637b2f8588ac","522103f1848b40621c5d48471d9784c8174ca060555891ace6d2b03c58eece946b1a9121020ee5d32b54d429c152fdc7b1db84f2074b0564d35400d89d11870f9273ec140c52ae","76a914f4fa1cc7de742d135ea82c17adf0bb9cf5f4fb8388ac"],"ed47705334f4643892ca46396eb3f4196a5e30880589e4009ef38eae895d4a13","0afbc2920af1b027f31f87b592276eb4c32094bb4d3697021b4c6380","b6d98692cec5145f67585f3434ec3c2b3030182e1cb3ec58b855c5c164dfaaa3","Tx pays to empty output script"],
-[180480,"00000000fd3ceb2404ff07a785c7fdcc76619edc8ed61bd25134eaa22084366a","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",["","","","76a9142903b138c24be9e070b3e73ec495d77a204615e788ac","76a91433a1941fd9a37b9821d376f5a51bd4b52fa50e2888ac","76a914e4374e8155d0865742ca12b8d4d14d41b57d682f88ac","76a914001fa7459a6cfc64bdc178ba7e7a21603bb2568f88ac","76a914f6039952bc2b307aeec5371bfb96b66078ec17f688ac"],"d34ef98386f413769502808d4bac5f20f8dfd5bffc9eedafaa71de0eb1f01489","0db414c859a07e8205876354a210a75042d0463404913d61a8e068e58a3ae2aa080026","c582d51c0ca365e3fcf36c51cb646d7f83a67e867cb4743fd2128e3e022b700c","Tx spends from empty output script"],
-[926485,"000000000000015d6077a411a8f5cc95caf775ccf11c54e27df75ce58d187313","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",["a914feb8a29635c56d9cd913122f90678756bf23887687","76a914c01a7ca16b47be50cbdbc60724f701d52d75156688ac","76a914913bcc2be49cb534c20474c4dee1e9c4c317e7eb88ac","76a914913bcc2be49cb534c20474c4dee1e9c4c317e7eb88ac","76a914913bcc2be49cb534c20474c4dee1e9c4c317e7eb88ac","76a914913bcc2be49cb534c20474c4dee1e9c4c317e7eb88ac","76a914913bcc2be49cb534c20474c4dee1e9c4c317e7eb88ac","76a914913bcc2be49cb534c20474c4dee1e9c4c317e7eb88ac"],"8f13b9a9c85611635b47906c3053ac53cfcec7211455d4cb0d63dc9acc13d472","09027acea61b6cc3fb33f5d52f7d088a6b2f75d234e89ca800","546c574a0472144bcaf9b6aeabf26372ad87c7af7d1ee0dbfae5e099abeae49c","Duplicate pushdata 913bcc2be49cb534c20474c4dee1e9c4c317e7eb"],
-[987876,"0000000000000c00901f2049055e2a437c819d79a3d54fd63e6af796cd7b8a79","000000202694f74969fdb542090e95a56bc8aa2d646e27033850e32f1c5f000000000000f7e53676b3f12d5beb524ed617f2d25f5a93b5f4f52c1ba2678260d72712f8dd0a6dfe5740257e1a4b1768960101000000010000000000000000000000000000000000000000000000000000000000000000ffffffff1603e4120ff9c30a1c216900002f424d4920546573742fffffff0001205fa012000000001e76a914c486de584a735ec2f22da7cd9681614681f92173d83d0aa68688ac00000000",[],"fe4d230dbb0f4fec9bed23a5283e08baf996e3f32b93f52c7de1f641ddfd04ad","010c0b40","0965a544743bbfa36f254446e75630c09404b3d164a261892372977538928ed5","Coinbase tx has unparseable output script"],
-[1263442,"000000006f27ddfe1dd680044a34548f41bed47eba9e6f0b310da21423bc5f33","000000201c8d1a529c39a396db2db234d5ec152fa651a2872966daccbde028b400000000083f14492679151dbfaa1a825ef4c18518e780c1f91044180280a7d33f4a98ff5f45765aaddc001d38333b9a02010000000001010000000000000000000000000000000000000000000000000000000000000000ffffffff230352471300fe5f45765afe94690a000963676d696e6572343208000000000000000000ffffffff024423a804000000001976a914f2c25ac3d59f3d674b1d1d0a25c27339aaac0ba688ac0000000000000000266a24aa21a9edcb26cb3052426b9ebb4d19c819ef87c19677bbf3a7c46ef0855bd1b2abe83491012000000000000000000000000000000000000000000000000000000000000000000000000002000000000101d20978463906ba4ff5e7192494b88dd5eb0de85d900ab253af909106faa22cc5010000000004000000014777ff000000000016001446c29eabe8208a33aa1023c741fa79aa92e881ff0347304402207d7ca96134f2bcfdd6b536536fdd39ad17793632016936f777ebb32c22943fda02206014d2fb8a6aa58279797f861042ba604ebd2f8f61e5bddbd9d3be5a245047b201004b632103eeaeba7ce5dc2470221e9517fb498e8d6bd4e73b85b8be655196972eb9ccd5566754b2752103a40b74d43df244799d041f32ce1ad515a6cd99501701540e38750d883ae21d3a68ac00000000",["002027a5000c7917f785d8fc6e5a55adfca8717ecb973ebb7743849ff956d896a7ed"],"31d66d516a9eda7de865df29f6ef6cb8e4bf9309e5dac899968a9a62a5df61e3","0385acb4f0fe889ef0","4e6d564c2a2452065c205dd7eb2791124e0c4e0dbb064c410c24968572589dec","Includes witness data"],
-[1414221,"0000000000000027b2b3b3381f114f674f481544ff2be37ae3788d7e078383b1","000000204ea88307a7959d8207968f152bedca5a93aefab253f1fb2cfb032a400000000070cebb14ec6dbc27a9dfd066d9849a4d3bac5f674665f73a5fe1de01a022a0c851fda85bf05f4c19a779d1450102000000010000000000000000000000000000000000000000000000000000000000000000ffffffff18034d94154d696e6572476174653030310d000000f238f401ffffffff01c817a804000000000000000000",[],"5e5e12d90693c8e936f01847859404c67482439681928353ca1296982042864e","00","021e8882ef5a0ed932edeebbecfeda1d7ce528ec7b3daa27641acf1189d7b5dc","Empty data"]
-]
diff --git a/src/test/fuzz/CMakeLists.txt b/src/test/fuzz/CMakeLists.txt
index 7abf8e307b0c..2409e828012f 100644
--- a/src/test/fuzz/CMakeLists.txt
+++ b/src/test/fuzz/CMakeLists.txt
@@ -20,7 +20,6 @@ add_executable(fuzz
   block_header.cpp
   block_index.cpp
   block_index_tree.cpp
-  blockfilter.cpp
   bloom_filter.cpp
   buffered_file.cpp
   chain.cpp
diff --git a/src/test/fuzz/blockfilter.cpp b/src/test/fuzz/blockfilter.cpp
deleted file mode 100644
index ed0f9e0dd12a..000000000000
--- a/src/test/fuzz/blockfilter.cpp
+++ /dev/null
@@ -1,47 +0,0 @@
-// Copyright (c) 2020-present 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 <test/fuzz/FuzzedDataProvider.h>
-#include <test/fuzz/fuzz.h>
-#include <test/fuzz/util.h>
-#include <test/util/random.h>
-
-#include <cstdint>
-#include <optional>
-#include <string>
-#include <vector>
-
-FUZZ_TARGET(blockfilter)
-{
-    SeedRandomStateForTest(SeedRand::ZEROS);
-    FuzzedDataProvider fuzzed_data_provider(buffer.data(), buffer.size());
-    const std::optional<BlockFilter> block_filter = ConsumeDeserializable<BlockFilter>(fuzzed_data_provider);
-    if (!block_filter) {
-        return;
-    }
-    {
-        (void)block_filter->ComputeHeader(ConsumeUInt256(fuzzed_data_provider));
-        (void)block_filter->GetBlockHash();
-        (void)block_filter->GetEncodedFilter();
-        (void)block_filter->GetHash();
-    }
-    {
-        const BlockFilterType block_filter_type = block_filter->GetFilterType();
-        (void)BlockFilterTypeName(block_filter_type);
-    }
-    {
-        const GCSFilter gcs_filter = block_filter->GetFilter();
-        (void)gcs_filter.GetN();
-        (void)gcs_filter.GetParams();
-        (void)gcs_filter.GetEncoded();
-        (void)gcs_filter.Match(ConsumeRandomLengthByteVector(fuzzed_data_provider));
-        GCSFilter::ElementSet element_set;
-        LIMITED_WHILE(fuzzed_data_provider.ConsumeBool(), 30000)
-        {
-            element_set.insert(ConsumeRandomLengthByteVector(fuzzed_data_provider));
-        }
-        gcs_filter.MatchAny(element_set);
-    }
-}
diff --git a/src/test/fuzz/deserialize.cpp b/src/test/fuzz/deserialize.cpp
index ec46036356dd..d85e7d471db4 100644
--- a/src/test/fuzz/deserialize.cpp
+++ b/src/test/fuzz/deserialize.cpp
@@ -6,7 +6,6 @@
 #include <addrman.h>
 #include <addrman_impl.h>
 #include <blockencodings.h>
-#include <blockfilter.h>
 #include <chain.h>
 #include <coins.h>
 #include <common/args.h>
@@ -136,10 +135,6 @@ void AssertEqualAfterSerializeDeserialize(const T& obj)
 
 } // namespace
 
-FUZZ_TARGET_DESERIALIZE(block_filter_deserialize, {
-    BlockFilter block_filter;
-    DeserializeFromFuzzingInput(buffer, block_filter);
-})
 FUZZ_TARGET(addr_info_deserialize, .init = initialize_deserialize)
 {
     FuzzedDataProvider fdp{buffer.data(), buffer.size()};
diff --git a/src/test/fuzz/golomb_rice.cpp b/src/test/fuzz/golomb_rice.cpp
index a09126be7920..bb01384f87b2 100644
--- a/src/test/fuzz/golomb_rice.cpp
+++ b/src/test/fuzz/golomb_rice.cpp
@@ -2,7 +2,6 @@
 // Distributed under the MIT software license, see the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
-#include <blockfilter.h>
 #include <serialize.h>
 #include <streams.h>
 #include <test/fuzz/FuzzedDataProvider.h>
@@ -21,6 +20,10 @@
 
 namespace {
 
+// BIP158 Golomb-Rice parameters (formerly from blockfilter.h)
+constexpr uint8_t BASIC_FILTER_P = 19;
+constexpr uint32_t BASIC_FILTER_M = 784931;
+
 uint64_t HashToRange(const std::vector<uint8_t>& element, const uint64_t f)
 {
     const uint64_t hash = CSipHasher(0x0706050403020100ULL, 0x0F0E0D0C0B0A0908ULL)
diff --git a/src/test/fuzz/rpc.cpp b/src/test/fuzz/rpc.cpp
index 23a1d7ce9f2d..42c02e7aae74 100644
--- a/src/test/fuzz/rpc.cpp
+++ b/src/test/fuzz/rpc.cpp
@@ -111,7 +111,6 @@ const std::vector<std::string> RPC_COMMANDS_SAFE_FOR_FUZZING{
     "getblock",
     "getblockchaininfo",
     "getblockcount",
-    "getblockfilter",
     "getblockfrompeer", // when no peers are connected, no p2p message is sent
     "getblockhash",
     "getblockheader",
@@ -125,7 +124,6 @@ const std::vector<std::string> RPC_COMMANDS_SAFE_FOR_FUZZING{
     "getdescriptoractivity",
     "getdescriptorinfo",
     "getdifficulty",
-    "getindexinfo",
     "getmemoryinfo",
     "getmempoolancestors",
     "getmempooldescendants",
@@ -148,7 +146,6 @@ const std::vector<std::string> RPC_COMMANDS_SAFE_FOR_FUZZING{
     "getrpcinfo",
     "gettxout",
     "gettxoutsetinfo",
-    "gettxspendingprevout",
     "help",
     "invalidateblock",
     "listbanned",
@@ -159,7 +156,6 @@ const std::vector<std::string> RPC_COMMANDS_SAFE_FOR_FUZZING{
     "prioritisetransaction",
     "pruneblockchain",
     "reconsiderblock",
-    "scanblocks",
     "scantxoutset",
     "sendmsgtopeer", // when no peers are connected, no p2p message is sent
     "sendrawtransaction",
diff --git a/src/test/fuzz/string.cpp b/src/test/fuzz/string.cpp
index a7f8516f111f..633820721111 100644
--- a/src/test/fuzz/string.cpp
+++ b/src/test/fuzz/string.cpp
@@ -2,7 +2,6 @@
 // Distributed under the MIT software license, see the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
-#include <blockfilter.h>
 #include <clientversion.h>
 #include <common/args.h>
 #include <common/license_info.h>
@@ -55,8 +54,6 @@ FUZZ_TARGET(string)
 
     (void)AmountErrMsg(random_string_1, random_string_2);
     (void)AmountHighWarn(random_string_1);
-    BlockFilterType block_filter_type;
-    (void)BlockFilterTypeByName(random_string_1, block_filter_type);
     (void)Capitalize(random_string_1);
     (void)CopyrightHolders(random_string_1);
     FeeEstimateMode fee_estimate_mode;
diff --git a/src/test/netbase_tests.cpp b/src/test/netbase_tests.cpp
index e376b0cf5a3b..1ab6b2717580 100644
--- a/src/test/netbase_tests.cpp
+++ b/src/test/netbase_tests.cpp
@@ -515,7 +515,7 @@ static const std::vector<CAddress> fixture_addresses({
     },
     CAddress{
         CService(CNetAddr(in6_addr(COMPAT_IN6ADDR_LOOPBACK_INIT)), 0xf1f2 /* port */),
-        static_cast<ServiceFlags>(NODE_WITNESS | NODE_COMPACT_FILTERS | NODE_NETWORK_LIMITED),
+        static_cast<ServiceFlags>(NODE_WITNESS | ServiceFlags(1 << 6) | NODE_NETWORK_LIMITED),
         NodeSeconds{0xffffffffs}, /* Sun Feb  7 06:28:15 UTC 2106 */
     },
 });
@@ -536,7 +536,7 @@ static constexpr const char* stream_addrv1_hex =
     "00f1"                             // port
 
     "ffffffff"                         // time, Sun Feb  7 06:28:15 UTC 2106
-    "4804000000000000"                 // service flags, NODE_WITNESS | NODE_COMPACT_FILTERS | NODE_NETWORK_LIMITED
+    "4804000000000000"                 // service flags, NODE_WITNESS | ServiceFlags(1 << 6) | NODE_NETWORK_LIMITED
     "00000000000000000000000000000001" // address, fixed 16 bytes (IPv6)
     "f1f2";                            // port
 
@@ -560,7 +560,7 @@ static constexpr const char* stream_addrv2_hex =
     "00f1"                             // port
 
     "ffffffff"                         // time, Sun Feb  7 06:28:15 UTC 2106
-    "fd4804"                           // service flags, COMPACTSIZE(NODE_WITNESS | NODE_COMPACT_FILTERS | NODE_NETWORK_LIMITED)
+    "fd4804"                           // service flags, COMPACTSIZE(NODE_WITNESS | ServiceFlags(1 << 6) | NODE_NETWORK_LIMITED)
     "02"                               // network id, IPv6
     "10"                               // address length, COMPACTSIZE(16)
     "00000000000000000000000000000001" // address
diff --git a/src/test/txindex_tests.cpp b/src/test/txindex_tests.cpp
deleted file mode 100644
index 46711e080c60..000000000000
--- a/src/test/txindex_tests.cpp
+++ /dev/null
@@ -1,69 +0,0 @@
-// Copyright (c) 2017-present 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 <addresstype.h>
-#include <chainparams.h>
-#include <index/txindex.h>
-#include <interfaces/chain.h>
-#include <test/util/setup_common.h>
-#include <util/byte_units.h>
-#include <validation.h>
-
-#include <boost/test/unit_test.hpp>
-
-BOOST_AUTO_TEST_SUITE(txindex_tests)
-
-BOOST_FIXTURE_TEST_CASE(txindex_initial_sync, TestChain100Setup)
-{
-    TxIndex txindex(interfaces::MakeChain(m_node), 1_MiB, true);
-    BOOST_REQUIRE(txindex.Init());
-
-    CTransactionRef tx_disk;
-    uint256 block_hash;
-
-    // Transaction should not be found in the index before it is started.
-    for (const auto& txn : m_coinbase_txns) {
-        BOOST_CHECK(!txindex.FindTx(txn->GetHash(), block_hash, tx_disk));
-    }
-
-    // BlockUntilSyncedToCurrentChain should return false before txindex is started.
-    BOOST_CHECK(!txindex.BlockUntilSyncedToCurrentChain());
-
-    txindex.Sync();
-
-    // Check that txindex excludes genesis block transactions.
-    const CBlock& genesis_block = Params().GenesisBlock();
-    for (const auto& txn : genesis_block.vtx) {
-        BOOST_CHECK(!txindex.FindTx(txn->GetHash(), block_hash, tx_disk));
-    }
-
-    // Check that txindex has all txs that were in the chain before it started.
-    for (const auto& txn : m_coinbase_txns) {
-        if (!txindex.FindTx(txn->GetHash(), block_hash, tx_disk)) {
-            BOOST_ERROR("FindTx failed");
-        } else if (tx_disk->GetHash() != txn->GetHash()) {
-            BOOST_ERROR("Read incorrect tx");
-        }
-    }
-
-    // Check that new transactions in new blocks make it into the index.
-    for (int i = 0; i < 10; i++) {
-        CScript coinbase_script_pub_key = GetScriptForDestination(PKHash(coinbaseKey.GetPubKey()));
-        std::vector<CMutableTransaction> no_txns;
-        const CBlock& block = CreateAndProcessBlock(no_txns, coinbase_script_pub_key);
-        const CTransaction& txn = *block.vtx[0];
-
-        BOOST_CHECK(txindex.BlockUntilSyncedToCurrentChain());
-        if (!txindex.FindTx(txn.GetHash(), block_hash, tx_disk)) {
-            BOOST_ERROR("FindTx failed");
-        } else if (tx_disk->GetHash() != txn.GetHash()) {
-            BOOST_ERROR("Read incorrect tx");
-        }
-    }
-
-    // shutdown sequence (c.f. Shutdown() in init.cpp)
-    txindex.Stop();
-}
-
-BOOST_AUTO_TEST_SUITE_END()
diff --git a/src/test/txospenderindex_tests.cpp b/src/test/txospenderindex_tests.cpp
deleted file mode 100644
index 44d2bf0e5e70..000000000000
--- a/src/test/txospenderindex_tests.cpp
+++ /dev/null
@@ -1,77 +0,0 @@
-// Copyright (c) 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 <index/txospenderindex.h>
-#include <test/util/common.h>
-#include <test/util/setup_common.h>
-#include <validation.h>
-
-#include <boost/test/unit_test.hpp>
-
-BOOST_AUTO_TEST_SUITE(txospenderindex_tests)
-
-BOOST_FIXTURE_TEST_CASE(txospenderindex_initial_sync, TestChain100Setup)
-{
-    // Setup phase:
-    // Mine blocks for coinbase maturity, so we can spend some coinbase outputs in the test.
-    const CScript& coinbase_script = m_coinbase_txns[0]->vout[0].scriptPubKey;
-    for (int i = 0; i < 10; i++) CreateAndProcessBlock({}, coinbase_script);
-
-    // Spend 10 outputs
-    std::vector<COutPoint> spent(10);
-    std::vector<CMutableTransaction> spender(spent.size());
-    for (size_t i = 0; i < spent.size(); i++) {
-        // Outpoint
-        auto coinbase_tx = m_coinbase_txns[i];
-        spent[i] = COutPoint(coinbase_tx->GetHash(), 0);
-
-        // Spending tx
-        spender[i].version = 1;
-        spender[i].vin.resize(1);
-        spender[i].vin[0].prevout.hash = spent[i].hash;
-        spender[i].vin[0].prevout.n = spent[i].n;
-        spender[i].vout.resize(1);
-        spender[i].vout[0].nValue = coinbase_tx->GetValueOut();
-        spender[i].vout[0].scriptPubKey = coinbase_script;
-
-        // Sign
-        std::vector<unsigned char> vchSig;
-        const uint256 hash = SignatureHash(coinbase_script, spender[i], 0, SIGHASH_ALL, 0, SigVersion::BASE);
-        BOOST_REQUIRE(coinbaseKey.Sign(hash, vchSig));
-        vchSig.push_back((unsigned char)SIGHASH_ALL);
-        spender[i].vin[0].scriptSig << vchSig;
-    }
-
-    // Generate and ensure block has been fully processed
-    const uint256 tip_hash = CreateAndProcessBlock(spender, coinbase_script).GetHash();
-    m_node.validation_signals->SyncWithValidationInterfaceQueue();
-    BOOST_CHECK_EQUAL(WITH_LOCK(::cs_main, return m_node.chainman->ActiveTip()->GetBlockHash()), tip_hash);
-
-    // Now we concluded the setup phase, run index
-    TxoSpenderIndex txospenderindex(interfaces::MakeChain(m_node), 1 << 20, true);
-    BOOST_REQUIRE(txospenderindex.Init());
-    BOOST_CHECK(!txospenderindex.BlockUntilSyncedToCurrentChain()); // false when not synced
-    BOOST_CHECK_NE(txospenderindex.GetSummary().best_block_hash, tip_hash);
-
-    // Transaction should not be found in the index before it is synced.
-    for (const auto& outpoint : spent) {
-        BOOST_CHECK(!txospenderindex.FindSpender(outpoint).value());
-    }
-
-    txospenderindex.Sync();
-    BOOST_CHECK_EQUAL(txospenderindex.GetSummary().best_block_hash, tip_hash);
-
-    for (size_t i = 0; i < spent.size(); i++) {
-        const auto tx_spender{txospenderindex.FindSpender(spent[i])};
-        BOOST_REQUIRE(tx_spender.has_value());
-        BOOST_REQUIRE(tx_spender->has_value());
-        BOOST_CHECK_EQUAL((*tx_spender)->tx->GetHash(), spender[i].GetHash());
-        BOOST_CHECK_EQUAL((*tx_spender)->block_hash, tip_hash);
-    }
-
-    // Shutdown sequence (c.f. Shutdown() in init.cpp)
-    txospenderindex.Stop();
-}
-
-BOOST_AUTO_TEST_SUITE_END()
diff --git a/src/test/util/CMakeLists.txt b/src/test/util/CMakeLists.txt
index 1d3b6ce741eb..783820c66907 100644
--- a/src/test/util/CMakeLists.txt
+++ b/src/test/util/CMakeLists.txt
@@ -3,7 +3,6 @@
 # file COPYING or https://opensource.org/license/mit/.
 
 add_library(test_util STATIC EXCLUDE_FROM_ALL
-  blockfilter.cpp
   coins.cpp
   coverage.cpp
   json.cpp
diff --git a/src/test/util/blockfilter.cpp b/src/test/util/blockfilter.cpp
deleted file mode 100644
index 3492ca72abc3..000000000000
--- a/src/test/util/blockfilter.cpp
+++ /dev/null
@@ -1,31 +0,0 @@
-// Copyright (c) 2019-present 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 <test/util/blockfilter.h>
-
-#include <chainparams.h>
-#include <node/blockstorage.h>
-#include <primitives/block.h>
-#include <undo.h>
-#include <validation.h>
-
-using node::BlockManager;
-
-bool ComputeFilter(BlockFilterType filter_type, const CBlockIndex& block_index, BlockFilter& filter, const BlockManager& blockman)
-{
-    LOCK(::cs_main);
-
-    CBlock block;
-    if (!blockman.ReadBlock(block, block_index)) {
-        return false;
-    }
-
-    CBlockUndo block_undo;
-    if (block_index.nHeight > 0 && !blockman.ReadBlockUndo(block_undo, block_index)) {
-        return false;
-    }
-
-    filter = BlockFilter(filter_type, block, block_undo);
-    return true;
-}
diff --git a/src/test/util/blockfilter.h b/src/test/util/blockfilter.h
deleted file mode 100644
index dc8761d25469..000000000000
--- a/src/test/util/blockfilter.h
+++ /dev/null
@@ -1,17 +0,0 @@
-// Copyright (c) 2019-present 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_TEST_UTIL_BLOCKFILTER_H
-#define BITCOIN_TEST_UTIL_BLOCKFILTER_H
-
-#include <blockfilter.h>
-
-class CBlockIndex;
-namespace node {
-class BlockManager;
-}
-
-bool ComputeFilter(BlockFilterType filter_type, const CBlockIndex& block_index, BlockFilter& filter, const node::BlockManager& blockman);
-
-#endif // BITCOIN_TEST_UTIL_BLOCKFILTER_H
diff --git a/src/test/util/net.h b/src/test/util/net.h
index 8954e631d3d7..e20edc037cf1 100644
--- a/src/test/util/net.h
+++ b/src/test/util/net.h
@@ -123,7 +123,6 @@ constexpr ServiceFlags ALL_SERVICE_FLAGS[]{
     NODE_NETWORK,
     NODE_BLOOM,
     NODE_WITNESS,
-    NODE_COMPACT_FILTERS,
     NODE_NETWORK_LIMITED,
     NODE_P2P_V2,
 };
diff --git a/src/validation.cpp b/src/validation.cpp
index 211a8122a95c..375e967ad55f 100644
--- a/src/validation.cpp
+++ b/src/validation.cpp
@@ -6351,11 +6351,6 @@ std::pair<int, int> Chainstate::GetPruneRange(int last_height_can_prune) const
         0, m_chain.Height() - static_cast<int>(MIN_BLOCKS_TO_KEEP));
 
     // last block to prune is the lesser of (caller-specified height, MIN_BLOCKS_TO_KEEP from the tip)
-    //
-    // While you might be tempted to prune the background chainstate more
-    // aggressively (i.e. fewer MIN_BLOCKS_TO_KEEP), this won't work with index
-    // building - specifically blockfilterindex requires undo data, and if
-    // we don't maintain this trailing window, we hit indexing failures.
     int prune_end = std::min(last_height_can_prune, max_prune);
 
     return {prune_start, prune_end};
diff --git a/test/functional/feature_assumeutxo.py b/test/functional/feature_assumeutxo.py
index ae130ee20359..9e0c91407592 100755
--- a/test/functional/feature_assumeutxo.py
+++ b/test/functional/feature_assumeutxo.py
@@ -55,7 +55,6 @@
 START_HEIGHT = 199
 SNAPSHOT_BASE_HEIGHT = 299
 FINAL_HEIGHT = 399
-COMPLETE_IDX = {'synced': True, 'best_block_height': FINAL_HEIGHT}
 
 
 class AssumeutxoTest(BitcoinTestFramework):
@@ -66,8 +65,8 @@ def set_test_params(self):
         self.rpc_timeout = 120
         self.extra_args = [
             [],
-            ["-fastprune", "-prune=1", "-blockfilterindex=1", "-coinstatsindex=1"],
-            ["-persistmempool=0","-txindex=1", "-blockfilterindex=1", "-coinstatsindex=1"],
+            ["-fastprune", "-prune=1"],
+            ["-persistmempool=0"],
             []
         ]
 
@@ -535,8 +534,7 @@ def check_dump_output(output):
         self.log.info("Check that UTXO-querying RPCs operate on snapshot chainstate")
         snapshot_hash = loaded['tip_hash']
         snapshot_num_coins = loaded['coins_loaded']
-        # coinstatsindex might be not caught up yet and is not relevant for this test, so don't use it
-        utxo_info = n1.gettxoutsetinfo(use_index=False)
+        utxo_info = n1.gettxoutsetinfo()
         assert_equal(utxo_info['txouts'], snapshot_num_coins)
         assert_equal(utxo_info['height'], SNAPSHOT_BASE_HEIGHT)
         assert_equal(utxo_info['bestblock'], snapshot_hash)
@@ -690,13 +688,6 @@ def check_tx_counts(final: bool) -> None:
         # completing the background sync.
         self.assert_only_network_limited_service(n1)
 
-        # Ensure indexes have synced.
-        completed_idx_state = {
-            'basic block filter index': COMPLETE_IDX,
-            'coinstatsindex': COMPLETE_IDX,
-        }
-        self.wait_until(lambda: n1.getindexinfo() == completed_idx_state)
-
         self.log.info("Re-check nTx and nChainTx values")
         check_tx_counts(final=True)
 
@@ -711,15 +702,11 @@ def check_tx_counts(final: bool) -> None:
             chainstate, = n.getchainstates()['chainstates']
             assert_equal(chainstate['blocks'], FINAL_HEIGHT)
 
-            if i != 0:
-                # Ensure indexes have synced for the assumeutxo node
-                self.wait_until(lambda: n.getindexinfo() == completed_idx_state)
-
 
-        # Node 2: all indexes + reindex
-        # -----------------------------
+        # Node 2: reindex
+        # ---------------
 
-        self.log.info("-- Testing all indexes + reindex")
+        self.log.info("-- Testing reindex")
         assert_equal(n2.getblockcount(), START_HEIGHT)
         assert 'NETWORK' in n2.getnetworkinfo()['localservicesnames']  # sanity check
 
@@ -771,13 +758,6 @@ def check_tx_counts(final: bool) -> None:
         # Once background chain sync completes, the full node must start offering historical blocks again.
         self.wait_until(lambda: {'NETWORK', 'NETWORK_LIMITED'}.issubset(n2.getnetworkinfo()['localservicesnames']))
 
-        completed_idx_state = {
-            'basic block filter index': COMPLETE_IDX,
-            'coinstatsindex': COMPLETE_IDX,
-            'txindex': COMPLETE_IDX,
-        }
-        self.wait_until(lambda: n2.getindexinfo() == completed_idx_state)
-
         for i in (0, 2):
             n = self.nodes[i]
             self.log.info(f"Restarting node {i} to ensure (Check|Load)BlockIndex passes")
@@ -789,10 +769,6 @@ def check_tx_counts(final: bool) -> None:
             chainstate, = n.getchainstates()['chainstates']
             assert_equal(chainstate['blocks'], FINAL_HEIGHT)
 
-            if i != 0:
-                # Ensure indexes have synced for the assumeutxo node
-                self.wait_until(lambda: n.getindexinfo() == completed_idx_state)
-
         self.log.info("Test -reindex-chainstate of an assumeutxo-synced node")
         self.restart_node(2, extra_args=[
             '-reindex-chainstate=1', *self.extra_args[2]])
diff --git a/test/functional/feature_coinstatsindex.py b/test/functional/feature_coinstatsindex.py
deleted file mode 100755
index 729c4db83372..000000000000
--- a/test/functional/feature_coinstatsindex.py
+++ /dev/null
@@ -1,341 +0,0 @@
-#!/usr/bin/env python3
-# Copyright (c) 2020-present The Bitcoin Core developers
-# Distributed under the MIT software license, see the accompanying
-# file COPYING or http://www.opensource.org/licenses/mit-license.php.
-"""Test coinstatsindex across nodes.
-
-Test that the values returned by gettxoutsetinfo are consistent
-between a node running the coinstatsindex and a node without
-the index.
-"""
-
-from decimal import Decimal
-
-from test_framework.blocktools import (
-    COINBASE_MATURITY,
-    create_block,
-    create_coinbase,
-)
-from test_framework.messages import (
-    COIN,
-    CTxOut,
-)
-from test_framework.script import (
-    CScript,
-    OP_FALSE,
-    OP_RETURN,
-)
-from test_framework.test_framework import BitcoinTestFramework
-from test_framework.util import (
-    assert_not_equal,
-    assert_equal,
-    assert_raises_rpc_error,
-)
-from test_framework.wallet import (
-    MiniWallet,
-    getnewdestination,
-)
-
-
-class CoinStatsIndexTest(BitcoinTestFramework):
-    def set_test_params(self):
-        self.setup_clean_chain = True
-        self.num_nodes = 2
-        self.extra_args = [
-            [],
-            ["-coinstatsindex"]
-        ]
-
-    def run_test(self):
-        self.wallet = MiniWallet(self.nodes[0])
-        self._test_coin_stats_index()
-        self._test_use_index_option()
-        self._test_reorg_index()
-        self._test_index_rejects_hash_serialized()
-        self._test_init_index_after_reorg()
-
-    def block_sanity_check(self, block_info):
-        block_subsidy = 50
-        assert_equal(
-            block_info['prevout_spent'] + block_subsidy,
-            block_info['new_outputs_ex_coinbase'] + block_info['coinbase'] + block_info['unspendable']
-        )
-
-    def sync_index_node(self):
-        self.wait_until(lambda: self.nodes[1].getindexinfo()['coinstatsindex']['synced'] is True)
-
-    def _test_coin_stats_index(self):
-        node = self.nodes[0]
-        index_node = self.nodes[1]
-        # Both none and muhash options allow the usage of the index
-        index_hash_options = ['none', 'muhash']
-
-        # Generate a normal transaction and mine it
-        self.generate(self.wallet, COINBASE_MATURITY + 1)
-        self.wallet.send_self_transfer(from_node=node)
-        self.generate(node, 1)
-
-        self.log.info("Test that gettxoutsetinfo() output is consistent with or without coinstatsindex option")
-        res0 = node.gettxoutsetinfo('none')
-
-        # The fields 'disk_size' and 'transactions' do not exist on the index
-        del res0['disk_size'], res0['transactions']
-
-        for hash_option in index_hash_options:
-            res1 = index_node.gettxoutsetinfo(hash_option)
-            # The fields 'block_info' and 'total_unspendable_amount' only exist on the index
-            del res1['block_info'], res1['total_unspendable_amount']
-            res1.pop('muhash', None)
-
-            # Everything left should be the same
-            assert_equal(res1, res0)
-
-        self.log.info("Test that gettxoutsetinfo() can get fetch data on specific heights with index")
-
-        # Generate a new tip
-        self.generate(node, 5)
-
-        for hash_option in index_hash_options:
-            # Fetch old stats by height
-            res2 = index_node.gettxoutsetinfo(hash_option, 102)
-            del res2['block_info'], res2['total_unspendable_amount']
-            res2.pop('muhash', None)
-            assert_equal(res0, res2)
-
-            # Fetch old stats by hash
-            res3 = index_node.gettxoutsetinfo(hash_option, res0['bestblock'])
-            del res3['block_info'], res3['total_unspendable_amount']
-            res3.pop('muhash', None)
-            assert_equal(res0, res3)
-
-            # It does not work without coinstatsindex
-            assert_raises_rpc_error(-8, "Querying specific block heights requires coinstatsindex", node.gettxoutsetinfo, hash_option, 102)
-
-        self.log.info("Test gettxoutsetinfo() with index and verbose flag")
-
-        for hash_option in index_hash_options:
-            # Genesis block is unspendable
-            res4 = index_node.gettxoutsetinfo(hash_option, 0)
-            assert_equal(res4['total_unspendable_amount'], 50)
-            assert_equal(res4['block_info'], {
-                'unspendable': 50,
-                'prevout_spent': 0,
-                'new_outputs_ex_coinbase': 0,
-                'coinbase': 0,
-                'unspendables': {
-                    'genesis_block': 50,
-                    'bip30': 0,
-                    'scripts': 0,
-                    'unclaimed_rewards': 0
-                }
-            })
-            self.block_sanity_check(res4['block_info'])
-
-            # Test an older block height that included a normal tx
-            res5 = index_node.gettxoutsetinfo(hash_option, 102)
-            assert_equal(res5['total_unspendable_amount'], 50)
-            assert_equal(res5['block_info'], {
-                'unspendable': 0,
-                'prevout_spent': 50,
-                'new_outputs_ex_coinbase': Decimal('49.99968800'),
-                'coinbase': Decimal('50.00031200'),
-                'unspendables': {
-                    'genesis_block': 0,
-                    'bip30': 0,
-                    'scripts': 0,
-                    'unclaimed_rewards': 0,
-                }
-            })
-            self.block_sanity_check(res5['block_info'])
-
-        # Generate and send a normal tx with two outputs
-        tx1 = self.wallet.send_to(
-            from_node=node,
-            scriptPubKey=self.wallet.get_output_script(),
-            amount=21 * COIN,
-        )
-
-        # Find the right position of the 21 BTC output
-        tx1_out_21 = self.wallet.get_utxo(txid=tx1["txid"], vout=tx1["sent_vout"])
-
-        # Generate and send another tx with an OP_RETURN output (which is unspendable)
-        tx2 = self.wallet.create_self_transfer(utxo_to_spend=tx1_out_21)['tx']
-        tx2_val = '20.99'
-        tx2.vout = [CTxOut(int(Decimal(tx2_val) * COIN), CScript([OP_RETURN] + [OP_FALSE] * 30))]
-        tx2_hex = tx2.serialize().hex()
-        self.nodes[0].sendrawtransaction(tx2_hex, 0, tx2_val)
-
-        # Include both txs in a block
-        self.generate(self.nodes[0], 1)
-
-        for hash_option in index_hash_options:
-            # Check all amounts were registered correctly
-            res6 = index_node.gettxoutsetinfo(hash_option, 108)
-            assert_equal(res6['total_unspendable_amount'], Decimal('70.99000000'))
-            assert_equal(res6['block_info'], {
-                'unspendable': Decimal('20.99000000'),
-                'prevout_spent': 71,
-                'new_outputs_ex_coinbase': Decimal('49.99999000'),
-                'coinbase': Decimal('50.01001000'),
-                'unspendables': {
-                    'genesis_block': 0,
-                    'bip30': 0,
-                    'scripts': Decimal('20.99000000'),
-                    'unclaimed_rewards': 0,
-                }
-            })
-            self.block_sanity_check(res6['block_info'])
-
-        # Create a coinbase that does not claim full subsidy and also
-        # has two outputs
-        cb = create_coinbase(109, nValue=35)
-        cb.vout.append(CTxOut(5 * COIN, CScript([OP_FALSE])))
-
-        # Generate a block that includes previous coinbase
-        tip = self.nodes[0].getbestblockhash()
-        block_time = self.nodes[0].getblock(tip)['time'] + 1
-        block = create_block(int(tip, 16), cb, ntime=block_time)
-        block.solve()
-        self.nodes[0].submitblock(block.serialize().hex())
-        self.sync_all()
-
-        for hash_option in index_hash_options:
-            res7 = index_node.gettxoutsetinfo(hash_option, 109)
-            assert_equal(res7['total_unspendable_amount'], Decimal('80.99000000'))
-            assert_equal(res7['block_info'], {
-                'unspendable': 10,
-                'prevout_spent': 0,
-                'new_outputs_ex_coinbase': 0,
-                'coinbase': 40,
-                'unspendables': {
-                    'genesis_block': 0,
-                    'bip30': 0,
-                    'scripts': 0,
-                    'unclaimed_rewards': 10
-                }
-            })
-            self.block_sanity_check(res7['block_info'])
-
-        self.log.info("Test that the index is robust across restarts")
-
-        res8 = index_node.gettxoutsetinfo('muhash')
-        self.restart_node(1, extra_args=self.extra_args[1])
-        res9 = index_node.gettxoutsetinfo('muhash')
-        assert_equal(res8, res9)
-
-        self.generate(index_node, 1, sync_fun=self.no_op)
-        res10 = index_node.gettxoutsetinfo('muhash')
-        assert res8['txouts'] < res10['txouts']
-
-        self.log.info("Test that the index works with -reindex")
-
-        self.restart_node(1, extra_args=["-coinstatsindex", "-reindex"])
-        self.sync_index_node()
-        res11 = index_node.gettxoutsetinfo('muhash')
-        assert_equal(res11, res10)
-
-        self.log.info("Test that the index works with -reindex-chainstate")
-
-        self.restart_node(1, extra_args=["-coinstatsindex", "-reindex-chainstate"])
-        self.sync_index_node()
-        res12 = index_node.gettxoutsetinfo('muhash')
-        assert_equal(res12, res10)
-
-        self.log.info("Test obtaining info for a non-existent block hash")
-        assert_raises_rpc_error(-5, "Block not found", index_node.gettxoutsetinfo, hash_type="none", hash_or_height="ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff", use_index=True)
-
-    def _test_use_index_option(self):
-        self.log.info("Test use_index option for nodes running the index")
-
-        self.connect_nodes(0, 1)
-        self.nodes[0].waitforblockheight(110)
-        res = self.nodes[0].gettxoutsetinfo('muhash')
-        option_res = self.nodes[1].gettxoutsetinfo(hash_type='muhash', hash_or_height=None, use_index=False)
-        del res['disk_size'], option_res['disk_size']
-        assert_equal(res, option_res)
-
-    def _test_reorg_index(self):
-        self.log.info("Test that index can handle reorgs")
-
-        # Generate two block, let the index catch up, then invalidate the blocks
-        index_node = self.nodes[1]
-        reorg_blocks = self.generatetoaddress(index_node, 2, getnewdestination()[2])
-        reorg_block = reorg_blocks[1]
-        self.sync_index_node()
-        res_invalid = index_node.gettxoutsetinfo('muhash')
-        index_node.invalidateblock(reorg_blocks[0])
-        assert_equal(index_node.gettxoutsetinfo('muhash')['height'], 110)
-
-        # Add two new blocks
-        block = self.generate(index_node, 2, sync_fun=self.no_op)[1]
-        res = index_node.gettxoutsetinfo(hash_type='muhash', hash_or_height=None, use_index=False)
-
-        # Test that the result of the reorged block is not returned for its old block height
-        res2 = index_node.gettxoutsetinfo(hash_type='muhash', hash_or_height=112)
-        assert_equal(res["bestblock"], block)
-        assert_equal(res["muhash"], res2["muhash"])
-        assert_not_equal(res["muhash"], res_invalid["muhash"])
-
-        # Test that requesting reorged out block by hash is still returning correct results
-        res_invalid2 = index_node.gettxoutsetinfo(hash_type='muhash', hash_or_height=reorg_block)
-        assert_equal(res_invalid2["muhash"], res_invalid["muhash"])
-        assert_not_equal(res["muhash"], res_invalid2["muhash"])
-
-        # Add another block, so we don't depend on reconsiderblock remembering which
-        # blocks were touched by invalidateblock
-        self.generate(index_node, 1)
-
-        # Ensure that removing and re-adding blocks yields consistent results
-        block = index_node.getblockhash(99)
-        index_node.invalidateblock(block)
-        index_node.reconsiderblock(block)
-        res3 = index_node.gettxoutsetinfo(hash_type='muhash', hash_or_height=112)
-        assert_equal(res2, res3)
-
-    def _test_index_rejects_hash_serialized(self):
-        self.log.info("Test that the rpc raises if the legacy hash is passed with the index")
-
-        msg = "hash_serialized_3 hash type cannot be queried for a specific block"
-        assert_raises_rpc_error(-8, msg, self.nodes[1].gettxoutsetinfo, hash_type='hash_serialized_3', hash_or_height=111)
-
-        for use_index in {True, False, None}:
-            assert_raises_rpc_error(-8, msg, self.nodes[1].gettxoutsetinfo, hash_type='hash_serialized_3', hash_or_height=111, use_index=use_index)
-
-    def _test_init_index_after_reorg(self):
-        self.log.info("Test a reorg while the index is deactivated")
-        index_node = self.nodes[1]
-        block = self.nodes[0].getbestblockhash()
-        self.generate(index_node, 2, sync_fun=self.no_op)
-        self.sync_index_node()
-
-        # Restart without index
-        self.restart_node(1, extra_args=[])
-        self.connect_nodes(0, 1)
-        index_node.invalidateblock(block)
-        self.generatetoaddress(index_node, 5, getnewdestination()[2])
-        res = index_node.gettxoutsetinfo(hash_type='muhash', hash_or_height=None, use_index=False)
-
-        # Restart with index that still has its best block on the old chain
-        self.restart_node(1, extra_args=self.extra_args[1])
-        self.sync_index_node()
-        res1 = index_node.gettxoutsetinfo(hash_type='muhash', hash_or_height=None, use_index=True)
-        assert_equal(res["muhash"], res1["muhash"])
-
-        self.log.info("Test index with an unclean restart after a reorg")
-        self.restart_node(1, extra_args=self.extra_args[1])
-        committed_height = index_node.getblockcount()
-        self.generate(index_node, 2, sync_fun=self.no_op)
-        self.sync_index_node()
-        block2 = index_node.getbestblockhash()
-        index_node.invalidateblock(block2)
-        self.generatetoaddress(index_node, 1, getnewdestination()[2], sync_fun=self.no_op)
-        self.sync_index_node()
-        index_node.kill_process()
-        self.start_node(1, extra_args=self.extra_args[1])
-        self.sync_index_node()
-        # Because of the unclean shutdown above, indexes reset to the point we last committed them to disk.
-        assert_equal(index_node.getindexinfo()['coinstatsindex']['best_block_height'], committed_height)
-
-
-if __name__ == '__main__':
-    CoinStatsIndexTest(__file__).main()
diff --git a/test/functional/feature_coinstatsindex_compatibility.py b/test/functional/feature_coinstatsindex_compatibility.py
deleted file mode 100755
index 855dc74d82e2..000000000000
--- a/test/functional/feature_coinstatsindex_compatibility.py
+++ /dev/null
@@ -1,64 +0,0 @@
-#!/usr/bin/env python3
-# Copyright (c) 2025-present The Bitcoin Core developers
-# Distributed under the MIT software license, see the accompanying
-# file COPYING or http://www.opensource.org/licenses/mit-license.php.
-"""Test coinstatsindex across node versions.
-
-This test may be removed some time after v29 has reached end of life.
-"""
-
-import shutil
-
-from test_framework.test_framework import BitcoinTestFramework
-from test_framework.util import assert_equal
-
-
-class CoinStatsIndexTest(BitcoinTestFramework):
-    def set_test_params(self):
-        self.num_nodes = 2
-        self.supports_cli = False
-        self.extra_args = [["-coinstatsindex"],["-coinstatsindex"]]
-
-    def skip_test_if_missing_module(self):
-        self.skip_if_no_previous_releases()
-
-    def setup_nodes(self):
-        self.add_nodes(
-            self.num_nodes,
-            extra_args=self.extra_args,
-            versions=[
-                None,
-                280200,
-            ],
-        )
-        self.start_nodes()
-
-    def run_test(self):
-        self._test_coin_stats_index_compatibility()
-
-    def _test_coin_stats_index_compatibility(self):
-        node = self.nodes[0]
-        legacy_node = self.nodes[1]
-        for n in self.nodes:
-            self.wait_until(lambda: n.getindexinfo()['coinstatsindex']['synced'] is True)
-
-        self.log.info("Test that gettxoutsetinfo() output is consistent between the different index versions")
-        res0 = node.gettxoutsetinfo('muhash')
-        res1 = legacy_node.gettxoutsetinfo('muhash')
-        assert_equal(res1, res0)
-
-        self.log.info("Test that gettxoutsetinfo() output is consistent for the new index running on a datadir with the old version")
-        self.stop_nodes()
-        self.cleanup_folder(node.chain_path / "indexes" / "coinstatsindex")
-        shutil.copytree(legacy_node.chain_path / "indexes" / "coinstats", node.chain_path / "indexes" / "coinstats")
-        old_version_path = node.chain_path / "indexes" / "coinstats"
-        msg = f'[warning] Old version of coinstatsindex found at {old_version_path}. This folder can be safely deleted unless you plan to downgrade your node to version 29 or lower.'
-        with node.assert_debug_log(expected_msgs=[msg]):
-            self.start_node(0, ['-coinstatsindex'])
-        self.wait_until(lambda: node.getindexinfo()['coinstatsindex']['synced'] is True)
-        res2 = node.gettxoutsetinfo('muhash')
-        assert_equal(res2, res0)
-
-
-if __name__ == '__main__':
-    CoinStatsIndexTest(__file__).main()
diff --git a/test/functional/feature_index_prune.py b/test/functional/feature_index_prune.py
deleted file mode 100755
index 0654e04f5865..000000000000
--- a/test/functional/feature_index_prune.py
+++ /dev/null
@@ -1,207 +0,0 @@
-#!/usr/bin/env python3
-# Copyright (c) 2020-present The Bitcoin Core developers
-# Distributed under the MIT software license, see the accompanying
-# file COPYING or http://www.opensource.org/licenses/mit-license.php.
-"""Test indices in conjunction with prune."""
-import concurrent.futures
-import os
-from test_framework.authproxy import JSONRPCException
-from test_framework.test_framework import BitcoinTestFramework
-from test_framework.test_node import TestNode
-from test_framework.util import (
-    assert_equal,
-    assert_greater_than,
-    assert_raises_rpc_error,
-)
-
-from typing import List, Any
-
-def send_batch_request(node: TestNode, method: str, params: List[Any]) -> List[Any]:
-    """Send batch request and parse all results"""
-    data = [getattr(node, method).get_request(*p) for p in params]
-    response = node.batch(data)
-    result = []
-    for item in response:
-        assert "error" not in item, item["error"]
-        result.append(item["result"])
-
-    return result
-
-
-class FeatureIndexPruneTest(BitcoinTestFramework):
-    def set_test_params(self):
-        self.num_nodes = 4
-        self.extra_args = [
-            ["-fastprune", "-prune=1", "-blockfilterindex=1"],
-            ["-fastprune", "-prune=1", "-coinstatsindex=1"],
-            ["-fastprune", "-prune=1", "-blockfilterindex=1", "-coinstatsindex=1"],
-            [],
-        ]
-
-    def setup_network(self):
-        self.setup_nodes()  # No P2P connection, so that linear_sync works
-
-    def linear_sync(self, node_from, *, height_from=None):
-        # Linear sync over RPC, because P2P sync may not be linear
-        to_height = node_from.getblockcount()
-        if height_from is None:
-            height_from = min([n.getblockcount() for n in self.nodes]) + 1
-        with concurrent.futures.ThreadPoolExecutor(max_workers=self.num_nodes) as rpc_threads:
-            for i in range(height_from, to_height + 1):
-                b = node_from.getblock(blockhash=node_from.getblockhash(i), verbosity=0)
-                list(rpc_threads.map(lambda n: n.submitblock(b), self.nodes))
-
-    def generate(self, node, num_blocks, sync_fun=None):
-        return super().generate(node, num_blocks, sync_fun=sync_fun or (lambda: self.linear_sync(node)))
-
-    def sync_index(self, height):
-        expected_filter = {
-            'basic block filter index': {'synced': True, 'best_block_height': height},
-        }
-        self.wait_until(lambda: self.nodes[0].getindexinfo() == expected_filter)
-
-        expected_stats = {
-            'coinstatsindex': {'synced': True, 'best_block_height': height}
-        }
-        self.wait_until(lambda: self.nodes[1].getindexinfo() == expected_stats, timeout=150)
-
-        expected = {**expected_filter, **expected_stats}
-        self.wait_until(lambda: self.nodes[2].getindexinfo() == expected)
-
-    def restart_without_indices(self):
-        for i in range(3):
-            self.restart_node(i, extra_args=["-fastprune", "-prune=1"])
-
-    def check_for_block(self, node, hash):
-        try:
-            self.nodes[node].getblock(hash)
-            return True
-        except JSONRPCException:
-            return False
-
-    def run_test(self):
-        filter_nodes = [self.nodes[0], self.nodes[2]]
-        stats_nodes = [self.nodes[1], self.nodes[2]]
-
-        self.log.info("check if we can access blockfilters and coinstats when pruning is enabled but no blocks are actually pruned")
-        self.sync_index(height=200)
-        tip = self.nodes[0].getbestblockhash()
-        for node in filter_nodes:
-            assert_greater_than(len(node.getblockfilter(tip)['filter']), 0)
-        for node in stats_nodes:
-            assert node.gettxoutsetinfo(hash_type="muhash", hash_or_height=tip)['muhash']
-
-        self.generate(self.nodes[0], 500)
-        self.sync_index(height=700)
-
-        self.log.info("prune some blocks")
-        for node in self.nodes[:2]:
-            with node.assert_debug_log(['limited pruning to height 689']):
-                pruneheight_new = node.pruneblockchain(400)
-                # the prune heights used here and below are magic numbers that are determined by the
-                # thresholds at which block files wrap, so they depend on disk serialization and default block file size.
-                assert_equal(pruneheight_new, 248)
-
-        self.log.info("check if we can access the tips blockfilter and coinstats when we have pruned some blocks")
-        tip = self.nodes[0].getbestblockhash()
-        for node in filter_nodes:
-            assert_greater_than(len(node.getblockfilter(tip)['filter']), 0)
-        for node in stats_nodes:
-            assert node.gettxoutsetinfo(hash_type="muhash", hash_or_height=tip)['muhash']
-
-        self.log.info("check if we can access the blockfilter and coinstats of a pruned block")
-        height_hash = self.nodes[0].getblockhash(2)
-        for node in filter_nodes:
-            assert_greater_than(len(node.getblockfilter(height_hash)['filter']), 0)
-        for node in stats_nodes:
-            assert node.gettxoutsetinfo(hash_type="muhash", hash_or_height=height_hash)['muhash']
-
-        # mine and sync index up to a height that will later be the pruneheight
-        self.generate(self.nodes[0], 51)
-        self.sync_index(height=751)
-
-        self.restart_without_indices()
-
-        self.log.info("make sure trying to access the indices throws errors")
-        for node in filter_nodes:
-            msg = "Index is not enabled for filtertype basic"
-            assert_raises_rpc_error(-1, msg, node.getblockfilter, height_hash)
-        for node in stats_nodes:
-            msg = "Querying specific block heights requires coinstatsindex"
-            assert_raises_rpc_error(-8, msg, node.gettxoutsetinfo, "muhash", height_hash)
-
-        self.generate(self.nodes[0], 749)
-
-        self.log.info("prune exactly up to the indices best blocks while the indices are disabled")
-        for i in range(3):
-            pruneheight_2 = self.nodes[i].pruneblockchain(1000)
-            assert_equal(pruneheight_2, 750)
-            # Restart the nodes again with the indices activated
-            self.restart_node(i, extra_args=self.extra_args[i])
-
-        self.log.info("make sure that we can continue with the partially synced indices after having pruned up to the index height")
-        self.sync_index(height=1500)
-
-        self.log.info("prune further than the indices best blocks while the indices are disabled")
-        self.restart_without_indices()
-        self.generate(self.nodes[0], 1000)
-
-        for i in range(3):
-            pruneheight_3 = self.nodes[i].pruneblockchain(2000)
-            assert_greater_than(pruneheight_3, pruneheight_2)
-            self.stop_node(i)
-
-        self.log.info("make sure we get an init error when starting the nodes again with the indices")
-        filter_msg = "Error: basic block filter index best block of the index goes beyond pruned data (including undo data). Please disable the index or reindex (which will download the whole blockchain again)"
-        stats_msg = "Error: coinstatsindex best block of the index goes beyond pruned data (including undo data). Please disable the index or reindex (which will download the whole blockchain again)"
-        end_msg = f"{os.linesep}Error: A fatal internal error occurred, see debug.log for details: Failed to start indexes, shutting down…"
-        for i, msg in enumerate([filter_msg, stats_msg, filter_msg]):
-            self.nodes[i].assert_start_raises_init_error(extra_args=self.extra_args[i], expected_msg=msg+end_msg)
-
-        self.log.info("fetching the missing blocks with getblockfrompeer doesn't work for block filter index and coinstatsindex")
-        # Only checking the first two nodes since this test takes a long time
-        # and the third node is kind of redundant in this context
-        for i, msg in enumerate([filter_msg, stats_msg]):
-            self.restart_node(i, extra_args=["-prune=1", "-fastprune"])
-            node = self.nodes[i]
-            prune_height = node.getblockchaininfo()["pruneheight"]
-            self.connect_nodes(i, 3)
-            peers = node.getpeerinfo()
-            assert_equal(len(peers), 1)
-            peer_id = peers[0]["id"]
-
-            # 1500 is the height to where the indices were able to sync previously
-            hashes = send_batch_request(node, "getblockhash", [[a] for a in range(1500, prune_height)])
-            send_batch_request(node, "getblockfrompeer", [[bh, peer_id] for bh in hashes])
-            # Ensure all necessary blocks have been fetched before proceeding
-            for bh in hashes:
-                self.wait_until(lambda: self.check_for_block(i, bh), timeout=10)
-
-            # Upon restart we expect the same errors as previously although all
-            # necessary blocks have been fetched. Both indices need the undo
-            # data of the blocks to be available as well and getblockfrompeer
-            # can not provide that.
-            self.stop_node(i)
-            node.assert_start_raises_init_error(extra_args=self.extra_args[i], expected_msg=msg+end_msg)
-
-        self.log.info("make sure the nodes start again with the indices and an additional -reindex arg")
-        for i in range(3):
-            restart_args = self.extra_args[i] + ["-reindex"]
-            self.restart_node(i, extra_args=restart_args)
-
-        self.linear_sync(self.nodes[3])
-        self.sync_index(height=2500)
-
-        for node in self.nodes[:2]:
-            with node.assert_debug_log(['limited pruning to height 2489']):
-                pruneheight_new = node.pruneblockchain(2500)
-                assert_equal(pruneheight_new, 2005)
-
-        self.log.info("ensure that prune locks don't prevent indices from failing in a reorg scenario")
-        with self.nodes[0].assert_debug_log(['basic block filter index prune lock moved back to 2480']):
-            self.nodes[3].invalidateblock(self.nodes[0].getblockhash(2480))
-            self.generate(self.nodes[3], 30, sync_fun=lambda: self.linear_sync(self.nodes[3], height_from=2480))
-
-
-if __name__ == '__main__':
-    FeatureIndexPruneTest(__file__).main()
diff --git a/test/functional/feature_init.py b/test/functional/feature_init.py
index 5f72d9f8934d..2c5087603adf 100755
--- a/test/functional/feature_init.py
+++ b/test/functional/feature_init.py
@@ -18,12 +18,6 @@
 )
 from test_framework.util import assert_equal
 
-ALL_INDEX_ARGS = [
-    '-txindex=1',
-    '-blockfilterindex=1',
-    '-coinstatsindex=1',
-    '-txospenderindex=1',
-]
 
 class InitTest(BitcoinTestFramework):
     """
@@ -41,7 +35,6 @@ def check_clean_start(self, node, extra_args):
         node.wait_for_rpc_connection()
         height = node.getblockcount()
         assert_equal(200, height)
-        self.wait_until(lambda: all(i["synced"] and i["best_block_height"] == height for i in node.getindexinfo().values()))
 
     def init_stress_test_interrupt(self):
         """
@@ -76,10 +69,6 @@ def sigterm_node():
             b'net thread start',
             b'addcon thread start',
             b'initload thread start',
-            b'txindex thread start',
-            b'block filter index thread start',
-            b'coinstatsindex thread start',
-            b'txospenderindex thread start',
             b'msghand thread start',
             b'net thread start',
             b'addcon thread start',
@@ -91,15 +80,13 @@ def sigterm_node():
                 if platform.system() == 'Windows':
                     # CREATE_NEW_PROCESS_GROUP is required in order to be able
                     # to terminate the child without terminating the test.
-                    node.start(extra_args=ALL_INDEX_ARGS, creationflags=subprocess.CREATE_NEW_PROCESS_GROUP)
+                    node.start(creationflags=subprocess.CREATE_NEW_PROCESS_GROUP)
                 else:
-                    node.start(extra_args=ALL_INDEX_ARGS)
+                    node.start()
             self.log.debug("Terminating node after terminate line was found")
             sigterm_node()
 
-        # Prior to deleting/perturbing index files, start node with all indexes enabled.
-        # 'check_clean_start' will ensure indexes are synchronized (i.e., data exists to modify)
-        self.check_clean_start(node, ALL_INDEX_ARGS)
+        self.check_clean_start(node, [])
         self.stop_node(0)
 
     def init_stress_test_removals(self):
@@ -132,19 +119,6 @@ def start_expecting_error(err_fragment, args):
                 'error_message': 'Error loading block database.',
                 'startup_args': ['-checkblocks=200', '-checklevel=4'],
             },
-            {
-                'filepath_glob': 'indexes/txindex/MANIFEST*',
-                'error_message': 'LevelDB error: Corruption: CURRENT points to a non-existent file',
-                'startup_args': ['-txindex=1'],
-            },
-            {
-                'filepath_glob': 'indexes/txospenderindex/db/MANIFEST*',
-                'error_message': 'LevelDB error: Corruption: CURRENT points to a non-existent file',
-                'startup_args': ['-txospenderindex=1'],
-            },
-            # Removing these files does not result in a startup error:
-            # 'indexes/blockfilter/basic/*.dat', 'indexes/blockfilter/basic/db/*.*', 'indexes/coinstatsindex/db/*.*',
-            # 'indexes/txindex/*.log', 'indexes/txindex/CURRENT', 'indexes/txindex/LOCK'
         ]
 
         perturbation_rounds = [
@@ -163,33 +137,6 @@ def start_expecting_error(err_fragment, args):
                 'error_message': 'Corrupted block database detected.',
                 'startup_args': ['-checkblocks=200', '-checklevel=4'],
             },
-            {
-                'filepath_glob': 'indexes/blockfilter/basic/db/*.*',
-                'error_message': 'LevelDB error: Corruption',
-                'startup_args': ['-blockfilterindex=1'],
-            },
-            {
-                'filepath_glob': 'indexes/coinstatsindex/db/*.*',
-                'error_message': 'LevelDB error: Corruption',
-                'startup_args': ['-coinstatsindex=1'],
-            },
-            {
-                'filepath_glob': 'indexes/txindex/*.log',
-                'error_message': 'LevelDB error: Corruption',
-                'startup_args': ['-txindex=1'],
-            },
-            {
-                'filepath_glob': 'indexes/txindex/CURRENT',
-                'error_message': 'LevelDB error: Corruption',
-                'startup_args': ['-txindex=1'],
-            },
-            {
-                'filepath_glob': 'indexes/txospenderindex/db/*',
-                'error_message': 'LevelDB error: Corruption',
-                'startup_args': ['-txospenderindex=1'],
-            },
-            # Perturbing these files does not result in a startup error:
-            # 'indexes/blockfilter/basic/*.dat', 'indexes/txindex/MANIFEST*', 'indexes/txindex/LOCK'
         ]
 
         for round_info in deletion_rounds:
@@ -211,11 +158,11 @@ def start_expecting_error(err_fragment, args):
                 self.log.debug(f"Restoring file from {bak_path} and restarting")
                 Path(bak_path).rename(target_file)
 
-            self.check_clean_start(node, ALL_INDEX_ARGS)
+            self.check_clean_start(node, [])
             self.stop_node(0)
 
         self.log.info("Test startup errors after perturbing certain essential files")
-        dirs = ["blocks", "chainstate", "indexes"]
+        dirs = ["blocks", "chainstate"]
         for round_info in perturbation_rounds:
             file_patt = round_info['filepath_glob']
             err_fragment = round_info['error_message']
@@ -313,12 +260,7 @@ def break_wait_test(self):
 
     def init_empty_test(self):
         self.log.info("Test that stopping and restarting a node that has done nothing is not causing a failure")
-        options = [
-            [],
-            ALL_INDEX_ARGS,
-        ]
-        for option in options:
-            self.restart_node(1, option)
+        self.restart_node(1, [])
 
     def run_test(self):
         self.init_pid_test()
diff --git a/test/functional/feature_pruning.py b/test/functional/feature_pruning.py
index 1745116c6955..affe534dbdb1 100755
--- a/test/functional/feature_pruning.py
+++ b/test/functional/feature_pruning.py
@@ -74,14 +74,14 @@ def set_test_params(self):
         # Create node 2 to test pruning.
         self.full_node_default_args = ["-maxreceivebuffer=20000", "-checkblocks=5"]
         # Create nodes 3 and 4 to test manual pruning (they will be re-started with manual pruning later)
-        # Create node 5 in prune mode with blockfilterindex, but do not connect
+        # Create node 5 in prune mode, but do not connect
         self.extra_args = [
             self.full_node_default_args,
             self.full_node_default_args,
             ["-maxreceivebuffer=20000", "-prune=550"],
             ["-maxreceivebuffer=20000"],
             ["-maxreceivebuffer=20000"],
-            ["-prune=550", "-blockfilterindex=1"],
+            ["-prune=550"],
         ]
         self.rpc_timeout = 120
 
@@ -117,10 +117,6 @@ def test_invalid_command_line_options(self):
             expected_msg='Error: Prune configured below the minimum of 550 MiB.  Please use a higher number.',
             extra_args=['-prune=549'],
         )
-        self.nodes[0].assert_start_raises_init_error(
-            expected_msg='Error: Prune mode is incompatible with -txindex.',
-            extra_args=['-prune=550', '-txindex'],
-        )
         self.nodes[0].assert_start_raises_init_error(
             expected_msg='Error: Prune mode is incompatible with -reindex-chainstate. Use full -reindex instead.',
             extra_args=['-prune=550', '-reindex-chainstate'],
@@ -448,25 +444,11 @@ def run_test(self):
         self.log.info("Test invalid pruning command line options")
         self.test_invalid_command_line_options()
 
-        self.log.info("Test scanblocks can not return pruned data")
-        self.test_scanblocks_pruned()
-
         self.log.info("Test pruneheight reflects the presence of block and undo data")
         self.test_pruneheight_undo_presence()
 
         self.log.info("Done")
 
-    def test_scanblocks_pruned(self):
-        node = self.nodes[5]
-        genesis_blockhash = node.getblockhash(0)
-        false_positive_spk = bytes.fromhex("001400000000000000000000000000000000000cadcb")
-
-        assert genesis_blockhash in node.scanblocks(
-            "start", [{"desc": f"raw({false_positive_spk.hex()})"}], 0, 0)['relevant_blocks']
-
-        assert_raises_rpc_error(-1, "Block not available (pruned data)", node.scanblocks,
-            "start", [{"desc": f"raw({false_positive_spk.hex()})"}], 0, 0, "basic", {"filter_false_positives": True})
-
     def test_pruneheight_undo_presence(self):
         node = self.nodes[5]
         pruneheight = node.getblockchaininfo()["pruneheight"]
diff --git a/test/functional/feature_reindex.py b/test/functional/feature_reindex.py
index 1e6c1490e124..1939b37f9dfc 100755
--- a/test/functional/feature_reindex.py
+++ b/test/functional/feature_reindex.py
@@ -78,25 +78,6 @@ def find_block(b, start):
         # All blocks should be accepted and processed.
         assert_equal(self.nodes[0].getblockcount(), 12)
 
-    def continue_reindex_after_shutdown(self):
-        node = self.nodes[0]
-        self.generate(node, 1500)
-
-        # Restart node with reindex and stop reindex as soon as it starts reindexing
-        self.log.info("Restarting node while reindexing..")
-        node.stop_node()
-        with node.busy_wait_for_debug_log([b'initload thread start']):
-            node.start(['-blockfilterindex', '-reindex'])
-            node.wait_for_rpc_connection(wait_for_import=False)
-        node.stop_node()
-
-        # Start node without the reindex flag and verify it does not wipe the indexes data again
-        db_path = node.chain_path / 'indexes' / 'blockfilter' / 'basic' / 'db'
-        with node.assert_debug_log(expected_msgs=[f'Opening LevelDB in {db_path}'], unexpected_msgs=[f'Wiping LevelDB in {db_path}']):
-            node.start(['-blockfilterindex'])
-            node.wait_for_rpc_connection(wait_for_import=False)
-        node.stop_node()
-
     def run_test(self):
         self.reindex(False)
         self.reindex(True)
@@ -104,7 +85,6 @@ def run_test(self):
         self.reindex(True)
 
         self.out_of_order()
-        self.continue_reindex_after_shutdown()
 
 
 if __name__ == '__main__':
diff --git a/test/functional/interface_rest.py b/test/functional/interface_rest.py
index 2009752cc7fc..f8cf34549d4f 100755
--- a/test/functional/interface_rest.py
+++ b/test/functional/interface_rest.py
@@ -52,7 +52,7 @@ def filter_output_indices_by_value(vouts, value):
 class RESTTest (BitcoinTestFramework):
     def set_test_params(self):
         self.num_nodes = 2
-        self.extra_args = [["-rest", "-blockfilterindex=1"], []]
+        self.extra_args = [["-rest"], []]
         # whitelist peers to speed up tx relay / mempool sync
         self.noban_tx_relay = True
         self.supports_cli = False
@@ -224,7 +224,7 @@ def run_test(self):
 
         self.generate(self.nodes[0], 1)  # generate block to not affect upcoming tests
 
-        self.log.info("Test the /block, /blockhashbyheight, /headers, and /blockfilterheaders URIs")
+        self.log.info("Test the /block, /blockhashbyheight, and /headers URIs")
         bb_hash = self.nodes[0].getbestblockhash()
 
         # Check result if block does not exists
@@ -289,7 +289,7 @@ def run_test(self):
         assert_equal(json_obj[0]['hash'], bb_hash)  # request/response hash should be the same
 
         # Check invalid uri (% symbol at the end of the request)
-        for invalid_uri in [f"/headers/{bb_hash}%", f"/blockfilterheaders/basic/{bb_hash}%", "/mempool/contents.json?%"]:
+        for invalid_uri in [f"/headers/{bb_hash}%", "/mempool/contents.json?%"]:
             resp = self.test_rest_request(invalid_uri, ret_type=RetType.OBJ, status=400)
             assert_equal(resp.read().decode('utf-8').rstrip(), "URI parsing failed, it likely contained RFC 3986 invalid characters")
 
@@ -300,27 +300,8 @@ def run_test(self):
 
         # See if we can get 5 headers in one response
         self.generate(self.nodes[1], 5)
-        expected_filter = {
-            'basic block filter index': {'synced': True, 'best_block_height': 208},
-        }
-        self.wait_until(lambda: self.nodes[0].getindexinfo() == expected_filter)
         json_obj = self.test_rest_request(f"/headers/{bb_hash}", query_params={"count": 5})
         assert_equal(len(json_obj), 5)  # now we should have 5 header objects
-        json_obj = self.test_rest_request(f"/blockfilterheaders/basic/{bb_hash}", query_params={"count": 5})
-        first_filter_header = json_obj[0]
-        assert_equal(len(json_obj), 5)  # now we should have 5 filter header objects
-        json_obj = self.test_rest_request(f"/blockfilter/basic/{bb_hash}")
-
-        # Compare with normal RPC blockfilter response
-        rpc_blockfilter = self.nodes[0].getblockfilter(bb_hash)
-        assert_equal(first_filter_header, rpc_blockfilter['header'])
-        assert_equal(json_obj['filter'], rpc_blockfilter['filter'])
-
-        # Test blockfilterheaders with an invalid hash and filtertype
-        resp = self.test_rest_request(f"/blockfilterheaders/{INVALID_PARAM}/{bb_hash}", ret_type=RetType.OBJ, status=400)
-        assert_equal(resp.read().decode('utf-8').rstrip(), f"Unknown filtertype {INVALID_PARAM}")
-        resp = self.test_rest_request(f"/blockfilterheaders/basic/{INVALID_PARAM}", ret_type=RetType.OBJ, status=400)
-        assert_equal(resp.read().decode('utf-8').rstrip(), f"Invalid hash: {INVALID_PARAM}")
 
         # Test number parsing
         for num in ['5a', '-5', '0', '2001', '99999999999999999999999999999999999']:
@@ -428,7 +409,6 @@ def run_test(self):
         # Test compatibility of deprecated and newer endpoints
         self.log.info("Test compatibility of deprecated and newer endpoints")
         assert_equal(self.test_rest_request(f"/headers/{bb_hash}", query_params={"count": 1}), self.test_rest_request(f"/headers/1/{bb_hash}"))
-        assert_equal(self.test_rest_request(f"/blockfilterheaders/basic/{bb_hash}", query_params={"count": 1}), self.test_rest_request(f"/blockfilterheaders/basic/5/{bb_hash}"))
 
         self.log.info("Test the /spenttxouts URI")
 
diff --git a/test/functional/interface_usdt_utxocache.py b/test/functional/interface_usdt_utxocache.py
index da90790d70d7..b9b4b2d32c7c 100755
--- a/test/functional/interface_usdt_utxocache.py
+++ b/test/functional/interface_usdt_utxocache.py
@@ -144,7 +144,6 @@ class UTXOCacheTracepointTest(BitcoinTestFramework):
     def set_test_params(self):
         self.setup_clean_chain = False
         self.num_nodes = 1
-        self.extra_args = [["-txindex"]]
 
     def skip_test_if_missing_module(self):
         self.skip_if_platform_not_linux()
diff --git a/test/functional/mempool_packages.py b/test/functional/mempool_packages.py
index a801dacebaad..f3bbe5093ff2 100755
--- a/test/functional/mempool_packages.py
+++ b/test/functional/mempool_packages.py
@@ -81,12 +81,6 @@ def run_test(self):
             entry = self.nodes[0].getmempoolentry(x)
             assert_equal(entry, mempool[x])
 
-            # Check that gettxspendingprevout is consistent with getrawmempool
-            witnesstx = self.nodes[0].getrawtransaction(txid=x, verbose=True)
-            for tx_in in witnesstx["vin"]:
-                spending_result = self.nodes[0].gettxspendingprevout([ {'txid' : tx_in["txid"], 'vout' : tx_in["vout"]} ])
-                assert_equal(spending_result, [ {'txid' : tx_in["txid"], 'vout' : tx_in["vout"], 'spendingtxid' : x} ])
-
             # Check that the descendant calculations are correct
             assert_equal(entry['descendantcount'], descendant_count)
             descendant_fees += entry['fees']['base']
diff --git a/test/functional/p2p_blockfilters.py b/test/functional/p2p_blockfilters.py
deleted file mode 100755
index 375a794b08aa..000000000000
--- a/test/functional/p2p_blockfilters.py
+++ /dev/null
@@ -1,286 +0,0 @@
-#!/usr/bin/env python3
-# Copyright (c) 2019-present The Bitcoin Core developers
-# Distributed under the MIT software license, see the accompanying
-# file COPYING or http://www.opensource.org/licenses/mit-license.php.
-"""Tests NODE_COMPACT_FILTERS (BIP 157/158).
-
-Tests that a node configured with -blockfilterindex and -peerblockfilters signals
-NODE_COMPACT_FILTERS and can serve cfilters, cfheaders and cfcheckpts.
-"""
-
-from test_framework.messages import (
-    FILTER_TYPE_BASIC,
-    NODE_COMPACT_FILTERS,
-    hash256,
-    msg_getcfcheckpt,
-    msg_getcfheaders,
-    msg_getcfilters,
-    ser_uint256,
-    uint256_from_str,
-)
-from test_framework.p2p import P2PInterface
-from test_framework.test_framework import BitcoinTestFramework
-from test_framework.util import (
-    assert_not_equal,
-    assert_equal,
-)
-
-class FiltersClient(P2PInterface):
-    def __init__(self):
-        super().__init__()
-        # Store the cfilters received.
-        self.cfilters = []
-
-    def pop_cfilters(self):
-        cfilters = self.cfilters
-        self.cfilters = []
-        return cfilters
-
-    def on_cfilter(self, message):
-        """Store cfilters received in a list."""
-        self.cfilters.append(message)
-
-
-class CompactFiltersTest(BitcoinTestFramework):
-    def set_test_params(self):
-        self.setup_clean_chain = True
-        self.rpc_timeout = 480
-        self.num_nodes = 2
-        self.extra_args = [
-            ["-blockfilterindex", "-peerblockfilters"],
-            ["-blockfilterindex"],
-        ]
-
-    def run_test(self):
-        # Node 0 supports COMPACT_FILTERS, node 1 does not.
-        peer_0 = self.nodes[0].add_p2p_connection(FiltersClient())
-        peer_1 = self.nodes[1].add_p2p_connection(FiltersClient())
-
-        # Nodes 0 & 1 share the same first 999 blocks in the chain.
-        self.generate(self.nodes[0], 999)
-
-        # Stale blocks by disconnecting nodes 0 & 1, mining, then reconnecting
-        self.disconnect_nodes(0, 1)
-
-        stale_block_hash = self.generate(self.nodes[0], 1, sync_fun=self.no_op)[0]
-        self.nodes[0].syncwithvalidationinterfacequeue()
-        assert_equal(self.nodes[0].getblockcount(), 1000)
-
-        self.generate(self.nodes[1], 1001, sync_fun=self.no_op)
-        assert_equal(self.nodes[1].getblockcount(), 2000)
-
-        # Check that nodes have signalled NODE_COMPACT_FILTERS correctly.
-        assert_not_equal(peer_0.nServices & NODE_COMPACT_FILTERS, 0)
-        assert_equal(peer_1.nServices & NODE_COMPACT_FILTERS, 0)
-
-        # Check that the localservices is as expected.
-        assert_not_equal(int(self.nodes[0].getnetworkinfo()['localservices'], 16) & NODE_COMPACT_FILTERS, 0)
-        assert_equal(int(self.nodes[1].getnetworkinfo()['localservices'], 16) & NODE_COMPACT_FILTERS, 0)
-
-        self.log.info("get cfcheckpt on chain to be re-orged out.")
-        request = msg_getcfcheckpt(
-            filter_type=FILTER_TYPE_BASIC,
-            stop_hash=int(stale_block_hash, 16),
-        )
-        peer_0.send_and_ping(message=request)
-        response = peer_0.last_message['cfcheckpt']
-        assert_equal(response.filter_type, request.filter_type)
-        assert_equal(response.stop_hash, request.stop_hash)
-        assert_equal(len(response.headers), 1)
-
-        self.log.info("Reorg node 0 to a new chain.")
-        self.connect_nodes(0, 1)
-        self.sync_blocks(timeout=600)
-        self.nodes[0].syncwithvalidationinterfacequeue()
-
-        main_block_hash = self.nodes[0].getblockhash(1000)
-        assert_not_equal(main_block_hash, stale_block_hash, error_message="node 0 chain did not reorganize")
-
-        self.log.info("Check that peers can fetch cfcheckpt on active chain.")
-        tip_hash = self.nodes[0].getbestblockhash()
-        request = msg_getcfcheckpt(
-            filter_type=FILTER_TYPE_BASIC,
-            stop_hash=int(tip_hash, 16),
-        )
-        peer_0.send_and_ping(request)
-        response = peer_0.last_message['cfcheckpt']
-        assert_equal(response.filter_type, request.filter_type)
-        assert_equal(response.stop_hash, request.stop_hash)
-
-        main_cfcheckpt = self.nodes[0].getblockfilter(main_block_hash, 'basic')['header']
-        tip_cfcheckpt = self.nodes[0].getblockfilter(tip_hash, 'basic')['header']
-        assert_equal(
-            response.headers,
-            [int(header, 16) for header in (main_cfcheckpt, tip_cfcheckpt)],
-        )
-
-        self.log.info("Check that peers can fetch cfcheckpt on stale chain.")
-        request = msg_getcfcheckpt(
-            filter_type=FILTER_TYPE_BASIC,
-            stop_hash=int(stale_block_hash, 16),
-        )
-        peer_0.send_and_ping(request)
-        response = peer_0.last_message['cfcheckpt']
-
-        stale_cfcheckpt = self.nodes[0].getblockfilter(stale_block_hash, 'basic')['header']
-        assert_equal(
-            response.headers,
-            [int(header, 16) for header in (stale_cfcheckpt, )],
-        )
-
-        self.log.info("Check that peers can fetch cfheaders on active chain.")
-        request = msg_getcfheaders(
-            filter_type=FILTER_TYPE_BASIC,
-            start_height=1,
-            stop_hash=int(main_block_hash, 16),
-        )
-        peer_0.send_and_ping(request)
-        response = peer_0.last_message['cfheaders']
-        main_cfhashes = response.hashes
-        assert_equal(len(main_cfhashes), 1000)
-        assert_equal(
-            compute_last_header(response.prev_header, response.hashes),
-            int(main_cfcheckpt, 16),
-        )
-
-        self.log.info("Check that peers can fetch cfheaders on stale chain.")
-        request = msg_getcfheaders(
-            filter_type=FILTER_TYPE_BASIC,
-            start_height=1,
-            stop_hash=int(stale_block_hash, 16),
-        )
-        peer_0.send_and_ping(request)
-        response = peer_0.last_message['cfheaders']
-        stale_cfhashes = response.hashes
-        assert_equal(len(stale_cfhashes), 1000)
-        assert_equal(
-            compute_last_header(response.prev_header, response.hashes),
-            int(stale_cfcheckpt, 16),
-        )
-
-        self.log.info("Check that peers can fetch cfilters.")
-        stop_hash = self.nodes[0].getblockhash(10)
-        request = msg_getcfilters(
-            filter_type=FILTER_TYPE_BASIC,
-            start_height=1,
-            stop_hash=int(stop_hash, 16),
-        )
-        peer_0.send_and_ping(request)
-        response = peer_0.pop_cfilters()
-        assert_equal(len(response), 10)
-
-        self.log.info("Check that cfilter responses are correct.")
-        for cfilter, cfhash, height in zip(response, main_cfhashes, range(1, 11)):
-            block_hash = self.nodes[0].getblockhash(height)
-            assert_equal(cfilter.filter_type, FILTER_TYPE_BASIC)
-            assert_equal(cfilter.block_hash, int(block_hash, 16))
-            computed_cfhash = uint256_from_str(hash256(cfilter.filter_data))
-            assert_equal(computed_cfhash, cfhash)
-
-        self.log.info("Check that peers can fetch cfilters for stale blocks.")
-        request = msg_getcfilters(
-            filter_type=FILTER_TYPE_BASIC,
-            start_height=1000,
-            stop_hash=int(stale_block_hash, 16),
-        )
-        peer_0.send_and_ping(request)
-        response = peer_0.pop_cfilters()
-        assert_equal(len(response), 1)
-
-        cfilter = response[0]
-        assert_equal(cfilter.filter_type, FILTER_TYPE_BASIC)
-        assert_equal(cfilter.block_hash, int(stale_block_hash, 16))
-        computed_cfhash = uint256_from_str(hash256(cfilter.filter_data))
-        assert_equal(computed_cfhash, stale_cfhashes[999])
-
-        self.log.info("Requests to node 1 without NODE_COMPACT_FILTERS results in disconnection.")
-        requests = [
-            msg_getcfcheckpt(
-                filter_type=FILTER_TYPE_BASIC,
-                stop_hash=int(main_block_hash, 16),
-            ),
-            msg_getcfheaders(
-                filter_type=FILTER_TYPE_BASIC,
-                start_height=1000,
-                stop_hash=int(main_block_hash, 16),
-            ),
-            msg_getcfilters(
-                filter_type=FILTER_TYPE_BASIC,
-                start_height=1000,
-                stop_hash=int(main_block_hash, 16),
-            ),
-        ]
-        for request in requests:
-            peer_1 = self.nodes[1].add_p2p_connection(P2PInterface())
-            with self.nodes[1].assert_debug_log(expected_msgs=["requested unsupported block filter type"]):
-                peer_1.send_without_ping(request)
-                peer_1.wait_for_disconnect()
-
-        self.log.info("Check that invalid requests result in disconnection.")
-        requests = [
-            # Requesting too many filters results in disconnection.
-            (
-                msg_getcfilters(
-                    filter_type=FILTER_TYPE_BASIC,
-                    start_height=0,
-                    stop_hash=int(main_block_hash, 16),
-                ), "requested too many cfilters/cfheaders"
-            ),
-            # Requesting too many filter headers results in disconnection.
-            (
-                msg_getcfheaders(
-                    filter_type=FILTER_TYPE_BASIC,
-                    start_height=0,
-                    stop_hash=int(tip_hash, 16),
-                ), "requested too many cfilters/cfheaders"
-            ),
-            # Requesting unknown filter type results in disconnection.
-            (
-                msg_getcfcheckpt(
-                    filter_type=255,
-                    stop_hash=int(main_block_hash, 16),
-                ), "requested unsupported block filter type"
-            ),
-            # Requesting unknown hash results in disconnection.
-            (
-                msg_getcfcheckpt(
-                    filter_type=FILTER_TYPE_BASIC,
-                    stop_hash=123456789,
-                ), "requested invalid block hash"
-            ),
-            (
-                # Request with (start block height > stop block height) results in disconnection.
-                msg_getcfheaders(
-                    filter_type=FILTER_TYPE_BASIC,
-                    start_height=1000,
-                    stop_hash=int(self.nodes[0].getblockhash(999), 16),
-                ), "sent invalid getcfilters/getcfheaders with start height 1000 and stop height 999"
-            ),
-        ]
-        for request, expected_log_msg in requests:
-            peer_0 = self.nodes[0].add_p2p_connection(P2PInterface())
-            with self.nodes[0].assert_debug_log(expected_msgs=[expected_log_msg]):
-                peer_0.send_without_ping(request)
-                peer_0.wait_for_disconnect()
-
-        self.log.info("Test -peerblockfilters without -blockfilterindex raises an error")
-        self.stop_node(0)
-        self.nodes[0].extra_args = ["-peerblockfilters"]
-        msg = "Error: Cannot set -peerblockfilters without -blockfilterindex."
-        self.nodes[0].assert_start_raises_init_error(expected_msg=msg)
-
-        self.log.info("Test unknown value to -blockfilterindex raises an error")
-        self.nodes[0].extra_args = ["-blockfilterindex=abc"]
-        msg = "Error: Unknown -blockfilterindex value abc."
-        self.nodes[0].assert_start_raises_init_error(expected_msg=msg)
-
-def compute_last_header(prev_header, hashes):
-    """Compute the last filter header from a starting header and a sequence of filter hashes."""
-    header = ser_uint256(prev_header)
-    for filter_hash in hashes:
-        header = hash256(ser_uint256(filter_hash) + header)
-    return uint256_from_str(header)
-
-
-if __name__ == '__main__':
-    CompactFiltersTest(__file__).main()
diff --git a/test/functional/rpc_getblockfilter.py b/test/functional/rpc_getblockfilter.py
deleted file mode 100755
index db72acd6e8b6..000000000000
--- a/test/functional/rpc_getblockfilter.py
+++ /dev/null
@@ -1,64 +0,0 @@
-#!/usr/bin/env python3
-# Copyright (c) 2018-present The Bitcoin Core developers
-# Distributed under the MIT software license, see the accompanying
-# file COPYING or http://www.opensource.org/licenses/mit-license.php.
-"""Test the getblockfilter RPC."""
-
-from test_framework.test_framework import BitcoinTestFramework
-from test_framework.util import (
-    assert_equal, assert_is_hex_string, assert_raises_rpc_error,
-    )
-
-FILTER_TYPES = ["basic"]
-
-class GetBlockFilterTest(BitcoinTestFramework):
-    def set_test_params(self):
-        self.setup_clean_chain = True
-        self.num_nodes = 2
-        self.extra_args = [["-blockfilterindex"], []]
-
-    def run_test(self):
-        # Create two chains by disconnecting nodes 0 & 1, mining, then reconnecting
-        self.disconnect_nodes(0, 1)
-
-        self.generate(self.nodes[0], 3, sync_fun=self.no_op)
-        self.generate(self.nodes[1], 4, sync_fun=self.no_op)
-
-        assert_equal(self.nodes[0].getblockcount(), 3)
-        chain0_hashes = [self.nodes[0].getblockhash(block_height) for block_height in range(4)]
-
-        # Reorg node 0 to a new chain
-        self.connect_nodes(0, 1)
-        self.sync_blocks()
-
-        assert_equal(self.nodes[0].getblockcount(), 4)
-        chain1_hashes = [self.nodes[0].getblockhash(block_height) for block_height in range(4)]
-
-        # Test getblockfilter returns a filter for all blocks and filter types on active chain
-        for block_hash in chain1_hashes:
-            for filter_type in FILTER_TYPES:
-                result = self.nodes[0].getblockfilter(block_hash, filter_type)
-                assert_is_hex_string(result['filter'])
-
-        # Test getblockfilter returns a filter for all blocks and filter types on stale chain
-        for block_hash in chain0_hashes:
-            for filter_type in FILTER_TYPES:
-                result = self.nodes[0].getblockfilter(block_hash, filter_type)
-                assert_is_hex_string(result['filter'])
-
-        # Test getblockfilter with unknown block
-        bad_block_hash = "0123456789abcdef" * 4
-        assert_raises_rpc_error(-5, "Block not found", self.nodes[0].getblockfilter, bad_block_hash, "basic")
-
-        # Test getblockfilter with undefined filter type
-        genesis_hash = self.nodes[0].getblockhash(0)
-        assert_raises_rpc_error(-5, "Unknown filtertype", self.nodes[0].getblockfilter, genesis_hash, "unknown")
-
-        # Test getblockfilter fails on node without compact block filter index
-        self.restart_node(0, extra_args=["-blockfilterindex=0"])
-        for filter_type in FILTER_TYPES:
-            assert_raises_rpc_error(-1, "Index is not enabled for filtertype {}".format(filter_type),
-                                    self.nodes[0].getblockfilter, genesis_hash, filter_type)
-
-if __name__ == '__main__':
-    GetBlockFilterTest(__file__).main()
diff --git a/test/functional/rpc_gettxspendingprevout.py b/test/functional/rpc_gettxspendingprevout.py
deleted file mode 100755
index 972056e627b9..000000000000
--- a/test/functional/rpc_gettxspendingprevout.py
+++ /dev/null
@@ -1,217 +0,0 @@
-#!/usr/bin/env python3
-# Copyright (c) The Bitcoin Core developers
-# Distributed under the MIT software license, see the accompanying
-# file COPYING or http://www.opensource.org/licenses/mit-license.php.
-"""Test gettxspendingprevout RPC."""
-
-from test_framework.test_framework import BitcoinTestFramework
-from test_framework.util import (
-    assert_equal,
-    assert_raises_rpc_error,
-)
-from test_framework.wallet import MiniWallet
-
-#### Query Helpers ####
-def prevout(txid, vout):
-    """Build a prevout query dict for use with gettxspendingprevout"""
-    return {'txid': txid, 'vout': vout}
-
-#### Result Helpers ####
-
-def unspent_out(txid, vout):
-    """Expected result for an available output (not spent)"""
-    return {'txid': txid, 'vout': vout}
-
-def spent_out(txid, vout, spending_tx_id):
-    """Expected result for an output with a known spender"""
-    return {'txid': txid, 'vout': vout, 'spendingtxid': spending_tx_id}
-
-def spent_out_in_block(txid, vout, spending_tx_id, blockhash, spending_tx):
-    """Expected result for an output spent in a confirmed block, with full tx data"""
-    return {'txid': txid, 'vout': vout, 'spendingtxid': spending_tx_id, 'blockhash': blockhash, 'spendingtx': spending_tx}
-
-class GetTxSpendingPrevoutTest(BitcoinTestFramework):
-    def set_test_params(self):
-        self.num_nodes = 3
-        self.noban_tx_relay = True
-        self.extra_args = [
-            ["-txospenderindex"],
-            ["-txospenderindex"],
-            [],
-        ]
-
-    def run_test(self):
-        node0, node1, node2 = self.nodes
-        self.wallet = MiniWallet(node0)
-        root_utxo = self.wallet.get_utxo()
-        txid_root_utxo = root_utxo['txid']
-
-        def create_tx(**kwargs):
-            return self.wallet.send_self_transfer_multi(from_node=node0, **kwargs)
-
-        # Create a tree of unconfirmed transactions in the mempool:
-        #             txA
-        #             / \
-        #            /   \
-        #           /     \
-        #          /       \
-        #         /         \
-        #       txB         txC
-        #       / \         / \
-        #      /   \       /   \
-        #    txD   txE   txF   txG
-        #            \   /
-        #             \ /
-        #             txH
-
-        txA = create_tx(utxos_to_spend=[root_utxo], num_outputs=2)
-        txB = create_tx(utxos_to_spend=[txA["new_utxos"][0]], num_outputs=2)
-        txC = create_tx(utxos_to_spend=[txA["new_utxos"][1]], num_outputs=2)
-        txD = create_tx(utxos_to_spend=[txB["new_utxos"][0]], num_outputs=1)
-        txE = create_tx(utxos_to_spend=[txB["new_utxos"][1]], num_outputs=1)
-        txF = create_tx(utxos_to_spend=[txC["new_utxos"][0]], num_outputs=2)
-        txG = create_tx(utxos_to_spend=[txC["new_utxos"][1]], num_outputs=1)
-        txH = create_tx(utxos_to_spend=[txE["new_utxos"][0], txF["new_utxos"][0]], num_outputs=1)
-
-        txs = [txA, txB, txC, txD, txE, txF, txG, txH]
-        txidA, txidB, txidC, txidD, txidE, txidF, txidG, txidH = [tx["txid"] for tx in txs]
-
-        self.sync_mempools()
-        self.wait_until(lambda: node0.getindexinfo()["txospenderindex"]["synced"])
-        self.wait_until(lambda: node1.getindexinfo()["txospenderindex"]["synced"])
-        mempool = node0.getrawmempool()
-        assert_equal(len(mempool), 8)
-        for tx in txs:
-            assert tx["txid"] in mempool
-
-        self.log.info("Find transactions spending outputs")
-        # wait until spending transactions are found in the mempool of node 0, 1 and 2
-        result = node0.gettxspendingprevout([prevout(txid_root_utxo, vout=0), prevout(txidA, vout=1)])
-        assert_equal(result, [spent_out(txid_root_utxo, vout=0, spending_tx_id=txidA),
-                              spent_out(txidA, vout=1, spending_tx_id=txidC)])
-        self.wait_until(lambda: node1.gettxspendingprevout([prevout(txid_root_utxo, vout=0), prevout(txidA, vout=1)]) == result)
-        self.wait_until(lambda: node2.gettxspendingprevout([prevout(txid_root_utxo, vout=0), prevout(txidA, vout=1)], mempool_only=True) == result)
-
-        self.log.info("Find transaction spending multiple outputs")
-        result = node0.gettxspendingprevout([prevout(txidE, vout=0), prevout(txidF, vout=0)])
-        assert_equal(result, [spent_out(txidE, vout=0, spending_tx_id=txidH),
-                              spent_out(txidF, vout=0, spending_tx_id=txidH)])
-
-        self.log.info("Find no transaction when output is unspent")
-        assert_equal(node0.gettxspendingprevout([prevout(txidH, vout=0)]), [unspent_out(txidH, vout=0)])
-        for node in self.nodes:
-            assert_equal(node.gettxspendingprevout([prevout(txidA, vout=5)]), [unspent_out(txidA, vout=5)])
-
-        self.log.info("Mixed spent and unspent outputs")
-        result = node0.gettxspendingprevout([prevout(txidB, vout=0), prevout(txidG, vout=3)])
-        assert_equal(result, [spent_out(txidB, vout=0, spending_tx_id=txidD),
-                              unspent_out(txidG, vout=3)])
-
-        self.log.info("Unknown input fields")
-        assert_raises_rpc_error(-3, "Unexpected key unknown", node0.gettxspendingprevout, [{'txid' : txidC, 'vout' : 1, 'unknown' : 42}])
-
-        self.log.info("Invalid vout provided")
-        assert_raises_rpc_error(-8, "Invalid parameter, vout cannot be negative", node0.gettxspendingprevout, [prevout(txidA, vout=-1)])
-
-        self.log.info("Invalid txid provided")
-        assert_raises_rpc_error(-3, "JSON value of type number for field txid is not of expected type string", node0.gettxspendingprevout, [prevout(42, vout=0)])
-
-        self.log.info("Missing outputs")
-        assert_raises_rpc_error(-8, "Invalid parameter, outputs are missing", node0.gettxspendingprevout, [])
-
-        self.log.info("Missing vout")
-        assert_raises_rpc_error(-3, "Missing vout", node0.gettxspendingprevout, [{'txid' : txidA}])
-
-        self.log.info("Missing txid")
-        assert_raises_rpc_error(-3, "Missing txid", node0.gettxspendingprevout, [{'vout' : 3}])
-
-        blockhash = self.generate(self.wallet, 1)[0]
-        # spending transactions are found in the index of nodes 0 and 1 but not node 2
-        for node in [node0, node1]:
-            result = node.gettxspendingprevout([prevout(txid_root_utxo, vout=0), prevout(txidA, vout=1)], return_spending_tx=True)
-            assert_equal(result, [spent_out_in_block(txid_root_utxo, vout=0, spending_tx_id=txidA, blockhash=blockhash, spending_tx=txA['hex']),
-                                  spent_out_in_block(txidA, vout=1, spending_tx_id=txidC, blockhash=blockhash, spending_tx=txC['hex'])])
-        # Spending transactions not in node 2 (no spending index)
-        result = node2.gettxspendingprevout([prevout(txid_root_utxo, vout=0), prevout(txidA, vout=1)], return_spending_tx=True)
-        assert_equal(result, [unspent_out(txid_root_utxo, vout=0), unspent_out(txidA, vout=1)])
-
-        # spending transaction is not found if we only search the mempool
-        result = node0.gettxspendingprevout([prevout(txid_root_utxo, vout=0), prevout(txidA, vout=1)], return_spending_tx=True, mempool_only=True)
-        assert_equal(result, [unspent_out(txid_root_utxo, vout=0), unspent_out(txidA, vout=1)])
-
-        self.log.info("Check that our txospenderindex is updated when a reorg replaces a spending transaction")
-        reorg_replace_utxo = self.wallet.get_utxo(mark_as_spent=False)
-        txid_reorg_replace_utxo = reorg_replace_utxo['txid']
-
-        tx1 = create_tx(utxos_to_spend=[reorg_replace_utxo], num_outputs=1)
-        blockhash = self.generate(self.wallet, 1)[0]
-
-        # tx1 is confirmed, and indexed in txospenderindex as spending our utxo
-        assert tx1["txid"] not in node0.getrawmempool()
-        result = node0.gettxspendingprevout([prevout(txid_reorg_replace_utxo, vout=0)], return_spending_tx=True)
-        assert_equal(result, [spent_out_in_block(txid_reorg_replace_utxo, vout=0, spending_tx_id=tx1["txid"], blockhash=blockhash, spending_tx=tx1['hex'])])
-
-        # replace tx1 with tx2 triggering a "reorg"
-        best_block_hash = node0.getbestblockhash()
-        for node in self.nodes:
-            node.invalidateblock(best_block_hash)
-            assert tx1["txid"] in node.getrawmempool()
-
-        # create and submit replacement
-        tx2 = create_tx(utxos_to_spend=[reorg_replace_utxo], num_outputs=2)
-        assert tx2["txid"] in node0.getrawmempool()
-
-        # check that when we find tx2 when we look in the mempool for a tx spending our output
-        result = node0.gettxspendingprevout([prevout(txid_reorg_replace_utxo, vout=0)], return_spending_tx=True)
-        assert_equal(result, [ {'txid' : txid_reorg_replace_utxo, 'vout' : 0, 'spendingtxid' : tx2["txid"], 'spendingtx' : tx2['hex']} ])
-
-        # check that our txospenderindex has been updated
-        blockhash = self.generate(self.wallet, 1)[0]
-        result = node0.gettxspendingprevout([prevout(txid_reorg_replace_utxo, vout=0)], return_spending_tx=True)
-        assert_equal(result, [spent_out_in_block(txid_reorg_replace_utxo, vout=0, spending_tx_id=tx2["txid"], blockhash=blockhash, spending_tx=tx2['hex'])])
-
-        self.log.info("Check that our txospenderindex is updated when a reorg cancels a spending transaction")
-        reorg_cancel_utxo = self.wallet.get_utxo(mark_as_spent=False)
-        txid_reorg_cancel_utxo = reorg_cancel_utxo['txid']
-
-        tx1 = create_tx(utxos_to_spend=[reorg_cancel_utxo], num_outputs=1)
-        tx2 = create_tx(utxos_to_spend=[tx1["new_utxos"][0]], num_outputs=1)
-        # tx1 spends our utxo, tx2 spends tx1
-        blockhash = self.generate(self.wallet, 1)[0]
-        # tx1 and tx2 are confirmed, and indexed in txospenderindex
-        result = node0.gettxspendingprevout([prevout(txid_reorg_cancel_utxo, vout=0)], return_spending_tx=True)
-        assert_equal(result, [spent_out_in_block(txid_reorg_cancel_utxo, vout=0, spending_tx_id=tx1["txid"], blockhash=blockhash, spending_tx=tx1['hex'])])
-        result = node0.gettxspendingprevout([prevout(tx1['txid'], vout=0)], return_spending_tx=True)
-        assert_equal(result, [spent_out_in_block(tx1['txid'], vout=0, spending_tx_id=tx2["txid"], blockhash=blockhash, spending_tx=tx2['hex'])])
-
-        # replace tx1 with tx3
-        blockhash = node0.getbestblockhash()
-        for node in self.nodes:
-            node.invalidateblock(blockhash)
-
-        tx3 = create_tx(utxos_to_spend=[reorg_cancel_utxo], num_outputs=2, fee_per_output=2000)
-        node0_mempool = node0.getrawmempool()
-        assert tx3["txid"] in node0_mempool
-        assert tx1["txid"] not in node0_mempool
-        assert tx2["txid"] not in node0_mempool
-
-        # tx2 is not in the mempool anymore, but still in txospender index which has not been rewound yet
-        result = node0.gettxspendingprevout([prevout(tx1['txid'], vout=0)], return_spending_tx=True)
-        assert_equal(result, [spent_out_in_block(tx1['txid'], vout=0, spending_tx_id=tx2["txid"], blockhash=blockhash, spending_tx=tx2['hex'])])
-
-        txinfo = node0.getrawtransaction(tx2["txid"], verbose = True, blockhash = blockhash)
-        assert_equal(txinfo["confirmations"], 0)
-        assert_equal(txinfo["in_active_chain"], False)
-
-        blockhash = self.generate(self.wallet, 1)[0]
-        # we check that the spending tx for tx1 is now tx3
-        result = node0.gettxspendingprevout([prevout(txid_reorg_cancel_utxo, vout=0)], return_spending_tx=True)
-        assert_equal(result, [spent_out_in_block(txid_reorg_cancel_utxo, vout=0, spending_tx_id=tx3["txid"], blockhash=blockhash, spending_tx=tx3['hex'])])
-
-        # we check that there is no more spending tx for tx1
-        result = node0.gettxspendingprevout([prevout(tx1['txid'], vout=0)], return_spending_tx=True)
-        assert_equal(result, [unspent_out(tx1['txid'], vout=0)])
-
-
-if __name__ == '__main__':
-    GetTxSpendingPrevoutTest(__file__).main()
diff --git a/test/functional/rpc_misc.py b/test/functional/rpc_misc.py
index 86f22f00399f..e3a02e6d1c6b 100755
--- a/test/functional/rpc_misc.py
+++ b/test/functional/rpc_misc.py
@@ -95,32 +95,6 @@ def run_test(self):
         self.log.info("test echoipc (testing spawned process in multiprocess build)")
         assert_equal(node.echoipc("hello"), "hello")
 
-        self.log.info("test getindexinfo")
-        # Without any indices running the RPC returns an empty object
-        assert_equal(node.getindexinfo(), {})
-
-        # Restart the node with indices and wait for them to sync
-        self.restart_node(0, ["-txindex", "-blockfilterindex", "-coinstatsindex", "-txospenderindex"])
-        self.wait_until(lambda: all(i["synced"] for i in node.getindexinfo().values()))
-
-        # Returns a list of all running indices by default
-        values = {"synced": True, "best_block_height": 200}
-        assert_equal(
-            node.getindexinfo(),
-            {
-                "txindex": values,
-                "basic block filter index": values,
-                "coinstatsindex": values,
-                "txospenderindex": values,
-            }
-        )
-        # Specifying an index by name returns only the status of that index
-        for i in {"txindex", "basic block filter index", "coinstatsindex", "txospenderindex"}:
-            assert_equal(node.getindexinfo(i), {i: values})
-
-        # Specifying an unknown index name returns an empty result
-        assert_equal(node.getindexinfo("foo"), {})
-
 
 if __name__ == '__main__':
     RpcMiscTest(__file__).main()
diff --git a/test/functional/rpc_rawtransaction.py b/test/functional/rpc_rawtransaction.py
index 78e12139fc90..f1f033b4e098 100755
--- a/test/functional/rpc_rawtransaction.py
+++ b/test/functional/rpc_rawtransaction.py
@@ -36,7 +36,6 @@
     assert_equal,
     assert_greater_than,
     assert_raises_rpc_error,
-    sync_txindex,
 )
 from test_framework.wallet import (
     getnewdestination,
@@ -69,7 +68,7 @@ class RawTransactionsTest(BitcoinTestFramework):
     def set_test_params(self):
         self.num_nodes = 3
         self.extra_args = [
-            ["-txindex"],
+            [],
             [],
             ["-fastprune", "-prune=1"],
         ]
@@ -97,66 +96,37 @@ def getrawtransaction_tests(self):
         self.generate(self.nodes[0], 1)
         txId = tx['txid']
         err_msg = (
-            "No such mempool transaction. Use -txindex or provide a block hash to enable"
-            " blockchain transaction queries. Use gettransaction for wallet transactions."
+            "No such mempool transaction. Provide a block hash to look it up in a"
+            " specific block. Use gettransaction for wallet transactions."
         )
 
         for n in [0, 2]:
-            self.log.info(f"Test getrawtransaction {'with' if n == 0 else 'without'} -txindex")
-
-            if n == 0:
-                sync_txindex(self, self.nodes[n])
-                # With -txindex.
-                # 1. valid parameters - only supply txid
-                assert_equal(self.nodes[n].getrawtransaction(txId), tx['hex'])
-
-                # 2. valid parameters - supply txid and 0 for non-verbose
-                assert_equal(self.nodes[n].getrawtransaction(txId, 0), tx['hex'])
-
-                # 3. valid parameters - supply txid and False for non-verbose
-                assert_equal(self.nodes[n].getrawtransaction(txId, False), tx['hex'])
-
-                # 4. valid parameters - supply txid and 1 for verbose.
-                # We only check the "hex" field of the output so we don't need to update this test every time the output format changes.
-                assert_equal(self.nodes[n].getrawtransaction(txId, 1)["hex"], tx['hex'])
-                assert_equal(self.nodes[n].getrawtransaction(txId, 2)["hex"], tx['hex'])
-
-                # 5. valid parameters - supply txid and True for non-verbose
-                assert_equal(self.nodes[n].getrawtransaction(txId, True)["hex"], tx['hex'])
-            else:
-                # Without -txindex, expect to raise.
-                for verbose in [None, 0, False, 1, True]:
-                    assert_raises_rpc_error(-5, err_msg, self.nodes[n].getrawtransaction, txId, verbose)
+            self.log.info("Test getrawtransaction without blockhash for a confirmed tx raises")
+            for verbose in [None, 0, False, 1, True]:
+                assert_raises_rpc_error(-5, err_msg, self.nodes[n].getrawtransaction, txId, verbose)
 
-            # 6. invalid parameters - supply txid and invalid boolean values (strings) for verbose
+            # invalid parameters - supply txid and invalid boolean values (strings) for verbose
             for value in ["True", "False"]:
                 assert_raises_rpc_error(-3, "not of expected type number", self.nodes[n].getrawtransaction, txid=txId, verbose=value)
                 assert_raises_rpc_error(-3, "not of expected type number", self.nodes[n].getrawtransaction, txid=txId, verbosity=value)
 
-            # 7. invalid parameters - supply txid and empty array
+            # invalid parameters - supply txid and empty array
             assert_raises_rpc_error(-3, "not of expected type number", self.nodes[n].getrawtransaction, txId, [])
 
-            # 8. invalid parameters - supply txid and empty dict
+            # invalid parameters - supply txid and empty dict
             assert_raises_rpc_error(-3, "not of expected type number", self.nodes[n].getrawtransaction, txId, {})
 
         # Make a tx by sending, then generate 2 blocks; block1 has the tx in it
         tx = self.wallet.send_self_transfer(from_node=self.nodes[2])['txid']
         block1, block2 = self.generate(self.nodes[2], 2)
         for n in [0, 2]:
-            self.log.info(f"Test getrawtransaction {'with' if n == 0 else 'without'} -txindex, with blockhash")
+            self.log.info("Test getrawtransaction with blockhash")
             # We should be able to get the raw transaction by providing the correct block
             gottx = self.nodes[n].getrawtransaction(txid=tx, verbose=True, blockhash=block1)
             assert_equal(gottx['txid'], tx)
             assert_equal(gottx['in_active_chain'], True)
-            if n == 0:
-                self.log.info("Test getrawtransaction with -txindex, without blockhash: 'in_active_chain' should be absent")
-                for v in [1,2]:
-                    gottx = self.nodes[n].getrawtransaction(txid=tx, verbosity=v)
-                    assert_equal(gottx['txid'], tx)
-                    assert 'in_active_chain' not in gottx
-            else:
-                self.log.info("Test getrawtransaction without -txindex, without blockhash: expect the call to raise")
-                assert_raises_rpc_error(-5, err_msg, self.nodes[n].getrawtransaction, txid=tx, verbose=True)
+            self.log.info("Test getrawtransaction without blockhash: expect the call to raise")
+            assert_raises_rpc_error(-5, err_msg, self.nodes[n].getrawtransaction, txid=tx, verbose=True)
             # We should not get the tx if we provide an unrelated block
             assert_raises_rpc_error(-5, "No such transaction found", self.nodes[n].getrawtransaction, txid=tx, blockhash=block2)
             # An invalid block hash should raise the correct errors
@@ -211,7 +181,7 @@ def getrawtransaction_verbosity_tests(self):
         ]
         # node 0 & 2 with verbosity 1 & 2
         for n, v in product([0, 2], [1, 2]):
-            self.log.info(f"Test getrawtransaction_verbosity {v} {'with' if n == 0 else 'without'} -txindex, with blockhash")
+            self.log.info(f"Test getrawtransaction_verbosity {v} with blockhash")
             gottx = self.nodes[n].getrawtransaction(txid=tx, verbosity=v, blockhash=block1)
             missing_fields = set(fields).difference(gottx.keys())
             if missing_fields:
@@ -235,8 +205,6 @@ def getrawtransaction_verbosity_tests(self):
                 if missing_fields:
                     raise AssertionError(f"fields {', '.join(missing_fields)} are not in transaction")
 
-        # check verbosity 2 without blockhash but with txindex
-        assert 'fee' in self.nodes[0].getrawtransaction(txid=tx, verbosity=2)
         # check that coinbase has no fee or does not throw any errors for verbosity 2
         coin_base = self.nodes[1].getblock(block1)['tx'][0]
         gottx = self.nodes[1].getrawtransaction(txid=coin_base, verbosity=2, blockhash=block1)
diff --git a/test/functional/rpc_scanblocks.py b/test/functional/rpc_scanblocks.py
deleted file mode 100755
index 0b13741edc94..000000000000
--- a/test/functional/rpc_scanblocks.py
+++ /dev/null
@@ -1,139 +0,0 @@
-#!/usr/bin/env python3
-# Copyright (c) 2021-present The Bitcoin Core developers
-# Distributed under the MIT software license, see the accompanying
-# file COPYING or http://www.opensource.org/licenses/mit-license.php.
-"""Test the scanblocks RPC call."""
-from test_framework.address import address_to_scriptpubkey
-from test_framework.blockfilter import (
-    bip158_basic_element_hash,
-    bip158_relevant_scriptpubkeys,
-)
-from test_framework.messages import COIN
-from test_framework.test_framework import BitcoinTestFramework
-from test_framework.util import (
-    assert_equal,
-    assert_raises_rpc_error,
-)
-from test_framework.wallet import (
-    MiniWallet,
-    getnewdestination,
-)
-
-
-class ScanblocksTest(BitcoinTestFramework):
-    def set_test_params(self):
-        self.num_nodes = 2
-        self.extra_args = [["-blockfilterindex=1"], []]
-
-    def run_test(self):
-        node = self.nodes[0]
-        wallet = MiniWallet(node)
-
-        # send 1.0, mempool only
-        _, spk_1, addr_1 = getnewdestination()
-        wallet.send_to(from_node=node, scriptPubKey=spk_1, amount=1 * COIN)
-
-        parent_key = "tpubD6NzVbkrYhZ4WaWSyoBvQwbpLkojyoTZPRsgXELWz3Popb3qkjcJyJUGLnL4qHHoQvao8ESaAstxYSnhyswJ76uZPStJRJCTKvosUCJZL5B"
-        # send 1.0, mempool only
-        # childkey 5 of `parent_key`
-        wallet.send_to(from_node=node,
-                       scriptPubKey=address_to_scriptpubkey("mkS4HXoTYWRTescLGaUTGbtTTYX5EjJyEE"),
-                       amount=1 * COIN)
-
-        # mine a block and assure that the mined blockhash is in the filterresult
-        blockhash = self.generate(node, 1)[0]
-        height = node.getblockheader(blockhash)['height']
-        self.wait_until(lambda: all(i["synced"] for i in node.getindexinfo().values()))
-
-        out = node.scanblocks("start", [f"addr({addr_1})"])
-        assert blockhash in out['relevant_blocks']
-        assert_equal(height, out['to_height'])
-        assert_equal(0, out['from_height'])
-        assert_equal(True, out['completed'])
-
-        # mine another block
-        blockhash_new = self.generate(node, 1)[0]
-        height_new = node.getblockheader(blockhash_new)['height']
-
-        # make sure the blockhash is not in the filter result if we set the start_height
-        # to the just mined block (unlikely to hit a false positive)
-        assert blockhash not in node.scanblocks(
-            "start", [f"addr({addr_1})"], height_new)['relevant_blocks']
-
-        # make sure the blockhash is present when using the first mined block as start_height
-        assert blockhash in node.scanblocks(
-            "start", [f"addr({addr_1})"], height)['relevant_blocks']
-        for v in [False, True]:
-            assert blockhash in node.scanblocks(
-                action="start",
-                scanobjects=[f"addr({addr_1})"],
-                start_height=height,
-                options={"filter_false_positives": v})['relevant_blocks']
-
-        # also test the stop height
-        assert blockhash in node.scanblocks(
-            "start", [f"addr({addr_1})"], height, height)['relevant_blocks']
-
-        # use the stop_height to exclude the relevant block
-        assert blockhash not in node.scanblocks(
-            "start", [f"addr({addr_1})"], 0, height - 1)['relevant_blocks']
-
-        # make sure the blockhash is present when using the first mined block as start_height
-        assert blockhash in node.scanblocks(
-            "start", [{"desc": f"pkh({parent_key}/*)", "range": [0, 100]}], height)['relevant_blocks']
-
-        # check that false-positives are included in the result now; note that
-        # finding a false-positive at runtime would take too long, hence we simply
-        # use a pre-calculated one that collides with the regtest genesis block's
-        # coinbase output and verify that their BIP158 ranged hashes match
-        genesis_blockhash = node.getblockhash(0)
-        genesis_spks = bip158_relevant_scriptpubkeys(node, genesis_blockhash)
-        assert_equal(len(genesis_spks), 1)
-        genesis_coinbase_spk = list(genesis_spks)[0]
-        false_positive_spk = bytes.fromhex("001400000000000000000000000000000000000cadcb")
-
-        genesis_coinbase_hash = bip158_basic_element_hash(genesis_coinbase_spk, 1, genesis_blockhash)
-        false_positive_hash = bip158_basic_element_hash(false_positive_spk, 1, genesis_blockhash)
-        assert_equal(genesis_coinbase_hash, false_positive_hash)
-
-        assert genesis_blockhash in node.scanblocks(
-            "start", [{"desc": f"raw({genesis_coinbase_spk.hex()})"}], 0, 0)['relevant_blocks']
-        assert genesis_blockhash in node.scanblocks(
-            "start", [{"desc": f"raw({false_positive_spk.hex()})"}], 0, 0)['relevant_blocks']
-
-        # check that the filter_false_positives option works
-        assert genesis_blockhash in node.scanblocks(
-            "start", [{"desc": f"raw({genesis_coinbase_spk.hex()})"}], 0, 0, "basic", {"filter_false_positives": True})['relevant_blocks']
-        assert genesis_blockhash not in node.scanblocks(
-            "start", [{"desc": f"raw({false_positive_spk.hex()})"}], 0, 0, "basic", {"filter_false_positives": True})['relevant_blocks']
-
-        # test node with disabled blockfilterindex
-        assert_raises_rpc_error(-1, "Index is not enabled for filtertype basic",
-                                self.nodes[1].scanblocks, "start", [f"addr({addr_1})"])
-
-        # test unknown filtertype
-        assert_raises_rpc_error(-5, "Unknown filtertype",
-                                node.scanblocks, "start", [f"addr({addr_1})"], 0, 10, "extended")
-
-        # test invalid start_height
-        assert_raises_rpc_error(-1, "Invalid start_height",
-                                node.scanblocks, "start", [f"addr({addr_1})"], 100000000)
-
-        # test invalid stop_height
-        assert_raises_rpc_error(-1, "Invalid stop_height",
-                                node.scanblocks, "start", [f"addr({addr_1})"], 10, 0)
-        assert_raises_rpc_error(-1, "Invalid stop_height",
-                                node.scanblocks, "start", [f"addr({addr_1})"], 10, 100000000)
-
-        # test accessing the status (must be empty)
-        assert_equal(node.scanblocks("status"), None)
-
-        # test aborting the current scan (there is no, must return false)
-        assert_equal(node.scanblocks("abort"), False)
-
-        # test invalid command
-        assert_raises_rpc_error(-8, "Invalid action 'foobar'", node.scanblocks, "foobar")
-
-
-if __name__ == '__main__':
-    ScanblocksTest(__file__).main()
diff --git a/test/functional/rpc_txoutproof.py b/test/functional/rpc_txoutproof.py
index 055942a87ce7..363e6555019c 100755
--- a/test/functional/rpc_txoutproof.py
+++ b/test/functional/rpc_txoutproof.py
@@ -12,23 +12,18 @@
 from test_framework.util import (
     assert_equal,
     assert_raises_rpc_error,
-    sync_txindex,
 )
 from test_framework.wallet import MiniWallet
 
 
 class MerkleBlockTest(BitcoinTestFramework):
     def set_test_params(self):
-        self.num_nodes = 2
-        self.extra_args = [
-            [],
-            ["-txindex"],
-        ]
+        self.num_nodes = 1
 
     def run_test(self):
         miniwallet = MiniWallet(self.nodes[0])
 
-        chain_height = self.nodes[1].getblockcount()
+        chain_height = self.nodes[0].getblockcount()
         assert_equal(chain_height, 200)
 
         txid1 = miniwallet.send_self_transfer(from_node=self.nodes[0])['txid']
@@ -77,9 +72,6 @@ def run_test(self):
         # We can get the proof if we provide a list of transactions and one of them is unspent. The ordering of the list should not matter.
         assert_equal(sorted(self.nodes[0].verifytxoutproof(self.nodes[0].gettxoutproof([txid1, txid2]))), sorted(txlist))
         assert_equal(sorted(self.nodes[0].verifytxoutproof(self.nodes[0].gettxoutproof([txid2, txid1]))), sorted(txlist))
-        # We can always get a proof if we have a -txindex
-        sync_txindex(self, self.nodes[1])
-        assert_equal(self.nodes[0].verifytxoutproof(self.nodes[1].gettxoutproof([txid_spent])), [txid_spent])
         # We can't get a proof if we specify transactions from different blocks
         assert_raises_rpc_error(-5, "Not all transactions found in specified or retrieved block", self.nodes[0].gettxoutproof, [txid1, txid3])
         # Test empty list
@@ -88,9 +80,9 @@ def run_test(self):
         assert_raises_rpc_error(-8, 'Invalid parameter, duplicated txid', self.nodes[0].gettxoutproof, [txid1, txid1])
 
         # Now we'll try tweaking a proof.
-        proof = self.nodes[1].gettxoutproof([txid1, txid2])
+        proof = self.nodes[0].gettxoutproof([txid1, txid2], blockhash)
         assert txid1 in self.nodes[0].verifytxoutproof(proof)
-        assert txid2 in self.nodes[1].verifytxoutproof(proof)
+        assert txid2 in self.nodes[0].verifytxoutproof(proof)
 
         tweaked_proof = from_hex(CMerkleBlock(), proof)
 
diff --git a/test/functional/test_framework/blockfilter.py b/test/functional/test_framework/blockfilter.py
deleted file mode 100644
index d02f0212a73f..000000000000
--- a/test/functional/test_framework/blockfilter.py
+++ /dev/null
@@ -1,49 +0,0 @@
-#!/usr/bin/env python3
-# Copyright (c) 2022-present The Bitcoin Core developers
-# Distributed under the MIT software license, see the accompanying
-# file COPYING or http://www.opensource.org/licenses/mit-license.php.
-"""Helper routines relevant for compact block filters (BIP158).
-"""
-from .crypto.siphash import siphash
-
-
-def bip158_basic_element_hash(script_pub_key, N, block_hash):
-    """ Calculates the ranged hash of a filter element as defined in BIP158:
-
-    'The first step in the filter construction is hashing the variable-sized
-    raw items in the set to the range [0, F), where F = N * M.'
-
-    'The items are first passed through the pseudorandom function SipHash, which takes a
-    128-bit key k and a variable-sized byte vector and produces a uniformly random 64-bit
-    output. Implementations of this BIP MUST use the SipHash parameters c = 2 and d = 4.'
-
-    'The parameter k MUST be set to the first 16 bytes of the hash (in standard
-    little-endian representation) of the block for which the filter is constructed. This
-    ensures the key is deterministic while still varying from block to block.'
-    """
-    M = 784931
-    block_hash_bytes = bytes.fromhex(block_hash)[::-1]
-    k0 = int.from_bytes(block_hash_bytes[0:8], 'little')
-    k1 = int.from_bytes(block_hash_bytes[8:16], 'little')
-    return (siphash(k0, k1, script_pub_key) * (N * M)) >> 64
-
-
-def bip158_relevant_scriptpubkeys(node, block_hash):
-    """ Determines the basic filter relevant scriptPubKeys as defined in BIP158:
-
-    'A basic filter MUST contain exactly the following items for each transaction in a block:
-       - The previous output script (the script being spent) for each input, except for
-         the coinbase transaction.
-       - The scriptPubKey of each output, aside from all OP_RETURN output scripts.'
-    """
-    spks = set()
-    for tx in node.getblock(blockhash=block_hash, verbosity=3)['tx']:
-        # gather prevout scripts
-        for i in tx['vin']:
-            if 'prevout' in i:
-                spks.add(bytes.fromhex(i['prevout']['scriptPubKey']['hex']))
-        # gather output scripts
-        for o in tx['vout']:
-            if o['scriptPubKey']['type'] != 'nulldata':
-                spks.add(bytes.fromhex(o['scriptPubKey']['hex']))
-    return spks
diff --git a/test/functional/test_framework/messages.py b/test/functional/test_framework/messages.py
index 012049c257cb..59e657fa290f 100755
--- a/test/functional/test_framework/messages.py
+++ b/test/functional/test_framework/messages.py
@@ -56,7 +56,6 @@
 NODE_NETWORK = (1 << 0)
 NODE_BLOOM = (1 << 2)
 NODE_WITNESS = (1 << 3)
-NODE_COMPACT_FILTERS = (1 << 6)
 NODE_NETWORK_LIMITED = (1 << 10)
 NODE_P2P_V2 = (1 << 11)
 
@@ -1755,156 +1754,6 @@ def serialize(self):
         return self.block_transactions.serialize(with_witness=False)
 
 
-class msg_getcfilters:
-    __slots__ = ("filter_type", "start_height", "stop_hash")
-    msgtype =  b"getcfilters"
-
-    def __init__(self, filter_type=None, start_height=None, stop_hash=None):
-        self.filter_type = filter_type
-        self.start_height = start_height
-        self.stop_hash = stop_hash
-
-    def deserialize(self, f):
-        self.filter_type = int.from_bytes(f.read(1), "little")
-        self.start_height = int.from_bytes(f.read(4), "little")
-        self.stop_hash = deser_uint256(f)
-
-    def serialize(self):
-        r = b""
-        r += self.filter_type.to_bytes(1, "little")
-        r += self.start_height.to_bytes(4, "little")
-        r += ser_uint256(self.stop_hash)
-        return r
-
-    def __repr__(self):
-        return "msg_getcfilters(filter_type={:#x}, start_height={}, stop_hash={:x})".format(
-            self.filter_type, self.start_height, self.stop_hash)
-
-class msg_cfilter:
-    __slots__ = ("filter_type", "block_hash", "filter_data")
-    msgtype =  b"cfilter"
-
-    def __init__(self, filter_type=None, block_hash=None, filter_data=None):
-        self.filter_type = filter_type
-        self.block_hash = block_hash
-        self.filter_data = filter_data
-
-    def deserialize(self, f):
-        self.filter_type = int.from_bytes(f.read(1), "little")
-        self.block_hash = deser_uint256(f)
-        self.filter_data = deser_string(f)
-
-    def serialize(self):
-        r = b""
-        r += self.filter_type.to_bytes(1, "little")
-        r += ser_uint256(self.block_hash)
-        r += ser_string(self.filter_data)
-        return r
-
-    def __repr__(self):
-        return "msg_cfilter(filter_type={:#x}, block_hash={:x})".format(
-            self.filter_type, self.block_hash)
-
-class msg_getcfheaders:
-    __slots__ = ("filter_type", "start_height", "stop_hash")
-    msgtype =  b"getcfheaders"
-
-    def __init__(self, filter_type=None, start_height=None, stop_hash=None):
-        self.filter_type = filter_type
-        self.start_height = start_height
-        self.stop_hash = stop_hash
-
-    def deserialize(self, f):
-        self.filter_type = int.from_bytes(f.read(1), "little")
-        self.start_height = int.from_bytes(f.read(4), "little")
-        self.stop_hash = deser_uint256(f)
-
-    def serialize(self):
-        r = b""
-        r += self.filter_type.to_bytes(1, "little")
-        r += self.start_height.to_bytes(4, "little")
-        r += ser_uint256(self.stop_hash)
-        return r
-
-    def __repr__(self):
-        return "msg_getcfheaders(filter_type={:#x}, start_height={}, stop_hash={:x})".format(
-            self.filter_type, self.start_height, self.stop_hash)
-
-class msg_cfheaders:
-    __slots__ = ("filter_type", "stop_hash", "prev_header", "hashes")
-    msgtype =  b"cfheaders"
-
-    def __init__(self, filter_type=None, stop_hash=None, prev_header=None, hashes=None):
-        self.filter_type = filter_type
-        self.stop_hash = stop_hash
-        self.prev_header = prev_header
-        self.hashes = hashes
-
-    def deserialize(self, f):
-        self.filter_type = int.from_bytes(f.read(1), "little")
-        self.stop_hash = deser_uint256(f)
-        self.prev_header = deser_uint256(f)
-        self.hashes = deser_uint256_vector(f)
-
-    def serialize(self):
-        r = b""
-        r += self.filter_type.to_bytes(1, "little")
-        r += ser_uint256(self.stop_hash)
-        r += ser_uint256(self.prev_header)
-        r += ser_uint256_vector(self.hashes)
-        return r
-
-    def __repr__(self):
-        return "msg_cfheaders(filter_type={:#x}, stop_hash={:x})".format(
-            self.filter_type, self.stop_hash)
-
-class msg_getcfcheckpt:
-    __slots__ = ("filter_type", "stop_hash")
-    msgtype =  b"getcfcheckpt"
-
-    def __init__(self, filter_type=None, stop_hash=None):
-        self.filter_type = filter_type
-        self.stop_hash = stop_hash
-
-    def deserialize(self, f):
-        self.filter_type = int.from_bytes(f.read(1), "little")
-        self.stop_hash = deser_uint256(f)
-
-    def serialize(self):
-        r = b""
-        r += self.filter_type.to_bytes(1, "little")
-        r += ser_uint256(self.stop_hash)
-        return r
-
-    def __repr__(self):
-        return "msg_getcfcheckpt(filter_type={:#x}, stop_hash={:x})".format(
-            self.filter_type, self.stop_hash)
-
-class msg_cfcheckpt:
-    __slots__ = ("filter_type", "stop_hash", "headers")
-    msgtype =  b"cfcheckpt"
-
-    def __init__(self, filter_type=None, stop_hash=None, headers=None):
-        self.filter_type = filter_type
-        self.stop_hash = stop_hash
-        self.headers = headers
-
-    def deserialize(self, f):
-        self.filter_type = int.from_bytes(f.read(1), "little")
-        self.stop_hash = deser_uint256(f)
-        self.headers = deser_uint256_vector(f)
-
-    def serialize(self):
-        r = b""
-        r += self.filter_type.to_bytes(1, "little")
-        r += ser_uint256(self.stop_hash)
-        r += ser_uint256_vector(self.headers)
-        return r
-
-    def __repr__(self):
-        return "msg_cfcheckpt(filter_type={:#x}, stop_hash={:x})".format(
-            self.filter_type, self.stop_hash)
-
 class msg_sendtxrcncl:
     __slots__ = ("version", "salt")
     msgtype = b"sendtxrcncl"
diff --git a/test/functional/test_framework/p2p.py b/test/functional/test_framework/p2p.py
index fae4eb94c21a..22c8cae295cd 100755
--- a/test/functional/test_framework/p2p.py
+++ b/test/functional/test_framework/p2p.py
@@ -39,9 +39,6 @@
     msg_block,
     MSG_BLOCK,
     msg_blocktxn,
-    msg_cfcheckpt,
-    msg_cfheaders,
-    msg_cfilter,
     msg_cmpctblock,
     msg_feefilter,
     msg_filteradd,
@@ -50,9 +47,6 @@
     msg_getaddr,
     msg_getblocks,
     msg_getblocktxn,
-    msg_getcfcheckpt,
-    msg_getcfheaders,
-    msg_getcfilters,
     msg_getdata,
     msg_getheaders,
     msg_headers,
@@ -120,9 +114,6 @@
     b"addrv2": msg_addrv2,
     b"block": msg_block,
     b"blocktxn": msg_blocktxn,
-    b"cfcheckpt": msg_cfcheckpt,
-    b"cfheaders": msg_cfheaders,
-    b"cfilter": msg_cfilter,
     b"cmpctblock": msg_cmpctblock,
     b"feefilter": msg_feefilter,
     b"filteradd": msg_filteradd,
@@ -131,9 +122,6 @@
     b"getaddr": msg_getaddr,
     b"getblocks": msg_getblocks,
     b"getblocktxn": msg_getblocktxn,
-    b"getcfcheckpt": msg_getcfcheckpt,
-    b"getcfheaders": msg_getcfheaders,
-    b"getcfilters": msg_getcfilters,
     b"getdata": msg_getdata,
     b"getheaders": msg_getheaders,
     b"headers": msg_headers,
diff --git a/test/functional/test_framework/util.py b/test/functional/test_framework/util.py
index 46a0cdaa068f..5ff508fae23b 100644
--- a/test/functional/test_framework/util.py
+++ b/test/functional/test_framework/util.py
@@ -726,12 +726,6 @@ def dumb_sync_blocks(*, src, dst, height=None):
     assert_equal(dst.getblockcount(), height)
 
 
-def sync_txindex(test_framework, node):
-    test_framework.log.debug("Waiting for node txindex to sync")
-    sync_start = int(time.time())
-    test_framework.wait_until(lambda: node.getindexinfo("txindex")["txindex"]["synced"])
-    test_framework.log.debug(f"Synced in {time.time() - sync_start} seconds")
-
 def is_dir_writable(dir_path: pathlib.Path) -> bool:
     """Return True if we can create a file in the directory, False otherwise"""
     try:
diff --git a/test/functional/test_framework/v2_p2p.py b/test/functional/test_framework/v2_p2p.py
index 087b885ae027..d3ef28d45535 100644
--- a/test/functional/test_framework/v2_p2p.py
+++ b/test/functional/test_framework/v2_p2p.py
@@ -43,12 +43,6 @@
     19: b"pong",
     20: b"sendcmpct",
     21: b"tx",
-    22: b"getcfilters",
-    23: b"cfilter",
-    24: b"getcfheaders",
-    25: b"cfheaders",
-    26: b"getcfcheckpt",
-    27: b"cfcheckpt",
     28: b"addrv2",
 }
 
diff --git a/test/functional/test_runner.py b/test/functional/test_runner.py
index 729bac963436..d9ebd9c5ec39 100755
--- a/test/functional/test_runner.py
+++ b/test/functional/test_runner.py
@@ -117,7 +117,6 @@
     'p2p_orphan_handling.py',
     'feature_maxtipage.py',
     'p2p_dns_seeds.py',
-    'p2p_blockfilters.py',
     'feature_bip68_sequence.py',
     'rpc_packages.py',
     'rpc_bind.py --ipv4',
@@ -198,7 +197,6 @@
     'p2p_v2_misbehaving.py',
     'example_test.py',
     'mempool_truc.py',
-    'rpc_getblockfilter.py',
     'rpc_getblockfrompeer.py',
     'rpc_invalidateblock.py',
     'feature_utxo_set_hash.py',
@@ -263,7 +261,6 @@
     'p2p_ping.py',
     'p2p_tx_privacy.py',
     'rpc_getdescriptoractivity.py',
-    'rpc_scanblocks.py',
     'tool_bitcoin.py',
     'p2p_sendtxrcncl.py',
     'rpc_scantxoutset.py',
@@ -275,15 +272,12 @@
     'interface_ipc_mining.py',
     'feature_anchors.py',
     'mempool_datacarrier.py',
-    'feature_coinstatsindex.py',
-    'feature_coinstatsindex_compatibility.py',
     'p2p_permissions.py',
     'feature_blocksdir.py',
     'feature_remove_pruned_files_on_startup.py',
     'p2p_i2p_ports.py',
     'p2p_i2p_sessions.py',
     'feature_presegwit_node_upgrade.py',
-    'rpc_gettxspendingprevout.py',
     'rpc_help.py',
     'tool_rpcauth.py',
     'p2p_handshake.py',
diff --git a/test/functional/tool_utxo_to_sqlite.py b/test/functional/tool_utxo_to_sqlite.py
index 1c73bd80963c..3570ed358c5c 100755
--- a/test/functional/tool_utxo_to_sqlite.py
+++ b/test/functional/tool_utxo_to_sqlite.py
@@ -77,7 +77,7 @@ class UtxoToSqliteTest(BitcoinTestFramework):
     def set_test_params(self):
         self.num_nodes = 1
         # we want to create some UTXOs with non-standard output scripts
-        self.extra_args = [['-acceptnonstdtxn=1', '-coinstatsindex=1']]
+        self.extra_args = [['-acceptnonstdtxn=1']]
 
     def skip_test_if_missing_module(self):
         self.skip_if_no_py_sqlite3()
@@ -146,9 +146,9 @@ def run_test(self):
             target_height = node.getblockcount() - 10
             node.dumptxoutset(fifo_filename, "rollback", {"rollback": target_height})
             p.wait(timeout=10)
-            muhash_direct_sqlite = calculate_muhash_from_sqlite_utxos(output_direct_filename, "hex", "hex")
-            muhash_index = node.gettxoutsetinfo('muhash', target_height)['muhash']
-            assert_equal(muhash_index, muhash_direct_sqlite)
+            # The historical muhash cannot be queried directly from the node here,
+            # but the dump-via-FIFO path itself is exercised.
+            calculate_muhash_from_sqlite_utxos(output_direct_filename, "hex", "hex")
             os.remove(fifo_filename)
 
 
diff --git a/test/lint/lint-circular-dependencies.py b/test/lint/lint-circular-dependencies.py
index e0651c52450b..5718d7a59447 100755
--- a/test/lint/lint-circular-dependencies.py
+++ b/test/lint/lint-circular-dependencies.py
@@ -17,9 +17,6 @@
     "node/utxo_snapshot -> validation -> node/utxo_snapshot",
     "kernel/coinstats -> validation -> kernel/coinstats",
     "versionbits -> versionbits_impl -> versionbits",
-
-    # Temporary, removed in followup https://github.com/bitcoin/bitcoin/pull/24230
-    "index/base -> node/context -> net_processing -> index/blockfilterindex -> index/base",
 )
 
 CODE_DIR = "src"