diff --git a/doc/release-notes-6825.md b/doc/release-notes-6825.md
new file mode 100644
index 0000000000000..a21eb6cc35faa
--- /dev/null
+++ b/doc/release-notes-6825.md
@@ -0,0 +1,19 @@
+# Breaking Change: Block Filter Index Format Update
+
+## Summary
+The compact block filter index format has been updated to include Dash special transaction data, providing feature parity with bloom filters for SPV client support. This change is **incompatible** with existing blockfilter indexes. Existing blockfilter indexes will automatically be re-created with the new version.
+
+## Technical Details
+- The blockfilter index now includes fields from Dash special transactions:
+  - ProRegTx (masternode registration)
+  - ProUpServTx (masternode service updates)
+  - ProUpRegTx (masternode operator updates)
+  - ProUpRevTx (masternode revocation)
+  - AssetLockTx (platform credit outputs)
+- A versioning system has been added to detect incompatible indexes on startup
+- The index version is now 2 (previously unversioned)
+
+## Benefits
+- SPV clients can now detect and track Dash-specific transactions
+- Feature parity between bloom filters and compact block filters
+- Protection against serving incorrect filter data to light clients
diff --git a/src/Makefile.am b/src/Makefile.am
index 18c318829dc59..45c98edb9a8f8 100644
--- a/src/Makefile.am
+++ b/src/Makefile.am
@@ -200,6 +200,7 @@ BITCOIN_CORE_H = \
   evo/simplifiedmns.h \
   evo/smldiff.h \
   evo/specialtx.h \
+  evo/specialtx_filter.h \
   evo/specialtxman.h \
   dsnotificationinterface.h \
   governance/governance.h \
@@ -479,6 +480,7 @@ libbitcoin_node_a_SOURCES = \
   evo/simplifiedmns.cpp \
   evo/smldiff.cpp \
   evo/specialtx.cpp \
+  evo/specialtx_filter.cpp \
   evo/specialtxman.cpp \
   flatfile.cpp \
   governance/classes.cpp \
diff --git a/src/blockfilter.cpp b/src/blockfilter.cpp
index e58c4c2110ed9..f4638dabcc0d1 100644
--- a/src/blockfilter.cpp
+++ b/src/blockfilter.cpp
@@ -7,6 +7,7 @@
 
 #include <blockfilter.h>
 #include <crypto/siphash.h>
+#include <evo/specialtx_filter.h>
 #include <hash.h>
 #include <primitives/transaction.h>
 #include <script/script.h>
@@ -195,6 +196,11 @@ static GCSFilter::ElementSet BasicFilterElements(const CBlock& block,
             if (script.empty() || script[0] == OP_RETURN) continue;
             elements.emplace(script.begin(), script.end());
         }
+
+        // Extract special transaction elements using delegation pattern
+        ExtractSpecialTxFilterElements(*tx, [&elements](Span<const unsigned char> data) {
+            elements.emplace(data.begin(), data.end());
+        });
     }
 
     for (const CTxUndo& tx_undo : block_undo.vtxundo) {
diff --git a/src/common/bloom.cpp b/src/common/bloom.cpp
index cc876beffa72a..9d39f35c12e3c 100644
--- a/src/common/bloom.cpp
+++ b/src/common/bloom.cpp
@@ -119,6 +119,11 @@ bool CBloomFilter::CheckScript(const CScript &script) const
 // Filter is updated only if it has BLOOM_UPDATE_ALL flag to be able to have
 // simple SPV wallets that doesn't work with DIP2 transactions (multicoin
 // wallets, etc.)
+// NOTE(maintenance): Keep this implementation in sync with
+// ExtractSpecialTxFilterElements in src/evo/specialtx_filter.cpp.
+// Both routines must handle the same set of special-transaction fields.
+// If you modify one, update the other to prevent mismatches between
+// bloom filter relevance and compact filter element extraction.
 bool CBloomFilter::CheckSpecialTransactionMatchesAndUpdate(const CTransaction &tx)
 {
     if (!tx.HasExtraPayloadField()) {
diff --git a/src/evo/assetlocktx.cpp b/src/evo/assetlocktx.cpp
index 3ab20f04e0bf9..62a4ef259ad62 100644
--- a/src/evo/assetlocktx.cpp
+++ b/src/evo/assetlocktx.cpp
@@ -6,7 +6,6 @@
 #include <evo/specialtx.h>
 
 #include <llmq/commitment.h>
-#include <llmq/signing.h>
 #include <llmq/quorums.h>
 
 #include <chainparams.h>
@@ -22,6 +21,11 @@
 
 using node::BlockManager;
 
+namespace llmq {
+// forward declaration to avoid circular dependency
+uint256 BuildSignHash(Consensus::LLMQType llmqType, const uint256& quorumHash, const uint256& id, const uint256& msgHash);
+} // namespace llmq
+
 /**
  *  Common code for Asset Lock and Asset Unlock
  */
diff --git a/src/evo/specialtx_filter.cpp b/src/evo/specialtx_filter.cpp
new file mode 100644
index 0000000000000..b61173dc7587e
--- /dev/null
+++ b/src/evo/specialtx_filter.cpp
@@ -0,0 +1,132 @@
+// 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 <evo/specialtx_filter.h>
+
+#include <evo/assetlocktx.h>
+#include <evo/providertx.h>
+#include <evo/specialtx.h>
+#include <primitives/transaction.h>
+#include <script/script.h>
+#include <span.h>
+#include <streams.h>
+
+/**
+ * Rationale for Special Transaction Field Extraction:
+ *
+ * This implementation extracts specific fields from Dash special transactions
+ * to maintain parity with the bloom filter implementation (CBloomFilter::CheckSpecialTransactionMatchesAndUpdate).
+ *
+ * The fields extracted are those that SPV clients might need to detect:
+ * - Owner/Voting keys: To track masternode ownership and voting rights
+ * - Payout scripts: To detect payments to specific addresses
+ * - ProTx hashes: To track masternode lifecycle and updates
+ * - Collateral outpoints: To track masternode collateral
+ * - Credit outputs: To track platform-related transactions
+ *
+ * Each transaction type has different fields based on its purpose:
+ * - ProRegTx: All identity and payout fields (initial registration)
+ * - ProUpServTx: ProTx hash and operator payout (service updates)
+ * - ProUpRegTx: ProTx hash, voting key, and payout (ownership updates)
+ * - ProUpRevTx: ProTx hash only (revocation tracking)
+ * - AssetLockTx: Credit output scripts (platform credits)
+ */
+// Helper function to add a script to the filter if it's not empty
+static void AddScriptElement(const CScript& script, const std::function<void(Span<const unsigned char>)>& addElement)
+{
+    if (!script.empty()) {
+        addElement(MakeUCharSpan(script));
+    }
+}
+
+// Helper function to add a hash/key to the filter
+template <typename T>
+static void AddHashElement(const T& hash, const std::function<void(Span<const unsigned char>)>& addElement)
+{
+    addElement(MakeUCharSpan(hash));
+}
+
+// NOTE(maintenance): Keep this in sync with
+// CBloomFilter::CheckSpecialTransactionMatchesAndUpdate in
+// src/common/bloom.cpp. If you add or remove fields for a special
+// transaction type here, update the bloom filter routine accordingly
+// (and vice versa) to avoid compact-filter vs bloom-filter divergence.
+void ExtractSpecialTxFilterElements(const CTransaction& tx, const std::function<void(Span<const unsigned char>)>& addElement)
+{
+    if (!tx.HasExtraPayloadField()) {
+        return; // not a special transaction
+    }
+
+    switch (tx.nType) {
+    case TRANSACTION_PROVIDER_REGISTER: {
+        if (const auto opt_proTx = GetTxPayload<CProRegTx>(tx)) {
+            // Add collateral outpoint
+            CDataStream stream(SER_NETWORK, PROTOCOL_VERSION);
+            stream << opt_proTx->collateralOutpoint;
+            addElement(MakeUCharSpan(stream));
+
+            // Add owner key ID
+            AddHashElement(opt_proTx->keyIDOwner, addElement);
+
+            // Add voting key ID
+            AddHashElement(opt_proTx->keyIDVoting, addElement);
+
+            // Add payout script
+            AddScriptElement(opt_proTx->scriptPayout, addElement);
+        }
+        break;
+    }
+    case TRANSACTION_PROVIDER_UPDATE_SERVICE: {
+        if (const auto opt_proTx = GetTxPayload<CProUpServTx>(tx)) {
+            // Add ProTx hash
+            AddHashElement(opt_proTx->proTxHash, addElement);
+
+            // Add operator payout script
+            AddScriptElement(opt_proTx->scriptOperatorPayout, addElement);
+        }
+        break;
+    }
+    case TRANSACTION_PROVIDER_UPDATE_REGISTRAR: {
+        if (const auto opt_proTx = GetTxPayload<CProUpRegTx>(tx)) {
+            // Add ProTx hash
+            AddHashElement(opt_proTx->proTxHash, addElement);
+
+            // Add voting key ID
+            AddHashElement(opt_proTx->keyIDVoting, addElement);
+
+            // Add payout script
+            AddScriptElement(opt_proTx->scriptPayout, addElement);
+        }
+        break;
+    }
+    case TRANSACTION_PROVIDER_UPDATE_REVOKE: {
+        if (const auto opt_proTx = GetTxPayload<CProUpRevTx>(tx)) {
+            // Add ProTx hash
+            AddHashElement(opt_proTx->proTxHash, addElement);
+        }
+        break;
+    }
+    case TRANSACTION_ASSET_LOCK: {
+        // Asset Lock transactions have special outputs (creditOutputs) that should be included
+        if (const auto opt_assetlockTx = GetTxPayload<CAssetLockPayload>(tx)) {
+            const auto& extraOuts = opt_assetlockTx->getCreditOutputs();
+            for (const CTxOut& txout : extraOuts) {
+                const CScript& script = txout.scriptPubKey;
+                // Exclude OP_RETURN outputs as they are not spendable
+                if (!script.empty() && script[0] != OP_RETURN) {
+                    AddScriptElement(script, addElement);
+                }
+            }
+        }
+        break;
+    }
+    case TRANSACTION_ASSET_UNLOCK:
+    case TRANSACTION_COINBASE:
+    case TRANSACTION_QUORUM_COMMITMENT:
+    case TRANSACTION_MNHF_SIGNAL:
+        // No additional special fields needed for these transaction types
+        // Their standard outputs are already included in the base filter
+        break;
+    } // no default case, so the compiler can warn about missing cases
+}
diff --git a/src/evo/specialtx_filter.h b/src/evo/specialtx_filter.h
new file mode 100644
index 0000000000000..a706a6b1b6dbc
--- /dev/null
+++ b/src/evo/specialtx_filter.h
@@ -0,0 +1,26 @@
+// 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.
+
+#ifndef BITCOIN_EVO_SPECIALTX_FILTER_H
+#define BITCOIN_EVO_SPECIALTX_FILTER_H
+
+#include <functional>
+#include <span.h>
+
+class CTransaction;
+
+/**
+ * Extract filterable elements from special transactions for use in compact block filters.
+ * This function extracts the same fields that are included in bloom filters to ensure
+ * SPV clients can detect special transactions using either filtering mechanism.
+ *
+ * @param tx The transaction to extract elements from
+ * @param addElement Callback to add extracted elements to the filter. Uses
+ *                   Span<const unsigned char> to avoid intermediate
+ *                   allocations.
+ */
+void ExtractSpecialTxFilterElements(const CTransaction& tx,
+                                    const std::function<void(Span<const unsigned char>)>& addElement);
+
+#endif // BITCOIN_EVO_SPECIALTX_FILTER_H
diff --git a/src/index/blockfilterindex.cpp b/src/index/blockfilterindex.cpp
index f21b8afe4b438..c0cf84e512850 100644
--- a/src/index/blockfilterindex.cpp
+++ b/src/index/blockfilterindex.cpp
@@ -30,6 +30,7 @@ using node::UndoReadFromDisk;
 constexpr uint8_t DB_BLOCK_HASH{'s'};
 constexpr uint8_t DB_BLOCK_HEIGHT{'t'};
 constexpr uint8_t DB_FILTER_POS{'P'};
+constexpr uint8_t DB_VERSION{'V'};
 
 constexpr unsigned int MAX_FLTR_FILE_SIZE = 0x1000000; // 16 MiB
 /** The pre-allocation chunk size for fltr?????.dat files */
@@ -111,11 +112,34 @@ BlockFilterIndex::BlockFilterIndex(BlockFilterType filter_type,
 
     m_name = filter_name + " block filter index";
     m_db = std::make_unique<BaseIndex::DB>(path / "db", n_cache_size, f_memory, f_wipe);
+
+    // Check version
+    int version = 0;
+    if (!m_db->Read(DB_VERSION, version) || version < CURRENT_VERSION) {
+        // No version or too old version means we need to start from scratch
+        LogPrintf("%s: Outdated or no version blockfilter, starting from scratch\n", __func__);
+        m_db.reset();
+        m_db = std::make_unique<BaseIndex::DB>(path / "db", n_cache_size, f_memory, /*f_wipe=*/true);
+        m_db->Write(DB_VERSION, CURRENT_VERSION);
+    }
+
     m_filter_fileseq = std::make_unique<FlatFileSeq>(std::move(path), "fltr", FLTR_FILE_CHUNK_SIZE);
 }
 
 bool BlockFilterIndex::Init()
 {
+    // Check version compatibility first
+    int version = 0;
+    if (m_db->Exists(DB_VERSION)) {
+        if (!m_db->Read(DB_VERSION, version)) {
+            return error("%s: Failed to read %s index version from database", __func__, GetName());
+        }
+        if (version > CURRENT_VERSION) {
+            return error("%s: %s index version %d is too high (expected <= %d)",
+                        __func__, GetName(), version, CURRENT_VERSION);
+        }
+    }
+
     if (!m_db->Read(DB_FILTER_POS, m_next_filter_pos)) {
         // Check that the cause of the read failure is that the key does not exist. Any other errors
         // indicate database corruption or a disk failure, and starting the index would cause
@@ -136,6 +160,11 @@ bool BlockFilterIndex::CommitInternal(CDBBatch& batch)
 {
     const FlatFilePos& pos = m_next_filter_pos;
 
+    // Write the current version if this is a new index
+    if (!m_db->Exists(DB_VERSION)) {
+        batch.Write(DB_VERSION, CURRENT_VERSION);
+    }
+
     // Flush current filter file to disk.
     CAutoFile file(m_filter_fileseq->Open(pos), SER_DISK, CLIENT_VERSION);
     if (file.IsNull()) {
diff --git a/src/index/blockfilterindex.h b/src/index/blockfilterindex.h
index baabeb2d30575..e9316c5ca3373 100644
--- a/src/index/blockfilterindex.h
+++ b/src/index/blockfilterindex.h
@@ -25,6 +25,9 @@ static constexpr int CFCHECKPT_INTERVAL = 1000;
 class BlockFilterIndex final : public BaseIndex
 {
 private:
+    /** Version of the blockfilter index format. Increment this when breaking changes are made. */
+    static constexpr int CURRENT_VERSION = 2;
+
     BlockFilterType m_filter_type;
     std::string m_name;
     std::unique_ptr<BaseIndex::DB> m_db;
diff --git a/src/test/blockfilter_tests.cpp b/src/test/blockfilter_tests.cpp
index 3b16f36058ede..54ab568e7d3a0 100644
--- a/src/test/blockfilter_tests.cpp
+++ b/src/test/blockfilter_tests.cpp
@@ -7,7 +7,14 @@
 
 #include <blockfilter.h>
 #include <core_io.h>
+#include <evo/assetlocktx.h>
+#include <evo/netinfo.h>
+#include <evo/providertx.h>
+#include <evo/specialtx.h>
+#include <netaddress.h>
+#include <netbase.h>
 #include <serialize.h>
+#include <span.h>
 #include <streams.h>
 #include <univalue.h>
 #include <util/strencodings.h>
@@ -191,4 +198,248 @@ BOOST_AUTO_TEST_CASE(blockfilter_type_names)
     BOOST_CHECK(!BlockFilterTypeByName("unknown", filter_type));
 }
 
+BOOST_AUTO_TEST_CASE(blockfilter_special_transactions_test)
+{
+    // Test that special transaction fields are properly included in block filters
+    // This ensures parity with bloom filter functionality
+
+    // Test 1: ProRegTx (Provider Registration Transaction)
+    CMutableTransaction protx;
+    protx.nVersion = 3;
+    protx.nType = TRANSACTION_PROVIDER_REGISTER;
+
+    CProRegTx proRegPayload;
+    proRegPayload.nVersion = 1;
+    proRegPayload.nType = MnType::Regular;
+    proRegPayload.nMode = 0;
+    proRegPayload.collateralOutpoint = COutPoint(uint256S("1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef"), 0);
+
+    // Set up network info (required for serialization)
+    proRegPayload.netInfo = NetInfoInterface::MakeNetInfo(1);  // Version 1
+
+    proRegPayload.keyIDOwner = CKeyID(uint160(ParseHex("1111111111111111111111111111111111111111")));
+    proRegPayload.keyIDVoting = CKeyID(uint160(ParseHex("2222222222222222222222222222222222222222")));
+
+    // Generate a valid BLS key
+    CBLSSecretKey blsKey;
+    blsKey.MakeNewKey();
+    proRegPayload.pubKeyOperator.Set(blsKey.GetPublicKey(), false);
+    proRegPayload.inputsHash = uint256();  // Empty inputs hash
+
+    // Create payout script
+    CScript payoutScript = CScript() << OP_DUP << OP_HASH160 << ToByteVector(ParseHex("3333333333333333333333333333333333333333")) << OP_EQUALVERIFY << OP_CHECKSIG;
+    proRegPayload.scriptPayout = payoutScript;
+
+    SetTxPayload(protx, proRegPayload);
+
+    // Test 2: ProUpServTx (Provider Update Service Transaction)
+    CMutableTransaction proupservtx;
+    proupservtx.nVersion = 3;
+    proupservtx.nType = TRANSACTION_PROVIDER_UPDATE_SERVICE;
+
+    CProUpServTx proUpServPayload;
+    proUpServPayload.nVersion = 1;
+    proUpServPayload.proTxHash = uint256S("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa");
+    proUpServPayload.netInfo = NetInfoInterface::MakeNetInfo(1);
+    CScript operatorPayoutScript = CScript() << OP_DUP << OP_HASH160 << ToByteVector(ParseHex("5555555555555555555555555555555555555555")) << OP_EQUALVERIFY << OP_CHECKSIG;
+    proUpServPayload.scriptOperatorPayout = operatorPayoutScript;
+    proUpServPayload.inputsHash = uint256();
+
+    SetTxPayload(proupservtx, proUpServPayload);
+
+    // Test 3: ProUpRegTx (Provider Update Registrar Transaction)
+    CMutableTransaction proupregtx;
+    proupregtx.nVersion = 3;
+    proupregtx.nType = TRANSACTION_PROVIDER_UPDATE_REGISTRAR;
+
+    CProUpRegTx proUpRegPayload;
+    proUpRegPayload.nVersion = 1;
+    proUpRegPayload.proTxHash = uint256S("bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb");
+    proUpRegPayload.nMode = 0;
+    proUpRegPayload.pubKeyOperator.Set(blsKey.GetPublicKey(), false);
+    proUpRegPayload.keyIDVoting = CKeyID(uint160(ParseHex("6666666666666666666666666666666666666666")));
+    CScript newPayoutScript = CScript() << OP_DUP << OP_HASH160 << ToByteVector(ParseHex("7777777777777777777777777777777777777777")) << OP_EQUALVERIFY << OP_CHECKSIG;
+    proUpRegPayload.scriptPayout = newPayoutScript;
+    proUpRegPayload.inputsHash = uint256();
+
+    SetTxPayload(proupregtx, proUpRegPayload);
+
+    // Test 4: ProUpRevTx (Provider Update Revoke Transaction)
+    CMutableTransaction prouprevtx;
+    prouprevtx.nVersion = 3;
+    prouprevtx.nType = TRANSACTION_PROVIDER_UPDATE_REVOKE;
+
+    CProUpRevTx proUpRevPayload;
+    proUpRevPayload.nVersion = 1;
+    proUpRevPayload.proTxHash = uint256S("cccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc");
+    proUpRevPayload.nReason = 1;
+    proUpRevPayload.inputsHash = uint256();
+
+    SetTxPayload(prouprevtx, proUpRevPayload);
+
+    // Test 5: AssetLockTx
+    CMutableTransaction assetlockTx;
+    assetlockTx.nVersion = 3;
+    assetlockTx.nType = TRANSACTION_ASSET_LOCK;
+
+    CAssetLockPayload assetLockPayload;
+    CScript creditScript = CScript() << OP_DUP << OP_HASH160 << ToByteVector(ParseHex("4444444444444444444444444444444444444444")) << OP_EQUALVERIFY << OP_CHECKSIG;
+    CTxOut creditOut(1000, creditScript);
+    std::vector<CTxOut> creditOutputs = {creditOut};
+    assetLockPayload = CAssetLockPayload(creditOutputs);
+
+    SetTxPayload(assetlockTx, assetLockPayload);
+
+    // Create block with all special transactions
+    CBlock block;
+    block.vtx.push_back(MakeTransactionRef(protx));
+    block.vtx.push_back(MakeTransactionRef(proupservtx));
+    block.vtx.push_back(MakeTransactionRef(proupregtx));
+    block.vtx.push_back(MakeTransactionRef(prouprevtx));
+    block.vtx.push_back(MakeTransactionRef(assetlockTx));
+
+    // Create minimal block undo
+    CBlockUndo block_undo;
+    for (size_t i = 0; i < block.vtx.size(); i++) {
+        block_undo.vtxundo.emplace_back();
+    }
+
+    // Create block filter
+    BlockFilter block_filter(BlockFilterType::BASIC_FILTER, block, block_undo);
+    const GCSFilter& filter = block_filter.GetFilter();
+
+    // Test ProRegTx fields
+    // collateralOutpoint
+    CDataStream outpointStream(SER_NETWORK, PROTOCOL_VERSION);
+    outpointStream << proRegPayload.collateralOutpoint;
+    auto outpointSpan = MakeUCharSpan(outpointStream);
+    BOOST_CHECK(filter.Match(GCSFilter::Element(outpointSpan.begin(), outpointSpan.end())));
+
+    // keyIDOwner
+    BOOST_CHECK(filter.Match(GCSFilter::Element(proRegPayload.keyIDOwner.begin(), proRegPayload.keyIDOwner.end())));
+
+    // keyIDVoting
+    BOOST_CHECK(filter.Match(GCSFilter::Element(proRegPayload.keyIDVoting.begin(), proRegPayload.keyIDVoting.end())));
+
+    // scriptPayout
+    BOOST_CHECK(filter.Match(GCSFilter::Element(payoutScript.begin(), payoutScript.end())));
+
+    // Test ProUpServTx fields
+    // proTxHash
+    BOOST_CHECK(filter.Match(GCSFilter::Element(proUpServPayload.proTxHash.begin(), proUpServPayload.proTxHash.end())));
+
+    // scriptOperatorPayout
+    BOOST_CHECK(filter.Match(GCSFilter::Element(operatorPayoutScript.begin(), operatorPayoutScript.end())));
+
+    // Test ProUpRegTx fields
+    // proTxHash
+    BOOST_CHECK(filter.Match(GCSFilter::Element(proUpRegPayload.proTxHash.begin(), proUpRegPayload.proTxHash.end())));
+
+    // keyIDVoting
+    BOOST_CHECK(filter.Match(GCSFilter::Element(proUpRegPayload.keyIDVoting.begin(), proUpRegPayload.keyIDVoting.end())));
+
+    // scriptPayout
+    BOOST_CHECK(filter.Match(GCSFilter::Element(newPayoutScript.begin(), newPayoutScript.end())));
+
+    // Test ProUpRevTx fields
+    // proTxHash
+    BOOST_CHECK(filter.Match(GCSFilter::Element(proUpRevPayload.proTxHash.begin(), proUpRevPayload.proTxHash.end())));
+
+    // Test AssetLock creditOutputs script
+    BOOST_CHECK(filter.Match(GCSFilter::Element(creditScript.begin(), creditScript.end())));
+
+    // Check that unrelated data is not in the filter
+    CKeyID unrelatedKey(uint160(ParseHex("9999999999999999999999999999999999999999")));
+    BOOST_CHECK(!filter.Match(GCSFilter::Element(unrelatedKey.begin(), unrelatedKey.end())));
+}
+
+BOOST_AUTO_TEST_CASE(blockfilter_special_transactions_edge_cases)
+{
+    // Test edge cases for special transaction filtering
+
+    // Test 1: Empty scripts should be handled gracefully
+    CMutableTransaction protx_empty;
+    protx_empty.nVersion = 3;
+    protx_empty.nType = TRANSACTION_PROVIDER_REGISTER;
+
+    CProRegTx proRegPayload_empty;
+    proRegPayload_empty.nVersion = 1;
+    proRegPayload_empty.nType = MnType::Regular;
+    proRegPayload_empty.nMode = 0;
+    proRegPayload_empty.collateralOutpoint = COutPoint(uint256S("1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef"), 0);
+    proRegPayload_empty.netInfo = NetInfoInterface::MakeNetInfo(1);
+    proRegPayload_empty.keyIDOwner = CKeyID(uint160(ParseHex("1111111111111111111111111111111111111111")));
+    proRegPayload_empty.keyIDVoting = CKeyID(uint160(ParseHex("2222222222222222222222222222222222222222")));
+
+    CBLSSecretKey blsKey;
+    blsKey.MakeNewKey();
+    proRegPayload_empty.pubKeyOperator.Set(blsKey.GetPublicKey(), false);
+    proRegPayload_empty.inputsHash = uint256();
+
+    // Empty payout script
+    proRegPayload_empty.scriptPayout = CScript();
+
+    SetTxPayload(protx_empty, proRegPayload_empty);
+
+    // Test 2: AssetLock with OP_RETURN output (should be excluded)
+    CMutableTransaction assetlock_opreturn;
+    assetlock_opreturn.nVersion = 3;
+    assetlock_opreturn.nType = TRANSACTION_ASSET_LOCK;
+
+    CAssetLockPayload assetLockPayload_opreturn;
+    CScript opReturnScript = CScript() << OP_RETURN << ToByteVector(ParseHex("deadbeef"));
+    CScript normalScript = CScript() << OP_DUP << OP_HASH160 << ToByteVector(ParseHex("8888888888888888888888888888888888888888")) << OP_EQUALVERIFY << OP_CHECKSIG;
+
+    CTxOut opReturnOut(0, opReturnScript);
+    CTxOut normalOut(1000, normalScript);
+    std::vector<CTxOut> mixedOutputs = {opReturnOut, normalOut};
+    assetLockPayload_opreturn = CAssetLockPayload(mixedOutputs);
+
+    SetTxPayload(assetlock_opreturn, assetLockPayload_opreturn);
+
+    // Test 3: ProUpServTx with empty operator payout script
+    CMutableTransaction proupserv_empty;
+    proupserv_empty.nVersion = 3;
+    proupserv_empty.nType = TRANSACTION_PROVIDER_UPDATE_SERVICE;
+
+    CProUpServTx proUpServPayload_empty;
+    proUpServPayload_empty.nVersion = 1;
+    proUpServPayload_empty.proTxHash = uint256S("dddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddd");
+    proUpServPayload_empty.netInfo = NetInfoInterface::MakeNetInfo(1);
+    proUpServPayload_empty.scriptOperatorPayout = CScript();  // Empty script
+    proUpServPayload_empty.inputsHash = uint256();
+
+    SetTxPayload(proupserv_empty, proUpServPayload_empty);
+
+    // Create block with edge case transactions
+    CBlock block;
+    block.vtx.push_back(MakeTransactionRef(protx_empty));
+    block.vtx.push_back(MakeTransactionRef(assetlock_opreturn));
+    block.vtx.push_back(MakeTransactionRef(proupserv_empty));
+
+    // Create minimal block undo
+    CBlockUndo block_undo;
+    for (size_t i = 0; i < block.vtx.size(); i++) {
+        block_undo.vtxundo.emplace_back();
+    }
+
+    // Create block filter - should not crash with edge cases
+    BlockFilter block_filter(BlockFilterType::BASIC_FILTER, block, block_undo);
+    const GCSFilter& filter = block_filter.GetFilter();
+
+    // Test that non-empty fields are still included
+    BOOST_CHECK(filter.Match(GCSFilter::Element(proRegPayload_empty.keyIDOwner.begin(),
+                                                proRegPayload_empty.keyIDOwner.end())));
+
+    // Test that OP_RETURN script is NOT in filter
+    BOOST_CHECK(!filter.Match(GCSFilter::Element(opReturnScript.begin(), opReturnScript.end())));
+
+    // Test that normal script from AssetLock IS in filter
+    BOOST_CHECK(filter.Match(GCSFilter::Element(normalScript.begin(), normalScript.end())));
+
+    // Test that ProUpServTx hash is still included even with empty payout script
+    BOOST_CHECK(filter.Match(GCSFilter::Element(proUpServPayload_empty.proTxHash.begin(),
+                                               proUpServPayload_empty.proTxHash.end())));
+}
+
 BOOST_AUTO_TEST_SUITE_END()
diff --git a/test/functional/p2p_blockfilters.py b/test/functional/p2p_blockfilters.py
index 48c4881950bdc..9df7f26ecca7c 100755
--- a/test/functional/p2p_blockfilters.py
+++ b/test/functional/p2p_blockfilters.py
@@ -9,6 +9,12 @@
 """
 
 from test_framework.messages import (
+    CAssetLockTx,
+    COIN,
+    COutPoint,
+    CTransaction,
+    CTxIn,
+    CTxOut,
     FILTER_TYPE_BASIC,
     NODE_COMPACT_FILTERS,
     hash256,
@@ -16,13 +22,24 @@
     msg_getcfheaders,
     msg_getcfilters,
     ser_uint256,
+    tx_from_hex,
     uint256_from_str,
 )
 from test_framework.p2p import P2PInterface
+from test_framework.script import (
+    CScript,
+    OP_RETURN,
+)
+from test_framework.script_util import (
+    key_to_p2pkh_script,
+)
 from test_framework.test_framework import BitcoinTestFramework
 from test_framework.util import (
     assert_equal,
+    assert_greater_than,
 )
+from test_framework.key import ECKey
+from decimal import Decimal
 
 class FiltersClient(P2PInterface):
     def __init__(self):
@@ -55,6 +72,9 @@ def run_test(self):
         peer_0 = self.nodes[0].add_p2p_connection(FiltersClient())
         peer_1 = self.nodes[1].add_p2p_connection(FiltersClient())
 
+        self.privkeys = [self.nodes[0].get_deterministic_priv_key().key]
+        self.change_addr = self.nodes[0].get_deterministic_priv_key().address
+
         # Nodes 0 & 1 share the same first 999 blocks in the chain.
         self.generate(self.nodes[0], 999)
 
@@ -280,6 +300,183 @@ def run_test(self):
             extra_args=['-blockfilterindex', '-reindex-chainstate'],
         )
 
+        self.test_special_transactions_in_filters()
+
+    def create_simple_assetlock(self, base_tx, base_tx_value, amount_locked_1, amount_locked_2=0):
+        """Create a simple AssetLockTx for testing"""
+        node = self.nodes[0]
+
+        # Create the AssetLockTx
+        inputs = [CTxIn(outpoint=COutPoint(int(base_tx, 16), 0))]
+
+        # Credit outputs (what will be credited on Platform)
+        credit_outputs = []
+        for amount in [amount_locked_1, amount_locked_2]:
+            if amount == 0:
+                continue
+
+            # Create a key for the credit outputs
+            key = ECKey()
+            key.generate()
+            pubkey = key.get_pubkey().get_bytes()
+            credit_outputs.append(CTxOut(int(amount * COIN), key_to_p2pkh_script(pubkey)))
+
+        # AssetLock payload
+        lock_tx_payload = CAssetLockTx(1, credit_outputs)
+
+        # Calculate remaining amount (minus small fee)
+        fee = Decimal("0.0001")
+        remaining = base_tx_value - amount_locked_1 - amount_locked_2 - fee
+
+        # Create the transaction
+        lock_tx = CTransaction()
+        lock_tx.vin = inputs
+
+        # Add change output if there's remaining amount
+        if remaining > 0:
+            change_script = bytes.fromhex(node.validateaddress(self.change_addr)['scriptPubKey'])
+            lock_tx.vout = [CTxOut(int(remaining * COIN), change_script)]
+
+        # Add OP_RETURN output with the locked amount
+        lock_tx.vout.append(CTxOut(int((amount_locked_1 + amount_locked_2) * COIN), CScript([OP_RETURN, b""])))
+
+        lock_tx.nVersion = 3
+        lock_tx.nType = 8  # asset lock type
+        lock_tx.vExtraPayload = lock_tx_payload.serialize()
+
+        # Sign the transaction
+        tx_hex = lock_tx.serialize().hex()
+        signed_tx = node.signrawtransactionwithkey(tx_hex, self.privkeys)
+        return tx_from_hex(signed_tx["hex"]).serialize().hex()
+
+    def test_special_transactions_in_filters(self):
+        """Test that special transactions are included in block filters.
+
+        Note: This functional test only covers AssetLockTx transactions because:
+        - ProRegTx requires 1000 DASH collateral and masternode setup
+        - ProUpServTx/ProUpRegTx/ProUpRevTx require existing masternodes
+        - All special transaction types are comprehensively tested in unit tests
+          (see src/test/blockfilter_tests.cpp)
+
+        The test verifies filter functionality by comparing filter sizes between
+        blocks with and without special transactions, as GCS filter decoding
+        is not readily available in Python test framework.
+        """
+        self.log.info("Test that special transactions are included in block filters")
+
+        # Restart node 0 with blockfilterindex enabled
+        self.restart_node(0, extra_args=["-blockfilterindex", "-peerblockfilters"])
+
+        # Test AssetLockTx transactions
+        self.test_assetlock_basic()
+        self.test_assetlock_multiple_outputs()
+
+        self.log.info("Special transaction block filter test completed successfully")
+
+    def test_assetlock_basic(self):
+        """Test that AssetLockTx credit outputs are included in block filters"""
+        self.log.info("Testing AssetLockTx in block filters...")
+
+        node = self.nodes[0]
+
+        # Create an AssetLockTx
+        amount_to_lock = Decimal("0.1")
+        block = node.getblock(node.getblockhash(300), 2)
+        base_tx = block['tx'][0]['txid']
+        base_tx_value = block['tx'][0]['vout'][0]['value']
+        signed_hex = self.create_simple_assetlock(base_tx, base_tx_value, amount_to_lock)
+        txid = node.sendrawtransaction(signed_hex)
+
+        # Verify it's recognized as an AssetLockTx
+        tx_details = node.getrawtransaction(txid, True)
+        assert tx_details.get('type') == 8, f"Expected type 8 (AssetLockTx), got {tx_details.get('type')}"
+        # Note: vExtraPayload may not appear in RPC output but the transaction is still valid
+
+        # Mine it into a block
+        block_hash = self.generate(node, 1, sync_fun=self.no_op)[0]
+
+        # Verify the transaction is in the block with the assetLockTx field
+        block = node.getblock(block_hash, 2)
+        found_tx = None
+        for tx in block['tx']:
+            if tx['txid'] == txid:
+                found_tx = tx
+                break
+
+        assert found_tx is not None, f"Transaction {txid} not found in block"
+        assert 'assetLockTx' in found_tx, "Mined transaction should have assetLockTx field"
+        assert 'creditOutputs' in found_tx['assetLockTx'], "AssetLockTx should have creditOutputs"
+        assert len(found_tx['assetLockTx']['creditOutputs']) >= 1, "Expected at least one credit output"
+
+        # Get the filter
+        filter_result = node.getblockfilter(block_hash, 'basic')
+        assert 'filter' in filter_result, "Block should have a filter"
+
+        # To properly verify, we'll create a control block without special tx
+        # and compare filter sizes
+        control_block_hash = self.generate(node, 1, sync_fun=self.no_op)[0]
+        control_filter = node.getblockfilter(control_block_hash, 'basic')
+
+        # The block with AssetLockTx should have a larger filter due to credit outputs
+        special_filter_size = len(filter_result['filter'])
+        control_filter_size = len(control_filter['filter'])
+
+        self.log.debug(f"Filter with AssetLockTx: {special_filter_size} hex chars")
+        self.log.debug(f"Control filter: {control_filter_size} hex chars")
+
+        # The filter with special tx should be larger (credit outputs add data)
+        assert_greater_than(special_filter_size, control_filter_size)
+
+        self.log.info("AssetLockTx basic test passed")
+
+    def test_assetlock_multiple_outputs(self):
+        """Test that multiple AssetLockTx credit outputs are all included in block filters"""
+        self.log.info("Testing AssetLockTx with multiple credit outputs...")
+
+        node = self.nodes[0]
+
+        # Create an AssetLockTx with multiple credit outputs
+        # This tests that all credit outputs are properly included in the filter
+
+        amount1 = Decimal("0.03")
+        amount2 = Decimal("0.04")
+
+        block = node.getblock(node.getblockhash(301), 2)
+        base_tx = block['tx'][0]['txid']
+        base_tx_value = block['tx'][0]['vout'][0]['value']
+        signed_hex = self.create_simple_assetlock(base_tx, base_tx_value, amount1, amount2)
+        txid = node.sendrawtransaction(signed_hex)
+
+        # Mine it into a block
+        block_hash = self.generate(node, 1, sync_fun=self.no_op)[0]
+
+        # Verify our tx is included and has the expected special payload
+        block = node.getblock(block_hash, 2)
+        tx = next((t for t in block["tx"] if t["txid"] == txid), None)
+        assert tx is not None, f"AssetLockTx {txid} not found in block {block_hash}"
+        assert "assetLockTx" in tx, "Mined transaction should have assetLockTx field"
+        assert "creditOutputs" in tx["assetLockTx"], "AssetLockTx should have creditOutputs"
+
+        # Get the filter to verify it was created
+        filter_result = node.getblockfilter(block_hash, 'basic')
+        assert 'filter' in filter_result, "Block should have a filter"
+
+        # Compare with a control block to verify multiple credit outputs increase filter size
+        control_block_hash = self.generate(node, 1, sync_fun=self.no_op)[0]
+        control_filter = node.getblockfilter(control_block_hash, 'basic')
+
+        # Filter with multiple credit outputs should be larger than control
+        multi_output_filter_size = len(filter_result['filter'])
+        control_filter_size = len(control_filter['filter'])
+
+        self.log.debug(f"Filter with multiple outputs: {multi_output_filter_size} hex chars")
+        self.log.debug(f"Control filter: {control_filter_size} hex chars")
+
+        assert_greater_than(multi_output_filter_size, control_filter_size)
+
+        self.log.info("AssetLockTx multiple outputs test passed")
+
+
 def compute_last_header(prev_header, hashes):
     """Compute the last filter header from a starting header and a sequence of filter hashes."""
     header = ser_uint256(prev_header)
diff --git a/test/lint/lint-circular-dependencies.py b/test/lint/lint-circular-dependencies.py
index 6fc42097b579a..e1573c17d6d0b 100755
--- a/test/lint/lint-circular-dependencies.py
+++ b/test/lint/lint-circular-dependencies.py
@@ -23,7 +23,6 @@
     "node/coinstats -> validation -> node/coinstats",
     # Dash
     "banman -> common/bloom -> evo/assetlocktx -> llmq/quorums -> net -> banman",
-    "banman -> common/bloom -> evo/assetlocktx -> llmq/signing -> net_processing -> banman",
     "chainlock/chainlock -> instantsend/instantsend -> chainlock/chainlock",
     "chainlock/chainlock -> instantsend/instantsend -> instantsend/signing -> chainlock/chainlock",
     "chainlock/chainlock -> instantsend/instantsend -> net_processing -> chainlock/chainlock",
@@ -34,16 +33,16 @@
     "coinjoin/context -> coinjoin/server -> net_processing -> coinjoin/context",
     "coinjoin/server -> net_processing -> coinjoin/server",
     "common/bloom -> evo/assetlocktx -> llmq/quorums -> net -> common/bloom",
-    "common/bloom -> evo/assetlocktx -> llmq/signing -> net_processing -> merkleblock -> common/bloom",
+    "common/bloom -> evo/assetlocktx -> llmq/commitment -> evo/deterministicmns -> evo/simplifiedmns -> merkleblock -> common/bloom",
+    "evo/assetlocktx -> llmq/commitment -> validation -> txmempool -> evo/assetlocktx",
     "consensus/tx_verify -> evo/assetlocktx -> llmq/commitment -> validation -> consensus/tx_verify",
-    "consensus/tx_verify -> evo/assetlocktx -> llmq/signing -> net_processing -> txmempool -> consensus/tx_verify",
-    "evo/assetlocktx -> llmq/signing -> net_processing -> txmempool -> evo/assetlocktx",
+    "consensus/tx_verify -> evo/assetlocktx -> llmq/commitment -> validation -> txmempool -> consensus/tx_verify",
     "evo/chainhelper -> evo/specialtxman -> validation -> evo/chainhelper",
     "evo/deterministicmns -> index/txindex -> validation -> evo/deterministicmns",
     "evo/deterministicmns -> index/txindex -> validation -> txmempool -> evo/deterministicmns",
     "evo/netinfo -> evo/providertx -> evo/netinfo",
     "evo/smldiff -> llmq/blockprocessor -> llmq/utils -> llmq/snapshot -> evo/smldiff",
-    "core_io -> evo/assetlocktx -> llmq/signing -> net_processing -> evo/smldiff -> core_io",
+    "core_io -> evo/mnhftx -> llmq/signing -> net_processing -> evo/smldiff -> core_io",
     "evo/specialtxman -> validation -> evo/specialtxman",
     "governance/governance -> governance/object -> governance/governance",
     "governance/governance -> masternode/sync -> governance/governance",