feat(rpc): add mining-transaction snapshot proofs

.gitignore

@@ -181,3 +181,4 @@ compile_commands.json
 # Linux perf profiling artifacts
 perf.data
 perf.data.old
+activity.md

doc/release-notes-7107.md

@@ -0,0 +1,7 @@
+New RPCs
+--------
+
+- Add `getquorumproofchain` and `verifyquorumproofchain` for compact mining-transaction
+  proofs from an independently trusted snapshot, plus `getchainlockbyheight` for
+  archived certificates. Proof generation requires `-quorumproofindex` on an
+  unpruned node; enabling it scans historical blocks at startup. (#7107)

src/Makefile.am

@@ -314,6 +314,8 @@ BITCOIN_CORE_H = \
   llmq/observer.h \
   llmq/options.h \
   llmq/params.h \
+  llmq/quorumproofdata.h \
+  llmq/quorumproofs.h \
   llmq/quorums.h \
   llmq/quorumsman.h \
   llmq/signhash.h \
@@ -598,6 +600,7 @@ libbitcoin_node_a_SOURCES = \
   llmq/net_signing.cpp \
   llmq/observer.cpp \
   llmq/options.cpp \
+  llmq/quorumproofs.cpp \
   llmq/quorums.cpp \
   llmq/quorumsman.cpp \
   llmq/signhash.cpp \

src/Makefile.test.include

@@ -151,6 +151,7 @@ BITCOIN_TESTS =\
   test/llmq_snapshot_tests.cpp \
   test/llmq_utils_tests.cpp \
   test/logging_tests.cpp \
+  test/quorum_proofs_tests.cpp \
   test/masternode_payments_tests.cpp \
   test/dbwrapper_tests.cpp \
   test/validation_tests.cpp \

src/evo/chainhelper.cpp

@@ -23,7 +23,8 @@ CChainstateHelper::CChainstateHelper(CEvoDB& evodb, CDeterministicMNManager& dmn
                                      llmq::CInstantSendManager& isman, llmq::CQuorumBlockProcessor& qblockman,
                                      llmq::CQuorumSnapshotManager& qsnapman, const ChainstateManager& chainman,
                                      const Consensus::Params& consensus_params, const chainlock::Chainlocks& chainlocks,
-                                     const llmq::CQuorumManager& qman) :
+                                     const llmq::CQuorumManager& qman,
+                                     llmq::CQuorumProofManager& quorum_proof_manager) :
     isman{isman},
     mn_sync{mn_sync},
     m_dmnman{dmnman},
@@ -33,7 +34,7 @@ CChainstateHelper::CChainstateHelper(CEvoDB& evodb, CDeterministicMNManager& dmn
     superblocks{std::make_unique<governance::SuperblockManager>()},
     mn_payments{std::make_unique<CMNPaymentsProcessor>(dmnman, *superblocks, consensus_params)},
     special_tx{std::make_unique<CSpecialTxProcessor>(*credit_pool_manager, dmnman, *ehf_manager, qblockman, qsnapman,
-                                                     chainman, consensus_params, chainlocks, qman)}
+                                                     chainman, consensus_params, chainlocks, qman, quorum_proof_manager)}
 {}
 
 CChainstateHelper::~CChainstateHelper() = default;

src/evo/chainhelper.h

@@ -35,6 +35,7 @@ namespace llmq {
 class CInstantSendManager;
 class CQuorumBlockProcessor;
 class CQuorumManager;
+class CQuorumProofManager;
 class CQuorumSnapshotManager;
 } // namespace llmq
 class CChainstateHelper
@@ -60,7 +61,8 @@ class CChainstateHelper
                                llmq::CInstantSendManager& isman, llmq::CQuorumBlockProcessor& qblockman,
                                llmq::CQuorumSnapshotManager& qsnapman, const ChainstateManager& chainman,
                                const Consensus::Params& consensus_params, const chainlock::Chainlocks& chainlocks,
-                               const llmq::CQuorumManager& qman);
+                               const llmq::CQuorumManager& qman,
+                               llmq::CQuorumProofManager& quorum_proof_manager);
     ~CChainstateHelper();
 
     bool IsSuperblockValidationRequired(const CBlockIndex* const pindex);

src/evo/specialtxman.cpp

@@ -17,6 +17,7 @@
 #include <evo/simplifiedmns.h>
 #include <llmq/blockprocessor.h>
 #include <llmq/commitment.h>
+#include <llmq/quorumproofs.h>
 #include <llmq/quorumsman.h>
 #include <llmq/utils.h>
 #include <messagesigner.h>
@@ -857,6 +858,22 @@ bool CSpecialTxProcessor::ProcessSpecialTxsInBlock(Chainstate& chainstate, const
                 return false;
             }
 
+            // Index the chainlock from cbtx for proof generation
+            // Only index if not just checking
+            // Note: We can't check ActiveChain().Contains(pindex) here because the chain tip
+            // hasn't been updated yet during ConnectBlock - the tip is updated AFTER this function returns
+            if (!fJustCheck && opt_cbTx->bestCLSignature.IsValid()) {
+                int chainlockedHeight = pindex->nHeight - static_cast<int>(opt_cbTx->bestCLHeightDiff) - 1;
+                const CBlockIndex* pChainlockedBlock = pindex->GetAncestor(chainlockedHeight);
+                if (pChainlockedBlock) {
+                    m_quorum_proof_manager.IndexChainlock(
+                        chainlockedHeight,
+                        opt_cbTx->bestCLSignature,
+                        pindex->GetBlockHash(),
+                        pindex->nHeight);
+                }
+            }
+
             int64_t nTime6_3 = GetTimeMicros();
             nTimeCbTxCL += nTime6_3 - nTime6_2;
             LogPrint(BCLog::BENCHMARK, "      - CheckCbTxBestChainlock: %.2fms [%.2fs]\n",
@@ -918,6 +935,14 @@ bool CSpecialTxProcessor::UndoSpecialTxsInBlock(const Chainstate& chainstate, co
         if (!m_qblockman.UndoBlock(chainstate, block, pindex)) {
             return false;
         }
+
+        // Remove chainlock index for this block's cbtx
+        if (block.vtx.size() > 0 && block.vtx[0]->nType == TRANSACTION_COINBASE) {
+            if (const auto opt_cbTx = GetTxPayload<CCbTx>(*block.vtx[0]); opt_cbTx && opt_cbTx->bestCLSignature.IsValid()) {
+                int chainlockedHeight = pindex->nHeight - static_cast<int>(opt_cbTx->bestCLHeightDiff) - 1;
+                m_quorum_proof_manager.RemoveChainlockIndex(chainlockedHeight, pindex->GetBlockHash());
+            }
+        }
     } catch (const std::exception& e) {
         bls::bls_legacy_scheme.store(bls_legacy_scheme);
         LogPrintf("CSpecialTxProcessor::%s -- bls_legacy_scheme=%d\n", __func__, bls::bls_legacy_scheme.load());

src/evo/specialtxman.h

@@ -34,6 +34,7 @@ namespace Consensus { struct Params; }
 namespace llmq {
 class CQuorumBlockProcessor;
 class CQuorumManager;
+class CQuorumProofManager;
 class CQuorumSnapshotManager;
 } // namespace llmq
 
@@ -51,12 +52,14 @@ class CSpecialTxProcessor
     const Consensus::Params& m_consensus_params;
     const chainlock::Chainlocks& m_chainlocks;
     const llmq::CQuorumManager& m_qman;
+    llmq::CQuorumProofManager& m_quorum_proof_manager;
 
 public:
     explicit CSpecialTxProcessor(CCreditPoolManager& cpoolman, CDeterministicMNManager& dmnman, CMNHFManager& mnhfman,
                                  llmq::CQuorumBlockProcessor& qblockman, llmq::CQuorumSnapshotManager& qsnapman,
                                  const ChainstateManager& chainman, const Consensus::Params& consensus_params,
-                                 const chainlock::Chainlocks& chainlocks, const llmq::CQuorumManager& qman) :
+                                 const chainlock::Chainlocks& chainlocks, const llmq::CQuorumManager& qman,
+                                 llmq::CQuorumProofManager& quorum_proof_manager) :
         m_cpoolman(cpoolman),
         m_dmnman{dmnman},
         m_mnhfman{mnhfman},
@@ -65,7 +68,8 @@ class CSpecialTxProcessor
         m_chainman(chainman),
         m_consensus_params{consensus_params},
         m_chainlocks{chainlocks},
-        m_qman{qman}
+        m_qman{qman},
+        m_quorum_proof_manager{quorum_proof_manager}
     {
     }
 

src/init.cpp

@@ -116,6 +116,7 @@
 #include <llmq/net_signing.h>
 #include <llmq/observer.h>
 #include <llmq/options.h>
+#include <llmq/quorumproofs.h>
 #include <masternode/meta.h>
 #include <masternode/sync.h>
 #include <masternode/utils.h>
@@ -638,6 +639,7 @@ void SetupServerArgs(ArgsManager& argsman)
     argsman.AddArg("-reindex-chainstate", "Rebuild chain state from the currently indexed blocks. When in pruning mode or if blocks on disk might be corrupted, use full -reindex instead. Deactivate all optional indexes before running this.", ArgsManager::ALLOW_ANY, OptionsCategory::INDEXING);
     argsman.AddArg("-spentindex", strprintf("Maintain a full spent index, used to query the spending txid and input index for an outpoint (default: %u)", DEFAULT_SPENTINDEX), ArgsManager::ALLOW_ANY, OptionsCategory::INDEXING);
     argsman.AddArg("-timestampindex", strprintf("Maintain a timestamp index for block hashes, used to query blocks hashes by a range of timestamps (default: %u)", DEFAULT_TIMESTAMPINDEX), ArgsManager::ALLOW_ANY, OptionsCategory::INDEXING);
+    argsman.AddArg("-quorumproofindex", "Index historical ChainLocks and quorum mining witnesses for SDK proofs (requires unpruned blocks)", ArgsManager::ALLOW_ANY, OptionsCategory::INDEXING);
     argsman.AddArg("-txindex", strprintf("Maintain a full transaction index, used by the getrawtransaction rpc call (default: %u)", DEFAULT_TXINDEX), ArgsManager::ALLOW_ANY, OptionsCategory::INDEXING);
     argsman.AddArg("-blockfilterindex=<type>",
                  strprintf("Maintain an index of compact filters by block (default: %s, values: %s).", DEFAULT_BLOCKFILTERINDEX, ListBlockFilterTypes()) +
@@ -2090,6 +2092,16 @@ bool AppInitMain(NodeContext& node, interfaces::BlockAndHeaderTipInfo* tip_info)
 
     ChainstateManager& chainman = *Assert(node.chainman);
 
+    if (node.llmq_ctx && llmq::QuorumProofIndexEnabled()) {
+        if (node::fPruneMode) return InitError(_("Quorum proof indexing requires unpruned blocks"));
+        LOCK(cs_main);
+        try {
+            node.llmq_ctx->quorum_proof_manager->MigrateChainlockIndex(chainman.ActiveChain(), chainparams);
+        } catch (const std::exception& e) {
+            return InitError(Untranslated(strprintf("Quorum proof indexing failed: %s", e.what())));
+        }
+    }
+
     assert(!node.dstxman);
     node.dstxman = std::make_unique<CDSTXManager>(*node.chainlocks);
 

src/llmq/blockprocessor.cpp

@@ -8,6 +8,7 @@
 #include <evo/specialtx.h>
 #include <llmq/commitment.h>
 #include <llmq/options.h>
+#include <llmq/quorumproofdata.h>
 #include <llmq/utils.h>
 #include <util/helpers.h>
 #include <util/std23.h>
@@ -18,6 +19,7 @@
 #include <consensus/params.h>
 #include <consensus/validation.h>
 #include <deploymentstatus.h>
+#include <hash.h>
 #include <net.h>
 #include <primitives/block.h>
 #include <primitives/transaction.h>
@@ -275,6 +277,17 @@ bool CQuorumBlockProcessor::ProcessBlock(Chainstate& chainstate, const CBlock& b
         }
     }
 
+    if (!fJustCheck && QuorumProofIndexEnabled()) {
+        for (size_t i = 1; i < block.vtx.size(); ++i) {
+            if (block.vtx[i]->nType != TRANSACTION_QUORUM_COMMITMENT) continue;
+            const auto payload = GetTxPayload<CFinalCommitmentTxPayload>(*block.vtx[i]);
+            if (!payload || payload->commitment.IsNull()) continue;
+            QuorumProofData data{ProofTransaction::Build(block, i), block.GetBlockHeader()};
+            m_evoDb.Write(std::make_pair(DB_QUORUM_PROOF_DATA,
+                std::make_pair(payload->commitment.llmqType, payload->commitment.quorumHash)), data);
+        }
+    }
+
     m_evoDb.Write(DB_BEST_BLOCK_UPGRADE, blockHash);
 
     return true;
@@ -523,6 +536,8 @@ bool CQuorumBlockProcessor::UndoBlock(const Chainstate& chainstate, const CBlock
             LogPrint(BCLog::LLMQ, "%s -- retaining commitment for block %s used by another chainstate\n",
                      __func__, pindex->GetBlockHash().ToString());
         } else {
+            // Proof data follows the commitment's lifetime across chainstates.
+            m_evoDb.Erase(std::make_pair(DB_QUORUM_PROOF_DATA, std::make_pair(qc.llmqType, qc.quorumHash)));
             const auto& llmq_params_opt = Params().GetLLMQ(qc.llmqType);
             assert(llmq_params_opt.has_value());
 

src/llmq/context.cpp

@@ -6,6 +6,7 @@
 
 #include <bls/bls_worker.h>
 #include <llmq/blockprocessor.h>
+#include <llmq/quorumproofs.h>
 #include <llmq/quorumsman.h>
 #include <llmq/signing.h>
 #include <llmq/snapshot.h>
@@ -20,6 +21,7 @@ LLMQContext::LLMQContext(CDeterministicMNManager& dmnman, CEvoDB& evo_db, Chains
         std::make_unique<llmq::CQuorumBlockProcessor>(chainman, dmnman, evo_db, *qsnapman, bls_threads)},
     qman{std::make_unique<llmq::CQuorumManager>(*bls_worker, dmnman, evo_db, *quorum_block_processor, *qsnapman,
                                                 chainman, db_params)},
+    quorum_proof_manager{std::make_unique<llmq::CQuorumProofManager>(evo_db, *quorum_block_processor)},
     sigman{std::make_unique<llmq::CSigningManager>(*qman, db_params, max_recsigs_age)}
 {
     // Have to start it early to let VerifyDB check ChainLock signatures in coinbase

src/llmq/context.h

@@ -18,6 +18,7 @@ class PeerManager;
 namespace llmq {
 class CQuorumBlockProcessor;
 class CQuorumManager;
+class CQuorumProofManager;
 class CQuorumSnapshotManager;
 class CSigningManager;
 } // namespace llmq
@@ -45,6 +46,7 @@ struct LLMQContext {
     const std::unique_ptr<llmq::CQuorumSnapshotManager> qsnapman;
     const std::unique_ptr<llmq::CQuorumBlockProcessor> quorum_block_processor;
     const std::unique_ptr<llmq::CQuorumManager> qman;
+    const std::unique_ptr<llmq::CQuorumProofManager> quorum_proof_manager;
     const std::unique_ptr<llmq::CSigningManager> sigman;
 };
 

src/llmq/quorumproofdata.h

@@ -0,0 +1,37 @@
+// Copyright (c) 2025-2026 The Dash Core developers
+// Distributed under the MIT software license, see the accompanying file COPYING.
+#ifndef BITCOIN_LLMQ_QUORUMPROOFDATA_H
+#define BITCOIN_LLMQ_QUORUMPROOFDATA_H
+#include <primitives/block.h>
+#include <serialize.h>
+#include <uint256.h>
+#include <string>
+#include <vector>
+namespace llmq {
+inline constexpr size_t MAX_PROOF_BYTES = 1024 * 1024;
+inline constexpr size_t MAX_PROOF_CERTIFICATES = 4096;
+inline constexpr size_t MAX_PROOF_HEADERS = 4096;
+struct ProofMerklePath {
+    uint32_t index{0};
+    uint32_t count{0};
+    std::vector<uint256> siblings;
+    SERIALIZE_METHODS(ProofMerklePath, obj) { READWRITE(obj.index, obj.count, obj.siblings); }
+    bool Verify(uint256 leaf, const uint256& root) const;
+    static ProofMerklePath Build(const std::vector<uint256>& leaves, uint32_t index);
+};
+struct ProofTransaction {
+    std::vector<unsigned char> transaction;
+    ProofMerklePath path;
+    SERIALIZE_METHODS(ProofTransaction, obj) { READWRITE(obj.transaction, obj.path); }
+    bool Verify(const CBlockHeader& header) const;
+    static ProofTransaction Build(const CBlock& block, uint32_t index);
+};
+struct QuorumProofData {
+    ProofTransaction mining;
+    CBlockHeader header;
+    SERIALIZE_METHODS(QuorumProofData, obj) { READWRITE(obj.mining, obj.header); }
+};
+extern const std::string DB_QUORUM_PROOF_DATA;
+bool QuorumProofIndexEnabled();
+} // namespace llmq
+#endif // BITCOIN_LLMQ_QUORUMPROOFDATA_H