test: replace argument is_first to global flag to see if cycle quorum is ready

knst · knst · commit 32d35b118ef5 · 2025-08-20T00:52:34.000+07:00
This flag is easy to forget and if it is forgotten, everything works as expected,
but extra 24 * 3 useless blocks are generated for each
diff --git a/test/functional/feature_llmq_connections.py b/test/functional/feature_llmq_connections.py
@@ -88,7 +88,7 @@ def run_test(self):
                 try:
                     with mn.get_node(self).assert_debug_log(['removing masternodes quorum connections']):
                         with mn.get_node(self).assert_debug_log(['keeping mn quorum connections']):
-                            self.mine_cycle_quorum(is_first=False)
+                            self.mine_cycle_quorum()
                             mn.get_node(self).mockscheduler(60) # we check for old connections via the scheduler every 60 seconds
                     removed = True
                 except:
@@ -103,7 +103,7 @@ def run_test(self):
             if len(mn.get_node(self).quorum("memberof", mn.proTxHash)) > 0:
                 try:
                     with mn.get_node(self).assert_debug_log(['adding mn inter-quorum connections']):
-                        self.mine_cycle_quorum(is_first=False)
+                        self.mine_cycle_quorum()
                     added = True
                 except:
                     pass # it's ok to not add connections sometimes
diff --git a/test/functional/feature_llmq_rotation.py b/test/functional/feature_llmq_rotation.py
@@ -135,6 +135,7 @@ def run_test(self):
         self.log.info("Cycle H+2C height:" + str(self.nodes[0].getblockcount()))
         self.log.info("Wait for chainlock")
         self.wait_for_chainlocked_block_all_nodes(self.nodes[0].getbestblockhash())
+        self.cycle_quorum_is_ready = True
 
         b_0 = self.nodes[0].getbestblockhash()
 
@@ -150,8 +151,7 @@ def run_test(self):
             self.generate(self.nodes[0], 1, sync_fun=lambda: self.sync_blocks(nodes))
             self.wait_for_chainlocked_block_all_nodes(self.nodes[0].getbestblockhash())
 
-
-        (quorum_info_0_0, quorum_info_0_1) = self.mine_cycle_quorum(is_first=False)
+        (quorum_info_0_0, quorum_info_0_1) = self.mine_cycle_quorum()
         assert(self.test_quorum_listextended(quorum_info_0_0, llmq_type_name))
         assert(self.test_quorum_listextended(quorum_info_0_1, llmq_type_name))
         quorum_members_0_0 = extract_quorum_members(quorum_info_0_0)
@@ -173,7 +173,7 @@ def run_test(self):
         self.log.info("Wait for chainlock")
         self.wait_for_chainlocked_block_all_nodes(self.nodes[0].getbestblockhash())
 
-        (quorum_info_1_0, quorum_info_1_1) = self.mine_cycle_quorum(is_first=False)
+        (quorum_info_1_0, quorum_info_1_1) = self.mine_cycle_quorum()
         assert(self.test_quorum_listextended(quorum_info_1_0, llmq_type_name))
         assert(self.test_quorum_listextended(quorum_info_1_1, llmq_type_name))
         quorum_members_1_0 = extract_quorum_members(quorum_info_1_0)
@@ -207,7 +207,7 @@ def run_test(self):
         self.wait_for_chainlocked_block_all_nodes(self.nodes[0].getbestblockhash())
 
         self.log.info("Mine a quorum to invalidate")
-        (quorum_info_3_0, quorum_info_3_1) = self.mine_cycle_quorum(is_first=False)
+        (quorum_info_3_0, quorum_info_3_1) = self.mine_cycle_quorum()
 
         new_quorum_list = self.nodes[0].quorum("list", llmq_type)
         assert_equal(len(new_quorum_list[llmq_type_name]), len(quorum_list[llmq_type_name]) + 2)
diff --git a/test/functional/rpc_verifyislock.py b/test/functional/rpc_verifyislock.py
@@ -58,7 +58,7 @@ def run_test(self):
         assert node.verifyislock(request_id, txid, rec_sig, node.getblockcount() + 100)
 
         # Mine one more cycle of rotated quorums
-        self.mine_cycle_quorum(is_first=False)
+        self.mine_cycle_quorum()
         # Create an ISLOCK using an active quorum which will be replaced when a new cycle happens
         request_id = None
         utxos = node.listunspent()
@@ -81,7 +81,7 @@ def run_test(self):
         # Create the ISDLOCK, then mine a cycle quorum to move renew active set
         isdlock = self.create_isdlock(rawtx)
         # Mine one block to trigger the "signHeight + dkgInterval" verification for the ISDLOCK
-        self.mine_cycle_quorum(is_first=False)
+        self.mine_cycle_quorum()
         # Verify the ISLOCK for a transaction that is not yet known by the node
         rawtx_txid = node.decoderawtransaction(rawtx)["txid"]
         assert_raises_rpc_error(-5, "No such mempool or blockchain transaction", node.getrawtransaction, rawtx_txid)
diff --git a/test/functional/test_framework/test_framework.py b/test/functional/test_framework/test_framework.py
@@ -1529,6 +1529,8 @@ def set_dash_test_params(self, num_nodes, masterodes_count, extra_args=None, evo
         # This is EXPIRATION_TIMEOUT + EXPIRATION_BIAS in CQuorumDataRequest
         self.quorum_data_request_expiration_timeout = 360
 
+        # used by helper mine_cycle_quorum
+        self.cycle_quorum_is_ready = False
 
     def delay_v20_and_mn_rr(self, height=None):
         self.v20_height = height
@@ -2194,7 +2196,7 @@ def mine_quorum(self, llmq_type_name="llmq_test", llmq_type=100, expected_connec
 
         return new_quorum
 
-    def mine_cycle_quorum(self, is_first=True):
+    def mine_cycle_quorum(self):
         spork21_active = self.nodes[0].spork('show')['SPORK_21_QUORUM_ALL_CONNECTED'] <= 1
         spork23_active = self.nodes[0].spork('show')['SPORK_23_QUORUM_POSE'] <= 1
 
@@ -2217,10 +2219,12 @@ def mine_cycle_quorum(self, is_first=True):
 
         skip_count = cycle_length - (cur_block % cycle_length)
         # move forward to next 3 DKG rounds for the first quorum
-        extra_blocks = 24 * 3 if is_first else 0
+        extra_blocks = 0 if self.cycle_quorum_is_ready else 24 * 3
         self.move_blocks(nodes, extra_blocks + skip_count)
         self.log.info('Moved from block %d to %d' % (cur_block, self.nodes[0].getblockcount()))
 
+        self.cycle_quorum_is_ready = True
+
         q_0 = self.nodes[0].getbestblockhash()
         self.log.info("Expected quorum_0 at:" + str(self.nodes[0].getblockcount()))
         self.log.info("Expected quorum_0 hash:" + str(q_0))
