feat: use single-node quorum for feature_llmq_chainlocks_automatic; isolate node-1 (NOT Masternode) to avoid intermittent random failures

Author: knst

test/functional/feature_llmq_chainlocks_automatic.py

@@ -19,14 +19,11 @@
 
 class LLMQChainLocksAutomaticTest(DashTestFramework):
     def set_test_params(self):
-        self.set_dash_test_params(6, 5)
+        self.set_dash_test_params(3, 1)
+        self.set_dash_llmq_test_params(1, 1)
         self.delay_v20_and_mn_rr(height=200)
 
     def run_test(self):
-        # Connect all nodes to node1 so that we always have the whole network connected
-        for i in range(2, len(self.nodes)):
-            self.connect_nodes(i, 1)
-
         self.log.info("Wait for initial sync and activate v20")
         self.test_coinbase_best_cl(self.nodes[0], expected_cl_in_cb=False)
         self.activate_v20(expected_activation_height=200)
@@ -39,7 +36,7 @@ def run_test(self):
 
         # Mine enough blocks to create a quorum
         self.log.info("Mine blocks to create first quorum")
-        self.mine_quorum()
+        self.mine_single_node_quorum()
 
         self.log.info("Test automatic chainlock detection from coinbase transactions")
         self.test_automatic_chainlock_detection()
@@ -54,6 +51,7 @@ def test_automatic_chainlock_detection(self):
         """Test that chainlocks embedded in coinbase transactions are automatically detected and processed"""
 
         # Get the current chain state
+        self.wait_for_chainlocked_block(self.nodes[0], self.nodes[0].getbestblockhash())
         initial_best_cl = self.nodes[0].getbestchainlock()
         initial_height = self.nodes[0].getblockcount()
 
@@ -62,8 +60,8 @@ def test_automatic_chainlock_detection(self):
         # Mine a few blocks to generate some chainlocks
         self.log.info("Mining blocks to generate chainlocks...")
         for i in range(5):
-            self.generate(self.nodes[0], 1, sync_fun=self.no_op)
-            time.sleep(0.1)  # Small delay to allow chainlock processing
+            h = self.generate(self.nodes[0], 1, sync_fun=self.no_op)
+            self.wait_for_chainlocked_block(self.nodes[0], h[0])
 
         # Wait for chainlocks to be created and processed
         self.wait_for_chainlocked_block_all_nodes(self.nodes[0].getbestblockhash())
@@ -145,12 +143,12 @@ def test_automatic_detection_edge_cases(self):
         # Test with node isolation and reconnection
         self.log.info("Testing automatic detection with node isolation...")
 
-        # Isolate node 5 and mine some blocks
-        self.isolate_node(5)
-        isolated_blocks = self.generate(self.nodes[5], 2, sync_fun=self.no_op)
+        # Isolate node 1 and mine some blocks
+        self.isolate_node(1)
+        isolated_blocks = self.generate(self.nodes[1], 2, sync_fun=self.no_op)
 
         # Reconnect and see if automatic detection still works
-        self.reconnect_isolated_node(5, 1)
+        self.reconnect_isolated_node(1, 0)
 
         # Mine a block on the main chain that should cause reorganization
         main_block = self.generate(self.nodes[0], 1, sync_fun=self.no_op)[0]
@@ -188,19 +186,5 @@ def test_coinbase_best_cl(self, node, expected_cl_in_cb=True, expected_null_cl=F
             # Verify CL signature
             assert node.verifychainlock(target_block_hash, best_cl_signature, best_cl_height)
 
-    def wait_for_chainlocked_block_all_nodes(self, block_hash, timeout=15):
-        """Wait for a specific block to be chainlocked on all nodes"""
-        for node in self.nodes:
-            wait_until_helper(lambda: self.is_block_chainlocked(node, block_hash), timeout=timeout)
-
-    def is_block_chainlocked(self, node, block_hash):
-        """Check if a block is chainlocked on a specific node"""
-        try:
-            block = node.getblock(block_hash, 1)
-            return block.get("chainlock", False)
-        except:
-            return False
-
-
 if __name__ == '__main__':
     LLMQChainLocksAutomaticTest().main()

test/functional/feature_llmq_singlenode.py

@@ -38,21 +38,6 @@ def set_test_params(self):
         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

test/functional/test_framework/test_framework.py

@@ -2097,6 +2097,21 @@ def move_blocks(self, nodes, num_blocks):
         self.bump_mocktime(1, nodes=nodes)
         self.generate(self.nodes[0], num_blocks, sync_fun=lambda: self.sync_blocks(nodes))
 
+    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 mine_quorum(self, llmq_type_name="llmq_test", llmq_type=100, expected_connections=None, expected_members=None, expected_contributions=None, expected_complaints=0, expected_justifications=0, expected_commitments=None, mninfos_online=None, mninfos_valid=None, skip_maturity=False):
         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