feat: add special transaction support to compact block filters (BIP-157/158)

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 \

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](const std::vector<unsigned char>& data) {
+            elements.emplace(data.begin(), data.end());
+        });
     }
 
     for (const CTxUndo& tx_undo : block_undo.vtxundo) {

src/evo/specialtx_filter.cpp

@@ -0,0 +1,134 @@
+// Copyright (c) 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 <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(const std::vector<unsigned char>&)>& addElement)
+{
+    if (!script.empty()) {
+        addElement(std::vector<unsigned char>(script.begin(), script.end()));
+    }
+}
+
+// Helper function to add a hash/key to the filter
+template<typename T>
+static void AddHashElement(const T& hash,
+                          const std::function<void(const std::vector<unsigned char>&)>& addElement)
+{
+    addElement(std::vector<unsigned char>(hash.begin(), hash.end()));
+}
+
+void ExtractSpecialTxFilterElements(const CTransaction& tx,
+                                   const std::function<void(const std::vector<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;
+            auto span = MakeUCharSpan(stream);
+            addElement(std::vector<unsigned char>(span.begin(), span.end()));
+
+            // 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;
+    default:
+        // Unknown special transaction type - ignore
+        break;
+    }
+}

src/evo/specialtx_filter.h

@@ -0,0 +1,24 @@
+// Copyright (c) 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_EVO_SPECIALTX_FILTER_H
+#define BITCOIN_EVO_SPECIALTX_FILTER_H
+
+#include <functional>
+#include <vector>
+
+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 function to add extracted elements to the filter
+ */
+void ExtractSpecialTxFilterElements(const CTransaction& tx,
+                                   const std::function<void(const std::vector<unsigned char>&)>& addElement);
+
+#endif // BITCOIN_EVO_SPECIALTX_FILTER_H