refactor: improve is-waiting helper by including mempool sync bump of mocktime

Author: knst

test/functional/feature_asset_locks.py

@@ -391,10 +391,7 @@ def test_asset_unlocks(self, node_wallet, node, pubkey):
 
         assert_equal(node.getmempoolentry(txid)['fees']['base'], Decimal("0.0007"))
         is_id = node_wallet.sendtoaddress(node_wallet.getnewaddress(), 1)
-        self.bump_mocktime(30)
-        self.sync_mempools()
-        for node in self.nodes:
-            self.wait_for_instantlock(is_id, node)
+        self.wait_for_instantlock(is_id)
 
         rawtx = node.getrawtransaction(txid, 1)
         rawtx_is = node.getrawtransaction(is_id, 1)

test/functional/feature_llmq_is_cl_conflicts.py

@@ -99,11 +99,7 @@ def test_chainlock_overrides_islock(self, test_block_conflict, mine_confllicting
         rawtx4_txid = self.nodes[0].sendrawtransaction(rawtx4)
 
         # wait for transactions to propagate
-        self.bump_mocktime(30)
-        self.sync_mempools()
-        for node in self.nodes:
-            self.wait_for_instantlock(rawtx1_txid, node)
-            self.wait_for_instantlock(rawtx4_txid, node)
+        self.wait_for_instantlock(rawtx1_txid, rawtx4_txid)
 
         block = create_block_with_mnpayments(self.mninfo, self.nodes[0], [rawtx2_obj])
         if test_block_conflict:
@@ -160,10 +156,7 @@ def test_chainlock_overrides_islock(self, test_block_conflict, mine_confllicting
         rawtx5 = self.nodes[0].signrawtransactionwithwallet(rawtx5)['hex']
         rawtx5_txid = self.nodes[0].sendrawtransaction(rawtx5)
         # wait for the transaction to propagate
-        self.bump_mocktime(30)
-        self.sync_mempools()
-        for node in self.nodes:
-            self.wait_for_instantlock(rawtx5_txid, node)
+        self.wait_for_instantlock(rawtx5_txid)
 
         if mine_confllicting:
             # Lets verify that the ISLOCKs got pruned and conflicting txes were mined but never confirmed
@@ -243,18 +236,15 @@ def test_chainlock_overrides_islock_overrides_nonchainlock(self):
         # Should drop tx1 and accept tx2 because there is an isdlock waiting for it
         self.nodes[0].sendrawtransaction(rawtx2)
         # bump mocktime to force tx relay
-        self.bump_mocktime(60)
-        self.sync_mempools()
-        for node in self.nodes:
-            self.wait_for_instantlock(rawtx2_txid, node)
+        self.wait_for_instantlock(rawtx2_txid)
 
         # Should not allow competing txes now
         assert_raises_rpc_error(-26, "tx-txlock-conflict", self.nodes[0].sendrawtransaction, rawtx1)
 
         islock_tip = self.generate(self.nodes[0], 1)[0]
 
+        self.wait_for_instantlock(rawtx2_txid, skip_sync=True)
         for node in self.nodes:
-            self.wait_for_instantlock(rawtx2_txid, node)
             assert_equal(node.getrawtransaction(rawtx2_txid, True)['confirmations'], 1)
             assert_equal(node.getbestblockhash(), islock_tip)
 

test/functional/feature_llmq_is_retroactive.py

@@ -65,7 +65,7 @@ def run_test(self):
         # We have to wait in order to include tx in block
         self.bump_mocktime(10 * 60 + 1)
         block = self.generate(self.nodes[0], 1, sync_fun=self.no_op)[0]
-        self.wait_for_instantlock(txid, self.nodes[0])
+        self.wait_for_instantlock(txid, nodes=[self.nodes[0]], skip_sync=True)
         self.nodes[0].sporkupdate("SPORK_19_CHAINLOCKS_ENABLED", 0)
         self.wait_for_sporks_same()
         self.wait_for_chainlocked_block_all_nodes(block)
@@ -78,9 +78,7 @@ def run_test(self):
         txid = self.nodes[0].sendtoaddress(self.nodes[0].getnewaddress(), 1)
         # 3 nodes should be enough to create an IS lock even if nodes 4 and 5 (which have no tx itself)
         # are the only "neighbours" in intra-quorum connections for one of them.
-        self.bump_mocktime(30)
-        self.sync_mempools(self.nodes[:3])
-        self.wait_for_instantlock(txid, self.nodes[0])
+        self.wait_for_instantlock(txid, nodes=self.nodes[:3])
         block = self.generate(self.nodes[0], 1, sync_fun=self.no_op)[0]
         self.wait_for_chainlocked_block_all_nodes(block)
 
@@ -101,7 +99,7 @@ def run_test(self):
         self.nodes[3].sendrawtransaction(self.nodes[0].getrawtransaction(txid))
         # node 3 should vote on a tx now since it became aware of it via sendrawtransaction
         # and this should be enough to complete an IS lock
-        self.wait_for_instantlock(txid, self.nodes[0])
+        self.wait_for_instantlock(txid, nodes=[self.nodes[0]], skip_sync=True)
 
         self.log.info("testing retroactive signing with unknown TX")
         self.isolate_node(3)

test/functional/feature_llmq_singlenode.py

@@ -106,8 +106,7 @@ def run_test(self):
 
         self.log.info("Send funds and wait InstantSend lock")
         txid = self.nodes[0].sendtoaddress(self.nodes[0].getnewaddress(), 1)
-        self.bump_mocktime(30)
-        self.wait_for_instantlock(txid, self.nodes[0])
+        self.wait_for_instantlock(txid, nodes=[self.nodes[0]])
 
         self.log.info("Test various options to sign messages with nodes")
         recsig_time = self.mocktime
@@ -184,9 +183,8 @@ def run_test(self):
         self.log.info(f"Chainlock on block: {block_hash} is expecting")
         self.wait_for_best_chainlock(self.nodes[0], block_hash)
         txid = self.nodes[0].sendtoaddress(self.nodes[0].getnewaddress(), 1)
-        self.bump_mocktime(30)
         self.log.info(f"InstantSend lock on tx: {txid} is expecting")
-        self.wait_for_instantlock(txid, self.nodes[0])
+        self.wait_for_instantlock(txid, nodes=[self.nodes[0]])
 
 
 if __name__ == '__main__':

test/functional/feature_notifications.py

@@ -139,9 +139,7 @@ def run_test(self):
             tx_count = 10
             for _ in range(tx_count):
                 txid = self.nodes[0].sendtoaddress(self.nodes[1].getnewaddress(), 1)
-                self.bump_mocktime(30)
-                self.sync_mempools()
-                self.wait_for_instantlock(txid, self.nodes[0])
+                self.wait_for_instantlock(txid, nodes=[self.nodes[0]])
 
             # wait at most 10 seconds for expected number of files before reading the content
             self.bump_mocktime(30)

test/functional/interface_zmq_dash.py

@@ -296,9 +296,7 @@ def test_instantsend_publishers(self):
         assert_equal(['None'], self.nodes[0].getislocks([rpc_raw_tx_1['txid']]))
         # Send the first transaction and wait for the InstantLock
         rpc_raw_tx_1_hash = self.nodes[0].sendrawtransaction(rpc_raw_tx_1['hex'])
-        self.bump_mocktime(30)
-        self.sync_mempools()
-        self.wait_for_instantlock(rpc_raw_tx_1_hash, self.nodes[0])
+        self.wait_for_instantlock(rpc_raw_tx_1_hash)
         # Validate hashtxlock
         zmq_tx_lock_hash = self.subscribers[ZMQPublisher.hash_tx_lock].receive().read(32).hex()
         assert_equal(zmq_tx_lock_hash, rpc_raw_tx_1['txid'])
@@ -350,9 +348,7 @@ def test_instantsend_publishers(self):
             pass
         # Now send the tx itself
         self.test_node.send_tx(from_hex(msg_tx(),rpc_raw_tx_3['hex']))
-        self.bump_mocktime(30)
-        self.sync_mempools()
-        self.wait_for_instantlock(rpc_raw_tx_3['txid'], self.nodes[0])
+        self.wait_for_instantlock(rpc_raw_tx_3['txid'])
         # Validate hashtxlock
         zmq_tx_lock_hash = self.subscribers[ZMQPublisher.hash_tx_lock].receive().read(32).hex()
         assert_equal(zmq_tx_lock_hash, rpc_raw_tx_3['txid'])
@@ -385,9 +381,7 @@ def test_governance_publishers(self):
         }
         proposal_hex = ''.join(format(x, '02x') for x in json.dumps(proposal_data).encode())
         collateral = self.nodes[0].gobject("prepare", "0", proposal_rev, proposal_time, proposal_hex)
-        self.bump_mocktime(30)
-        self.sync_mempools()
-        self.wait_for_instantlock(collateral, self.nodes[0])
+        self.wait_for_instantlock(collateral, nodes=[self.nodes[0]])
         self.generate(self.nodes[0], 6, sync_fun=lambda: self.sync_blocks())
         rpc_proposal_hash = self.nodes[0].gobject("submit", "0", proposal_rev, proposal_time, proposal_hex, collateral)
         # Validate hashgovernanceobject

test/functional/p2p_instantsend.py

@@ -45,10 +45,7 @@ def test_block_doublespend(self):
         # feed the sender with some balance
         sender_addr = sender.getnewaddress()
         is_id = self.nodes[0].sendtoaddress(sender_addr, 1)
-        self.bump_mocktime(30)
-        self.sync_mempools()
-        for node in self.nodes:
-            self.wait_for_instantlock(is_id, node)
+        self.wait_for_instantlock(is_id)
         self.generate(self.nodes[0], 2)
 
         # create doublespending transaction, but don't relay it
@@ -61,10 +58,7 @@ def test_block_doublespend(self):
         # wait for the transaction to propagate
         connected_nodes = self.nodes.copy()
         del connected_nodes[self.isolated_idx]
-        self.sync_mempools(connected_nodes)
-        self.bump_mocktime(30)
-        for node in connected_nodes:
-            self.wait_for_instantlock(is_id, node)
+        self.wait_for_instantlock(is_id, nodes=connected_nodes)
         # send doublespend transaction to isolated node
         dblspnd_txid = isolated.sendrawtransaction(dblspnd_tx['hex'])
         # generate block on isolated node with doublespend transaction
@@ -106,10 +100,7 @@ def test_mempool_doublespend(self):
         # feed the sender with some balance
         sender_addr = sender.getnewaddress()
         is_id = self.nodes[0].sendtoaddress(sender_addr, 1)
-        self.bump_mocktime(30)
-        self.sync_mempools()
-        for node in self.nodes:
-            self.wait_for_instantlock(is_id, node)
+        self.wait_for_instantlock(is_id)
         self.generate(self.nodes[0], 2)
 
         # create doublespending transaction, but don't relay it
@@ -130,17 +121,11 @@ def test_mempool_doublespend(self):
         receiver_addr = receiver.getnewaddress()
         is_id = sender.sendtoaddress(receiver_addr, 0.9)
         # wait for the transaction to propagate
-        self.bump_mocktime(30)
-        self.sync_mempools()
-        for node in self.nodes:
-            self.wait_for_instantlock(is_id, node)
+        self.wait_for_instantlock(is_id)
         assert dblspnd_txid not in set(isolated.getrawmempool())
         # send coins back to the controller node without waiting for confirmations
         sentback_id = receiver.sendtoaddress(self.nodes[0].getnewaddress(), 0.9, "", "", True)
-        self.bump_mocktime(30)
-        self.sync_mempools()
-        for node in self.nodes:
-            self.wait_for_instantlock(sentback_id, node)
+        self.wait_for_instantlock(sentback_id)
         assert_equal(receiver.getwalletinfo()["balance"], 0)
         # mine more blocks
         self.generate(self.nodes[0], 2)

test/functional/rpc_verifyislock.py

@@ -41,9 +41,7 @@ def run_test(self):
         self.generate(self.nodes[0], 8, sync_fun=self.sync_blocks())
 
         txid = node.sendtoaddress(node.getnewaddress(), 1)
-        self.bump_mocktime(30)
-        self.sync_mempools()
-        self.wait_for_instantlock(txid, node)
+        self.wait_for_instantlock(txid, nodes=[node])
 
         request_id = self.get_request_id(self.nodes[0].getrawtransaction(txid))
         request_id_rpc = self.nodes[0].getislocks([txid])[0]["id"]

test/functional/test_framework/test_framework.py

@@ -1945,17 +1945,26 @@ def create_isdlock(self, hextx):
         return isdlock
 
     # due to privacy reasons random delay is used before sending transaction by network
-    # most times is just 2-5 seconds, but once in 1000 it's up to 1000 seconds.
-    # it's recommended to bump mocktime for 30 seconds before wait_for_instantlock
-    def wait_for_instantlock(self, txid, node, timeout=60):
+    # most times it's just 2-5 seconds, but once in 1000 times it's up to 10 seconds and has no bound from the top.
+    def wait_for_instantlock(self, *txids, nodes=None, timeout=60, skip_sync=False):
+        nodes = nodes or self.nodes
+
+        if not skip_sync:
+            self.bump_mocktime(30)
+            self.sync_mempools(nodes)
+
+        self.log.info(f"Expecting InstantLock for {list(txids)}")
 
         def check_instantlock():
             try:
-                return node.getrawtransaction(txid, True)["instantlock"]
+                return all(
+                    node.getrawtransaction(txid, True)["instantlock"]
+                    for txid in txids
+                    for node in nodes
+                )
             except Exception:
                 return False
 
-        self.log.info(f"Expecting InstantLock for {txid}")
         self.wait_until(check_instantlock, timeout=timeout)
 
     def wait_for_chainlocked_block(self, node, block_hash, expected=True, timeout=15):