rpc: predict rotated DKG participation

thepastaclaw · thepastaclaw · commit f26c8bead856 · 2026-07-05T20:51:17.000-05:00
diff --git a/src/llmq/utils.cpp b/src/llmq/utils.cpp
@@ -342,9 +342,13 @@ void BuildQuorumSnapshot(const Consensus::LLMQParams& llmqParams, const Consensu
 std::vector<QuorumMembers> BuildNewQuorumQuarterMembers(const Consensus::LLMQParams& llmqParams,
                                                         const llmq::UtilParameters& util_params,
                                                         const CDeterministicMNList& allMns,
-                                                        const PreviousQuorumQuarters& previousQuarters)
+                                                        const PreviousQuorumQuarters& previousQuarters,
+                                                        const uint256& modifier,
+                                                        gsl::not_null<const CBlockIndex*> pDeploymentIndex,
+                                                        int cycleBaseHeight,
+                                                        bool storeSnapshot)
 {
-    if (!llmqParams.useRotation || util_params.m_base_index->nHeight % llmqParams.dkgInterval != 0) {
+    if (!llmqParams.useRotation || cycleBaseHeight % llmqParams.dkgInterval != 0) {
         ASSERT_IF_DEBUG(false);
         return {};
     }
@@ -354,7 +358,6 @@ std::vector<QuorumMembers> BuildNewQuorumQuarterMembers(const Consensus::LLMQPar
 
     size_t quorumSize = static_cast<size_t>(llmqParams.size);
     auto quarterSize{quorumSize / 4};
-    const auto modifier = GetHashModifier(llmqParams, util_params.m_chainman.GetConsensus(), util_params.m_base_index);
 
     if (allMns.GetCounts().enabled() < quarterSize) {
         return quarterQuorumMembers;
@@ -363,7 +366,7 @@ std::vector<QuorumMembers> BuildNewQuorumQuarterMembers(const Consensus::LLMQPar
     auto MnsUsedAtH = CDeterministicMNList();
     std::vector<CDeterministicMNList> MnsUsedAtHIndexed{nQuorums};
 
-    bool skipRemovedMNs = DeploymentActiveAfter(util_params.m_base_index, util_params.m_chainman.GetConsensus(),
+    bool skipRemovedMNs = DeploymentActiveAfter(pDeploymentIndex.get(), util_params.m_chainman.GetConsensus(),
                                                 Consensus::DEPLOYMENT_V19) ||
                           (util_params.m_chainman.GetParams().NetworkIDString() == CBaseChainParams::TESTNET);
 
@@ -404,7 +407,7 @@ std::vector<QuorumMembers> BuildNewQuorumQuarterMembers(const Consensus::LLMQPar
     }
 
     if (LogAcceptDebug(BCLog::LLMQ)) {
-        LogPrint(BCLog::LLMQ, "%s h[%d] sortedCombinedMns[%s]\n", __func__, util_params.m_base_index->nHeight,
+        LogPrint(BCLog::LLMQ, "%s h[%d] sortedCombinedMns[%s]\n", __func__, cycleBaseHeight,
                  ToString(sortedCombinedMnsList));
     }
 
@@ -450,14 +453,31 @@ std::vector<QuorumMembers> BuildNewQuorumQuarterMembers(const Consensus::LLMQPar
         }
     }
 
-    llmq::CQuorumSnapshot quorumSnapshot{};
-    BuildQuorumSnapshot(llmqParams, util_params.m_chainman.GetConsensus(), allMns, MnsUsedAtH, sortedCombinedMnsList,
-                        quorumSnapshot, skipList, util_params.m_base_index);
-    util_params.m_qsnapman.StoreSnapshotForBlock(llmqParams.type, util_params.m_base_index, quorumSnapshot);
+    if (storeSnapshot) {
+        llmq::CQuorumSnapshot quorumSnapshot{};
+        BuildQuorumSnapshot(llmqParams, util_params.m_chainman.GetConsensus(), allMns, MnsUsedAtH, sortedCombinedMnsList,
+                            quorumSnapshot, skipList, util_params.m_base_index);
+        util_params.m_qsnapman.StoreSnapshotForBlock(llmqParams.type, util_params.m_base_index, quorumSnapshot);
+    }
 
     return quarterQuorumMembers;
 }
 
+std::vector<QuorumMembers> BuildNewQuorumQuarterMembers(const Consensus::LLMQParams& llmqParams,
+                                                        const llmq::UtilParameters& util_params,
+                                                        const CDeterministicMNList& allMns,
+                                                        const PreviousQuorumQuarters& previousQuarters)
+{
+    if (!llmqParams.useRotation || util_params.m_base_index->nHeight % llmqParams.dkgInterval != 0) {
+        ASSERT_IF_DEBUG(false);
+        return {};
+    }
+    const auto modifier = GetHashModifier(llmqParams, util_params.m_chainman.GetConsensus(), util_params.m_base_index);
+    return BuildNewQuorumQuarterMembers(llmqParams, util_params, allMns, previousQuarters, modifier,
+                                        util_params.m_base_index, util_params.m_base_index->nHeight,
+                                        /*storeSnapshot=*/true);
+}
+
 std::vector<QuorumMembers> ComputeQuorumMembersByQuarterRotation(const Consensus::LLMQParams& llmqParams,
                                                                  const llmq::UtilParameters& util_params)
 {
@@ -597,6 +617,85 @@ std::vector<CDeterministicMNCPtr> ComputeNonRotatedQuorumMembersFromWorkBlock(
     return CalculateQuorum(mn_list, modifier, llmq_params.size, EvoOnly);
 }
 
+std::optional<std::vector<CDeterministicMNCPtr>> ComputeRotatedQuorumMembersFromWorkBlock(
+    Consensus::LLMQType llmqType, const UtilParameters& util_params,
+    gsl::not_null<const CBlockIndex*> pWorkBlockIndex, int quorumHeight)
+{
+    const auto& llmq_params_opt = util_params.m_chainman.GetParams().GetLLMQ(llmqType);
+    if (!llmq_params_opt.has_value()) {
+        ASSERT_IF_DEBUG(false);
+        return std::nullopt;
+    }
+    const auto& llmq_params = llmq_params_opt.value();
+    if (!llmq_params.useRotation) {
+        ASSERT_IF_DEBUG(false);
+        return std::nullopt;
+    }
+
+    const int quorumIndex{quorumHeight % llmq_params.dkgInterval};
+    if (quorumIndex < 0 || quorumIndex >= llmq_params.signingActiveQuorumCount) {
+        ASSERT_IF_DEBUG(false);
+        return std::nullopt;
+    }
+    const int cycleBaseHeight{quorumHeight - quorumIndex};
+    if (cycleBaseHeight % llmq_params.dkgInterval != 0 ||
+        pWorkBlockIndex->nHeight != cycleBaseHeight - llmq::WORK_DIFF_DEPTH) {
+        ASSERT_IF_DEBUG(false);
+        return std::nullopt;
+    }
+
+    if (!DeploymentActiveAfter(pWorkBlockIndex.get(), util_params.m_chainman.GetConsensus(), Consensus::DEPLOYMENT_V20)) {
+        // pre-v20 modifier calculation needs the future cycle base block context, which isn't known yet.
+        return std::nullopt;
+    }
+
+    const auto nQuorums{static_cast<size_t>(llmq_params.signingActiveQuorumCount)};
+    PreviousQuorumQuarters previousQuarters(nQuorums);
+    auto prev_cycles{previousQuarters.GetCycles()};
+    for (size_t idx{0}; idx < prev_cycles.size(); idx++) {
+        const int previousCycleHeight{cycleBaseHeight - llmq_params.dkgInterval * static_cast<int>(idx + 1)};
+        if (previousCycleHeight < 0) {
+            return std::nullopt;
+        }
+        prev_cycles[idx]->m_cycle_index = pWorkBlockIndex->GetAncestor(previousCycleHeight);
+        if (prev_cycles[idx]->m_cycle_index == nullptr) {
+            return std::nullopt;
+        }
+        if (auto opt_snap = util_params.m_qsnapman.GetSnapshotForBlock(llmq_params.type, prev_cycles[idx]->m_cycle_index);
+            opt_snap.has_value()) {
+            prev_cycles[idx]->m_snap = opt_snap.value();
+        } else {
+            return std::nullopt;
+        }
+        prev_cycles[idx]->m_members = GetQuorumQuarterMembersBySnapshot(llmq_params, util_params.m_dmnman,
+                                                                        util_params.m_chainman.GetConsensus(),
+                                                                        prev_cycles[idx]->m_cycle_index,
+                                                                        prev_cycles[idx]->m_snap,
+                                                                        cycleBaseHeight);
+    }
+
+    CDeterministicMNList allMns = util_params.m_dmnman.GetListForBlock(pWorkBlockIndex);
+    const auto modifier = GetHashModifierFromWorkBlock(llmq_params, pWorkBlockIndex.get());
+    auto newQuarterMembers = BuildNewQuorumQuarterMembers(llmq_params, util_params, allMns, previousQuarters,
+                                                          modifier, pWorkBlockIndex, cycleBaseHeight,
+                                                          /*storeSnapshot=*/false);
+    if (newQuarterMembers.size() != nQuorums) {
+        return std::nullopt;
+    }
+
+    QuorumMembers quorumMembers;
+    for (auto* prev_cycle : prev_cycles | std::views::reverse) {
+        quorumMembers.insert(quorumMembers.end(),
+                             prev_cycle->m_members[quorumIndex].begin(),
+                             prev_cycle->m_members[quorumIndex].end());
+    }
+    quorumMembers.insert(quorumMembers.end(),
+                         newQuarterMembers[quorumIndex].begin(),
+                         newQuarterMembers[quorumIndex].end());
+
+    return quorumMembers;
+}
+
 QuorumMembers GetAllQuorumMembers(Consensus::LLMQType llmqType, const UtilParameters& util_params, bool reset_cache)
 {
     static RecursiveMutex cs_members;
diff --git a/src/llmq/utils.h b/src/llmq/utils.h
@@ -16,6 +16,7 @@
 
 #include <gsl/pointers.h>
 
+#include <optional>
 #include <unordered_set>
 #include <vector>
 
@@ -75,6 +76,13 @@ std::vector<CDeterministicMNCPtr> ComputeNonRotatedQuorumMembersFromWorkBlock(
     Consensus::LLMQType llmqType, const CChainParams& chainparams, const CDeterministicMNList& mn_list,
     gsl::not_null<const CBlockIndex*> pWorkBlockIndex, int quorumHeight);
 
+// Predicts the members of a future rotated v20 quorum from its already-known cycle work block,
+// before the next cycle base block exists on chain. Returns std::nullopt when the historical
+// snapshots needed for quarter rotation are not available.
+std::optional<std::vector<CDeterministicMNCPtr>> ComputeRotatedQuorumMembersFromWorkBlock(
+    Consensus::LLMQType llmqType, const UtilParameters& util_params,
+    gsl::not_null<const CBlockIndex*> pWorkBlockIndex, int quorumHeight);
+
 Uint256HashSet GetQuorumConnections(const Consensus::LLMQParams& llmqParams, const CSporkManager& sporkman,
                                     const UtilParameters& util_params, const uint256& forMember, bool onlyOutbound);
 
diff --git a/src/rpc/quorums.cpp b/src/rpc/quorums.cpp
@@ -998,7 +998,7 @@ static RPCHelpMan quorum_dkginfo()
             {
                 {RPCResult::Type::NUM, "active_dkgs", "Total number of active DKG sessions this node is participating in right now"},
                 {RPCResult::Type::NUM, "next_dkg", "The number of blocks until the next potential DKG session"},
-                {RPCResult::Type::ARR, "upcoming_dkgs", /*optional=*/true, "Upcoming DKG sessions for the given proTxHash whose work block is already mined, i.e. sessions starting within the work-diff depth",
+                {RPCResult::Type::ARR, "upcoming_dkgs", /*optional=*/true, "Upcoming DKG sessions for the given proTxHash whose work block is already mined. For rotated quorums all indices in a cycle share the cycle base work block",
                 {
                     {RPCResult::Type::OBJ, "", "",
                     {
@@ -1068,7 +1068,11 @@ static RPCHelpMan quorum_dkginfo()
                 if (quorumHeight <= nTipHeight) {
                     quorumHeight += llmq_params.dkgInterval;
                 }
-                if (quorumHeight <= nTipHeight || quorumHeight - nTipHeight > llmq::WORK_DIFF_DEPTH) {
+                const int cycleBaseHeight{quorumHeight - quorumIndex};
+                // Rotated quorums share the work block of their cycle base, so gate
+                // availability on the work block height rather than each index's start height
+                const int workHeight{(rotation_enabled ? cycleBaseHeight : quorumHeight) - llmq::WORK_DIFF_DEPTH};
+                if (workHeight > nTipHeight) {
                     continue;
                 }
 
@@ -1080,15 +1084,7 @@ static RPCHelpMan quorum_dkginfo()
                 obj.pushKV("blocksUntilStart", quorumHeight - nTipHeight);
                 obj.pushKV("proTxHash", proTxHash.ToString());
 
-                if (llmq_params.useRotation) {
-                    obj.pushKV("known", false);
-                    obj.pushKV("reason", "rotated quorum prediction is not exposed yet");
-                    upcoming.push_back(obj);
-                    continue;
-                }
-
-                int workHeight = quorumHeight - llmq::WORK_DIFF_DEPTH;
-                if (workHeight < 0 || workHeight > nTipHeight) {
+                if (workHeight < 0) {
                     obj.pushKV("known", false);
                     obj.pushKV("reason", "work block is not available yet");
                     upcoming.push_back(obj);
@@ -1103,9 +1099,25 @@ static RPCHelpMan quorum_dkginfo()
                     continue;
                 }
 
-                auto mnList = CHECK_NONFATAL(node.dmnman)->GetListForBlock(pWorkBlockIndex);
-                auto members = llmq::utils::ComputeNonRotatedQuorumMembersFromWorkBlock(
-                    llmq_params.type, Params(), mnList, pWorkBlockIndex, quorumHeight);
+                std::vector<CDeterministicMNCPtr> members;
+                if (rotation_enabled) {
+                    const LLMQContext& llmq_ctx = EnsureLLMQContext(node);
+                    auto predicted_members = llmq::utils::ComputeRotatedQuorumMembersFromWorkBlock(
+                        llmq_params.type,
+                        {*CHECK_NONFATAL(node.dmnman), *CHECK_NONFATAL(llmq_ctx.qsnapman), chainman, pindexTip},
+                        pWorkBlockIndex, quorumHeight);
+                    if (!predicted_members.has_value()) {
+                        obj.pushKV("known", false);
+                        obj.pushKV("reason", "rotated quorum snapshots are not available");
+                        upcoming.push_back(obj);
+                        continue;
+                    }
+                    members = std::move(predicted_members.value());
+                } else {
+                    auto mnList = CHECK_NONFATAL(node.dmnman)->GetListForBlock(pWorkBlockIndex);
+                    members = llmq::utils::ComputeNonRotatedQuorumMembersFromWorkBlock(
+                        llmq_params.type, Params(), mnList, pWorkBlockIndex, quorumHeight);
+                }
 
                 obj.pushKV("known", true);
                 int memberIndex{-1};
diff --git a/test/functional/feature_llmq_rotation.py b/test/functional/feature_llmq_rotation.py
@@ -294,15 +294,8 @@ def run_test(self):
         assert_equal(len(default_upcoming_100), 1)
         assert_equal(default_upcoming_100[0]["proTxHash"], active_mn.proTxHash)
 
-        # Rotated quorums cannot be predicted before their snapshots exist
-        upcoming_all = active_mn.get_node(self).quorum("dkginfo", active_mn.proTxHash)["upcoming_dkgs"]
-        rotated_entries = [d for d in upcoming_all if d["llmqType"] == llmq_type]
-        assert_greater_than_or_equal(len(rotated_entries), 1)
-        for entry in rotated_entries:
-            assert_equal(entry["known"], False)
-            assert_equal(entry["reason"], "rotated quorum prediction is not exposed yet")
-
         predicted_members = {}
+        predicted_rotated_members = {0: {}, 1: {}}
         for mn in self.mninfo:
             dkg_info = mn.get_node(self).quorum("dkginfo", mn.proTxHash)
             upcoming_100 = [d for d in dkg_info["upcoming_dkgs"] if d["llmqType"] == 100]
@@ -319,15 +312,37 @@ def run_test(self):
             assert_equal(predicted_100["memberCount"], self.llmq_size)
             assert_equal(predicted_100["isMember"], predicted_100["memberIndex"] != -1)
             predicted_members[mn.proTxHash] = predicted_100["isMember"]
-        assert_equal(sum(predicted_members.values()), self.llmq_size)
 
-        self.log.info("Mine the predicted type-100 quorum and compare selected members")
-        quorum_hash = self.mine_quorum()
-        quorum_info = self.nodes[0].quorum("info", 100, quorum_hash)
-        assert_equal(quorum_info["height"], expected_quorum_height)
-        actual_members = set(extract_quorum_members(quorum_info))
-        predicted_member_hashes = set(proTxHash for proTxHash, is_member in predicted_members.items() if is_member)
-        assert_equal(predicted_member_hashes, actual_members)
+            upcoming_rotated = [d for d in dkg_info["upcoming_dkgs"] if d["llmqType"] == llmq_type]
+            # All indices of the upcoming cycle share the cycle base work block, so
+            # every rotated quorumIndex must be reported once that work block is mined
+            assert_equal([d["quorumIndex"] for d in upcoming_rotated], [0, 1])
+            for predicted_rotated in upcoming_rotated:
+                quorum_index = predicted_rotated["quorumIndex"]
+                assert_equal(predicted_rotated["llmqTypeName"], llmq_type_name)
+                assert_equal(predicted_rotated["quorumHeight"], expected_quorum_height + quorum_index)
+                assert_equal(predicted_rotated["blocksUntilStart"], expected_quorum_height + quorum_index - tip)
+                assert_equal(predicted_rotated["proTxHash"], mn.proTxHash)
+                assert_equal(predicted_rotated["known"], True)
+                assert_equal(predicted_rotated["workBlockHeight"], expected_quorum_height - 8)
+                assert_equal(predicted_rotated["workBlockHash"], self.nodes[0].getblockhash(expected_quorum_height - 8))
+                assert_equal(predicted_rotated["memberCount"], self.llmq_size_dip0024)
+                assert_equal(predicted_rotated["isMember"], predicted_rotated["memberIndex"] != -1)
+                predicted_rotated_members[quorum_index][mn.proTxHash] = predicted_rotated["isMember"]
+        assert_equal(sum(predicted_members.values()), self.llmq_size)
+        for quorum_index in [0, 1]:
+            assert_equal(sum(predicted_rotated_members[quorum_index].values()), self.llmq_size_dip0024)
+
+        self.log.info("Mine the predicted rotated quorums and compare selected members")
+        quorum_infos_rotated = self.mine_cycle_quorum()
+        assert_equal(quorum_infos_rotated[0]["height"], expected_quorum_height)
+        for quorum_index, quorum_info_rotated in enumerate(quorum_infos_rotated):
+            assert_equal(quorum_info_rotated["quorumIndex"], quorum_index)
+            actual_rotated_members = set(extract_quorum_members(quorum_info_rotated))
+            predicted_rotated_member_hashes = set(
+                proTxHash for proTxHash, is_member in predicted_rotated_members[quorum_index].items() if is_member
+            )
+            assert_equal(predicted_rotated_member_hashes, actual_rotated_members)
 
     def test_getmnlistdiff_quorums(self, baseBlockHash, blockHash, baseQuorumList, expectedDeleted, expectedNew, testQuorumsCLSigs = True):
         d = self.test_getmnlistdiff_base(baseBlockHash, blockHash, testQuorumsCLSigs)
