test: reuse single-member quorum helper in feature_llmq_singlenode

Address review feedback on mine_quorum_single_member:

- Drop the unused skip_maturity parameter; no caller sets it, so the
  quorum is always matured.
- Mine a full DKG cycle per iteration instead of one block at a time.
  A single-member DKG has no phase/connection waits, so a batched
  generate reaches the commitment's mining window far more cheaply.
- Replace feature_llmq_singlenode.py's local mine_single_node_quorum
  with the shared helper (and drop the now-unused time import).
- Remove quorumIndex (and the now-constant is_mature) from the log;
  quorumIndex is meaningless for the non-rotating llmq_test quorum.

All assertions and test semantics are preserved. rpc_quorum.py,
rpc_verifychainlock.py, and feature_llmq_singlenode.py all pass.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

Author: thepastaclaw

test/functional/feature_llmq_singlenode.py

@@ -11,8 +11,6 @@
 
 '''
 
-import time
-
 from test_framework.authproxy import JSONRPCException
 from test_framework.test_framework import (
     DashTestFramework,
@@ -40,21 +38,6 @@ def set_test_params(self):
                 evo_count=2)
         self.set_dash_llmq_test_params(1, 1)
 
-    def mine_single_node_quorum(self):
-        node = self.nodes[0]
-        quorums = node.quorum('list')['llmq_test']
-
-        skip_count = 24 - (self.nodes[0].getblockcount() % 24)
-        if skip_count != 0:
-            self.bump_mocktime(1)
-            self.generate(self.nodes[0], skip_count)
-        time.sleep(1)
-        self.generate(self.nodes[0], 30)
-        new_quorums_list = node.quorum('list')['llmq_test']
-
-        self.log.info(f"Test Quorums at height={node.getblockcount()} : {new_quorums_list}")
-        assert new_quorums_list != quorums
-
     def check_sigs(self, hasrecsigs, isconflicting1, isconflicting2):
         has_sig = False
         conflicting_1 = False
@@ -97,7 +80,7 @@ def run_test(self):
         self.dynamically_add_masternode(evo=True)
         self.connect_nodes(1, 2)
 
-        self.mine_single_node_quorum()
+        self.mine_quorum_single_member()
 
         self.log_connections()
         assert_greater_than(len(self.nodes[0].quorum('list')['llmq_test']), 0)
@@ -158,13 +141,13 @@ def run_test(self):
         assert_raises_rpc_error(-8, "quorum not found", node.quorum, "verify", q_type, id, msgHash, recsig["sig"], hash_bad)
 
         self.log.info("Mine one more quorum, so that we have 2 active ones, nothing should change")
-        self.mine_single_node_quorum()
+        self.mine_quorum_single_member()
         self.assert_sigs_nochange(True, False, True, 3)
 
 
         self.log.info("Mine 2 more quorums, so that the one used for the the recovered sig should become inactive, nothing should change")
-        self.mine_single_node_quorum()
-        self.mine_single_node_quorum()
+        self.mine_quorum_single_member()
+        self.mine_quorum_single_member()
         self.assert_sigs_nochange(True, False, True, 3)
 
         self.log_connections()

test/functional/test_framework/test_framework.py

@@ -2229,14 +2229,14 @@ def mine_quorum(self, llmq_type_name="llmq_test", llmq_type=100, expected_connec
 
         return new_quorum
 
-    def mine_quorum_single_member(self, llmq_type_name="llmq_test", llmq_type=100, skip_maturity=False):
+    def mine_quorum_single_member(self, llmq_type_name="llmq_test", llmq_type=100):
         """Mine a single-member (llmq_size == 1) quorum and return its hash.
 
         A drop-in for mine_quorum in single-member tests. mine_quorum can't be
         reused here: a one-member DKG has no inter-member connections or probes,
         so its phase/connection waits never complete. Instead advance to the next
-        DKG cycle and generate until the quorum is listed, then mature it.
-        Mirrors feature_llmq_singlenode.py.
+        DKG cycle and mine a full cycle so the commitment is carried through its
+        mining window, then mature the quorum. Mirrors feature_llmq_singlenode.py.
         """
         assert_equal(self.llmq_size, 1)
         node = self.nodes[0]
@@ -2249,23 +2249,23 @@ def mine_quorum_single_member(self, llmq_type_name="llmq_test", llmq_type=100, s
             self.bump_mocktime(1)
             self.generate(node, skip_count)
 
-        # Generate through the DKG window until a new quorum is mined and listed.
+        # Mine through the DKG window a whole cycle at a time until the new
+        # quorum is mined and listed. A single-member DKG needs no phase waits,
+        # so a batched generate is enough (and far cheaper than block-by-block).
         def new_quorum_mined():
             self.bump_mocktime(1)
-            self.generate(node, 1)
+            self.generate(node, llmq_cycle_len)
             return len(set(node.quorum("list")[llmq_type_name]) - quorums) > 0
         self.wait_until(new_quorum_mined, timeout=60, sleep=0)
 
         new_quorum = (set(node.quorum("list")[llmq_type_name]) - quorums).pop()
         quorum_info = node.quorum("info", llmq_type, new_quorum)
 
-        if not skip_maturity:
-            # Mine 8 (SIGN_HEIGHT_OFFSET) more blocks so the new quorum is eligible for signing.
-            self.generate(node, 8)
+        # Mine 8 (SIGN_HEIGHT_OFFSET) more blocks so the new quorum is eligible for signing.
+        self.generate(node, 8)
 
-        self.log.info(f"New single-member quorum: height={quorum_info['height']}, quorumHash={new_quorum}, "
-                      f"is_mature={not skip_maturity}, quorumIndex={quorum_info['quorumIndex']}, "
-                      f"minedBlock={quorum_info['minedBlock']}")
+        self.log.info(f"New single-member quorum: height={quorum_info['height']}, "
+                      f"quorumHash={new_quorum}, minedBlock={quorum_info['minedBlock']}")
         return new_quorum
 
     def mine_cycle_quorum(self):