diff --git a/doc/release-notes-7101.md b/doc/release-notes-7101.md
new file mode 100644
index 000000000000..4daa80a0f8e7
--- /dev/null
+++ b/doc/release-notes-7101.md
@@ -0,0 +1,12 @@
+## Indexes
+
+### Async Index Migration (#7101)
+
+`TimestampIndex`, `SpentIndex`, and `AddressIndex` have been migrated from synchronous to asynchronous operation, following the same pattern as `TxIndex` and other indexes using `BaseIndex` framework.
+
+When enabling an index for the first time, the node will build the index in the background while remaining fully operational. Progress can be monitored via the `getindexinfo` RPC.
+
+Existing nodes with indexes enabled will automatically migrate data from the old location (block index database) to new separate databases on first startup. This migration may take 20-40 minutes or longer depending on hardware specifications and index sizes. The node will log progress during migration.
+
+Breaking changes:
+- `SpentIndex` and `AddressIndex` are incompatible with pruned nodes as they require access to undo data now
diff --git a/src/Makefile.am b/src/Makefile.am
index 47f3c6bd55fc..183dd83b1cb8 100644
--- a/src/Makefile.am
+++ b/src/Makefile.am
@@ -157,8 +157,6 @@ BITCOIN_CORE_H = \
   active/masternode.h \
   active/quorums.h \
   addrdb.h \
-  addressindex.h \
-  spentindex.h \
   addrman.h \
   addrman_impl.h \
   attributes.h \
@@ -247,10 +245,17 @@ BITCOIN_CORE_H = \
   httprpc.h \
   httpserver.h \
   i2p.h \
+  index/addressindex.h \
+  index/addressindex_types.h \
+  index/addressindex_util.h \
   index/base.h \
   index/blockfilterindex.h \
   index/coinstatsindex.h \
   index/disktxpos.h \
+  index/spentindex.h \
+  index/spentindex_types.h \
+  index/timestampindex.h \
+  index/timestampindex_types.h \
   index/txindex.h \
   indirectmap.h \
   init.h \
@@ -344,7 +349,6 @@ BITCOIN_CORE_H = \
   rpc/blockchain.h \
   rpc/client.h \
   rpc/evo_util.h \
-  rpc/index_util.h \
   rpc/mempool.h \
   rpc/mining.h \
   rpc/protocol.h \
@@ -379,7 +383,6 @@ BITCOIN_CORE_H = \
   support/events.h \
   support/lockedpool.h \
   sync.h \
-  timestampindex.h \
   threadsafety.h \
   timedata.h \
   torcontrol.h \
@@ -489,7 +492,6 @@ libbitcoin_node_a_SOURCES = \
   active/masternode.cpp \
   active/quorums.cpp \
   addrdb.cpp \
-  addressindex.cpp \
   addrman.cpp \
   banman.cpp \
   batchedlogger.cpp \
@@ -536,9 +538,13 @@ libbitcoin_node_a_SOURCES = \
   httprpc.cpp \
   httpserver.cpp \
   i2p.cpp \
+  index/addressindex.cpp \
+  index/addressindex_util.cpp \
   index/base.cpp \
   index/blockfilterindex.cpp \
   index/coinstatsindex.cpp \
+  index/spentindex.cpp \
+  index/timestampindex.cpp \
   index/txindex.cpp \
   init.cpp \
   instantsend/db.cpp \
@@ -601,7 +607,6 @@ libbitcoin_node_a_SOURCES = \
   rpc/coinjoin.cpp \
   rpc/evo.cpp \
   rpc/fees.cpp \
-  rpc/index_util.cpp \
   rpc/masternode.cpp \
   rpc/mempool.cpp \
   rpc/governance.cpp \
diff --git a/src/addressindex.cpp b/src/addressindex.cpp
deleted file mode 100644
index 4cefedaf752f..000000000000
--- a/src/addressindex.cpp
+++ /dev/null
@@ -1,43 +0,0 @@
-// Copyright (c) 2016 BitPay Inc.
-// Copyright (c) 2023-2024 The Dash Core developers
-// Distributed under the MIT software license, see the accompanying
-// file COPYING or http://www.opensource.org/licenses/mit-license.php.
-
-#include <addressindex.h>
-
-#include <key_io.h>
-#include <hash.h>
-#include <script/script.h>
-
-template <typename T1>
-inline std::vector<uint8_t> TrimScriptP2PKH(const T1& input) {
-    return std::vector<uint8_t>(input.begin() + 3, input.begin() + 23);
-};
-
-template <typename T1>
-inline std::vector<uint8_t> TrimScriptP2SH(const T1& input) {
-    return std::vector<uint8_t>(input.begin() + 2, input.begin() + 22);
-};
-
-template <typename T1>
-inline std::vector<uint8_t> TrimScriptP2PK(const T1& input) {
-    return std::vector<uint8_t>(input.begin() + 1, input.end() - 1);
-};
-
-bool AddressBytesFromScript(const CScript& script, AddressType& address_type, uint160& address_bytes) {
-    if (script.IsPayToScriptHash()) {
-        address_type  = AddressType::P2SH;
-        address_bytes = uint160(TrimScriptP2SH(script));
-    } else if (script.IsPayToPublicKeyHash()) {
-        address_type  = AddressType::P2PK_OR_P2PKH;
-        address_bytes = uint160(TrimScriptP2PKH(script));
-    } else if (script.IsPayToPublicKey()) {
-        address_type  = AddressType::P2PK_OR_P2PKH;
-        address_bytes = Hash160(TrimScriptP2PK(script));
-    } else {
-        address_type  = AddressType::UNKNOWN;
-        address_bytes.SetNull();
-        return false;
-    }
-    return true;
-}
diff --git a/src/core_write.cpp b/src/core_write.cpp
index 1f94e6e0e592..a7ab773fdc22 100644
--- a/src/core_write.cpp
+++ b/src/core_write.cpp
@@ -19,8 +19,7 @@
 #include <util/strencodings.h>
 #include <util/system.h>
 
-#include <addressindex.h>
-#include <spentindex.h>
+#include <index/spentindex.h>
 
 #include <evo/assetlocktx.h>
 #include <evo/cbtx.h>
diff --git a/src/dbwrapper.h b/src/dbwrapper.h
index 9f04c8523266..519495fefdc5 100644
--- a/src/dbwrapper.h
+++ b/src/dbwrapper.h
@@ -392,6 +392,22 @@ class CDBWrapper
     {
         pdb->CompactRange(nullptr, nullptr);
     }
+
+    /**
+     * Compact a specific range of keys in the database.
+     */
+    template<typename K>
+    void CompactRange(const K& key_begin, const K& key_end) const
+    {
+        CDataStream ssKey1(SER_DISK, CLIENT_VERSION), ssKey2(SER_DISK, CLIENT_VERSION);
+        ssKey1.reserve(DBWRAPPER_PREALLOC_KEY_SIZE);
+        ssKey2.reserve(DBWRAPPER_PREALLOC_KEY_SIZE);
+        ssKey1 << key_begin;
+        ssKey2 << key_end;
+        leveldb::Slice slKey1(CharCast(ssKey1.data()), ssKey1.size());
+        leveldb::Slice slKey2(CharCast(ssKey2.data()), ssKey2.size());
+        pdb->CompactRange(&slKey1, &slKey2);
+    }
 };
 
 template<typename CDBTransaction>
diff --git a/src/index/addressindex.cpp b/src/index/addressindex.cpp
new file mode 100644
index 000000000000..ffc15cdf330e
--- /dev/null
+++ b/src/index/addressindex.cpp
@@ -0,0 +1,395 @@
+// Copyright (c) 2026 The Dash Core developers
+// Distributed under the MIT software license, see the accompanying
+// file COPYING or http://www.opensource.org/licenses/mit-license.php.
+
+#include <index/addressindex.h>
+
+#include <chainparams.h>
+#include <clientversion.h>
+#include <hash.h>
+#include <index/addressindex_util.h>
+#include <logging.h>
+#include <node/blockstorage.h>
+#include <undo.h>
+#include <util/system.h>
+
+constexpr uint8_t DB_ADDRESSINDEX{'a'};
+constexpr uint8_t DB_ADDRESSUNSPENTINDEX{'u'};
+
+std::unique_ptr<AddressIndex> g_addressindex;
+
+AddressIndex::DB::DB(size_t n_cache_size, bool f_memory, bool f_wipe) :
+    BaseIndex::DB(gArgs.GetDataDirNet() / "indexes" / "addressindex", n_cache_size, f_memory, f_wipe)
+{
+}
+
+bool AddressIndex::DB::WriteBatch(const std::vector<CAddressIndexEntry>& address_entries,
+                                  const std::vector<CAddressUnspentIndexEntry>& unspent_entries)
+{
+    CDBBatch batch(*this);
+
+    // Write address transaction history
+    for (const auto& [key, value] : address_entries) {
+        batch.Write(std::make_pair(DB_ADDRESSINDEX, key), value);
+    }
+
+    // Write address unspent outputs (handles both adds and deletes)
+    for (const auto& [key, value] : unspent_entries) {
+        if (value.IsNull()) {
+            // Null value means delete entry
+            batch.Erase(std::make_pair(DB_ADDRESSUNSPENTINDEX, key));
+        } else {
+            batch.Write(std::make_pair(DB_ADDRESSUNSPENTINDEX, key), value);
+        }
+    }
+
+    return CDBWrapper::WriteBatch(batch);
+}
+
+bool AddressIndex::DB::ReadAddressIndex(const uint160& address_hash, const AddressType type,
+                                        std::vector<CAddressIndexEntry>& entries, const int32_t start, const int32_t end)
+{
+    std::unique_ptr<CDBIterator> pcursor(NewIterator());
+
+    if (start > 0 && end > 0) {
+        pcursor->Seek(std::make_pair(DB_ADDRESSINDEX, CAddressIndexIteratorHeightKey(type, address_hash, start)));
+    } else {
+        pcursor->Seek(std::make_pair(DB_ADDRESSINDEX, CAddressIndexIteratorKey(type, address_hash)));
+    }
+
+    while (pcursor->Valid()) {
+        std::pair<uint8_t, CAddressIndexKey> key;
+        if (pcursor->GetKey(key) && key.first == DB_ADDRESSINDEX && key.second.m_address_type == type &&
+            key.second.m_address_bytes == address_hash) {
+            if (end > 0 && key.second.m_block_height > end) {
+                break;
+            }
+            CAmount value;
+            if (pcursor->GetValue(value)) {
+                entries.emplace_back(key.second, value);
+                pcursor->Next();
+            } else {
+                return error("failed to get address index value");
+            }
+        } else {
+            break;
+        }
+    }
+
+    return true;
+}
+
+bool AddressIndex::DB::ReadAddressUnspentIndex(const uint160& address_hash, const AddressType type,
+                                               std::vector<CAddressUnspentIndexEntry>& entries, const bool height_sort)
+{
+    std::unique_ptr<CDBIterator> pcursor(NewIterator());
+
+    pcursor->Seek(std::make_pair(DB_ADDRESSUNSPENTINDEX, CAddressIndexIteratorKey(type, address_hash)));
+
+    while (pcursor->Valid()) {
+        std::pair<uint8_t, CAddressUnspentKey> key;
+        if (pcursor->GetKey(key) && key.first == DB_ADDRESSUNSPENTINDEX && key.second.m_address_type == type &&
+            key.second.m_address_bytes == address_hash) {
+            CAddressUnspentValue value;
+            if (pcursor->GetValue(value)) {
+                entries.emplace_back(key.second, value);
+                pcursor->Next();
+            } else {
+                return error("failed to get address unspent value");
+            }
+        } else {
+            break;
+        }
+    }
+
+    if (height_sort) {
+        std::sort(entries.begin(), entries.end(),
+                  [](const CAddressUnspentIndexEntry& a, const CAddressUnspentIndexEntry& b) {
+                      return a.second.m_block_height < b.second.m_block_height;
+                  });
+    }
+
+    return true;
+}
+
+bool AddressIndex::DB::EraseAddressIndex(const std::vector<CAddressIndexEntry>& entries)
+{
+    CDBBatch batch(*this);
+
+    for (const auto& [key, _] : entries) {
+        batch.Erase(std::make_pair(DB_ADDRESSINDEX, key));
+    }
+
+    return CDBWrapper::WriteBatch(batch);
+}
+
+bool AddressIndex::DB::UpdateAddressUnspentIndex(const std::vector<CAddressUnspentIndexEntry>& entries)
+{
+    CDBBatch batch(*this);
+
+    for (const auto& [key, value] : entries) {
+        if (value.IsNull()) {
+            batch.Erase(std::make_pair(DB_ADDRESSUNSPENTINDEX, key));
+        } else {
+            batch.Write(std::make_pair(DB_ADDRESSUNSPENTINDEX, key), value);
+        }
+    }
+
+    return CDBWrapper::WriteBatch(batch);
+}
+
+AddressIndex::AddressIndex(size_t n_cache_size, bool f_memory, bool f_wipe) :
+    m_db(std::make_unique<AddressIndex::DB>(n_cache_size, f_memory, f_wipe))
+{
+}
+
+AddressIndex::~AddressIndex() = default;
+
+bool AddressIndex::WriteBlock(const CBlock& block, const CBlockIndex* pindex)
+{
+    // Skip genesis block (no inputs to index)
+    if (pindex->nHeight == 0) {
+        return true;
+    }
+
+    // Read undo data for this block to get information about spent outputs
+    CBlockUndo blockundo;
+    if (!node::UndoReadFromDisk(blockundo, pindex)) {
+        return error("%s: Failed to read undo data for block %s at height %d", __func__,
+                     pindex->GetBlockHash().ToString(), pindex->nHeight);
+    }
+
+    std::vector<CAddressIndexEntry> addressIndex;
+    std::vector<CAddressUnspentIndexEntry> addressUnspentIndex;
+
+    // Process each non-coinbase transaction
+    // blockundo.vtxundo[i] corresponds to block.vtx[i+1] (coinbase is skipped in undo data)
+    for (size_t i = 0; i < blockundo.vtxundo.size(); i++) {
+        const CTransactionRef& tx = block.vtx[i + 1]; // +1 to skip coinbase
+        const CTxUndo& txundo = blockundo.vtxundo[i];
+        const uint256 txhash = tx->GetHash();
+
+        // Verify undo data matches transaction
+        if (tx->vin.size() != txundo.vprevout.size()) {
+            return error("%s: Undo data mismatch for tx %s", __func__, txhash.ToString());
+        }
+
+        // Process inputs (spending activity)
+        for (size_t j = 0; j < tx->vin.size(); j++) {
+            const CTxIn& input = tx->vin[j];
+            const Coin& coin = txundo.vprevout[j];
+            const CTxOut& prevout = coin.out;
+
+            AddressType address_type{AddressType::UNKNOWN};
+            uint160 address_bytes;
+            if (!AddressBytesFromScript(prevout.scriptPubKey, address_type, address_bytes)) {
+                continue;
+            }
+
+            // Record spending activity
+            addressIndex.emplace_back(CAddressIndexKey(address_type, address_bytes, pindex->nHeight, i + 1, txhash, j, true),
+                                      prevout.nValue * -1);
+
+            // Remove from unspent index
+            addressUnspentIndex.emplace_back(CAddressUnspentKey(address_type, address_bytes, input.prevout.hash,
+                                                                input.prevout.n),
+                                             CAddressUnspentValue() // Null value means delete
+            );
+        }
+
+        // Process outputs (receiving activity)
+        for (size_t k = 0; k < tx->vout.size(); k++) {
+            const CTxOut& out = tx->vout[k];
+
+            AddressType address_type{AddressType::UNKNOWN};
+            uint160 address_bytes;
+            if (!AddressBytesFromScript(out.scriptPubKey, address_type, address_bytes)) {
+                continue;
+            }
+
+            // Record receiving activity
+            addressIndex.emplace_back(CAddressIndexKey(address_type, address_bytes, pindex->nHeight, i + 1, txhash, k, false),
+                                      out.nValue);
+
+            // Add to unspent index
+            addressUnspentIndex.emplace_back(CAddressUnspentKey(address_type, address_bytes, txhash, k),
+                                             CAddressUnspentValue(out.nValue, out.scriptPubKey, pindex->nHeight));
+        }
+    }
+
+    // Also process coinbase outputs (receiving activity only)
+    const CTransactionRef& coinbase = block.vtx[0];
+    const uint256 coinbase_hash = coinbase->GetHash();
+    for (size_t k = 0; k < coinbase->vout.size(); k++) {
+        const CTxOut& out = coinbase->vout[k];
+
+        AddressType address_type{AddressType::UNKNOWN};
+        uint160 address_bytes;
+        if (!AddressBytesFromScript(out.scriptPubKey, address_type, address_bytes)) {
+            continue;
+        }
+
+        // Record receiving activity for coinbase
+        addressIndex.emplace_back(CAddressIndexKey(address_type, address_bytes, pindex->nHeight, 0, coinbase_hash, k, false),
+                                  out.nValue);
+
+        // Add coinbase outputs to unspent index
+        addressUnspentIndex.emplace_back(CAddressUnspentKey(address_type, address_bytes, coinbase_hash, k),
+                                         CAddressUnspentValue(out.nValue, out.scriptPubKey, pindex->nHeight));
+    }
+
+    return m_db->WriteBatch(addressIndex, addressUnspentIndex);
+}
+
+bool AddressIndex::Rewind(const CBlockIndex* current_tip, const CBlockIndex* new_tip)
+{
+    assert(current_tip->GetAncestor(new_tip->nHeight) == new_tip);
+
+    // Rewind the unspent index by processing blocks in reverse
+    // We need to undo all operations from current_tip back to (but not including) new_tip
+    for (const CBlockIndex* pindex = current_tip; pindex != new_tip; pindex = pindex->pprev) {
+        CBlock block;
+        if (!node::ReadBlockFromDisk(block, pindex, Params().GetConsensus())) {
+            return error("%s: Failed to read block %s from disk during rewind", __func__,
+                         pindex->GetBlockHash().ToString());
+        }
+
+        CBlockUndo blockundo;
+        if (pindex->nHeight > 0 && !node::UndoReadFromDisk(blockundo, pindex)) {
+            return error("%s: Failed to read undo data for block %s during rewind", __func__,
+                         pindex->GetBlockHash().ToString());
+        }
+
+        std::vector<CAddressIndexEntry> addressIndex;
+        std::vector<CAddressUnspentIndexEntry> addressUnspentIndex;
+
+        // Process transactions in reverse to undo them
+        // blockundo.vtxundo[i] corresponds to block.vtx[i+1] (coinbase skipped)
+        for (size_t i = 0; i < blockundo.vtxundo.size(); i++) {
+            const CTransactionRef& tx = block.vtx[i + 1];
+            const CTxUndo& txundo = blockundo.vtxundo[i];
+            const uint256 txhash = tx->GetHash();
+
+            // Undo outputs (remove from unspent index and transaction history)
+            for (size_t k = 0; k < tx->vout.size(); k++) {
+                const CTxOut& out = tx->vout[k];
+
+                AddressType address_type{AddressType::UNKNOWN};
+                uint160 address_bytes;
+
+                if (!AddressBytesFromScript(out.scriptPubKey, address_type, address_bytes)) {
+                    continue;
+                }
+
+                // Remove receiving activity from history
+                addressIndex.push_back(std::make_pair(CAddressIndexKey(address_type, address_bytes, pindex->nHeight,
+                                                                       i + 1, txhash, k, false),
+                                                      out.nValue));
+
+                // Remove from unspent index (mark for deletion)
+                addressUnspentIndex.push_back(std::make_pair(CAddressUnspentKey(address_type, address_bytes, txhash, k),
+                                                             CAddressUnspentValue() // null value signals deletion
+                                                             ));
+            }
+
+            // Undo inputs (restore to unspent index, remove spending from history)
+            for (size_t j = 0; j < tx->vin.size(); j++) {
+                const CTxIn& input = tx->vin[j];
+                const Coin& coin = txundo.vprevout[j];
+                const CTxOut& prevout = coin.out;
+
+                AddressType address_type{AddressType::UNKNOWN};
+                uint160 address_bytes;
+
+                if (!AddressBytesFromScript(prevout.scriptPubKey, address_type, address_bytes)) {
+                    continue;
+                }
+
+                // Remove spending activity from history
+                addressIndex.push_back(
+                    std::make_pair(CAddressIndexKey(address_type, address_bytes, pindex->nHeight, i + 1, txhash, j, true),
+                                   prevout.nValue * -1));
+
+                // Restore to unspent index
+                addressUnspentIndex.push_back(
+                    std::make_pair(CAddressUnspentKey(address_type, address_bytes, input.prevout.hash, input.prevout.n),
+                                   CAddressUnspentValue(prevout.nValue, prevout.scriptPubKey, coin.nHeight)));
+            }
+        }
+
+        // Process coinbase outputs (remove from indices)
+        if (!block.vtx.empty()) {
+            const CTransactionRef& coinbase_tx = block.vtx[0];
+            const uint256 cb_hash = coinbase_tx->GetHash();
+
+            for (size_t k = 0; k < coinbase_tx->vout.size(); k++) {
+                const CTxOut& out = coinbase_tx->vout[k];
+
+                AddressType address_type{AddressType::UNKNOWN};
+                uint160 address_bytes;
+
+                if (!AddressBytesFromScript(out.scriptPubKey, address_type, address_bytes)) {
+                    continue;
+                }
+
+                // Remove coinbase receiving activity
+                addressIndex.push_back(
+                    std::make_pair(CAddressIndexKey(address_type, address_bytes, pindex->nHeight, 0, cb_hash, k, false),
+                                   out.nValue));
+
+                // Remove from unspent index
+                addressUnspentIndex.push_back(std::make_pair(CAddressUnspentKey(address_type, address_bytes, cb_hash, k),
+                                                             CAddressUnspentValue() // null value signals deletion
+                                                             ));
+            }
+        }
+
+        // Erase address history entries and update unspent index
+        if (!m_db->EraseAddressIndex(addressIndex)) {
+            return error("%s: Failed to erase address index during rewind", __func__);
+        }
+
+        if (!m_db->UpdateAddressUnspentIndex(addressUnspentIndex)) {
+            return error("%s: Failed to update address unspent index during rewind", __func__);
+        }
+    }
+
+    // Call base class Rewind to update the best block pointer
+    return BaseIndex::Rewind(current_tip, new_tip);
+}
+
+void AddressIndex::BlockDisconnected(const std::shared_ptr<const CBlock>& block, const CBlockIndex* pindex)
+{
+    // When a block is disconnected (e.g., via invalidateblock), we need to rewind the index
+    // to remove this block's data
+    const CBlockIndex* best_block_index = CurrentIndex();
+
+    // Only rewind if we have this block indexed
+    if (best_block_index && best_block_index->nHeight >= pindex->nHeight && pindex->pprev) {
+        if (!Rewind(best_block_index, pindex->pprev)) {
+            error("%s: Failed to rewind %s to previous block after disconnect", __func__, GetName());
+        }
+    }
+}
+
+BaseIndex::DB& AddressIndex::GetDB() const { return *m_db; }
+
+bool AddressIndex::GetAddressIndex(const uint160& address_hash, const AddressType type,
+                                   std::vector<CAddressIndexEntry>& entries, const int32_t start, const int32_t end) const
+{
+    if (!BlockUntilSyncedToCurrentChain()) {
+        return false;
+    }
+
+    return m_db->ReadAddressIndex(address_hash, type, entries, start, end);
+}
+
+bool AddressIndex::GetAddressUnspentIndex(const uint160& address_hash, const AddressType type,
+                                          std::vector<CAddressUnspentIndexEntry>& entries, const bool height_sort) const
+{
+    if (!BlockUntilSyncedToCurrentChain()) {
+        return false;
+    }
+
+    return m_db->ReadAddressUnspentIndex(address_hash, type, entries, height_sort);
+}
diff --git a/src/index/addressindex.h b/src/index/addressindex.h
new file mode 100644
index 000000000000..5183699aab57
--- /dev/null
+++ b/src/index/addressindex.h
@@ -0,0 +1,92 @@
+// Copyright (c) 2026 The Dash 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_ADDRESSINDEX_H
+#define BITCOIN_INDEX_ADDRESSINDEX_H
+
+#include <index/addressindex_types.h>
+#include <index/base.h>
+
+#include <memory>
+#include <vector>
+
+static constexpr bool DEFAULT_ADDRESSINDEX{false};
+
+/**
+ * AddressIndex is an async index that maintains two separate databases:
+ * 1. Address transaction history (all transactions touching an address)
+ * 2. Address unspent outputs (UTXO set filtered by address)
+ *
+ * Uses undo data to access historical UTXO information, requiring undo files
+ * to be available (incompatible with pruned nodes).
+ */
+class AddressIndex final : public BaseIndex
+{
+protected:
+    class DB;
+
+private:
+    const std::unique_ptr<DB> m_db;
+
+protected:
+    class DB : public BaseIndex::DB
+    {
+    public:
+        explicit DB(size_t n_cache_size, bool f_memory = false, bool f_wipe = false);
+
+        /// Write a batch of address index entries
+        bool WriteBatch(const std::vector<CAddressIndexEntry>& address_entries,
+                        const std::vector<CAddressUnspentIndexEntry>& unspent_entries);
+
+        /// Read address transaction history
+        bool ReadAddressIndex(const uint160& address_hash, const AddressType type,
+                              std::vector<CAddressIndexEntry>& entries, const int32_t start = 0, const int32_t end = 0);
+
+        /// Read address unspent outputs
+        bool ReadAddressUnspentIndex(const uint160& address_hash, const AddressType type,
+                                     std::vector<CAddressUnspentIndexEntry>& entries, const bool height_sort = false);
+
+        /// Erase address transaction history entries
+        bool EraseAddressIndex(const std::vector<CAddressIndexEntry>& entries);
+
+        /// Update address unspent index (handles both adds and deletes)
+        bool UpdateAddressUnspentIndex(const std::vector<CAddressUnspentIndexEntry>& entries);
+    };
+
+    /// Override to return false - we need undo data
+    bool AllowPrune() const override { return false; }
+
+    /// Write block data to the index databases
+    bool WriteBlock(const CBlock& block, const CBlockIndex* pindex) override;
+
+    /// Custom rewind to handle both transaction history and unspent index
+    bool Rewind(const CBlockIndex* current_tip, const CBlockIndex* new_tip) override;
+
+    /// Handle block disconnections (e.g., from invalidateblock)
+    void BlockDisconnected(const std::shared_ptr<const CBlock>& block, const CBlockIndex* pindex) override;
+
+    BaseIndex::DB& GetDB() const override;
+
+    const char* GetName() const override { return "addressindex"; }
+
+public:
+    /// Constructs the index, which becomes available to be queried
+    explicit AddressIndex(size_t n_cache_size, bool f_memory = false, bool f_wipe = false);
+
+    /// Destructor
+    virtual ~AddressIndex() override;
+
+    /// Query address transaction history
+    bool GetAddressIndex(const uint160& address_hash, const AddressType type, std::vector<CAddressIndexEntry>& entries,
+                         const int32_t start = 0, const int32_t end = 0) const;
+
+    /// Query address unspent outputs
+    bool GetAddressUnspentIndex(const uint160& address_hash, const AddressType type,
+                                std::vector<CAddressUnspentIndexEntry>& entries, const bool height_sort = false) const;
+};
+
+/// Global AddressIndex instance
+extern std::unique_ptr<AddressIndex> g_addressindex;
+
+#endif // BITCOIN_INDEX_ADDRESSINDEX_H
diff --git a/src/addressindex.h b/src/index/addressindex_types.h
similarity index 56%
rename from src/addressindex.h
rename to src/index/addressindex_types.h
index 55dbc8284a58..48a0cddf2736 100644
--- a/src/addressindex.h
+++ b/src/index/addressindex_types.h
@@ -1,22 +1,23 @@
 // Copyright (c) 2009-2010 Satoshi Nakamoto
 // Copyright (c) 2009-2015 The Bitcoin Core developers
 // Copyright (c) 2016 BitPay Inc.
-// Copyright (c) 2023-2024 The Dash Core developers
+// Copyright (c) 2023-2026 The Dash Core developers
 // Distributed under the MIT software license, see the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
-#ifndef BITCOIN_ADDRESSINDEX_H
-#define BITCOIN_ADDRESSINDEX_H
+#ifndef BITCOIN_INDEX_ADDRESSINDEX_TYPES_H
+#define BITCOIN_INDEX_ADDRESSINDEX_TYPES_H
 
 #include <consensus/amount.h>
+#include <script/script.h>
 #include <serialize.h>
 #include <uint256.h>
 #include <util/underlying.h>
 
 #include <chrono>
 #include <tuple>
+#include <vector>
 
-class CScript;
 struct CAddressIndexKey;
 struct CMempoolAddressDelta;
 struct CMempoolAddressDeltaKey;
@@ -32,8 +33,11 @@ template<> struct is_serializable_enum<AddressType> : std::true_type {};
 using CAddressIndexEntry = std::pair<CAddressIndexKey, CAmount>;
 using CMempoolAddressDeltaEntry = std::pair<CMempoolAddressDeltaKey, CMempoolAddressDelta>;
 
-struct CMempoolAddressDelta
-{
+struct CAddressUnspentKey;
+struct CAddressUnspentValue;
+using CAddressUnspentIndexEntry = std::pair<CAddressUnspentKey, CAddressUnspentValue>;
+
+struct CMempoolAddressDelta {
 public:
     std::chrono::seconds m_time;
     CAmount m_amount;
@@ -42,14 +46,21 @@ struct CMempoolAddressDelta
 
 public:
     CMempoolAddressDelta(std::chrono::seconds time, CAmount amount, uint256 prev_hash, uint32_t prev_out) :
-        m_time{time}, m_amount{amount}, m_prev_hash{prev_hash}, m_prev_out{prev_out} {}
+        m_time{time},
+        m_amount{amount},
+        m_prev_hash{prev_hash},
+        m_prev_out{prev_out}
+    {
+    }
 
     CMempoolAddressDelta(std::chrono::seconds time, CAmount amount) :
-        m_time{time}, m_amount{amount} {}
+        m_time{time},
+        m_amount{amount}
+    {
+    }
 };
 
-struct CMempoolAddressDeltaKey
-{
+struct CMempoolAddressDeltaKey {
 public:
     AddressType m_address_type{AddressType::UNKNOWN};
     uint160 m_address_bytes;
@@ -58,7 +69,8 @@ struct CMempoolAddressDeltaKey
     bool m_tx_spent{false};
 
 public:
-    CMempoolAddressDeltaKey(AddressType address_type, uint160 address_bytes, uint256 tx_hash, uint32_t tx_index, bool tx_spent) :
+    CMempoolAddressDeltaKey(AddressType address_type, uint160 address_bytes, uint256 tx_hash, uint32_t tx_index,
+                            bool tx_spent) :
         m_address_type{address_type},
         m_address_bytes{address_bytes},
         m_tx_hash{tx_hash},
@@ -70,9 +82,9 @@ struct CMempoolAddressDeltaKey
         m_address_bytes{address_bytes} {};
 };
 
-struct CMempoolAddressDeltaKeyCompare
-{
-    bool operator()(const CMempoolAddressDeltaKey& a, const CMempoolAddressDeltaKey& b) const {
+struct CMempoolAddressDeltaKeyCompare {
+    bool operator()(const CMempoolAddressDeltaKey& a, const CMempoolAddressDeltaKey& b) const
+    {
         auto to_tuple = [](const CMempoolAddressDeltaKey& obj) {
             return std::tie(obj.m_address_type, obj.m_address_bytes, obj.m_tx_hash, obj.m_tx_index, obj.m_tx_spent);
         };
@@ -91,12 +103,10 @@ struct CAddressIndexKey {
     bool m_tx_spent{false};
 
 public:
-    CAddressIndexKey() {
-        SetNull();
-    }
+    CAddressIndexKey() { SetNull(); }
 
-    CAddressIndexKey(AddressType address_type, uint160 address_bytes, int32_t block_height, uint32_t block_tx_pos, uint256 tx_hash,
-                     uint32_t tx_index, bool tx_spent) :
+    CAddressIndexKey(AddressType address_type, uint160 address_bytes, int32_t block_height, uint32_t block_tx_pos,
+                     uint256 tx_hash, uint32_t tx_index, bool tx_spent) :
         m_address_type{address_type},
         m_address_bytes{address_bytes},
         m_block_height{block_height},
@@ -105,7 +115,8 @@ struct CAddressIndexKey {
         m_tx_index{tx_index},
         m_tx_spent{tx_spent} {};
 
-    void SetNull() {
+    void SetNull()
+    {
         m_address_type = AddressType::UNKNOWN;
         m_address_bytes.SetNull();
         m_block_height = 0;
@@ -116,12 +127,11 @@ struct CAddressIndexKey {
     }
 
 public:
-    size_t GetSerializeSize(int nType, int nVersion) const {
-        return 66;
-    }
+    size_t GetSerializeSize(int nType, int nVersion) const { return 66; }
 
-    template<typename Stream>
-    void Serialize(Stream& s) const {
+    template <typename Stream>
+    void Serialize(Stream& s) const
+    {
         ser_writedata8(s, ToUnderlying(m_address_type));
         m_address_bytes.Serialize(s);
         // Heights are stored big-endian for key sorting in LevelDB
@@ -132,8 +142,9 @@ struct CAddressIndexKey {
         ser_writedata8(s, static_cast<uint8_t>(m_tx_spent));
     }
 
-    template<typename Stream>
-    void Unserialize(Stream& s) {
+    template <typename Stream>
+    void Unserialize(Stream& s)
+    {
         m_address_type = static_cast<AddressType>(ser_readdata8(s));
         m_address_bytes.Unserialize(s);
         m_block_height = ser_readdata32be(s);
@@ -150,31 +161,31 @@ struct CAddressIndexIteratorKey {
     uint160 m_address_bytes;
 
 public:
-    CAddressIndexIteratorKey() {
-        SetNull();
-    }
+    CAddressIndexIteratorKey() { SetNull(); }
 
     CAddressIndexIteratorKey(AddressType address_type, uint160 address_bytes) :
-        m_address_type{address_type}, m_address_bytes{address_bytes} {};
+        m_address_type{address_type},
+        m_address_bytes{address_bytes} {};
 
-    void SetNull() {
+    void SetNull()
+    {
         m_address_type = AddressType::UNKNOWN;
         m_address_bytes.SetNull();
     }
 
 public:
-    size_t GetSerializeSize(int nType, int nVersion) const {
-        return 21;
-    }
+    size_t GetSerializeSize(int nType, int nVersion) const { return 21; }
 
-    template<typename Stream>
-    void Serialize(Stream& s) const {
+    template <typename Stream>
+    void Serialize(Stream& s) const
+    {
         ser_writedata8(s, ToUnderlying(m_address_type));
         m_address_bytes.Serialize(s);
     }
 
-    template<typename Stream>
-    void Unserialize(Stream& s) {
+    template <typename Stream>
+    void Unserialize(Stream& s)
+    {
         m_address_type = static_cast<AddressType>(ser_readdata8(s));
         m_address_bytes.Unserialize(s);
     }
@@ -187,39 +198,111 @@ struct CAddressIndexIteratorHeightKey {
     int32_t m_block_height{0};
 
 public:
-    CAddressIndexIteratorHeightKey() {
-        SetNull();
-    }
+    CAddressIndexIteratorHeightKey() { SetNull(); }
 
     CAddressIndexIteratorHeightKey(AddressType address_type, uint160 address_bytes, int32_t block_height) :
-        m_address_type{address_type}, m_address_bytes{address_bytes}, m_block_height{block_height} {};
+        m_address_type{address_type},
+        m_address_bytes{address_bytes},
+        m_block_height{block_height} {};
 
-    void SetNull() {
+    void SetNull()
+    {
         m_address_type = AddressType::UNKNOWN;
         m_address_bytes.SetNull();
         m_block_height = 0;
     }
 
 public:
-    size_t GetSerializeSize(int nType, int nVersion) const {
-        return 25;
-    }
+    size_t GetSerializeSize(int nType, int nVersion) const { return 25; }
 
-    template<typename Stream>
-    void Serialize(Stream& s) const {
+    template <typename Stream>
+    void Serialize(Stream& s) const
+    {
         ser_writedata8(s, ToUnderlying(m_address_type));
         m_address_bytes.Serialize(s);
         ser_writedata32be(s, m_block_height);
     }
 
-    template<typename Stream>
-    void Unserialize(Stream& s) {
+    template <typename Stream>
+    void Unserialize(Stream& s)
+    {
         m_address_type = static_cast<AddressType>(ser_readdata8(s));
         m_address_bytes.Unserialize(s);
         m_block_height = ser_readdata32be(s);
     }
 };
 
-bool AddressBytesFromScript(const CScript& script, AddressType& address_type, uint160& address_bytes);
+struct CAddressUnspentKey {
+public:
+    AddressType m_address_type{AddressType::UNKNOWN};
+    uint160 m_address_bytes;
+    uint256 m_tx_hash;
+    uint32_t m_tx_index{0};
+
+public:
+    CAddressUnspentKey() { SetNull(); }
+
+    CAddressUnspentKey(AddressType address_type, uint160 address_bytes, uint256 tx_hash, uint32_t tx_index) :
+        m_address_type{address_type},
+        m_address_bytes{address_bytes},
+        m_tx_hash{tx_hash},
+        m_tx_index{tx_index} {};
+
+    void SetNull()
+    {
+        m_address_type = AddressType::UNKNOWN;
+        m_address_bytes.SetNull();
+        m_tx_hash.SetNull();
+        m_tx_index = 0;
+    }
+
+public:
+    size_t GetSerializeSize(int nType, int nVersion) const { return 57; }
+
+    template <typename Stream>
+    void Serialize(Stream& s) const
+    {
+        ser_writedata8(s, ToUnderlying(m_address_type));
+        m_address_bytes.Serialize(s);
+        m_tx_hash.Serialize(s);
+        ser_writedata32(s, m_tx_index);
+    }
+
+    template <typename Stream>
+    void Unserialize(Stream& s)
+    {
+        m_address_type = static_cast<AddressType>(ser_readdata8(s));
+        m_address_bytes.Unserialize(s);
+        m_tx_hash.Unserialize(s);
+        m_tx_index = ser_readdata32(s);
+    }
+};
+
+struct CAddressUnspentValue {
+public:
+    CAmount m_amount{-1};
+    CScript m_tx_script;
+    int32_t m_block_height;
+
+public:
+    CAddressUnspentValue() { SetNull(); }
+
+    CAddressUnspentValue(CAmount amount, CScript tx_script, int32_t block_height) :
+        m_amount{amount},
+        m_tx_script{tx_script},
+        m_block_height{block_height} {};
+
+    void SetNull()
+    {
+        m_amount = -1;
+        m_tx_script.clear();
+        m_block_height = 0;
+    }
+
+    bool IsNull() const { return (m_amount == -1); }
+
+public:
+    SERIALIZE_METHODS(CAddressUnspentValue, obj) { READWRITE(obj.m_amount, obj.m_tx_script, obj.m_block_height); }
+};
 
-#endif // BITCOIN_ADDRESSINDEX_H
+#endif // BITCOIN_INDEX_ADDRESSINDEX_TYPES_H
diff --git a/src/index/addressindex_util.cpp b/src/index/addressindex_util.cpp
new file mode 100644
index 000000000000..468c85f35aea
--- /dev/null
+++ b/src/index/addressindex_util.cpp
@@ -0,0 +1,29 @@
+// Copyright (c) 2026 The Dash Core developers
+// Distributed under the MIT software license, see the accompanying
+// file COPYING or http://www.opensource.org/licenses/mit-license.php.
+
+#include <index/addressindex_util.h>
+
+#include <hash.h>
+#include <script/script.h>
+
+#include <vector>
+
+bool AddressBytesFromScript(const CScript& script, AddressType& address_type, uint160& address_bytes)
+{
+    if (script.IsPayToScriptHash()) {
+        address_type = AddressType::P2SH;
+        address_bytes = uint160(std::vector<uint8_t>(script.begin() + 2, script.begin() + 22));
+    } else if (script.IsPayToPublicKeyHash()) {
+        address_type = AddressType::P2PK_OR_P2PKH;
+        address_bytes = uint160(std::vector<uint8_t>(script.begin() + 3, script.begin() + 23));
+    } else if (script.IsPayToPublicKey()) {
+        address_type = AddressType::P2PK_OR_P2PKH;
+        address_bytes = Hash160(std::vector<uint8_t>(script.begin() + 1, script.end() - 1));
+    } else {
+        address_type = AddressType::UNKNOWN;
+        address_bytes.SetNull();
+        return false;
+    }
+    return true;
+}
diff --git a/src/index/addressindex_util.h b/src/index/addressindex_util.h
new file mode 100644
index 000000000000..6abd67a9dd88
--- /dev/null
+++ b/src/index/addressindex_util.h
@@ -0,0 +1,12 @@
+// Copyright (c) 2026 The Dash 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_ADDRESSINDEX_UTIL_H
+#define BITCOIN_INDEX_ADDRESSINDEX_UTIL_H
+
+#include <index/addressindex_types.h>
+
+bool AddressBytesFromScript(const CScript& script, AddressType& address_type, uint160& address_bytes);
+
+#endif // BITCOIN_INDEX_ADDRESSINDEX_UTIL_H
diff --git a/src/index/spentindex.cpp b/src/index/spentindex.cpp
new file mode 100644
index 000000000000..8bbaf1d63f7a
--- /dev/null
+++ b/src/index/spentindex.cpp
@@ -0,0 +1,171 @@
+// Copyright (c) 2026 The Dash Core developers
+// Distributed under the MIT software license, see the accompanying
+// file COPYING or http://www.opensource.org/licenses/mit-license.php.
+
+#include <index/spentindex.h>
+
+#include <chain.h>
+#include <chainparams.h>
+#include <index/addressindex_util.h>
+#include <logging.h>
+#include <node/blockstorage.h>
+#include <primitives/block.h>
+#include <primitives/transaction.h>
+#include <script/script.h>
+#include <undo.h>
+#include <util/system.h>
+
+constexpr uint8_t DB_SPENTINDEX{'p'};
+
+std::unique_ptr<SpentIndex> g_spentindex;
+
+SpentIndex::DB::DB(size_t n_cache_size, bool f_memory, bool f_wipe) :
+    BaseIndex::DB(gArgs.GetDataDirNet() / "indexes" / "spentindex", n_cache_size, f_memory, f_wipe)
+{
+}
+
+bool SpentIndex::DB::WriteBatch(const std::vector<CSpentIndexEntry>& entries)
+{
+    CDBBatch batch(*this);
+    for (const auto& [key, value] : entries) {
+        if (value.IsNull()) {
+            // Null value means delete entry (used during disconnect)
+            batch.Erase(std::make_pair(DB_SPENTINDEX, key));
+        } else {
+            batch.Write(std::make_pair(DB_SPENTINDEX, key), value);
+        }
+    }
+    return CDBWrapper::WriteBatch(batch);
+}
+
+bool SpentIndex::DB::ReadSpentIndex(const CSpentIndexKey& key, CSpentIndexValue& value)
+{
+    return Read(std::make_pair(DB_SPENTINDEX, key), value);
+}
+
+bool SpentIndex::DB::EraseSpentIndex(const std::vector<CSpentIndexKey>& keys)
+{
+    CDBBatch batch(*this);
+    for (const auto& key : keys) {
+        batch.Erase(std::make_pair(DB_SPENTINDEX, key));
+    }
+    return CDBWrapper::WriteBatch(batch);
+}
+
+SpentIndex::SpentIndex(size_t n_cache_size, bool f_memory, bool f_wipe) :
+    m_db(std::make_unique<SpentIndex::DB>(n_cache_size, f_memory, f_wipe))
+{
+}
+
+SpentIndex::~SpentIndex() = default;
+
+bool SpentIndex::WriteBlock(const CBlock& block, const CBlockIndex* pindex)
+{
+    // Skip genesis block (no inputs to index)
+    if (pindex->nHeight == 0) {
+        return true;
+    }
+
+    // Read undo data for this block to get information about spent outputs
+    CBlockUndo blockundo;
+    if (!node::UndoReadFromDisk(blockundo, pindex)) {
+        return error("%s: Failed to read undo data for block %s at height %d", __func__,
+                     pindex->GetBlockHash().ToString(), pindex->nHeight);
+    }
+
+    std::vector<CSpentIndexEntry> entries;
+
+    // Process each non-coinbase transaction
+    // blockundo.vtxundo[i] corresponds to block.vtx[i+1] (coinbase is skipped in undo data)
+    for (size_t i = 0; i < blockundo.vtxundo.size(); i++) {
+        const CTransactionRef& tx = block.vtx[i + 1]; // +1 to skip coinbase
+        const CTxUndo& txundo = blockundo.vtxundo[i];
+        const uint256 txhash = tx->GetHash();
+
+        // Process each input
+        if (tx->vin.size() != txundo.vprevout.size()) {
+            return error("%s: Undo data mismatch for tx %s", __func__, txhash.ToString());
+        }
+
+        for (size_t j = 0; j < tx->vin.size(); j++) {
+            const CTxIn& input = tx->vin[j];
+            const Coin& coin = txundo.vprevout[j];
+            const CTxOut& prevout = coin.out;
+
+            AddressType address_type{AddressType::UNKNOWN};
+            uint160 address_bytes;
+            AddressBytesFromScript(prevout.scriptPubKey, address_type, address_bytes);
+
+            // Create spent index entry: spent output -> spending tx info
+            CSpentIndexKey key(input.prevout.hash, input.prevout.n);
+            CSpentIndexValue value(txhash, j, pindex->nHeight, prevout.nValue, address_type, address_bytes);
+
+            entries.emplace_back(key, value);
+        }
+    }
+
+    return m_db->WriteBatch(entries);
+}
+
+bool SpentIndex::Rewind(const CBlockIndex* current_tip, const CBlockIndex* new_tip)
+{
+    assert(current_tip->GetAncestor(new_tip->nHeight) == new_tip);
+
+    // Erase spent index entries for blocks being rewound
+    for (const CBlockIndex* pindex = current_tip; pindex != new_tip; pindex = pindex->pprev) {
+        // Skip genesis block
+        if (pindex->nHeight == 0) continue;
+
+        // Read block to get transactions
+        CBlock block;
+        if (!node::ReadBlockFromDisk(block, pindex, Params().GetConsensus())) {
+            return error("%s: Failed to read block %s from disk during rewind", __func__,
+                         pindex->GetBlockHash().ToString());
+        }
+
+        std::vector<CSpentIndexKey> keys_to_erase;
+
+        // Process each non-coinbase transaction
+        for (size_t i = 1; i < block.vtx.size(); i++) {
+            const CTransactionRef& tx = block.vtx[i];
+
+            // Erase spent index entries for each input
+            for (const CTxIn& input : tx->vin) {
+                CSpentIndexKey key(input.prevout.hash, input.prevout.n);
+                keys_to_erase.push_back(key);
+            }
+        }
+
+        if (!keys_to_erase.empty() && !m_db->EraseSpentIndex(keys_to_erase)) {
+            return error("%s: Failed to erase spent index during rewind", __func__);
+        }
+    }
+
+    // Call base class Rewind to update the best block pointer
+    return BaseIndex::Rewind(current_tip, new_tip);
+}
+
+void SpentIndex::BlockDisconnected(const std::shared_ptr<const CBlock>& block, const CBlockIndex* pindex)
+{
+    // When a block is disconnected (e.g., via invalidateblock), we need to rewind the index
+    // to remove this block's data
+    const CBlockIndex* best_block_index = CurrentIndex();
+
+    // Only rewind if we have this block indexed
+    if (best_block_index && best_block_index->nHeight >= pindex->nHeight && pindex->pprev) {
+        if (!Rewind(best_block_index, pindex->pprev)) {
+            error("%s: Failed to rewind %s to previous block after disconnect", __func__, GetName());
+        }
+    }
+}
+
+BaseIndex::DB& SpentIndex::GetDB() const { return *m_db; }
+
+bool SpentIndex::GetSpentInfo(const CSpentIndexKey& key, CSpentIndexValue& value) const
+{
+    if (!BlockUntilSyncedToCurrentChain()) {
+        return false;
+    }
+
+    return m_db->ReadSpentIndex(key, value);
+}
diff --git a/src/index/spentindex.h b/src/index/spentindex.h
new file mode 100644
index 000000000000..c00626ab94cb
--- /dev/null
+++ b/src/index/spentindex.h
@@ -0,0 +1,82 @@
+// Copyright (c) 2026 The Dash 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_SPENTINDEX_H
+#define BITCOIN_INDEX_SPENTINDEX_H
+
+#include <index/base.h>
+#include <index/spentindex_types.h>
+
+#include <map>
+
+static constexpr bool DEFAULT_SPENTINDEX{false};
+
+struct CSpentIndexTxInfo {
+    std::map<CSpentIndexKey, CSpentIndexValue, CSpentIndexKeyCompare> mSpentInfo;
+};
+
+/**
+ * SpentIndex tracks which transactions spend specific outputs.
+ * For each spent output, it records the spending transaction details,
+ * including height, amount, and address information.
+ *
+ * The index reads undo data to extract spent output information (amount, address),
+ * which requires that undo files are available. Therefore, this index is NOT
+ * compatible with pruned nodes.
+ *
+ * The index maintains a separate LevelDB database at <datadir>/indexes/spentindex/
+ */
+class SpentIndex final : public BaseIndex
+{
+protected:
+    class DB;
+
+private:
+    const std::unique_ptr<DB> m_db;
+
+protected:
+    class DB : public BaseIndex::DB
+    {
+    public:
+        explicit DB(size_t n_cache_size, bool f_memory = false, bool f_wipe = false);
+
+        /// Write a batch of spent index entries
+        bool WriteBatch(const std::vector<CSpentIndexEntry>& entries);
+
+        /// Read spent information for a specific output
+        bool ReadSpentIndex(const CSpentIndexKey& key, CSpentIndexValue& value);
+
+        /// Erase spent index entries
+        bool EraseSpentIndex(const std::vector<CSpentIndexKey>& keys);
+    };
+
+    bool WriteBlock(const CBlock& block, const CBlockIndex* pindex) override;
+
+    /// Custom rewind to handle spent index cleanup
+    bool Rewind(const CBlockIndex* current_tip, const CBlockIndex* new_tip) override;
+
+    /// Handle block disconnections (e.g., from invalidateblock)
+    void BlockDisconnected(const std::shared_ptr<const CBlock>& block, const CBlockIndex* pindex) override;
+
+    BaseIndex::DB& GetDB() const override;
+    const char* GetName() const override { return "spentindex"; }
+
+    /// SpentIndex cannot work with pruned nodes as it requires UTXO data
+    bool AllowPrune() const override { return false; }
+
+public:
+    /// Constructs a new SpentIndex.
+    explicit SpentIndex(size_t n_cache_size, bool f_memory = false, bool f_wipe = false);
+
+    /// Destructor
+    virtual ~SpentIndex() override;
+
+    /// Retrieve spent information for a specific output
+    bool GetSpentInfo(const CSpentIndexKey& key, CSpentIndexValue& value) const;
+};
+
+/// Global SpentIndex instance
+extern std::unique_ptr<SpentIndex> g_spentindex;
+
+#endif // BITCOIN_INDEX_SPENTINDEX_H
diff --git a/src/index/spentindex_types.h b/src/index/spentindex_types.h
new file mode 100644
index 000000000000..536453235db0
--- /dev/null
+++ b/src/index/spentindex_types.h
@@ -0,0 +1,91 @@
+// Copyright (c) 2009-2010 Satoshi Nakamoto
+// Copyright (c) 2009-2015 The Bitcoin Core developers
+// Copyright (c) 2016 BitPay Inc.
+// Copyright (c) 2023-2026 The Dash 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_SPENTINDEX_TYPES_H
+#define BITCOIN_INDEX_SPENTINDEX_TYPES_H
+
+#include <consensus/amount.h>
+#include <index/addressindex_types.h>
+#include <serialize.h>
+#include <uint256.h>
+
+#include <map>
+#include <tuple>
+
+struct CSpentIndexKey {
+public:
+    uint256 m_tx_hash;
+    uint32_t m_tx_index{0};
+
+public:
+    CSpentIndexKey() { SetNull(); }
+
+    CSpentIndexKey(uint256 txout_hash, uint32_t txout_index) :
+        m_tx_hash{txout_hash},
+        m_tx_index{txout_index} {};
+
+    void SetNull()
+    {
+        m_tx_hash.SetNull();
+        m_tx_index = 0;
+    }
+
+public:
+    SERIALIZE_METHODS(CSpentIndexKey, obj) { READWRITE(obj.m_tx_hash, obj.m_tx_index); }
+};
+
+struct CSpentIndexValue {
+public:
+    uint256 m_tx_hash;
+    uint32_t m_tx_index{0};
+    int32_t m_block_height{0};
+    CAmount m_amount{0};
+    AddressType m_address_type{AddressType::UNKNOWN};
+    uint160 m_address_bytes;
+
+public:
+    CSpentIndexValue() { SetNull(); }
+
+    CSpentIndexValue(uint256 txin_hash, uint32_t txin_index, int32_t block_height, CAmount amount,
+                     AddressType address_type, uint160 address_bytes) :
+        m_tx_hash{txin_hash},
+        m_tx_index{txin_index},
+        m_block_height{block_height},
+        m_amount{amount},
+        m_address_type{address_type},
+        m_address_bytes{address_bytes} {};
+
+    void SetNull()
+    {
+        m_tx_hash.SetNull();
+        m_tx_index = 0;
+        m_block_height = 0;
+        m_amount = 0;
+        m_address_type = AddressType::UNKNOWN;
+        m_address_bytes.SetNull();
+    }
+
+    bool IsNull() const { return m_tx_hash.IsNull(); }
+
+public:
+    SERIALIZE_METHODS(CSpentIndexValue, obj)
+    {
+        READWRITE(obj.m_tx_hash, obj.m_tx_index, obj.m_block_height, obj.m_amount, obj.m_address_type, obj.m_address_bytes);
+    }
+};
+
+struct CSpentIndexKeyCompare {
+    bool operator()(const CSpentIndexKey& a, const CSpentIndexKey& b) const
+    {
+        auto to_tuple = [](const CSpentIndexKey& obj) { return std::tie(obj.m_tx_hash, obj.m_tx_index); };
+        return to_tuple(a) < to_tuple(b);
+    }
+};
+
+using CSpentIndexEntry = std::pair<CSpentIndexKey, CSpentIndexValue>;
+
+#endif // BITCOIN_INDEX_SPENTINDEX_TYPES_H
diff --git a/src/index/timestampindex.cpp b/src/index/timestampindex.cpp
new file mode 100644
index 000000000000..750b993a8d05
--- /dev/null
+++ b/src/index/timestampindex.cpp
@@ -0,0 +1,113 @@
+// Copyright (c) 2026 The Dash Core developers
+// Distributed under the MIT software license, see the accompanying
+// file COPYING or http://www.opensource.org/licenses/mit-license.php.
+
+#include <index/timestampindex.h>
+
+#include <chain.h>
+#include <logging.h>
+#include <util/system.h>
+
+constexpr uint8_t DB_TIMESTAMPINDEX{'s'};
+
+std::unique_ptr<TimestampIndex> g_timestampindex;
+
+TimestampIndex::DB::DB(size_t n_cache_size, bool f_memory, bool f_wipe) :
+    BaseIndex::DB(gArgs.GetDataDirNet() / "indexes" / "timestampindex", n_cache_size, f_memory, f_wipe)
+{
+}
+
+bool TimestampIndex::DB::Write(const CTimestampIndexKey& key)
+{
+    return CDBWrapper::Write(std::make_pair(DB_TIMESTAMPINDEX, key), true);
+}
+
+bool TimestampIndex::DB::ReadRange(uint32_t high, uint32_t low, std::vector<uint256>& hashes)
+{
+    std::unique_ptr<CDBIterator> pcursor(NewIterator());
+
+    // Seek to the starting timestamp
+    pcursor->Seek(std::make_pair(DB_TIMESTAMPINDEX, CTimestampIndexIteratorKey(low)));
+
+    // Iterate through all entries in the timestamp range
+    while (pcursor->Valid()) {
+        std::pair<uint8_t, CTimestampIndexKey> key;
+        if (pcursor->GetKey(key) && key.first == DB_TIMESTAMPINDEX && key.second.m_block_time <= high) {
+            hashes.push_back(key.second.m_block_hash);
+            pcursor->Next();
+        } else {
+            break;
+        }
+    }
+
+    return true;
+}
+
+bool TimestampIndex::DB::EraseTimestampIndex(const CTimestampIndexKey& key)
+{
+    return CDBWrapper::Erase(std::make_pair(DB_TIMESTAMPINDEX, key));
+}
+
+TimestampIndex::TimestampIndex(size_t n_cache_size, bool f_memory, bool f_wipe) :
+    m_db(std::make_unique<TimestampIndex::DB>(n_cache_size, f_memory, f_wipe))
+{
+}
+
+TimestampIndex::~TimestampIndex() = default;
+
+bool TimestampIndex::WriteBlock(const CBlock& block, const CBlockIndex* pindex)
+{
+    // Skip genesis block
+    if (pindex->nHeight == 0) return true;
+
+    // Create timestamp index key from block metadata
+    CTimestampIndexKey key(pindex->nTime, pindex->GetBlockHash());
+
+    // Write to database
+    return m_db->Write(key);
+}
+
+bool TimestampIndex::Rewind(const CBlockIndex* current_tip, const CBlockIndex* new_tip)
+{
+    assert(current_tip->GetAncestor(new_tip->nHeight) == new_tip);
+
+    // Erase timestamp index entries for blocks being rewound
+    for (const CBlockIndex* pindex = current_tip; pindex != new_tip; pindex = pindex->pprev) {
+        // Skip genesis block
+        if (pindex->nHeight == 0) continue;
+
+        CTimestampIndexKey key(pindex->nTime, pindex->GetBlockHash());
+        if (!m_db->EraseTimestampIndex(key)) {
+            return error("%s: Failed to erase timestamp index for block %s during rewind", __func__,
+                         pindex->GetBlockHash().ToString());
+        }
+    }
+
+    // Call base class Rewind to update the best block pointer
+    return BaseIndex::Rewind(current_tip, new_tip);
+}
+
+void TimestampIndex::BlockDisconnected(const std::shared_ptr<const CBlock>& block, const CBlockIndex* pindex)
+{
+    // When a block is disconnected (e.g., via invalidateblock), we need to rewind the index
+    // to remove this block's data
+    const CBlockIndex* best_block_index = CurrentIndex();
+
+    // Only rewind if we have this block indexed and it's not the genesis block
+    if (best_block_index && best_block_index->nHeight >= pindex->nHeight && pindex->pprev) {
+        if (!Rewind(best_block_index, pindex->pprev)) {
+            error("%s: Failed to rewind %s to previous block after disconnect", __func__, GetName());
+        }
+    }
+}
+
+BaseIndex::DB& TimestampIndex::GetDB() const { return *m_db; }
+
+bool TimestampIndex::GetBlockHashes(uint32_t high, uint32_t low, std::vector<uint256>& hashes) const
+{
+    if (!BlockUntilSyncedToCurrentChain()) {
+        return false;
+    }
+
+    return m_db->ReadRange(high, low, hashes);
+}
diff --git a/src/index/timestampindex.h b/src/index/timestampindex.h
new file mode 100644
index 000000000000..fc717e6c0d71
--- /dev/null
+++ b/src/index/timestampindex.h
@@ -0,0 +1,71 @@
+// Copyright (c) 2026 The Dash 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_TIMESTAMPINDEX_H
+#define BITCOIN_INDEX_TIMESTAMPINDEX_H
+
+#include <index/base.h>
+#include <index/timestampindex_types.h>
+
+static constexpr bool DEFAULT_TIMESTAMPINDEX{false};
+
+/**
+ * TimestampIndex is used to map block timestamps to block hashes.
+ * This allows efficient querying of blocks within a timestamp range.
+ *
+ * The index maintains a separate LevelDB database at <datadir>/indexes/timestampindex/
+ */
+class TimestampIndex final : public BaseIndex
+{
+protected:
+    class DB;
+
+private:
+    const std::unique_ptr<DB> m_db;
+
+protected:
+    class DB : public BaseIndex::DB
+    {
+    public:
+        explicit DB(size_t n_cache_size, bool f_memory = false, bool f_wipe = false);
+
+        /// Write a timestamp index entry to the database
+        bool Write(const CTimestampIndexKey& key);
+
+        /// Read timestamp index entries within the given range
+        bool ReadRange(uint32_t high, uint32_t low, std::vector<uint256>& hashes);
+
+        /// Erase timestamp index entry
+        bool EraseTimestampIndex(const CTimestampIndexKey& key);
+    };
+
+    bool WriteBlock(const CBlock& block, const CBlockIndex* pindex) override;
+
+    /// Custom rewind to handle timestamp index cleanup
+    bool Rewind(const CBlockIndex* current_tip, const CBlockIndex* new_tip) override;
+
+    /// Handle block disconnections (e.g., from invalidateblock)
+    void BlockDisconnected(const std::shared_ptr<const CBlock>& block, const CBlockIndex* pindex) override;
+
+    BaseIndex::DB& GetDB() const override;
+    const char* GetName() const override { return "timestampindex"; }
+
+    /// TimestampIndex works with pruned nodes since it only stores block metadata
+    bool AllowPrune() const override { return true; }
+
+public:
+    /// Constructs a new TimestampIndex.
+    explicit TimestampIndex(size_t n_cache_size, bool f_memory = false, bool f_wipe = false);
+
+    /// Destructor
+    virtual ~TimestampIndex() override;
+
+    /// Retrieve block hashes within the given timestamp range [low, high]
+    bool GetBlockHashes(uint32_t high, uint32_t low, std::vector<uint256>& hashes) const;
+};
+
+/// Global TimestampIndex instance
+extern std::unique_ptr<TimestampIndex> g_timestampindex;
+
+#endif // BITCOIN_INDEX_TIMESTAMPINDEX_H
diff --git a/src/index/timestampindex_types.h b/src/index/timestampindex_types.h
new file mode 100644
index 000000000000..95ecc4bebf95
--- /dev/null
+++ b/src/index/timestampindex_types.h
@@ -0,0 +1,74 @@
+// Copyright (c) 2009-2010 Satoshi Nakamoto
+// Copyright (c) 2009-2015 The Bitcoin Core developers
+// Copyright (c) 2016 BitPay Inc.
+// Copyright (c) 2023-2026 The Dash 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_TIMESTAMPINDEX_TYPES_H
+#define BITCOIN_INDEX_TIMESTAMPINDEX_TYPES_H
+
+#include <serialize.h>
+#include <uint256.h>
+
+struct CTimestampIndexIteratorKey {
+    uint32_t m_time{0};
+
+    CTimestampIndexIteratorKey() = default;
+    explicit CTimestampIndexIteratorKey(uint32_t time) :
+        m_time{time}
+    {
+    }
+
+    void SetNull() { m_time = 0; }
+
+    size_t GetSerializeSize(int nType, int nVersion) const { return 4; }
+
+    template <typename Stream>
+    void Serialize(Stream& s) const
+    {
+        ser_writedata32be(s, m_time);
+    }
+
+    template <typename Stream>
+    void Unserialize(Stream& s)
+    {
+        m_time = ser_readdata32be(s);
+    }
+};
+
+struct CTimestampIndexKey {
+    uint32_t m_block_time{0};
+    uint256 m_block_hash;
+
+    CTimestampIndexKey() = default;
+    CTimestampIndexKey(uint32_t block_time, uint256 block_hash) :
+        m_block_time{block_time},
+        m_block_hash{block_hash}
+    {
+    }
+
+    void SetNull()
+    {
+        m_block_time = 0;
+        m_block_hash.SetNull();
+    }
+
+    size_t GetSerializeSize(int nType, int nVersion) const { return 36; }
+
+    template <typename Stream>
+    void Serialize(Stream& s) const
+    {
+        ser_writedata32be(s, m_block_time);
+        m_block_hash.Serialize(s);
+    }
+
+    template <typename Stream>
+    void Unserialize(Stream& s)
+    {
+        m_block_time = ser_readdata32be(s);
+        m_block_hash.Unserialize(s);
+    }
+};
+
+#endif // BITCOIN_INDEX_TIMESTAMPINDEX_TYPES_H
diff --git a/src/init.cpp b/src/init.cpp
index f97d98f8a766..c6fa7aa66153 100644
--- a/src/init.cpp
+++ b/src/init.cpp
@@ -25,8 +25,11 @@
 #include <httprpc.h>
 #include <init/common.h>
 #include <interfaces/chain.h>
+#include <index/addressindex.h>
 #include <index/blockfilterindex.h>
 #include <index/coinstatsindex.h>
+#include <index/spentindex.h>
+#include <index/timestampindex.h>
 #include <index/txindex.h>
 #include <interfaces/init.h>
 #include <interfaces/node.h>
@@ -146,20 +149,14 @@ using node::CalculateCacheSizes;
 using node::ChainstateLoadingError;
 using node::ChainstateLoadVerifyError;
 using node::DashChainstateSetupClose;
-using node::DEFAULT_ADDRESSINDEX;
 using node::DEFAULT_PRINTPRIORITY;
-using node::DEFAULT_SPENTINDEX;
 using node::DEFAULT_STOPAFTERBLOCKIMPORT;
-using node::DEFAULT_TIMESTAMPINDEX;
 using node::LoadChainstate;
 using node::NodeContext;
 using node::ThreadImport;
 using node::VerifyLoadedChainstate;
-using node::fAddressIndex;
 using node::fPruneMode;
 using node::fReindex;
-using node::fSpentIndex;
-using node::fTimestampIndex;
 using node::nPruneTarget;
 #ifdef ENABLE_WALLET
 using wallet::DEFAULT_DISABLE_WALLET;
@@ -264,6 +261,15 @@ void Interrupt(NodeContext& node)
     if (g_txindex) {
         g_txindex->Interrupt();
     }
+    if (g_addressindex) {
+        g_addressindex->Interrupt();
+    }
+    if (g_timestampindex) {
+        g_timestampindex->Interrupt();
+    }
+    if (g_spentindex) {
+        g_spentindex->Interrupt();
+    }
     ForEachBlockFilterIndex([](BlockFilterIndex& index) { index.Interrupt(); });
     if (g_coin_stats_index) {
         g_coin_stats_index->Interrupt();
@@ -380,6 +386,18 @@ void PrepareShutdown(NodeContext& node)
         g_txindex->Stop();
         g_txindex.reset();
     }
+    if (g_addressindex) {
+        g_addressindex->Stop();
+        g_addressindex.reset();
+    }
+    if (g_timestampindex) {
+        g_timestampindex->Stop();
+        g_timestampindex.reset();
+    }
+    if (g_spentindex) {
+        g_spentindex->Stop();
+        g_spentindex.reset();
+    }
     if (g_coin_stats_index) {
         g_coin_stats_index->Stop();
         g_coin_stats_index.reset();
@@ -574,7 +592,7 @@ void SetupServerArgs(ArgsManager& argsman)
         -GetNumCores(), llmq::MAX_BLSCHECK_THREADS, llmq::DEFAULT_BLSCHECK_THREADS), ArgsManager::ALLOW_ANY, OptionsCategory::OPTIONS);
     argsman.AddArg("-persistmempool", strprintf("Whether to save the mempool on shutdown and load on restart (default: %u)", DEFAULT_PERSIST_MEMPOOL), 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, -rescan and -disablegovernance=false. "
+    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, -addressindex, -spentindex, -rescan and -disablegovernance=false. "
             "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 / 1024 / 1024), 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);
@@ -1029,18 +1047,6 @@ void InitParameterInteraction(ArgsManager& args)
         }
     }
 
-    // Make sure additional indexes are recalculated correctly in VerifyDB
-    // (we must reconnect blocks whenever we disconnect them for these indexes to work)
-    bool fAdditionalIndexes =
-        args.GetBoolArg("-addressindex", DEFAULT_ADDRESSINDEX) ||
-        args.GetBoolArg("-spentindex", DEFAULT_SPENTINDEX) ||
-        args.GetBoolArg("-timestampindex", DEFAULT_TIMESTAMPINDEX);
-
-    if (fAdditionalIndexes && args.GetIntArg("-checklevel", DEFAULT_CHECKLEVEL) < 4) {
-        args.ForceSetArg("-checklevel", "4");
-        LogPrintf("%s: parameter interaction: additional indexes -> setting -checklevel=4\n", __func__);
-    }
-
     if (args.IsArgSet("-masternodeblsprivkey")) {
         if (args.SoftSetBoolArg("-disablewallet", true)) {
             LogPrintf("%s: parameter interaction: -masternodeblsprivkey set -> setting -disablewallet=1\n", __func__);
@@ -1198,6 +1204,10 @@ bool AppInitParameterInteraction(const ArgsManager& args)
     if (args.GetIntArg("-prune", 0)) {
         if (args.GetBoolArg("-txindex", DEFAULT_TXINDEX))
             return InitError(_("Prune mode is incompatible with -txindex."));
+        if (args.GetBoolArg("-addressindex", DEFAULT_ADDRESSINDEX))
+            return InitError(_("Prune mode is incompatible with -addressindex."));
+        if (args.GetBoolArg("-spentindex", DEFAULT_SPENTINDEX))
+            return InitError(_("Prune mode is incompatible with -spentindex."));
         if (args.GetBoolArg("-reindex-chainstate", false)) {
             return InitError(_("Prune mode is incompatible with -reindex-chainstate. Use full -reindex instead."));
         }
@@ -1945,6 +1955,15 @@ bool AppInitMain(NodeContext& node, interfaces::BlockAndHeaderTipInfo* tip_info)
     if (args.GetBoolArg("-txindex", DEFAULT_TXINDEX)) {
         LogPrintf("* Using %.1f MiB for transaction index database\n", cache_sizes.tx_index * (1.0 / 1024 / 1024));
     }
+    if (args.GetBoolArg("-addressindex", DEFAULT_ADDRESSINDEX)) {
+        LogPrintf("* Using %.1f MiB for address index database\n", cache_sizes.address_index * (1.0 / 1024 / 1024));
+    }
+    if (args.GetBoolArg("-timestampindex", DEFAULT_TIMESTAMPINDEX)) {
+        LogPrintf("* Using %.1f MiB for timestamp index database\n", cache_sizes.timestamp_index * (1.0 / 1024 / 1024));
+    }
+    if (args.GetBoolArg("-spentindex", DEFAULT_SPENTINDEX)) {
+        LogPrintf("* Using %.1f MiB for spent index database\n", cache_sizes.spent_index * (1.0 / 1024 / 1024));
+    }
     for (BlockFilterType filter_type : g_enabled_filter_types) {
         LogPrintf("* Using %.1f MiB for %s block filter index database\n",
                   cache_sizes.filter_index * (1.0 / 1024 / 1024), BlockFilterTypeName(filter_type));
@@ -1998,9 +2017,6 @@ bool AppInitMain(NodeContext& node, interfaces::BlockAndHeaderTipInfo* tip_info)
                                               Assert(node.mempool.get()),
                                               args.GetDataDirNet(),
                                               fPruneMode,
-                                              args.GetBoolArg("-addressindex", DEFAULT_ADDRESSINDEX),
-                                              args.GetBoolArg("-spentindex", DEFAULT_SPENTINDEX),
-                                              args.GetBoolArg("-timestampindex", DEFAULT_TIMESTAMPINDEX),
                                               chainparams.GetConsensus(),
                                               fReindexChainState,
                                               cache_sizes.block_tree_db,
@@ -2041,15 +2057,6 @@ bool AppInitMain(NodeContext& node, interfaces::BlockAndHeaderTipInfo* tip_info)
                 return InitError(_("Incorrect or no genesis block found. Wrong datadir for network?"));
             case ChainstateLoadingError::ERROR_BAD_DEVNET_GENESIS_BLOCK:
                 return InitError(_("Incorrect or no devnet genesis block found. Wrong datadir for devnet specified?"));
-            case ChainstateLoadingError::ERROR_ADDRIDX_NEEDS_REINDEX:
-                strLoadError = _("You need to rebuild the database using -reindex to enable -addressindex");
-                break;
-            case ChainstateLoadingError::ERROR_SPENTIDX_NEEDS_REINDEX:
-                strLoadError = _("You need to rebuild the database using -reindex to enable -spentindex");
-                break;
-            case ChainstateLoadingError::ERROR_TIMEIDX_NEEDS_REINDEX:
-                strLoadError = _("You need to rebuild the database using -reindex to enable -timestampindex");
-                break;
             case ChainstateLoadingError::ERROR_PRUNED_NEEDS_REINDEX:
                 strLoadError = _("You need to rebuild the database using -reindex to go back to unpruned mode.  This will redownload the entire blockchain");
                 break;
@@ -2082,10 +2089,6 @@ bool AppInitMain(NodeContext& node, interfaces::BlockAndHeaderTipInfo* tip_info)
                 break;
             }
         } else {
-            LogPrintf("%s: address index %s\n", __func__, fAddressIndex ? "enabled" : "disabled");
-            LogPrintf("%s: timestamp index %s\n", __func__, fTimestampIndex ? "enabled" : "disabled");
-            LogPrintf("%s: spent index %s\n", __func__, fSpentIndex ? "enabled" : "disabled");
-
             std::optional<ChainstateLoadVerifyError> maybe_verify_error;
             try {
                 uiInterface.InitMessage(_("Verifying blocks…").translated);
@@ -2262,6 +2265,27 @@ bool AppInitMain(NodeContext& node, interfaces::BlockAndHeaderTipInfo* tip_info)
         }
     }
 
+    if (args.GetBoolArg("-addressindex", DEFAULT_ADDRESSINDEX)) {
+        g_addressindex = std::make_unique<AddressIndex>(cache_sizes.address_index, false, fReindex);
+        if (!g_addressindex->Start(chainman.ActiveChainstate())) {
+            return false;
+        }
+    }
+
+    if (args.GetBoolArg("-timestampindex", DEFAULT_TIMESTAMPINDEX)) {
+        g_timestampindex = std::make_unique<TimestampIndex>(cache_sizes.timestamp_index, false, fReindex);
+        if (!g_timestampindex->Start(chainman.ActiveChainstate())) {
+            return false;
+        }
+    }
+
+    if (args.GetBoolArg("-spentindex", DEFAULT_SPENTINDEX)) {
+        g_spentindex = std::make_unique<SpentIndex>(cache_sizes.spent_index, false, fReindex);
+        if (!g_spentindex->Start(chainman.ActiveChainstate())) {
+            return false;
+        }
+    }
+
     for (const auto& filter_type : g_enabled_filter_types) {
         InitBlockFilterIndex(filter_type, cache_sizes.filter_index, false, fReindex);
         if (!GetBlockFilterIndex(filter_type)->Start(chainman.ActiveChainstate())) {
diff --git a/src/node/blockstorage.cpp b/src/node/blockstorage.cpp
index 76fd09843ac7..732f526587f4 100644
--- a/src/node/blockstorage.cpp
+++ b/src/node/blockstorage.cpp
@@ -29,10 +29,6 @@ std::atomic_bool fReindex(false);
 bool fPruneMode = false;
 uint64_t nPruneTarget = 0;
 
-bool fAddressIndex = DEFAULT_ADDRESSINDEX;
-bool fTimestampIndex = DEFAULT_TIMESTAMPINDEX;
-bool fSpentIndex = DEFAULT_SPENTINDEX;
-
 bool CBlockIndexWorkComparator::operator()(const CBlockIndex* pa, const CBlockIndex* pb) const
 {
     // First sort by most total work, ...
@@ -395,12 +391,12 @@ bool BlockManager::LoadBlockIndexDB()
     m_block_tree_db->ReadReindexing(fReindexing);
     if (fReindexing) fReindex = true;
 
-    // Check whether we have an address index
-    m_block_tree_db->ReadFlag("addressindex", fAddressIndex);
-    // Check whether we have a timestamp index
-    m_block_tree_db->ReadFlag("timestampindex", fTimestampIndex);
-    // Check whether we have a spent index
-    m_block_tree_db->ReadFlag("spentindex", fSpentIndex);
+    // Migrate old synchronous index data from block index database
+    // to async indexes in separate databases
+    if (!m_block_tree_db->MigrateOldIndexData()) {
+        return false;
+    }
+
     return true;
 }
 
diff --git a/src/node/blockstorage.h b/src/node/blockstorage.h
index 2cfae856c2cc..e4c63f82cc50 100644
--- a/src/node/blockstorage.h
+++ b/src/node/blockstorage.h
@@ -33,10 +33,7 @@ struct Params;
 }
 
 namespace node {
-static constexpr bool DEFAULT_ADDRESSINDEX{false};
-static constexpr bool DEFAULT_SPENTINDEX{false};
 static constexpr bool DEFAULT_STOPAFTERBLOCKIMPORT{false};
-static constexpr bool DEFAULT_TIMESTAMPINDEX{false};
 
 /** The pre-allocation chunk size for blk?????.dat files (since 0.8) */
 static const unsigned int BLOCKFILE_CHUNK_SIZE = 0x1000000; // 16 MiB
@@ -56,13 +53,6 @@ extern bool fPruneMode;
 /** Number of bytes of block files that we're trying to stay below. */
 extern uint64_t nPruneTarget;
 
-/** True if we're running in -addressindex mode. */
-extern bool fAddressIndex;
-/** True if we're running in -timestampindex mode. */
-extern bool fTimestampIndex;
-/** True if we're running in -spentindex mode. */
-extern bool fSpentIndex;
-
 // Because validation code takes pointers to the map's CBlockIndex objects, if
 // we ever switch to another associative container, we need to either use a
 // container that has stable addressing (true of all std associative
diff --git a/src/node/caches.cpp b/src/node/caches.cpp
index a39ad7aeb661..c3f73a7a7a2f 100644
--- a/src/node/caches.cpp
+++ b/src/node/caches.cpp
@@ -4,6 +4,9 @@
 
 #include <node/caches.h>
 
+#include <index/addressindex.h>
+#include <index/spentindex.h>
+#include <index/timestampindex.h>
 #include <index/txindex.h>
 #include <txdb.h>
 #include <util/system.h>
@@ -19,6 +22,12 @@ CacheSizes CalculateCacheSizes(const ArgsManager& args, size_t n_indexes)
     nTotalCache -= sizes.block_tree_db;
     sizes.tx_index = std::min(nTotalCache / 8, args.GetBoolArg("-txindex", DEFAULT_TXINDEX) ? nMaxTxIndexCache << 20 : 0);
     nTotalCache -= sizes.tx_index;
+    sizes.address_index = std::min(nTotalCache / 8, args.GetBoolArg("-addressindex", DEFAULT_ADDRESSINDEX) ? int64_t(256 << 20) : int64_t(0));
+    nTotalCache -= sizes.address_index;
+    sizes.timestamp_index = std::min(nTotalCache / 64, args.GetBoolArg("-timestampindex", DEFAULT_TIMESTAMPINDEX) ? int64_t(8 << 20) : int64_t(0));
+    nTotalCache -= sizes.timestamp_index;
+    sizes.spent_index = std::min(nTotalCache / 8, args.GetBoolArg("-spentindex", DEFAULT_SPENTINDEX) ? int64_t(128 << 20) : int64_t(0));
+    nTotalCache -= sizes.spent_index;
     sizes.filter_index = 0;
     if (n_indexes > 0) {
         int64_t max_cache = std::min(nTotalCache / 8, max_filter_index_cache << 20);
diff --git a/src/node/caches.h b/src/node/caches.h
index 67388b91fd26..c72070cfe2ec 100644
--- a/src/node/caches.h
+++ b/src/node/caches.h
@@ -17,6 +17,9 @@ struct CacheSizes {
     int64_t coins;
     int64_t tx_index;
     int64_t filter_index;
+    int64_t address_index;
+    int64_t timestamp_index;
+    int64_t spent_index;
 };
 CacheSizes CalculateCacheSizes(const ArgsManager& args, size_t n_indexes = 0);
 } // namespace node
diff --git a/src/node/chainstate.cpp b/src/node/chainstate.cpp
index e60eaace5630..6b0a6872ce19 100644
--- a/src/node/chainstate.cpp
+++ b/src/node/chainstate.cpp
@@ -49,9 +49,6 @@ std::optional<ChainstateLoadingError> LoadChainstate(bool fReset,
                                                      CTxMemPool* mempool,
                                                      const fs::path& data_dir,
                                                      bool fPruneMode,
-                                                     bool is_addrindex_enabled,
-                                                     bool is_spentindex_enabled,
-                                                     bool is_timeindex_enabled,
                                                      const Consensus::Params& consensus_params,
                                                      bool fReindexChainState,
                                                      int64_t nBlockTreeDBCache,
@@ -119,25 +116,6 @@ std::optional<ChainstateLoadingError> LoadChainstate(bool fReset,
         return ChainstateLoadingError::ERROR_BAD_DEVNET_GENESIS_BLOCK;
     }
 
-    if (!fReset && !fReindexChainState) {
-        // Check for changed -addressindex state
-        if (!fAddressIndex && fAddressIndex != is_addrindex_enabled) {
-            return ChainstateLoadingError::ERROR_ADDRIDX_NEEDS_REINDEX;
-        }
-
-        // Check for changed -timestampindex state
-        if (!fTimestampIndex && fTimestampIndex != is_timeindex_enabled) {
-            return ChainstateLoadingError::ERROR_TIMEIDX_NEEDS_REINDEX;
-        }
-
-        // Check for changed -spentindex state
-        if (!fSpentIndex && fSpentIndex != is_spentindex_enabled) {
-            return ChainstateLoadingError::ERROR_SPENTIDX_NEEDS_REINDEX;
-        }
-    }
-
-    chainman.InitAdditionalIndexes();
-
     // Check for changed -prune state.  What we are concerned about is a user who has pruned blocks
     // in the past, but is now trying to run unpruned.
     if (chainman.m_blockman.m_have_pruned && !fPruneMode) {
diff --git a/src/node/chainstate.h b/src/node/chainstate.h
index 0022b7637d87..ff2777a2063b 100644
--- a/src/node/chainstate.h
+++ b/src/node/chainstate.h
@@ -37,9 +37,6 @@ enum class ChainstateLoadingError {
     ERROR_LOADING_BLOCK_DB,
     ERROR_BAD_GENESIS_BLOCK,
     ERROR_BAD_DEVNET_GENESIS_BLOCK,
-    ERROR_ADDRIDX_NEEDS_REINDEX,
-    ERROR_SPENTIDX_NEEDS_REINDEX,
-    ERROR_TIMEIDX_NEEDS_REINDEX,
     ERROR_PRUNED_NEEDS_REINDEX,
     ERROR_LOAD_GENESIS_BLOCK_FAILED,
     ERROR_CHAINSTATE_UPGRADE_FAILED,
@@ -93,9 +90,6 @@ std::optional<ChainstateLoadingError> LoadChainstate(bool fReset,
                                                      CTxMemPool* mempool,
                                                      const fs::path& data_dir,
                                                      bool fPruneMode,
-                                                     bool is_addrindex_enabled,
-                                                     bool is_spentindex_enabled,
-                                                     bool is_timeindex_enabled,
                                                      const Consensus::Params& consensus_params,
                                                      bool fReindexChainState,
                                                      int64_t nBlockTreeDBCache,
diff --git a/src/rpc/blockchain.cpp b/src/rpc/blockchain.cpp
index 203e20da3ba2..e80d5d591719 100644
--- a/src/rpc/blockchain.cpp
+++ b/src/rpc/blockchain.cpp
@@ -19,6 +19,7 @@
 #include <fs.h>
 #include <index/blockfilterindex.h>
 #include <index/coinstatsindex.h>
+#include <index/timestampindex.h>
 #include <index/txindex.h>
 #include <kernel/coinstats.h>
 #include <logging/timer.h>
@@ -29,7 +30,6 @@
 #include <node/utxo_snapshot.h>
 #include <merkleblock.h>
 #include <primitives/transaction.h>
-#include <rpc/index_util.h>
 #include <rpc/server.h>
 #include <rpc/server_util.h>
 #include <rpc/util.h>
@@ -552,13 +552,21 @@ static RPCHelpMan getblockhashes()
         },
     [&](const RPCHelpMan& self, const JSONRPCRequest& request) -> UniValue
 {
+    if (!g_timestampindex) {
+        throw JSONRPCError(RPC_MISC_ERROR, "Timestamp index is not enabled. Start with -timestampindex to enable.");
+    }
+
+    const IndexSummary summary = g_timestampindex->GetSummary();
+    if (!summary.synced) {
+        throw JSONRPCError(RPC_MISC_ERROR, strprintf("Timestamp index is syncing. Current height: %d", summary.best_block_height));
+    }
+
     unsigned int high = request.params[0].getInt<int>();
     unsigned int low = request.params[1].getInt<int>();
     std::vector<uint256> blockHashes;
 
-    ChainstateManager& chainman = EnsureAnyChainman(request.context);
-    if (LOCK(::cs_main); !GetTimestampIndex(*chainman.m_blockman.m_block_tree_db, high, low, blockHashes)) {
-        throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, "No information available for block hashes");
+    if (!g_timestampindex->GetBlockHashes(high, low, blockHashes)) {
+        throw JSONRPCError(RPC_MISC_ERROR, "Failed to read timestamp index.");
     }
 
     UniValue result(UniValue::VARR);
diff --git a/src/rpc/index_util.cpp b/src/rpc/index_util.cpp
deleted file mode 100644
index 743eb39d6940..000000000000
--- a/src/rpc/index_util.cpp
+++ /dev/null
@@ -1,96 +0,0 @@
-// Copyright (c) 2016 BitPay Inc.
-// Copyright (c) 2024-2025 The Dash Core developers
-// Distributed under the MIT software license, see the accompanying
-// file COPYING or http://www.opensource.org/licenses/mit-license.php.
-
-#include <rpc/index_util.h>
-
-#include <node/blockstorage.h>
-#include <rpc/protocol.h>
-#include <rpc/request.h>
-#include <txdb.h>
-#include <txmempool.h>
-#include <uint256.h>
-
-static void EnsureAddressIndexAvailable()
-{
-    if (!node::fAddressIndex) {
-        throw JSONRPCError(RPC_INVALID_REQUEST, "Address index is disabled. You should run Dash Core with -addressindex (requires reindex)");
-    }
-}
-
-bool GetAddressIndex(CBlockTreeDB& block_tree_db, const uint160& addressHash, const AddressType type,
-                     std::vector<CAddressIndexEntry>& addressIndex,
-                     const int32_t start, const int32_t end)
-{
-    AssertLockHeld(::cs_main);
-    EnsureAddressIndexAvailable();
-
-    return block_tree_db.ReadAddressIndex(addressHash, type, addressIndex, start, end);
-}
-
-bool GetAddressUnspentIndex(CBlockTreeDB& block_tree_db, const uint160& addressHash, const AddressType type,
-                            std::vector<CAddressUnspentIndexEntry>& unspentOutputs, const bool height_sort)
-{
-    AssertLockHeld(::cs_main);
-    EnsureAddressIndexAvailable();
-
-    if (!block_tree_db.ReadAddressUnspentIndex(addressHash, type, unspentOutputs))
-        return false;
-
-    if (height_sort) {
-        std::sort(unspentOutputs.begin(), unspentOutputs.end(),
-                  [](const CAddressUnspentIndexEntry &a, const CAddressUnspentIndexEntry &b) {
-                        return a.second.m_block_height < b.second.m_block_height;
-                  });
-    }
-
-    return true;
-}
-
-bool GetMempoolAddressDeltaIndex(const CTxMemPool& mempool,
-                                 const std::vector<CMempoolAddressDeltaKey>& addressDeltaIndex,
-                                 std::vector<CMempoolAddressDeltaEntry>& addressDeltaEntries,
-                                 const bool timestamp_sort)
-{
-    EnsureAddressIndexAvailable();
-
-    if (!mempool.getAddressIndex(addressDeltaIndex, addressDeltaEntries))
-        return false;
-
-    if (timestamp_sort) {
-        std::sort(addressDeltaEntries.begin(), addressDeltaEntries.end(),
-                  [](const CMempoolAddressDeltaEntry &a, const CMempoolAddressDeltaEntry &b) {
-                        return a.second.m_time < b.second.m_time;
-                  });
-    }
-
-    return true;
-}
-
-bool GetSpentIndex(CBlockTreeDB& block_tree_db, const CTxMemPool& mempool, const CSpentIndexKey& key,
-                   CSpentIndexValue& value)
-{
-    AssertLockHeld(::cs_main);
-
-    if (!node::fSpentIndex) {
-        throw JSONRPCError(RPC_INVALID_REQUEST, "Spent index is disabled. You should run Dash Core with -spentindex (requires reindex)");
-    }
-
-    if (mempool.getSpentIndex(key, value))
-        return true;
-
-    return block_tree_db.ReadSpentIndex(key, value);
-}
-
-bool GetTimestampIndex(CBlockTreeDB& block_tree_db, const uint32_t high, const uint32_t low,
-                       std::vector<uint256>& hashes)
-{
-    AssertLockHeld(::cs_main);
-
-    if (!node::fTimestampIndex) {
-        throw JSONRPCError(RPC_INVALID_REQUEST, "Timestamp index is disabled. You should run Dash Core with -timestampindex (requires reindex)");
-    }
-
-    return block_tree_db.ReadTimestampIndex(high, low, hashes);
-}
diff --git a/src/rpc/index_util.h b/src/rpc/index_util.h
deleted file mode 100644
index 1b480f82f53a..000000000000
--- a/src/rpc/index_util.h
+++ /dev/null
@@ -1,52 +0,0 @@
-// Copyright (c) 2016 BitPay Inc.
-// Copyright (c) 2024-2025 The Dash Core developers
-// Distributed under the MIT software license, see the accompanying
-// file COPYING or http://www.opensource.org/licenses/mit-license.php.
-
-#ifndef BITCOIN_RPC_INDEX_UTIL_H
-#define BITCOIN_RPC_INDEX_UTIL_H
-
-#include <consensus/amount.h>
-#include <addressindex.h>
-#include <spentindex.h>
-#include <sync.h>
-#include <threadsafety.h>
-
-#include <cstdint>
-#include <vector>
-
-class CBlockTreeDB;
-class CTxMemPool;
-class uint160;
-class uint256;
-
-enum class AddressType : uint8_t;
-
-extern RecursiveMutex cs_main; // NOLINT(readability-redundant-declaration)
-
-//! throws JSONRPCError if address index is unavailable
-bool GetAddressIndex(CBlockTreeDB& block_tree_db, const uint160& addressHash, const AddressType type,
-                     std::vector<CAddressIndexEntry>& addressIndex,
-                     const int32_t start, const int32_t end)
-    EXCLUSIVE_LOCKS_REQUIRED(::cs_main);
-//! throws JSONRPCError if address index is unavailable
-bool GetAddressUnspentIndex(CBlockTreeDB& block_tree_db, const uint160& addressHash, const AddressType type,
-                            std::vector<CAddressUnspentIndexEntry>& unspentOutputs, const bool height_sort = false)
-    EXCLUSIVE_LOCKS_REQUIRED(::cs_main);
-//! throws JSONRPCError if address index is unavailable
-bool GetMempoolAddressDeltaIndex(const CTxMemPool& mempool,
-                                 const std::vector<CMempoolAddressDeltaKey>& addressDeltaIndex,
-                                 std::vector<CMempoolAddressDeltaEntry>& addressDeltaEntries,
-                                 const bool timestamp_sort = false);
-
-//! throws JSONRPCError if spent index is unavailable
-bool GetSpentIndex(CBlockTreeDB& block_tree_db, const CTxMemPool& mempool, const CSpentIndexKey& key,
-                   CSpentIndexValue& value)
-    EXCLUSIVE_LOCKS_REQUIRED(::cs_main);
-
-//! throws JSONRPCError if timestamp index is unavailable
-bool GetTimestampIndex(CBlockTreeDB& block_tree_db, const uint32_t high, const uint32_t low,
-                       std::vector<uint256>& hashes)
-    EXCLUSIVE_LOCKS_REQUIRED(::cs_main);
-
-#endif // BITCOIN_RPC_INDEX_UTIL_H
diff --git a/src/rpc/node.cpp b/src/rpc/node.cpp
index b62b8b75de11..1a5a8405da88 100644
--- a/src/rpc/node.cpp
+++ b/src/rpc/node.cpp
@@ -4,13 +4,15 @@
 // Distributed under the MIT software license, see the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
-#include <addressindex.h>
 #include <chainparams.h>
 #include <consensus/consensus.h>
 #include <evo/mnauth.h>
 #include <httpserver.h>
+#include <index/addressindex.h>
 #include <index/blockfilterindex.h>
 #include <index/coinstatsindex.h>
+#include <index/spentindex.h>
+#include <index/timestampindex.h>
 #include <index/txindex.h>
 #include <init.h>
 #include <interfaces/chain.h>
@@ -21,7 +23,6 @@
 #include <net.h>
 #include <net_processing.h>
 #include <node/context.h>
-#include <rpc/index_util.h>
 #include <rpc/server.h>
 #include <rpc/server_util.h>
 #include <rpc/util.h>
@@ -410,6 +411,10 @@ static RPCHelpMan getaddressmempool()
         },
     [&](const RPCHelpMan& self, const JSONRPCRequest& request) -> UniValue
 {
+    if (!g_addressindex) {
+        throw JSONRPCError(RPC_MISC_ERROR, "Address index is not enabled. Start with -addressindex to enable.");
+    }
+
     CTxMemPool& mempool = EnsureAnyMemPool(request.context);
 
     std::vector<std::pair<uint160, AddressType>> addresses;
@@ -422,9 +427,13 @@ static RPCHelpMan getaddressmempool()
     for (const auto& [hash, type] : addresses) {
         input_addresses.push_back({type, hash});
     }
-    if (!GetMempoolAddressDeltaIndex(mempool, input_addresses, indexes, /* timestamp_sort = */ true)) {
-        throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, "No information available for address");
-    }
+
+    mempool.getAddressIndex(input_addresses, indexes);
+
+    std::sort(indexes.begin(), indexes.end(),
+              [](const CMempoolAddressDeltaEntry &a, const CMempoolAddressDeltaEntry &b) {
+                    return a.second.m_time < b.second.m_time;
+              });
 
     UniValue result(UniValue::VARR);
 
@@ -487,16 +496,21 @@ static RPCHelpMan getaddressutxos()
         throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, "Invalid address");
     }
 
+    if (!g_addressindex) {
+        throw JSONRPCError(RPC_MISC_ERROR, "Address index is not enabled. Start with -addressindex to enable.");
+    }
+
+    const IndexSummary summary = g_addressindex->GetSummary();
+    if (!summary.synced) {
+        throw JSONRPCError(RPC_MISC_ERROR, strprintf("Address index is syncing. Current height: %d", summary.best_block_height));
+    }
+
     std::vector<CAddressUnspentIndexEntry> unspentOutputs;
 
-    ChainstateManager& chainman = EnsureAnyChainman(request.context);
-    {
-        LOCK(::cs_main);
-        for (const auto& address : addresses) {
-            if (!GetAddressUnspentIndex(*chainman.m_blockman.m_block_tree_db, address.first, address.second, unspentOutputs,
-                                        /* height_sort = */ true)) {
-                throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, "No information available for address");
-            }
+    for (const auto& address : addresses) {
+        if (!g_addressindex->GetAddressUnspentIndex(address.first, address.second, unspentOutputs,
+                                    /* height_sort = */ true)) {
+            throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, "No information available for address");
         }
     }
 
@@ -575,15 +589,20 @@ static RPCHelpMan getaddressdeltas()
 
     std::vector<CAddressIndexEntry> addressIndex;
 
-    ChainstateManager& chainman = EnsureAnyChainman(request.context);
-    {
-        LOCK(::cs_main);
-        for (const auto& address : addresses) {
-            if (start <= 0 || end <= 0) { start = 0; end = 0; }
-            if (!GetAddressIndex(*chainman.m_blockman.m_block_tree_db, address.first, address.second,
-                                 addressIndex, start, end)) {
-                throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, "No information available for address");
-            }
+    if (!g_addressindex) {
+        throw JSONRPCError(RPC_MISC_ERROR, "Address index is not enabled. Start with -addressindex to enable.");
+    }
+
+    const IndexSummary summary = g_addressindex->GetSummary();
+    if (!summary.synced) {
+        throw JSONRPCError(RPC_MISC_ERROR, strprintf("Address index is syncing. Current height: %d", summary.best_block_height));
+    }
+
+    for (const auto& address : addresses) {
+        if (start <= 0 || end <= 0) { start = 0; end = 0; }
+        if (!g_addressindex->GetAddressIndex(address.first, address.second,
+                                             addressIndex, start, end)) {
+            throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, "No information available for address");
         }
     }
 
@@ -643,18 +662,23 @@ static RPCHelpMan getaddressbalance()
 
     std::vector<CAddressIndexEntry> addressIndex;
 
-    ChainstateManager& chainman = EnsureAnyChainman(request.context);
+    if (!g_addressindex) {
+        throw JSONRPCError(RPC_MISC_ERROR, "Address index is not enabled. Start with -addressindex to enable.");
+    }
 
-    int nHeight;
-    {
-        LOCK(::cs_main);
-        for (const auto& address : addresses) {
-            if (!GetAddressIndex(*chainman.m_blockman.m_block_tree_db, address.first, address.second, addressIndex,
-                                 /*start=*/0, /*end=*/0)) {
-                throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, "No information available for address");
-            }
+    // Check sync status first to return a clear error message
+    // Use the index's best block height instead of chain tip to avoid inconsistency
+    const IndexSummary summary = g_addressindex->GetSummary();
+    if (!summary.synced) {
+        throw JSONRPCError(RPC_MISC_ERROR, strprintf("Address index is syncing. Current height: %d", summary.best_block_height));
+    }
+    int nHeight = summary.best_block_height;
+
+    for (const auto& address : addresses) {
+        if (!g_addressindex->GetAddressIndex(address.first, address.second, addressIndex,
+                                             /*start=*/0, /*end=*/0)) {
+            throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, "No information available for address");
         }
-        nHeight = chainman.ActiveChain().Height();
     }
 
 
@@ -727,15 +751,20 @@ static RPCHelpMan getaddresstxids()
 
     std::vector<CAddressIndexEntry> addressIndex;
 
-    ChainstateManager& chainman = EnsureAnyChainman(request.context);
-    {
-        LOCK(::cs_main);
-        for (const auto& address : addresses) {
-            if (start <= 0 || end <= 0) { start = 0; end = 0; }
-            if (!GetAddressIndex(*chainman.m_blockman.m_block_tree_db, address.first, address.second,
-                                 addressIndex, start, end)) {
-                throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, "No information available for address");
-            }
+    if (!g_addressindex) {
+        throw JSONRPCError(RPC_MISC_ERROR, "Address index is not enabled. Start with -addressindex to enable.");
+    }
+
+    const IndexSummary summary = g_addressindex->GetSummary();
+    if (!summary.synced) {
+        throw JSONRPCError(RPC_MISC_ERROR, strprintf("Address index is syncing. Current height: %d", summary.best_block_height));
+    }
+
+    for (const auto& address : addresses) {
+        if (start <= 0 || end <= 0) { start = 0; end = 0; }
+        if (!g_addressindex->GetAddressIndex(address.first, address.second,
+                                             addressIndex, start, end)) {
+            throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, "No information available for address");
         }
     }
 
@@ -801,12 +830,42 @@ static RPCHelpMan getspentinfo()
     uint256 txid = ParseHashV(txidValue, "txid");
     int outputIndex = indexValue.getInt<int>();
 
+    if (outputIndex < 0) {
+        throw JSONRPCError(RPC_INVALID_PARAMETER, "Invalid index (must be non-negative)");
+    }
+
+    if (!g_spentindex) {
+        throw JSONRPCError(RPC_MISC_ERROR, "Spent index is not enabled. Start with -spentindex to enable.");
+    }
+
     CSpentIndexKey key(txid, outputIndex);
     CSpentIndexValue value;
+    bool found = false;
+
+    // Check the async index first (may return false if still syncing)
+    if (g_spentindex->GetSpentInfo(key, value)) {
+        found = true;
+    }
 
-    ChainstateManager& chainman = EnsureAnyChainman(request.context);
+    // Check mempool for unconfirmed spends.
+    //
+    // Mempool entry overwrites index entry if present.
+    // During reorg, mempool may have newer state than index (which updates asynchronously).
     CTxMemPool& mempool = EnsureAnyMemPool(request.context);
-    if (LOCK(::cs_main); !GetSpentIndex(*chainman.m_blockman.m_block_tree_db, mempool, key, value)) {
+    {
+        LOCK(mempool.cs);
+        CSpentIndexValue mempoolValue;
+        if (mempool.getSpentIndex(key, mempoolValue)) {
+            value = mempoolValue;  // Overwrite with mempool entry (current state)
+            found = true;
+        }
+    }
+
+    if (!found) {
+        const IndexSummary summary = g_spentindex->GetSummary();
+        if (!summary.synced) {
+            throw JSONRPCError(RPC_MISC_ERROR, strprintf("Unable to get spent info. Spent index is syncing, current height: %d", summary.best_block_height));
+        }
         throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, "Unable to get spent info");
     }
 
@@ -1106,6 +1165,18 @@ static RPCHelpMan getindexinfo()
         result.pushKVs(SummaryToJSON(index.GetSummary(), index_name));
     });
 
+    if (g_addressindex) {
+        result.pushKVs(SummaryToJSON(g_addressindex->GetSummary(), index_name));
+    }
+
+    if (g_timestampindex) {
+        result.pushKVs(SummaryToJSON(g_timestampindex->GetSummary(), index_name));
+    }
+
+    if (g_spentindex) {
+        result.pushKVs(SummaryToJSON(g_spentindex->GetSummary(), index_name));
+    }
+
     return result;
 }
     };
diff --git a/src/rpc/rawtransaction.cpp b/src/rpc/rawtransaction.cpp
index 5db203c01832..e5d7bbb82128 100644
--- a/src/rpc/rawtransaction.cpp
+++ b/src/rpc/rawtransaction.cpp
@@ -12,6 +12,7 @@
 #include <consensus/tx_verify.h>
 #include <consensus/validation.h>
 #include <core_io.h>
+#include <index/spentindex.h>
 #include <index/txindex.h>
 #include <init.h>
 #include <key_io.h>
@@ -56,7 +57,6 @@
 #include <instantsend/lock.h>
 #include <llmq/commitment.h>
 #include <llmq/context.h>
-#include <rpc/index_util.h>
 #include <util/irange.h>
 
 #include <cstdint>
@@ -72,39 +72,71 @@ using node::PSBTAnalysis;
 void TxToJSON(const CTransaction& tx, const uint256 hashBlock, const  CTxMemPool& mempool, const CChainState& active_chainstate, const llmq::CChainLocksHandler& clhandler, const llmq::CInstantSendManager& isman, UniValue& entry, TxVerbosity verbosity = TxVerbosity::SHOW_DETAILS)
 {
     CHECK_NONFATAL(verbosity >= TxVerbosity::SHOW_DETAILS);
-    LOCK(::cs_main);
-    // Call into TxToUniv() in bitcoin-common to decode the transaction hex.
-    //
-    // Blockchain contextual information (confirmations and blocktime) is not
-    // available to code in bitcoin-common, so we query them here and push the
-    // data into the returned UniValue.
 
     uint256 txid = tx.GetHash();
     CSpentIndexTxInfo *txSpentInfoPtr{nullptr};
 
     // Add spent information if spentindex is enabled
+    // Note: We query the async index BEFORE acquiring cs_main since BlockUntilSyncedToCurrentChain()
+    // requires cs_main NOT to be held
     CSpentIndexTxInfo txSpentInfo;
-    if (node::fSpentIndex) {
+    if (g_spentindex) {
         txSpentInfo = CSpentIndexTxInfo{};
+        // Collect spent info for inputs
         for (const auto& txin : tx.vin) {
             if (!tx.IsCoinBase()) {
                 CSpentIndexValue spentInfo;
                 CSpentIndexKey spentKey(txin.prevout.hash, txin.prevout.n);
-                if (GetSpentIndex(*active_chainstate.m_blockman.m_block_tree_db, mempool, spentKey, spentInfo)) {
+                if (g_spentindex->GetSpentInfo(spentKey, spentInfo)) {
                     txSpentInfo.mSpentInfo.emplace(spentKey, spentInfo);
                 }
             }
         }
+        // Collect spent info for outputs
         for (unsigned int i = 0; i < tx.vout.size(); i++) {
             CSpentIndexValue spentInfo;
             CSpentIndexKey spentKey(txid, i);
-            if (GetSpentIndex(*active_chainstate.m_blockman.m_block_tree_db, mempool, spentKey, spentInfo)) {
+            if (g_spentindex->GetSpentInfo(spentKey, spentInfo)) {
                 txSpentInfo.mSpentInfo.emplace(spentKey, spentInfo);
             }
         }
+
+        // Now check mempool (which requires mempool.cs).
+        //
+        // Mempool entry overwrites index entry if present.
+        // During reorg, mempool may have newer state than index (which updates asynchronously).
+        {
+            LOCK(mempool.cs);
+            for (const auto& txin : tx.vin) {
+                if (!tx.IsCoinBase()) {
+                    CSpentIndexValue spentInfo;
+                    CSpentIndexKey spentKey(txin.prevout.hash, txin.prevout.n);
+                    if (mempool.getSpentIndex(spentKey, spentInfo)) {
+                        // Mempool entry overwrites index entry if present
+                        txSpentInfo.mSpentInfo[spentKey] = spentInfo;
+                    }
+                }
+            }
+            for (unsigned int i = 0; i < tx.vout.size(); i++) {
+                CSpentIndexValue spentInfo;
+                CSpentIndexKey spentKey(txid, i);
+                if (mempool.getSpentIndex(spentKey, spentInfo)) {
+                    // Mempool entry overwrites index entry if present
+                    txSpentInfo.mSpentInfo[spentKey] = spentInfo;
+                }
+            }
+        }
+
         txSpentInfoPtr = &txSpentInfo;
     }
 
+    LOCK(::cs_main);
+    // Call into TxToUniv() in bitcoin-common to decode the transaction hex.
+    //
+    // Blockchain contextual information (confirmations and blocktime) is not
+    // available to code in bitcoin-common, so we query them here and push the
+    // data into the returned UniValue.
+
     TxToUniv(tx, /*block_hash=*/uint256(), entry, /*include_hex=*/true, /*serialize_flags=*/0, /*txundo=*/nullptr, verbosity, txSpentInfoPtr);
 
     bool chainLock = false;
diff --git a/src/spentindex.h b/src/spentindex.h
deleted file mode 100644
index 5382a2b096d5..000000000000
--- a/src/spentindex.h
+++ /dev/null
@@ -1,185 +0,0 @@
-// Copyright (c) 2009-2010 Satoshi Nakamoto
-// Copyright (c) 2009-2015 The Bitcoin Core developers
-// Copyright (c) 2016 BitPay Inc.
-// Copyright (c) 2023-2024 The Dash Core developers
-// Distributed under the MIT software license, see the accompanying
-// file COPYING or http://www.opensource.org/licenses/mit-license.php.
-
-#ifndef BITCOIN_SPENTINDEX_H
-#define BITCOIN_SPENTINDEX_H
-
-#include <addressindex.h>
-#include <consensus/amount.h>
-#include <script/script.h>
-#include <serialize.h>
-#include <uint256.h>
-
-#include <tuple>
-
-struct CAddressUnspentKey;
-struct CAddressUnspentValue;
-struct CSpentIndexKey;
-struct CSpentIndexValue;
-
-using CAddressUnspentIndexEntry = std::pair<CAddressUnspentKey, CAddressUnspentValue>;
-using CSpentIndexEntry = std::pair<CSpentIndexKey, CSpentIndexValue>;
-
-struct CSpentIndexKey {
-public:
-    uint256 m_tx_hash;
-    uint32_t m_tx_index{0};
-
-public:
-    CSpentIndexKey() {
-        SetNull();
-    }
-
-    CSpentIndexKey(uint256 txout_hash, uint32_t txout_index) :
-        m_tx_hash{txout_hash}, m_tx_index{txout_index} {};
-
-    void SetNull() {
-        m_tx_hash.SetNull();
-        m_tx_index = 0;
-    }
-
-public:
-    SERIALIZE_METHODS(CSpentIndexKey, obj)
-    {
-        READWRITE(obj.m_tx_hash, obj.m_tx_index);
-    }
-};
-
-struct CSpentIndexValue {
-public:
-    uint256 m_tx_hash;
-    uint32_t m_tx_index{0};
-    int32_t m_block_height{0};
-    CAmount m_amount{0};
-    AddressType m_address_type{AddressType::UNKNOWN};
-    uint160 m_address_bytes;
-
-public:
-    CSpentIndexValue() {
-        SetNull();
-    }
-
-    CSpentIndexValue(uint256 txin_hash, uint32_t txin_index, int32_t block_height, CAmount amount, AddressType address_type,
-                     uint160 address_bytes) :
-        m_tx_hash{txin_hash},
-        m_tx_index{txin_index},
-        m_block_height{block_height},
-        m_amount{amount},
-        m_address_type{address_type},
-        m_address_bytes{address_bytes} {};
-
-    void SetNull() {
-        m_tx_hash.SetNull();
-        m_tx_index = 0;
-        m_block_height = 0;
-        m_amount = 0;
-        m_address_type = AddressType::UNKNOWN;
-        m_address_bytes.SetNull();
-    }
-
-    bool IsNull() const {
-        return m_tx_hash.IsNull();
-    }
-
-public:
-    SERIALIZE_METHODS(CSpentIndexValue, obj)
-    {
-        READWRITE(obj.m_tx_hash, obj.m_tx_index, obj.m_block_height, obj.m_amount, obj.m_address_type, obj.m_address_bytes);
-    }
-};
-
-struct CSpentIndexKeyCompare
-{
-    bool operator()(const CSpentIndexKey& a, const CSpentIndexKey& b) const {
-        auto to_tuple = [](const CSpentIndexKey& obj) {
-            return std::tie(obj.m_tx_hash, obj.m_tx_index);
-        };
-        return to_tuple(a) < to_tuple(b);
-    }
-};
-
-struct CSpentIndexTxInfo
-{
-    std::map<CSpentIndexKey, CSpentIndexValue, CSpentIndexKeyCompare> mSpentInfo;
-};
-
-struct CAddressUnspentKey {
-public:
-    AddressType m_address_type{AddressType::UNKNOWN};
-    uint160 m_address_bytes;
-    uint256 m_tx_hash;
-    uint32_t m_tx_index{0};
-
-public:
-    CAddressUnspentKey() {
-        SetNull();
-    }
-
-    CAddressUnspentKey(AddressType address_type, uint160 address_bytes, uint256 tx_hash, uint32_t tx_index) :
-        m_address_type{address_type}, m_address_bytes{address_bytes}, m_tx_hash{tx_hash}, m_tx_index{tx_index} {};
-
-    void SetNull() {
-        m_address_type = AddressType::UNKNOWN;
-        m_address_bytes.SetNull();
-        m_tx_hash.SetNull();
-        m_tx_index = 0;
-    }
-
-public:
-    size_t GetSerializeSize(int nType, int nVersion) const {
-        return 57;
-    }
-
-    template<typename Stream>
-    void Serialize(Stream& s) const {
-        ser_writedata8(s, ToUnderlying(m_address_type));
-        m_address_bytes.Serialize(s);
-        m_tx_hash.Serialize(s);
-        ser_writedata32(s, m_tx_index);
-    }
-
-    template<typename Stream>
-    void Unserialize(Stream& s) {
-        m_address_type = static_cast<AddressType>(ser_readdata8(s));
-        m_address_bytes.Unserialize(s);
-        m_tx_hash.Unserialize(s);
-        m_tx_index = ser_readdata32(s);
-    }
-};
-
-struct CAddressUnspentValue {
-public:
-    CAmount m_amount{-1};
-    CScript m_tx_script;
-    int32_t m_block_height;
-
-public:
-    CAddressUnspentValue() {
-        SetNull();
-    }
-
-    CAddressUnspentValue(CAmount amount, CScript tx_script, int32_t block_height) :
-        m_amount{amount}, m_tx_script{tx_script}, m_block_height{block_height} {};
-
-    void SetNull() {
-        m_amount = -1;
-        m_tx_script.clear();
-        m_block_height = 0;
-    }
-
-    bool IsNull() const {
-        return (m_amount == -1);
-    }
-
-public:
-    SERIALIZE_METHODS(CAddressUnspentValue, obj)
-    {
-        READWRITE(obj.m_amount, obj.m_tx_script, obj.m_block_height);
-    }
-};
-
-#endif // BITCOIN_SPENTINDEX_H
diff --git a/src/test/util/setup_common.cpp b/src/test/util/setup_common.cpp
index 2d758f1afc5f..0a725b153a2f 100644
--- a/src/test/util/setup_common.cpp
+++ b/src/test/util/setup_common.cpp
@@ -85,9 +85,6 @@ using node::BlockAssembler;
 using node::CalculateCacheSizes;
 using node::DashChainstateSetup;
 using node::DashChainstateSetupClose;
-using node::DEFAULT_ADDRESSINDEX;
-using node::DEFAULT_SPENTINDEX;
-using node::DEFAULT_TIMESTAMPINDEX;
 using node::LoadChainstate;
 using node::NodeContext;
 using node::VerifyLoadedChainstate;
@@ -332,9 +329,6 @@ TestingSetup::TestingSetup(const std::string& chainName, const std::vector<const
                                            Assert(m_node.mempool.get()),
                                            Assert(m_node.args)->GetDataDirNet(),
                                            fPruneMode,
-                                           m_args.GetBoolArg("-addressindex", DEFAULT_ADDRESSINDEX),
-                                           m_args.GetBoolArg("-spentindex", DEFAULT_SPENTINDEX),
-                                           m_args.GetBoolArg("-timestampindex", DEFAULT_TIMESTAMPINDEX),
                                            chainparams.GetConsensus(),
                                            m_args.GetBoolArg("-reindex-chainstate", false),
                                            m_cache_sizes.block_tree_db,
diff --git a/src/timestampindex.h b/src/timestampindex.h
deleted file mode 100644
index 36f62acb3026..000000000000
--- a/src/timestampindex.h
+++ /dev/null
@@ -1,81 +0,0 @@
-// Copyright (c) 2009-2010 Satoshi Nakamoto
-// Copyright (c) 2009-2015 The Bitcoin Core developers
-// Copyright (c) 2016 BitPay Inc.
-// Copyright (c) 2023-2024 The Dash Core developers
-// Distributed under the MIT software license, see the accompanying
-// file COPYING or http://www.opensource.org/licenses/mit-license.php.
-
-#ifndef BITCOIN_TIMESTAMPINDEX_H
-#define BITCOIN_TIMESTAMPINDEX_H
-
-#include <serialize.h>
-#include <uint256.h>
-
-struct CTimestampIndexIteratorKey {
-public:
-    uint32_t m_time;
-
-public:
-    CTimestampIndexIteratorKey() {
-        SetNull();
-    }
-
-    CTimestampIndexIteratorKey(uint32_t time) : m_time{time} {};
-
-    void SetNull() {
-        m_time = 0;
-    }
-
-public:
-    size_t GetSerializeSize(int nType, int nVersion) const {
-        return 4;
-    }
-
-    template<typename Stream>
-    void Serialize(Stream& s) const {
-        ser_writedata32be(s, m_time);
-    }
-
-    template<typename Stream>
-    void Unserialize(Stream& s) {
-        m_time = ser_readdata32be(s);
-    }
-};
-
-struct CTimestampIndexKey {
-public:
-    uint32_t m_block_time;
-    uint256 m_block_hash;
-
-public:
-    CTimestampIndexKey() {
-        SetNull();
-    }
-
-    CTimestampIndexKey(uint32_t block_time, uint256 block_hash) :
-        m_block_time{block_time}, m_block_hash{block_hash} {};
-
-    void SetNull() {
-        m_block_time = 0;
-        m_block_hash.SetNull();
-    }
-
-public:
-    size_t GetSerializeSize(int nType, int nVersion) const {
-        return 36;
-    }
-
-    template<typename Stream>
-    void Serialize(Stream& s) const {
-        ser_writedata32be(s, m_block_time);
-        m_block_hash.Serialize(s);
-    }
-
-    template<typename Stream>
-    void Unserialize(Stream& s) {
-        m_block_time = ser_readdata32be(s);
-        m_block_hash.Unserialize(s);
-    }
-};
-
-#endif // BITCOIN_TIMESTAMPINDEX_H
diff --git a/src/txdb.cpp b/src/txdb.cpp
index 73827a9a3e5f..ea4ddc203b7f 100644
--- a/src/txdb.cpp
+++ b/src/txdb.cpp
@@ -1,12 +1,18 @@
 // Copyright (c) 2009-2010 Satoshi Nakamoto
 // Copyright (c) 2009-2021 The Bitcoin Core developers
+// Copyright (c) 2025 The Dash Core developers
 // Distributed under the MIT software license, see the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
 #include <txdb.h>
 
 #include <chain.h>
+#include <index/addressindex_types.h>
+#include <index/spentindex_types.h>
+#include <index/timestampindex_types.h>
+#include <logging.h>
 #include <pow.h>
+#include <primitives/block.h>
 #include <primitives/transaction.h>
 #include <random.h>
 #include <shutdown.h>
@@ -21,10 +27,6 @@
 
 static constexpr uint8_t DB_COIN{'C'};
 static constexpr uint8_t DB_BLOCK_FILES{'f'};
-static constexpr uint8_t DB_ADDRESSINDEX{'a'};
-static constexpr uint8_t DB_ADDRESSUNSPENTINDEX{'u'};
-static constexpr uint8_t DB_TIMESTAMPINDEX{'s'};
-static constexpr uint8_t DB_SPENTINDEX{'p'};
 static constexpr uint8_t DB_BLOCK_INDEX{'b'};
 
 static constexpr uint8_t DB_BEST_BLOCK{'B'};
@@ -39,6 +41,12 @@ static constexpr uint8_t DB_COINS{'c'};
 // CBlockTreeDB::DB_TXINDEX{'t'}
 // CBlockTreeDB::ReadFlag("txindex")
 
+// Old synchronous index keys (deprecated):
+static constexpr uint8_t DB_ADDRESSINDEX{'a'};
+static constexpr uint8_t DB_ADDRESSUNSPENTINDEX{'u'};
+static constexpr uint8_t DB_SPENTINDEX{'p'};
+static constexpr uint8_t DB_TIMESTAMPINDEX{'s'};
+
 bool CCoinsViewDB::NeedsUpgrade()
 {
     std::unique_ptr<CDBIterator> cursor{m_db->NewIterator()};
@@ -276,139 +284,6 @@ bool CBlockTreeDB::WriteBatchSync(const std::vector<std::pair<int, const CBlockF
     return WriteBatch(batch, true);
 }
 
-bool CBlockTreeDB::ReadSpentIndex(const CSpentIndexKey key, CSpentIndexValue& value) {
-    return Read(std::make_pair(DB_SPENTINDEX, key), value);
-}
-
-bool CBlockTreeDB::UpdateSpentIndex(const std::vector<CSpentIndexEntry>& vect) {
-    CDBBatch batch(*this);
-    for (const auto& [key, value] : vect) {
-        if (value.IsNull()) {
-            batch.Erase(std::make_pair(DB_SPENTINDEX, key));
-        } else {
-            batch.Write(std::make_pair(DB_SPENTINDEX, key), value);
-        }
-    }
-    return WriteBatch(batch);
-}
-
-bool CBlockTreeDB::UpdateAddressUnspentIndex(const std::vector<CAddressUnspentIndexEntry>& vect) {
-    CDBBatch batch(*this);
-    for (const auto& [key, value] : vect) {
-        if (value.IsNull()) {
-            batch.Erase(std::make_pair(DB_ADDRESSUNSPENTINDEX, key));
-        } else {
-            batch.Write(std::make_pair(DB_ADDRESSUNSPENTINDEX, key), value);
-        }
-    }
-    return WriteBatch(batch);
-}
-
-bool CBlockTreeDB::ReadAddressUnspentIndex(const uint160& addressHash, const AddressType type,
-                                           std::vector<CAddressUnspentIndexEntry>& unspentOutputs)
-{
-    std::unique_ptr<CDBIterator> pcursor(NewIterator());
-
-    pcursor->Seek(std::make_pair(DB_ADDRESSUNSPENTINDEX, CAddressIndexIteratorKey(type, addressHash)));
-
-    while (pcursor->Valid()) {
-        std::pair<uint8_t, CAddressUnspentKey> key;
-        if (pcursor->GetKey(key) && key.first == DB_ADDRESSUNSPENTINDEX && key.second.m_address_bytes == addressHash) {
-            CAddressUnspentValue nValue;
-            if (pcursor->GetValue(nValue)) {
-                unspentOutputs.push_back(std::make_pair(key.second, nValue));
-                pcursor->Next();
-            } else {
-                return error("failed to get address unspent value");
-            }
-        } else {
-            break;
-        }
-    }
-
-    return true;
-}
-
-bool CBlockTreeDB::WriteAddressIndex(const std::vector<CAddressIndexEntry>& vect) {
-    CDBBatch batch(*this);
-    for (const auto& [key, value] : vect) {
-        batch.Write(std::make_pair(DB_ADDRESSINDEX, key), value);
-    }
-    return WriteBatch(batch);
-}
-
-bool CBlockTreeDB::EraseAddressIndex(const std::vector<CAddressIndexEntry>& vect) {
-    CDBBatch batch(*this);
-    for (const auto& [key, _] : vect) {
-        batch.Erase(std::make_pair(DB_ADDRESSINDEX, key));
-    }
-    return WriteBatch(batch);
-}
-
-bool CBlockTreeDB::ReadAddressIndex(const uint160& addressHash, const AddressType type,
-                                    std::vector<CAddressIndexEntry>& addressIndex,
-                                    const int32_t start, const int32_t end)
-{
-    std::unique_ptr<CDBIterator> pcursor(NewIterator());
-
-    if (start > 0 && end > 0) {
-        pcursor->Seek(std::make_pair(DB_ADDRESSINDEX, CAddressIndexIteratorHeightKey(type, addressHash, start)));
-    } else {
-        pcursor->Seek(std::make_pair(DB_ADDRESSINDEX, CAddressIndexIteratorKey(type, addressHash)));
-    }
-
-    while (pcursor->Valid()) {
-        std::pair<uint8_t, CAddressIndexKey> key;
-        if (pcursor->GetKey(key) && key.first == DB_ADDRESSINDEX && key.second.m_address_bytes == addressHash) {
-            if (end > 0 && key.second.m_block_height > end) {
-                break;
-            }
-            CAmount nValue;
-            if (pcursor->GetValue(nValue)) {
-                addressIndex.push_back(std::make_pair(key.second, nValue));
-                pcursor->Next();
-            } else {
-                return error("failed to get address index value");
-            }
-        } else {
-            break;
-        }
-    }
-
-    return true;
-}
-
-bool CBlockTreeDB::WriteTimestampIndex(const CTimestampIndexKey& timestampIndex) {
-    CDBBatch batch(*this);
-    batch.Write(std::make_pair(DB_TIMESTAMPINDEX, timestampIndex), 0);
-    return WriteBatch(batch);
-}
-
-bool CBlockTreeDB::EraseTimestampIndex(const CTimestampIndexKey& timestampIndex)
-{
-    CDBBatch batch(*this);
-    batch.Erase(std::make_pair(DB_TIMESTAMPINDEX, timestampIndex));
-    return WriteBatch(batch);
-}
-
-bool CBlockTreeDB::ReadTimestampIndex(const uint32_t high, const uint32_t low, std::vector<uint256>& hashes) {
-    std::unique_ptr<CDBIterator> pcursor(NewIterator());
-
-    pcursor->Seek(std::make_pair(DB_TIMESTAMPINDEX, CTimestampIndexIteratorKey(low)));
-
-    while (pcursor->Valid()) {
-        std::pair<uint8_t, CTimestampIndexKey> key;
-        if (pcursor->GetKey(key) && key.first == DB_TIMESTAMPINDEX && key.second.m_block_time <= high) {
-            hashes.push_back(key.second.m_block_hash);
-            pcursor->Next();
-        } else {
-            break;
-        }
-    }
-
-    return true;
-}
-
 bool CBlockTreeDB::WriteFlag(const std::string &name, bool fValue) {
     return Write(std::make_pair(DB_FLAG, name), fValue ? uint8_t{'1'} : uint8_t{'0'});
 }
@@ -464,3 +339,248 @@ bool CBlockTreeDB::LoadBlockIndexGuts(const Consensus::Params& consensusParams,
 
     return true;
 }
+
+/**
+ * Template helper to migrate a single index type from the old block index database
+ * to a new async index database.
+ *
+ * @tparam DbKey         The key prefix byte for this index type
+ * @tparam KeyType       The index key struct type
+ * @tparam ValueType     The index value type
+ * @param source_db      The old database to migrate from (CBlockTreeDB)
+ * @param target_db      The new database to migrate to
+ * @param index_name     Human-readable name for logging
+ * @param batch_size     Maximum batch size before flushing
+ * @return               Number of entries migrated, or -1 on error
+ */
+template <uint8_t DbKey, typename KeyType, typename ValueType>
+static int64_t MigrateIndex(CBlockTreeDB& source_db, CDBWrapper& target_db,
+                            const char* index_name, size_t batch_size)
+{
+    using KeyPair = std::pair<uint8_t, KeyType>;
+
+    size_t count = 0;
+    CDBBatch new_batch(target_db);
+    CDBBatch erase_batch(source_db);
+
+    KeyPair start = std::make_pair(DbKey, KeyType());
+    KeyPair key;
+    ValueType value;
+
+    // Compact after erasing this much data to reclaim disk space
+    const size_t compact_threshold = 256 << 20; // 256 MiB
+    size_t erased_since_compact = 0;
+
+    std::unique_ptr<CDBIterator> pcursor(source_db.NewIterator());
+    pcursor->Seek(start);
+
+    while (pcursor->Valid()) {
+        if (pcursor->GetKey(key) && key.first == DbKey) {
+            if (!pcursor->GetValue(value)) {
+                LogPrintf("Failed to read %s value\n", index_name);
+                return -1;
+            }
+
+            new_batch.Write(key, value);
+            erase_batch.Erase(key);
+            count++;
+            pcursor->Next();
+
+            if (new_batch.SizeEstimate() > batch_size) {
+                LogPrintf("Migrating partial batch of %s entries (%.2f MiB, %d entries)...\n",
+                         index_name, new_batch.SizeEstimate() * (1.0 / 1048576.0), count);
+                erased_since_compact += erase_batch.SizeEstimate();
+                if (!target_db.WriteBatch(new_batch)) {
+                    LogPrintf("Failed to write %s batch to new database\n", index_name);
+                    return -1;
+                }
+                if (!source_db.WriteBatch(erase_batch)) {
+                    LogPrintf("Failed to erase old %s data\n", index_name);
+                    return -1;
+                }
+                new_batch.Clear();
+                erase_batch.Clear();
+
+                // Compact periodically to reclaim disk space
+                if (erased_since_compact >= compact_threshold) {
+                    // Close iterator before compaction so LevelDB can delete old SST files
+                    pcursor.reset();
+                    source_db.CompactRange(start, key);
+                    erased_since_compact = 0;
+
+                    // Reopen iterator - seek to start finds next unprocessed key since we erased previous ones
+                    pcursor.reset(source_db.NewIterator());
+                    pcursor->Seek(start);
+                }
+            }
+        } else {
+            break;
+        }
+    }
+
+    // Always write final batch with sync to ensure durability
+    if (!target_db.WriteBatch(new_batch, true)) {
+        LogPrintf("Failed to write final %s batch\n", index_name);
+        return -1;
+    }
+    if (!source_db.WriteBatch(erase_batch, true)) {
+        LogPrintf("Failed to erase final %s batch\n", index_name);
+        return -1;
+    }
+    new_batch.Clear();
+    erase_batch.Clear();
+
+    // Close iterator before final compaction
+    pcursor.reset();
+
+    // Compact final range if we migrated any keys
+    if (count > 0) {
+        source_db.CompactRange(start, key);
+    }
+
+    return static_cast<int64_t>(count);
+}
+
+/**
+ * Write best block locator to an index database.
+ * Note: Source database compaction is done incrementally in MigrateIndex.
+ */
+static bool FinalizeMigration(CDBWrapper& target_db, const uint256& best_block_hash,
+                              const char* index_name)
+{
+    if (!best_block_hash.IsNull()) {
+        CBlockLocator locator;
+        locator.vHave.push_back(best_block_hash);
+        CDBBatch best_block_batch(target_db);
+        best_block_batch.Write(DB_BEST_BLOCK, locator);
+        if (!target_db.WriteBatch(best_block_batch, true)) {
+            return error("%s: Failed to write best block for %s", __func__, index_name);
+        }
+        LogPrintf("Set %s best block to %s\n", index_name, best_block_hash.ToString());
+    }
+
+    return true;
+}
+
+bool CBlockTreeDB::MigrateOldIndexData()
+{
+    // Migrate old synchronous index data that was stored in the block index database
+    // to new async indexes in separate databases under indexes/{timestampindex,spentindex,addressindex}/
+    // This preserves existing index data so users don't need to rebuild.
+    // Indexes are migrated independently since they can be enabled individually.
+
+    // Only migrate indexes that are actually enabled via command-line flags
+    // NOTE: not using DEFAULT_* constants here to avoid circular dependencies
+    const bool fTimestampIndex = gArgs.GetBoolArg("-timestampindex", false);
+    const bool fSpentIndex = gArgs.GetBoolArg("-spentindex", false);
+    const bool fAddressIndex = gArgs.GetBoolArg("-addressindex", false);
+
+    if (!fTimestampIndex && !fSpentIndex && !fAddressIndex) {
+        // No indexes enabled, skip migration entirely
+        return true;
+    }
+
+    LogPrintf("Checking for old index data in block index database...\n");
+
+    size_t batch_size = (size_t)gArgs.GetIntArg("-dbbatchsize", nDefaultDbBatchSize);
+    size_t total_count = 0;
+    const fs::path indexes_path = gArgs.GetDataDirNet() / "indexes";
+
+    // Read the best block hash from coins database to set as best block for migrated indexes
+    // Old synchronous indexes were updated during ConnectBlock, so they're synced to the active chain tip
+    uint256 best_block_hash;
+    {
+        fs::path chainstate_path = gArgs.GetDataDirNet() / "chainstate";
+        CDBWrapper coins_db(chainstate_path, 0, false, false);
+        if (!coins_db.Read(DB_BEST_BLOCK, best_block_hash)) {
+            // If we can't read the best block, the indexes will resync from scratch
+            LogPrintf("Warning: Could not read best block from chainstate, migrated indexes will resync\n");
+            best_block_hash.SetNull();
+        } else {
+            LogPrintf("Migrating indexes with best block: %s\n", best_block_hash.ToString());
+        }
+    }
+
+    // Migrate timestamp index (only if enabled)
+    if (fTimestampIndex) {
+        const fs::path db_path = indexes_path / "timestampindex";
+        CDBWrapper timestamp_db(db_path, 0, false, false);
+
+        int64_t count = MigrateIndex<DB_TIMESTAMPINDEX, CTimestampIndexKey, bool>(
+            *this, timestamp_db, "timestamp index", batch_size);
+        if (count < 0) {
+            return error("%s: Failed to migrate timestamp index", __func__);
+        }
+        if (count > 0) {
+            LogPrintf("Migrated %d timestamp index entries\n", count);
+            total_count += count;
+            if (!FinalizeMigration(timestamp_db, best_block_hash, "timestamp index")) {
+                return false;
+            }
+        }
+    }
+
+    // Migrate spent index (only if enabled)
+    if (fSpentIndex) {
+        const fs::path db_path = indexes_path / "spentindex";
+        CDBWrapper spent_db(db_path, 0, false, false);
+
+        int64_t count = MigrateIndex<DB_SPENTINDEX, CSpentIndexKey, CSpentIndexValue>(
+            *this, spent_db, "spent index", batch_size);
+        if (count < 0) {
+            return error("%s: Failed to migrate spent index", __func__);
+        }
+        if (count > 0) {
+            LogPrintf("Migrated %d spent index entries\n", count);
+            total_count += count;
+            if (!FinalizeMigration(spent_db, best_block_hash, "spent index")) {
+                return false;
+            }
+        }
+    }
+
+    // Migrate address index (includes both address and unspent indexes) (only if enabled)
+    if (fAddressIndex) {
+        const fs::path db_path = indexes_path / "addressindex";
+        CDBWrapper address_db(db_path, 0, false, false);
+
+        // Migrate address index (transaction history)
+        int64_t address_count = MigrateIndex<DB_ADDRESSINDEX, CAddressIndexKey, CAmount>(
+            *this, address_db, "address index", batch_size);
+        if (address_count < 0) {
+            return error("%s: Failed to migrate address index", __func__);
+        }
+        if (address_count > 0) {
+            LogPrintf("Migrated %d address index entries\n", address_count);
+            total_count += address_count;
+        }
+
+        // Migrate address unspent index
+        int64_t unspent_count = MigrateIndex<DB_ADDRESSUNSPENTINDEX, CAddressUnspentKey, CAddressUnspentValue>(
+            *this, address_db, "address unspent index", batch_size);
+        if (unspent_count < 0) {
+            return error("%s: Failed to migrate address unspent index", __func__);
+        }
+        if (unspent_count > 0) {
+            LogPrintf("Migrated %d address unspent index entries\n", unspent_count);
+            total_count += unspent_count;
+        }
+
+        // Write best block locator if we migrated any address index data
+        if (address_count > 0 || unspent_count > 0) {
+            if (!FinalizeMigration(address_db, best_block_hash, "address and address unspent indexes")) {
+                return false;
+            }
+        }
+    }
+
+    if (total_count > 0) {
+        LogPrintf("Compacting remaining block index database...\n");
+        CompactFull();
+        LogPrintf("Successfully migrated %d index entries to new databases\n", total_count);
+    } else {
+        LogPrintf("No old index data found\n");
+    }
+
+    return true;
+}
diff --git a/src/txdb.h b/src/txdb.h
index 886071586514..e7321639b7cd 100644
--- a/src/txdb.h
+++ b/src/txdb.h
@@ -1,5 +1,6 @@
 // Copyright (c) 2009-2010 Satoshi Nakamoto
 // Copyright (c) 2009-2021 The Bitcoin Core developers
+// Copyright (c) 2025 The Dash Core developers
 // Distributed under the MIT software license, see the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
@@ -8,9 +9,7 @@
 
 #include <coins.h>
 #include <dbwrapper.h>
-#include <spentindex.h>
 #include <sync.h>
-#include <timestampindex.h>
 
 #include <memory>
 #include <optional>
@@ -89,27 +88,13 @@ class CBlockTreeDB : public CDBWrapper
     bool WriteReindexing(bool fReindexing);
     void ReadReindexing(bool &fReindexing);
 
-    bool ReadSpentIndex(const CSpentIndexKey key, CSpentIndexValue& value);
-    bool UpdateSpentIndex(const std::vector<CSpentIndexEntry>& vect);
-
-    bool ReadAddressUnspentIndex(const uint160& addressHash, const AddressType type,
-                                 std::vector<CAddressUnspentIndexEntry>& vect);
-    bool UpdateAddressUnspentIndex(const std::vector<CAddressUnspentIndexEntry>& vect);
-
-    bool WriteAddressIndex(const std::vector<CAddressIndexEntry>& vect);
-    bool EraseAddressIndex(const std::vector<CAddressIndexEntry>& vect);
-    bool ReadAddressIndex(const uint160& addressHash, const AddressType type,
-                          std::vector<CAddressIndexEntry>& addressIndex,
-                          const int32_t start = 0, const int32_t end = 0);
-
-    bool WriteTimestampIndex(const CTimestampIndexKey& timestampIndex);
-    bool EraseTimestampIndex(const CTimestampIndexKey& timestampIndex);
-    bool ReadTimestampIndex(const uint32_t high, const uint32_t low, std::vector<uint256>& hashes);
-
     bool WriteFlag(const std::string &name, bool fValue);
     bool ReadFlag(const std::string &name, bool &fValue);
     bool LoadBlockIndexGuts(const Consensus::Params& consensusParams, std::function<CBlockIndex*(const uint256&)> insertBlockIndex)
         EXCLUSIVE_LOCKS_REQUIRED(::cs_main);
+
+    /// Migrate old synchronous index data to new async index databases
+    bool MigrateOldIndexData() EXCLUSIVE_LOCKS_REQUIRED(::cs_main);
 };
 
 #endif // BITCOIN_TXDB_H
diff --git a/src/txmempool.cpp b/src/txmempool.cpp
index febec3d957ad..db66309f03ec 100644
--- a/src/txmempool.cpp
+++ b/src/txmempool.cpp
@@ -11,6 +11,7 @@
 #include <consensus/tx_verify.h>
 #include <consensus/validation.h>
 #include <hash.h>
+#include <index/addressindex_util.h>
 #include <policy/fees.h>
 #include <policy/policy.h>
 #include <policy/settings.h>
@@ -28,9 +29,16 @@
 #include <instantsend/instantsend.h>
 
 #include <cmath>
+#include <memory>
 #include <optional>
 #include <ranges>
 
+// Forward declarations for index globals and utilities
+class AddressIndex;
+class SpentIndex;
+extern std::unique_ptr<AddressIndex> g_addressindex;
+extern std::unique_ptr<SpentIndex> g_spentindex;
+
 bool TestLockPointValidity(CChain& active_chain, const LockPoints& lp)
 {
     AssertLockHeld(cs_main);
@@ -529,6 +537,8 @@ void CTxMemPool::addUnchecked(const CTxMemPoolEntry &entry, setEntries &setAnces
 
 void CTxMemPool::addAddressIndex(const CTxMemPoolEntry& entry, const CCoinsViewCache& view)
 {
+    if (!g_addressindex) return;
+
     LOCK(cs);
     const CTransaction& tx = entry.GetTx();
     std::vector<CMempoolAddressDeltaKey> inserted;
@@ -570,7 +580,7 @@ void CTxMemPool::addAddressIndex(const CTxMemPoolEntry& entry, const CCoinsViewC
     mapAddressInserted.insert(std::make_pair(txhash, inserted));
 }
 
-bool CTxMemPool::getAddressIndex(const std::vector<CMempoolAddressDeltaKey>& addresses,
+void CTxMemPool::getAddressIndex(const std::vector<CMempoolAddressDeltaKey>& addresses,
                                  std::vector<CMempoolAddressDeltaEntry>& results) const
 {
     LOCK(cs);
@@ -582,7 +592,6 @@ bool CTxMemPool::getAddressIndex(const std::vector<CMempoolAddressDeltaKey>& add
             ait++;
         }
     }
-    return true;
 }
 
 void CTxMemPool::removeAddressIndex(const uint256 txhash)
@@ -598,6 +607,8 @@ void CTxMemPool::removeAddressIndex(const uint256 txhash)
 
 void CTxMemPool::addSpentIndex(const CTxMemPoolEntry& entry, const CCoinsViewCache& view)
 {
+    if (!g_spentindex) return;
+
     LOCK(cs);
 
     const CTransaction& tx = entry.GetTx();
diff --git a/src/txmempool.h b/src/txmempool.h
index 959d02b6860f..8d41cebcfe5f 100644
--- a/src/txmempool.h
+++ b/src/txmempool.h
@@ -14,11 +14,12 @@
 #include <utility>
 #include <vector>
 
-#include <addressindex.h>
 #include <coins.h>
 #include <consensus/amount.h>
 #include <evo/netinfo.h>
 #include <gsl/pointers.h>
+#include <index/addressindex_types.h>
+#include <index/spentindex_types.h>
 #include <indirectmap.h>
 #include <netaddress.h>
 #include <policy/feerate.h>
@@ -26,7 +27,6 @@
 #include <primitives/transaction.h>
 #include <pubkey.h>
 #include <random.h>
-#include <spentindex.h>
 #include <sync.h>
 #include <util/epochguard.h>
 #include <util/hasher.h>
@@ -611,7 +611,7 @@ class CTxMemPool
     void addUnchecked(const CTxMemPoolEntry& entry, setEntries& setAncestors, bool validFeeEstimate = true) EXCLUSIVE_LOCKS_REQUIRED(cs, cs_main);
 
     void addAddressIndex(const CTxMemPoolEntry& entry, const CCoinsViewCache& view);
-    bool getAddressIndex(const std::vector<CMempoolAddressDeltaKey>& addresses,
+    void getAddressIndex(const std::vector<CMempoolAddressDeltaKey>& addresses,
                          std::vector<CMempoolAddressDeltaEntry>& results) const;
     void removeAddressIndex(const uint256 txhash);
 
diff --git a/src/validation.cpp b/src/validation.cpp
index 95629b462cf1..65eb701cc0dc 100644
--- a/src/validation.cpp
+++ b/src/validation.cpp
@@ -74,15 +74,9 @@ using node::BlockManager;
 using node::BlockMap;
 using node::CBlockIndexHeightOnlyComparator;
 using node::CBlockIndexWorkComparator;
-using node::DEFAULT_ADDRESSINDEX;
-using node::DEFAULT_SPENTINDEX;
-using node::DEFAULT_TIMESTAMPINDEX;
-using node::fAddressIndex;
 using node::fImporting;
 using node::fPruneMode;
 using node::fReindex;
-using node::fSpentIndex;
-using node::fTimestampIndex;
 using node::ReadBlockFromDisk;
 using node::SnapshotMetadata;
 using node::UndoReadFromDisk;
@@ -1061,14 +1055,10 @@ bool MemPoolAccept::Finalize(const ATMPArgs& args, Workspace& ws)
     ::g_stats_client->count("transactions.sigOps", nSigOps, 1.0f);
 
     // Add memory address index
-    if (fAddressIndex) {
-        m_pool.addAddressIndex(*entry, m_view);
-    }
+    m_pool.addAddressIndex(*entry, m_view);
 
     // Add memory spent index
-    if (fSpentIndex) {
-        m_pool.addSpentIndex(*entry, m_view);
-    }
+    m_pool.addSpentIndex(*entry, m_view);
 
     // trim mempool and check if tx was trimmed
     // If we are validating a package, don't trim here because we could evict a previous transaction
@@ -2017,8 +2007,6 @@ DisconnectResult CChainState::DisconnectBlock(const CBlock& block, const CBlockI
         return DISCONNECT_FAILED;
     }
 
-    std::vector<CAddressIndexEntry> addressIndex;
-    std::vector<CAddressUnspentIndexEntry> addressUnspentIndex;
     std::vector<CSpentIndexEntry> spentIndex;
 
     std::optional<MNListUpdates> mnlist_updates_opt{std::nullopt};
@@ -2043,25 +2031,6 @@ DisconnectResult CChainState::DisconnectBlock(const CBlock& block, const CBlockI
         bool is_coinbase = tx.IsCoinBase();
         bool is_bip30_exception = (is_coinbase && !fEnforceBIP30);
 
-        if (fAddressIndex) {
-            for (unsigned int k = tx.vout.size(); k-- > 0;) {
-                const CTxOut &out = tx.vout[k];
-
-                AddressType address_type{AddressType::UNKNOWN};
-                uint160 address_bytes;
-
-                if (!AddressBytesFromScript(out.scriptPubKey, address_type, address_bytes)) {
-                    continue;
-                }
-
-                // undo receiving activity
-                addressIndex.push_back(std::make_pair(CAddressIndexKey(address_type, address_bytes, pindex->nHeight, i, hash, k, false), out.nValue));
-
-                // undo unspent index
-                addressUnspentIndex.push_back(std::make_pair(CAddressUnspentKey(address_type, address_bytes, hash, k), CAddressUnspentValue()));
-            }
-        }
-
         // Check that all outputs are available and match the outputs in the block itself
         // exactly.
         for (size_t o = 0; o < tx.vout.size(); o++) {
@@ -2087,66 +2056,14 @@ DisconnectResult CChainState::DisconnectBlock(const CBlock& block, const CBlockI
             for (unsigned int j = tx.vin.size(); j > 0;) {
                 --j;
                 const COutPoint& out = tx.vin[j].prevout;
-                int undoHeight = txundo.vprevout[j].nHeight;
                 int res = ApplyTxInUndo(std::move(txundo.vprevout[j]), view, out);
                 if (res == DISCONNECT_FAILED) return DISCONNECT_FAILED;
                 fClean = fClean && res != DISCONNECT_UNCLEAN;
-
-                const CTxIn input = tx.vin[j];
-
-                if (fSpentIndex) {
-                    // undo and delete the spent index
-                    spentIndex.push_back(std::make_pair(CSpentIndexKey(input.prevout.hash, input.prevout.n), CSpentIndexValue()));
-                }
-
-                if (fAddressIndex) {
-                    const Coin &coin = view.AccessCoin(tx.vin[j].prevout);
-                    const CTxOut &prevout = coin.out;
-
-                    AddressType address_type{AddressType::UNKNOWN};
-                    uint160 address_bytes;
-
-                    if (!AddressBytesFromScript(prevout.scriptPubKey, address_type, address_bytes)) {
-                        continue;
-                    }
-
-                    // undo spending activity
-                    addressIndex.push_back(std::make_pair(CAddressIndexKey(address_type, address_bytes, pindex->nHeight, i, hash, j, true), prevout.nValue * -1));
-
-                    // restore unspent index
-                    addressUnspentIndex.push_back(std::make_pair(CAddressUnspentKey(address_type, address_bytes, input.prevout.hash, input.prevout.n), CAddressUnspentValue(prevout.nValue, prevout.scriptPubKey, undoHeight)));
-                }
             }
             // At this point, all of txundo.vprevout should have been moved out.
         }
     }
 
-
-    if (fSpentIndex) {
-        if (!m_blockman.m_block_tree_db->UpdateSpentIndex(spentIndex)) {
-            AbortNode("Failed to delete spent index");
-            return DISCONNECT_FAILED;
-        }
-    }
-
-    if (fAddressIndex) {
-        if (!m_blockman.m_block_tree_db->EraseAddressIndex(addressIndex)) {
-            AbortNode("Failed to delete address index");
-            return DISCONNECT_FAILED;
-        }
-        if (!m_blockman.m_block_tree_db->UpdateAddressUnspentIndex(addressUnspentIndex)) {
-            AbortNode("Failed to write address unspent index");
-            return DISCONNECT_FAILED;
-        }
-    }
-
-    if (fTimestampIndex) {
-        if (!m_blockman.m_block_tree_db->EraseTimestampIndex(CTimestampIndexKey(pindex->nTime, pindex->GetBlockHash()))) {
-            AbortNode("Failed to delete timestamp index");
-            return DISCONNECT_FAILED;
-        }
-    }
-
     // move best block pointer to prevout block
     view.SetBestBlock(pindex->pprev->GetBlockHash());
     m_evoDb.WriteBestBlock(pindex->pprev->GetBlockHash());
@@ -2261,7 +2178,6 @@ static int64_t nTimePayeeValid = 0;
 static int64_t nTimeProcessSpecial = 0;
 static int64_t nTimeDashSpecific = 0;
 static int64_t nTimeConnect = 0;
-static int64_t nTimeIndexConnect = 0;
 static int64_t nTimeIndexWrite = 0;
 static int64_t nTimeTotal = 0;
 static int64_t nBlocksTotal = 0;
@@ -2437,8 +2353,6 @@ bool CChainState::ConnectBlock(const CBlock& block, BlockValidationState& state,
     int nInputs = 0;
     unsigned int nSigOps = 0;
     blockundo.vtxundo.reserve(block.vtx.size() - 1);
-    std::vector<CAddressIndexEntry> addressIndex;
-    std::vector<CAddressUnspentIndexEntry> addressUnspentIndex;
     std::vector<CSpentIndexEntry> spentIndex;
 
     bool fDIP0001Active_context = DeploymentActiveAt(*pindex, m_params.GetConsensus(), Consensus::DEPLOYMENT_DIP0001);
@@ -2453,12 +2367,9 @@ bool CChainState::ConnectBlock(const CBlock& block, BlockValidationState& state,
     int64_t nTime2_1 = GetTimeMicros(); nTimeProcessSpecial += nTime2_1 - nTime2;
     LogPrint(BCLog::BENCHMARK, "      - ProcessSpecialTxsInBlock: %.2fms [%.2fs (%.2fms/blk)]\n", MILLI * (nTime2_1 - nTime2), nTimeProcessSpecial * MICRO, nTimeProcessSpecial * MILLI / nBlocksTotal);
 
-    int64_t nTime2_index = 0;
-
     for (unsigned int i = 0; i < block.vtx.size(); i++)
     {
         const CTransaction &tx = *(block.vtx[i]);
-        const uint256 txhash = tx.GetHash();
 
         nInputs += tx.vin.size();
 
@@ -2490,37 +2401,6 @@ bool CChainState::ConnectBlock(const CBlock& block, BlockValidationState& state,
                 LogPrintf("ERROR: %s: contains a non-BIP68-final transaction\n", __func__);
                 return state.Invalid(BlockValidationResult::BLOCK_CONSENSUS, "bad-txns-nonfinal");
             }
-
-            if (fAddressIndex || fSpentIndex)
-            {
-                int64_t nTime2_index1 = GetTimeMicros();
-
-                for (size_t j = 0; j < tx.vin.size(); j++) {
-                    const CTxIn input = tx.vin[j];
-                    const Coin& coin = view.AccessCoin(tx.vin[j].prevout);
-                    const CTxOut &prevout = coin.out;
-
-                    AddressType address_type{AddressType::UNKNOWN};
-                    uint160 address_bytes;
-
-                    AddressBytesFromScript(prevout.scriptPubKey, address_type, address_bytes);
-
-                    if (fAddressIndex && address_type != AddressType::UNKNOWN) {
-                        // record spending activity
-                        addressIndex.push_back(std::make_pair(CAddressIndexKey(address_type, address_bytes, pindex->nHeight, i, txhash, j, true), prevout.nValue * -1));
-
-                        // remove address from unspent index
-                        addressUnspentIndex.push_back(std::make_pair(CAddressUnspentKey(address_type, address_bytes, input.prevout.hash, input.prevout.n), CAddressUnspentValue()));
-                    }
-
-                    if (fSpentIndex) {
-                        // add the spent index to determine the txid and input that spent an output
-                        // and to find the amount and address from an input
-                        spentIndex.push_back(std::make_pair(CSpentIndexKey(input.prevout.hash, input.prevout.n), CSpentIndexValue(txhash, j, pindex->nHeight, prevout.nValue, address_type, address_bytes)));
-                    }
-                }
-                nTime2_index += GetTimeMicros() - nTime2_index1;
-            }
         }
 
         // GetTransactionSigOpCount counts 2 types of sigops:
@@ -2549,27 +2429,6 @@ bool CChainState::ConnectBlock(const CBlock& block, BlockValidationState& state,
             control.Add(vChecks);
         }
 
-        if (fAddressIndex) {
-            int64_t nTime2_index2 = GetTimeMicros();
-            for (unsigned int k = 0; k < tx.vout.size(); k++) {
-                const CTxOut &out = tx.vout[k];
-
-                AddressType address_type{AddressType::UNKNOWN};
-                uint160 address_bytes;
-
-                if (!AddressBytesFromScript(out.scriptPubKey, address_type, address_bytes)) {
-                    continue;
-                }
-
-                // record receiving activity
-                addressIndex.push_back(std::make_pair(CAddressIndexKey(address_type, address_bytes, pindex->nHeight, i, txhash, k, false), out.nValue));
-
-                // record unspent output
-                addressUnspentIndex.push_back(std::make_pair(CAddressUnspentKey(address_type, address_bytes, txhash, k), CAddressUnspentValue(out.nValue, out.scriptPubKey, pindex->nHeight)));
-            }
-            nTime2_index += GetTimeMicros() - nTime2_index2;
-        }
-
         CTxUndo undoDummy;
         if (i > 0) {
             blockundo.vtxundo.push_back(CTxUndo());
@@ -2577,8 +2436,6 @@ bool CChainState::ConnectBlock(const CBlock& block, BlockValidationState& state,
         UpdateCoins(tx, view, i == 0 ? undoDummy : blockundo.vtxundo.back(), pindex->nHeight);
     }
 
-    nTimeIndexConnect += nTime2_index;
-    LogPrint(BCLog::BENCHMARK, "        - Connect index: %.2fms [%.2fs (%.2fms/blk)]\n", MILLI * nTime2_index, nTimeIndexConnect * MICRO, nTimeIndexConnect * MILLI / nBlocksTotal);
     int64_t nTime3 = GetTimeMicros(); nTimeConnect += nTime3 - nTime2;
     LogPrint(BCLog::BENCHMARK, "      - Connect %u transactions: %.2fms (%.3fms/tx, %.3fms/txin) [%.2fs (%.2fms/blk)]\n", (unsigned)block.vtx.size(), MILLI * (nTime3 - nTime2), MILLI * (nTime3 - nTime2) / block.vtx.size(), nInputs <= 1 ? 0 : MILLI * (nTime3 - nTime2) / (nInputs-1), nTimeConnect * MICRO, nTimeConnect * MILLI / nBlocksTotal);
 
@@ -2678,24 +2535,6 @@ bool CChainState::ConnectBlock(const CBlock& block, BlockValidationState& state,
         m_blockman.m_dirty_blockindex.insert(pindex);
     }
 
-    if (fAddressIndex) {
-        if (!m_blockman.m_block_tree_db->WriteAddressIndex(addressIndex)) {
-            return AbortNode(state, "Failed to write address index");
-        }
-
-        if (!m_blockman.m_block_tree_db->UpdateAddressUnspentIndex(addressUnspentIndex)) {
-            return AbortNode(state, "Failed to write address unspent index");
-        }
-    }
-
-    if (fSpentIndex)
-        if (!m_blockman.m_block_tree_db->UpdateSpentIndex(spentIndex))
-            return AbortNode(state, "Failed to write transaction index");
-
-    if (fTimestampIndex)
-        if (!m_blockman.m_block_tree_db->WriteTimestampIndex(CTimestampIndexKey(pindex->nTime, pindex->GetBlockHash())))
-            return AbortNode(state, "Failed to write timestamp index");
-
     int64_t nTime8 = GetTimeMicros(); nTimeIndexWrite += nTime8 - nTime7;
     LogPrint(BCLog::BENCHMARK, "      - Index writing: %.2fms [%.2fs (%.2fms/blk)]\n", MILLI * (nTime8 - nTime7), nTimeIndexWrite * MICRO, nTimeIndexWrite * MILLI / nBlocksTotal);
 
@@ -4742,62 +4581,12 @@ bool CChainState::RollforwardBlock(const CBlockIndex* pindex, CCoinsViewCache& i
             pindex->GetBlockHash().ToString(), state.ToString());
     }
 
-    std::vector<CAddressIndexEntry> addressIndex;
-    std::vector<CAddressUnspentIndexEntry> addressUnspentIndex;
     std::vector<CSpentIndexEntry> spentIndex;
 
     for (size_t i = 0; i < block.vtx.size(); i++) {
         const CTransactionRef& tx = block.vtx[i];
-        const uint256 txhash = tx->GetHash();
 
         if (!tx->IsCoinBase()) {
-            // Update indexes
-            if (fAddressIndex || fSpentIndex) {
-                for (size_t j = 0; j < tx->vin.size(); j++) {
-                    const CTxIn input = tx->vin[j];
-                    const Coin& coin = inputs.AccessCoin(tx->vin[j].prevout);
-                    const CTxOut& prevout = coin.out;
-
-                    AddressType address_type{AddressType::UNKNOWN};
-                    uint160 address_bytes;
-
-                    AddressBytesFromScript(prevout.scriptPubKey, address_type, address_bytes);
-
-                    if (fAddressIndex && address_type != AddressType::UNKNOWN) {
-                        // record spending activity
-                        addressIndex.push_back(std::make_pair(CAddressIndexKey(address_type, address_bytes, pindex->nHeight, i, txhash, j, true), prevout.nValue * -1));
-
-                        // remove address from unspent index
-                        addressUnspentIndex.push_back(std::make_pair(CAddressUnspentKey(address_type, address_bytes, input.prevout.hash, input.prevout.n), CAddressUnspentValue()));
-                    }
-
-                    if (fSpentIndex) {
-                        // add the spent index to determine the txid and input that spent an output
-                        // and to find the amount and address from an input
-                        spentIndex.push_back(std::make_pair(CSpentIndexKey(input.prevout.hash, input.prevout.n), CSpentIndexValue(txhash, j, pindex->nHeight, prevout.nValue, address_type, address_bytes)));
-                    }
-                }
-            }
-
-            if (fAddressIndex) {
-                for (size_t k = 0; k < tx->vout.size(); k++) {
-                    const CTxOut& out = tx->vout[k];
-
-                    AddressType address_type{AddressType::UNKNOWN};
-                    uint160 address_bytes;
-
-                    if (!AddressBytesFromScript(out.scriptPubKey, address_type, address_bytes)) {
-                        continue;
-                    }
-
-                    // record receiving activity
-                    addressIndex.push_back(std::make_pair(CAddressIndexKey(address_type, address_bytes, pindex->nHeight, i, txhash, k, false), out.nValue));
-
-                    // record unspent output
-                    addressUnspentIndex.push_back(std::make_pair(CAddressUnspentKey(address_type, address_bytes, txhash, k), CAddressUnspentValue(out.nValue, out.scriptPubKey, pindex->nHeight)));
-                }
-            }
-
             for (const CTxIn &txin : tx->vin) {
                 inputs.SpendCoin(txin.prevout);
             }
@@ -4806,26 +4595,6 @@ bool CChainState::RollforwardBlock(const CBlockIndex* pindex, CCoinsViewCache& i
         AddCoins(inputs, *tx, pindex->nHeight, true);
     }
 
-    if (fAddressIndex) {
-        if (!m_blockman.m_block_tree_db->WriteAddressIndex(addressIndex)) {
-            return error("RollforwardBlock(DASH): Failed to write address index");
-        }
-
-        if (!m_blockman.m_block_tree_db->UpdateAddressUnspentIndex(addressUnspentIndex)) {
-            return error("RollforwardBlock(DASH): Failed to write address unspent index");
-        }
-    }
-
-    if (fSpentIndex) {
-        if (!m_blockman.m_block_tree_db->UpdateSpentIndex(spentIndex))
-            return error("RollforwardBlock(DASH): Failed to write transaction index");
-    }
-
-    if (fTimestampIndex) {
-        if (!m_blockman.m_block_tree_db->WriteTimestampIndex(CTimestampIndexKey(pindex->nTime, pindex->GetBlockHash())))
-            return error("RollforwardBlock(DASH): Failed to write timestamp index");
-    }
-
     return true;
 }
 
@@ -5000,27 +4769,10 @@ bool ChainstateManager::LoadBlockIndex()
         // needs_init.
 
         LogPrintf("Initializing databases...\n");
-        InitAdditionalIndexes();
     }
     return true;
 }
 
-void ChainstateManager::InitAdditionalIndexes()
-{
-    // Use the provided setting for -addressindex in the new database
-    fAddressIndex = gArgs.GetBoolArg("-addressindex", DEFAULT_ADDRESSINDEX);
-    m_blockman.m_block_tree_db->WriteFlag("addressindex", fAddressIndex);
-
-    // Use the provided setting for -timestampindex in the new database
-    fTimestampIndex = gArgs.GetBoolArg("-timestampindex", DEFAULT_TIMESTAMPINDEX);
-    m_blockman.m_block_tree_db->WriteFlag("timestampindex", fTimestampIndex);
-
-    // Use the provided setting for -spentindex in the new database
-    fSpentIndex = gArgs.GetBoolArg("-spentindex", DEFAULT_SPENTINDEX);
-    m_blockman.m_block_tree_db->WriteFlag("spentindex", fSpentIndex);
-
-}
-
 bool CChainState::AddGenesisBlock(const CBlock& block, BlockValidationState& state)
 {
     FlatFilePos blockPos{m_blockman.SaveBlockToDisk(block, 0, m_chain, m_params, nullptr)};
diff --git a/src/zmq/zmqpublishnotifier.cpp b/src/zmq/zmqpublishnotifier.cpp
index 83d43e474212..c84e55b5124b 100644
--- a/src/zmq/zmqpublishnotifier.cpp
+++ b/src/zmq/zmqpublishnotifier.cpp
@@ -18,6 +18,7 @@
 #include <streams.h>
 #include <sync.h>
 #include <uint256.h>
+#include <util/underlying.h>
 #include <version.h>
 #include <zmq/zmqutil.h>
 
diff --git a/test/functional/feature_addressindex.py b/test/functional/feature_addressindex.py
index a059ff9f7a73..93410764218e 100755
--- a/test/functional/feature_addressindex.py
+++ b/test/functional/feature_addressindex.py
@@ -15,7 +15,6 @@
     COIN,
 )
 from test_framework.test_framework import BitcoinTestFramework
-from test_framework.test_node import ErrorMatch
 from test_framework.script_util import (
     keyhash_to_p2pkh_script,
     scripthash_to_p2sh_script,
@@ -47,14 +46,12 @@ def setup_network(self):
         self.import_deterministic_coinbase_privkeys()
 
     def run_test(self):
-        self.log.info("Test that settings can be disabled without -reindex...")
+        self.log.info("Test that settings can be disabled and re-enabled...")
         self.restart_node(1, ["-addressindex=0"])
         self.connect_nodes(0, 1)
         self.sync_all()
-        self.log.info("Test that settings can't be enabled without -reindex...")
-        self.stop_node(1)
-        self.nodes[1].assert_start_raises_init_error(["-addressindex"], "You need to rebuild the database using -reindex to enable -addressindex", match=ErrorMatch.PARTIAL_REGEX)
-        self.start_node(1, ["-addressindex", "-reindex"])
+        # AddressIndex is now async, so it can be enabled without -reindex
+        self.restart_node(1, ["-addressindex"])
         self.connect_nodes(0, 1)
         self.sync_all()
 
diff --git a/test/functional/feature_spentindex.py b/test/functional/feature_spentindex.py
index 17f2b1202754..f9f1ba736277 100755
--- a/test/functional/feature_spentindex.py
+++ b/test/functional/feature_spentindex.py
@@ -4,7 +4,7 @@
 # file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
 #
-# Test addressindex generation and fetching
+# Test spentindex generation and fetching
 #
 
 from decimal import Decimal
@@ -19,7 +19,6 @@
 from test_framework.script_util import (
     keyhash_to_p2pkh_script,
 )
-from test_framework.test_node import ErrorMatch
 from test_framework.test_framework import BitcoinTestFramework
 from test_framework.util import assert_equal
 
@@ -48,14 +47,12 @@ def setup_network(self):
         self.import_deterministic_coinbase_privkeys()
 
     def run_test(self):
-        self.log.info("Test that settings can be disabled without -reindex...")
+        self.log.info("Test that settings can be disabled and re-enabled...")
         self.restart_node(1, ["-spentindex=0"])
         self.connect_nodes(0, 1)
         self.sync_all()
-        self.log.info("Test that settings can't be enabled without -reindex...")
-        self.stop_node(1)
-        self.nodes[1].assert_start_raises_init_error(["-spentindex"], "You need to rebuild the database using -reindex to enable -spentindex", match=ErrorMatch.PARTIAL_REGEX)
-        self.start_node(1, ["-spentindex", "-reindex"])
+        # SpentIndex is now async, so it can be enabled without -reindex
+        self.restart_node(1, ["-spentindex"])
         self.connect_nodes(0, 1)
         self.sync_all()
 
@@ -124,6 +121,14 @@ def run_test(self):
         assert_equal(txVerbose3["vin"][0]["value"], Decimal(unspent[0]["amount"]) - tx_fee)
         assert_equal(txVerbose3["vin"][0]["valueSat"], amount)
 
+        self.log.info("Testing getspentinfo with mempool data...")
+        # Check that getspentinfo returns mempool spend info for unconfirmed transactions
+        # The output from txid is now spent by txid2 (which is in mempool, not yet mined)
+        info_mempool = self.nodes[1].getspentinfo({"txid": txid, "index": 0})
+        assert_equal(info_mempool["txid"], txid2)
+        assert_equal(info_mempool["index"], 0)
+        assert_equal(info_mempool["height"], -1)  # Height -1 indicates mempool transaction
+
         # Check the database index
         self.generate(self.nodes[0], 1)
 
@@ -132,6 +137,36 @@ def run_test(self):
         assert_equal(txVerbose4["vin"][0]["value"], Decimal(unspent[0]["amount"]) - tx_fee)
         assert_equal(txVerbose4["vin"][0]["valueSat"], amount)
 
+        self.log.info("Testing reorg handling...")
+        # Get the block hash containing txid
+        block_hash = self.nodes[1].getblockhash(106)
+
+        # Verify spent info exists before reorg
+        info_before = self.nodes[1].getspentinfo({"txid": unspent[0]["txid"], "index": unspent[0]["vout"]})
+        assert_equal(info_before["txid"], txid)
+
+        # Invalidate the block containing the spending transaction on all nodes
+        for node in self.nodes:
+            node.invalidateblock(block_hash)
+
+        # After invalidation, transactions go back to mempool
+        # getspentinfo should still find the spend in mempool with height -1
+        info_after_invalidate = self.nodes[1].getspentinfo({"txid": unspent[0]["txid"], "index": unspent[0]["vout"]})
+        assert_equal(info_after_invalidate["txid"], txid)
+        assert_equal(info_after_invalidate["index"], 0)
+        assert_equal(info_after_invalidate["height"], -1)  # Now in mempool
+
+        # Reconsider the block on all nodes
+        for node in self.nodes:
+            node.reconsiderblock(block_hash)
+        self.sync_all()
+
+        # Verify spent info is back after reconsider
+        info_after = self.nodes[1].getspentinfo({"txid": unspent[0]["txid"], "index": unspent[0]["vout"]})
+        assert_equal(info_after["txid"], txid)
+        assert_equal(info_after["index"], 0)
+        assert_equal(info_after["height"], 106)
+
         self.log.info("Passed")
 
 
diff --git a/test/functional/feature_timestampindex.py b/test/functional/feature_timestampindex.py
index 76b188b8cd1f..14111a7e4719 100755
--- a/test/functional/feature_timestampindex.py
+++ b/test/functional/feature_timestampindex.py
@@ -8,7 +8,6 @@
 #
 
 from test_framework.test_framework import BitcoinTestFramework
-from test_framework.test_node import ErrorMatch
 from test_framework.util import assert_equal
 
 
@@ -16,43 +15,61 @@ class TimestampIndexTest(BitcoinTestFramework):
 
     def set_test_params(self):
         self.setup_clean_chain = True
-        self.num_nodes = 4
+        self.num_nodes = 2
 
     def setup_network(self):
         self.add_nodes(self.num_nodes)
-        # Nodes 0/1 are "wallet" nodes
         self.start_node(0)
         self.start_node(1, ["-timestampindex"])
-        # Nodes 2/3 are used for testing
-        self.start_node(2)
-        self.start_node(3, ["-timestampindex"])
         self.connect_nodes(0, 1)
-        self.connect_nodes(0, 2)
-        self.connect_nodes(0, 3)
-
-        self.sync_all()
 
     def run_test(self):
         self.log.info("Test that settings can be disabled without -reindex...")
-        self.restart_node(1, ["-timestampindex=0"])
+        self.generate(self.nodes[0], 1)
+        self.stop_node(1)
+        self.generate(self.nodes[0], 1, sync_fun=self.no_op)
+        self.start_node(1, ["-timestampindex=0"])
         self.connect_nodes(0, 1)
         self.sync_all()
-        self.log.info("Test that settings can't be enabled without -reindex...")
+
+        self.log.info("Test that settings can be enabled without -reindex...")
         self.stop_node(1)
-        self.nodes[1].assert_start_raises_init_error(["-timestampindex"], "You need to rebuild the database using -reindex to enable -timestampindex", match=ErrorMatch.PARTIAL_REGEX)
-        self.start_node(1, ["-timestampindex", "-reindex"])
+        self.generate(self.nodes[0], 1, sync_fun=self.no_op)
+        self.start_node(1, ["-timestampindex"])
         self.connect_nodes(0, 1)
         self.sync_all()
 
-        self.log.info("Mining 5 blocks...")
-        blockhashes = self.generate(self.nodes[0], 5)
+        self.log.info("Check timestamp index via getblockhashes rpc")
+        blockhashes = []
+        for _ in range(5):
+            self.bump_mocktime(1)
+            blockhashes += self.generate(self.nodes[0], 1)
         low = self.nodes[0].getblock(blockhashes[0])["time"]
         high = self.nodes[0].getblock(blockhashes[4])["time"]
-        self.log.info("Checking timestamp index...")
+        self.bump_mocktime(1)
         hashes = self.nodes[1].getblockhashes(high, low)
         assert_equal(len(hashes), 5)
         assert_equal(sorted(blockhashes), sorted(hashes))
-        self.log.info("Passed")
+
+        self.log.info("Testing reorg handling...")
+        # Invalidate the last 2 blocks on both nodes
+        self.nodes[0].invalidateblock(blockhashes[3])
+        self.nodes[1].invalidateblock(blockhashes[3])
+
+        # Verify that invalidated blocks are no longer in the index
+        hashes_after_invalidate = self.nodes[1].getblockhashes(high, low)
+        assert_equal(len(hashes_after_invalidate), 3)
+        assert_equal(sorted(hashes_after_invalidate), sorted(blockhashes[:3]))
+
+        # Reconsider the blocks on both nodes
+        self.nodes[0].reconsiderblock(blockhashes[3])
+        self.nodes[1].reconsiderblock(blockhashes[3])
+        self.sync_all()
+
+        # Verify all blocks are back in the index
+        hashes_after_reconsider = self.nodes[1].getblockhashes(high, low)
+        assert_equal(len(hashes_after_reconsider), 5)
+        assert_equal(sorted(hashes_after_reconsider), sorted(blockhashes))
 
 
 if __name__ == '__main__':
diff --git a/test/functional/rpc_misc.py b/test/functional/rpc_misc.py
index e3f706edcf89..be0b24193858 100755
--- a/test/functional/rpc_misc.py
+++ b/test/functional/rpc_misc.py
@@ -86,7 +86,8 @@ def run_test(self):
         assert_equal(node.getindexinfo(), {})
 
         # Restart the node with indices and wait for them to sync
-        self.restart_node(0, ["-txindex", "-blockfilterindex", "-coinstatsindex"])
+        self.restart_node(0, ["-txindex", "-blockfilterindex", "-coinstatsindex",
+                              "-addressindex", "-timestampindex", "-spentindex"])
         self.wait_until(lambda: all(i["synced"] for i in node.getindexinfo().values()))
 
         # Returns a list of all running indices by default
@@ -97,10 +98,14 @@ def run_test(self):
                 "txindex": values,
                 "basic block filter index": values,
                 "coinstatsindex": values,
+                "addressindex": values,
+                "timestampindex": values,
+                "spentindex": values,
             }
         )
         # Specifying an index by name returns only the status of that index
-        for i in {"txindex", "basic block filter index", "coinstatsindex"}:
+        for i in {"txindex", "basic block filter index", "coinstatsindex",
+                  "addressindex", "timestampindex", "spentindex"}:
             assert_equal(node.getindexinfo(i), {i: values})
 
         # Specifying an unknown index name returns an empty result
diff --git a/test/util/data/non-backported.txt b/test/util/data/non-backported.txt
index a33f92fa6a74..5fd05d5d7e84 100644
--- a/test/util/data/non-backported.txt
+++ b/test/util/data/non-backported.txt
@@ -18,6 +18,12 @@ src/evo/*.cpp
 src/evo/*.h
 src/governance/*.cpp
 src/governance/*.h
+src/index/addres*.cpp
+src/index/addres*.h
+src/index/spent*.cpp
+src/index/spent*.h
+src/index/timestamp*.cpp
+src/index/timestamp*.h
 src/instantsend/*.cpp
 src/instantsend/*.h
 src/llmq/*.cpp