suggestions

Author: UdjinM6

test/functional/feature_asset_locks.py

@@ -607,7 +607,7 @@ def test_withdrawal_limits(self, node_wallet, node, pubkey):
     def test_mn_rr(self, node_wallet, node, pubkey):
         self.log.info("Activate mn_rr...")
         locked = self.get_credit_pool_balance()
-        self.generate(node, 12 - node.getblockcount() % 12)
+        self.generate(node, 12 - node.getblockcount() % 12, sync_fun=self.no_op)
         self.activate_mn_rr(expected_activation_height=node.getblockcount() + 12 * 3)
         self.log.info(f'height: {node.getblockcount()} credit: {self.get_credit_pool_balance()}')
         assert_equal(locked, self.get_credit_pool_balance())

test/functional/feature_dip3_deterministicmns.py

@@ -49,7 +49,7 @@ def start_controller_node(self):
     def run_test(self):
         self.log.info("funding controller node")
         while self.nodes[0].getbalance() < (self.num_initial_mn + 3) * 1000:
-            self.generate(self.nodes[0], 10) # generate enough for collaterals
+            self.generate(self.nodes[0], 10, sync_fun=self.no_op) # generate enough for collaterals
         self.log.info("controller node has {} dash".format(self.nodes[0].getbalance()))
 
         # Make sure we're below block 135 (which activates dip3)
@@ -65,11 +65,11 @@ def run_test(self):
         mns.append(before_dip3_mn)
 
         # block 150 starts enforcing DIP3 MN payments
-        self.generate(self.nodes[0], 150 - self.nodes[0].getblockcount())
+        self.generate(self.nodes[0], 150 - self.nodes[0].getblockcount(), sync_fun=self.no_op)
         assert self.nodes[0].getblockcount() == 150
 
         self.log.info("mining final block for DIP3 activation")
-        self.generate(self.nodes[0], 1)
+        self.generate(self.nodes[0], 1, sync_fun=self.no_op)
 
         # We have hundreds of blocks to sync here, give it more time
         self.log.info("syncing blocks for all nodes")
@@ -239,7 +239,7 @@ def create_mn_collateral(self, node, mn):
         mn.collateral_address = node.getnewaddress()
         mn.collateral_txid = node.sendtoaddress(mn.collateral_address, 1000)
         mn.collateral_vout = None
-        self.generate(node, 1)
+        self.generate(node, 1, sync_fun=self.no_op)
 
         rawtx = node.getrawtransaction(mn.collateral_txid, 1)
         for txout in rawtx['vout']:
@@ -271,7 +271,7 @@ def register_mn(self, node, mn):
         mn.rewards_address = node.getnewaddress()
 
         mn.protx_hash = node.protx('register', mn.collateral_txid, mn.collateral_vout, '127.0.0.1:%d' % mn.p2p_port, mn.ownerAddr, mn.operatorAddr, mn.votingAddr, mn.operator_reward, mn.rewards_address, mn.fundsAddr)
-        self.generate(node, 1)
+        self.generate(node, 1, sync_fun=self.no_op)
 
     def start_mn(self, mn):
         if len(self.nodes) <= mn.idx:
@@ -305,7 +305,7 @@ def test_protx_update_service(self, mn):
 
         # undo
         self.nodes[0].protx('update_service', mn.protx_hash, '127.0.0.1:%d' % mn.p2p_port, mn.blsMnkey, "", mn.fundsAddr)
-        self.generate(self.nodes[0], 1)
+        self.generate(self.nodes[0], 1, sync_fun=self.no_op)
 
     def assert_mnlists(self, mns):
         for node in self.nodes:

test/functional/feature_dip3_v19.py

@@ -90,7 +90,7 @@ def run_test(self):
 
         evo_info_0 = self.dynamically_add_masternode(evo=True, rnd=7)
         assert evo_info_0 is not None
-        self.generate(self.nodes[0], 8, sync_fun=lambda: self.sync_blocks(self.nodes))
+        self.generate(self.nodes[0], 8, sync_fun=lambda: self.sync_blocks())
 
         self.log.info("Checking that protxs with duplicate EvoNodes fields are rejected")
         evo_info_1 = self.dynamically_add_masternode(evo=True, rnd=7, should_be_rejected=True)
@@ -100,7 +100,7 @@ def run_test(self):
         assert evo_info_2 is None
         evo_info_3 = self.dynamically_add_masternode(evo=True, rnd=9)
         assert evo_info_3 is not None
-        self.generate(self.nodes[0], 8, sync_fun=lambda: self.sync_blocks(self.nodes))
+        self.generate(self.nodes[0], 8, sync_fun=lambda: self.sync_blocks())
         self.dynamically_evo_update_service(evo_info_0, 9, should_be_rejected=True)
 
         revoke_protx = self.mninfo[-1].proTxHash
@@ -128,12 +128,12 @@ def test_revoke_protx(self, node_idx, revoke_protx, revoke_keyoperator):
         funds_address = self.nodes[0].getnewaddress()
         fund_txid = self.nodes[0].sendtoaddress(funds_address, 1)
         self.wait_for_instantlock(fund_txid, self.nodes[0])
-        tip = self.generate(self.nodes[0], 1, sync_fun=lambda: self.sync_all(self.nodes))[0]
+        tip = self.generate(self.nodes[0], 1, sync_fun=lambda: self.sync_all())[0]
         assert_equal(self.nodes[0].getrawtransaction(fund_txid, 1, tip)['confirmations'], 1)
 
         protx_result = self.nodes[0].protx('revoke', revoke_protx, revoke_keyoperator, 1, funds_address)
         self.wait_for_instantlock(protx_result, self.nodes[0])
-        tip = self.generate(self.nodes[0], 1)[0]
+        tip = self.generate(self.nodes[0], 1, sync_fun=self.no_op)[0]
         assert_equal(self.nodes[0].getrawtransaction(protx_result, 1, tip)['confirmations'], 1)
         # Revoking a MN results in disconnects. Wait for disconnects to actually happen
         # and then reconnect the corresponding node back to let sync_blocks finish correctly.

test/functional/feature_dip4_coinbasemerkleroots.py

@@ -91,7 +91,7 @@ def run_test(self):
         #############################
         # Now start testing quorum commitment merkle roots
 
-        self.generate(self.nodes[0], 1)
+        self.generate(self.nodes[0], 1, sync_fun=self.no_op)
         oldhash = self.nodes[0].getbestblockhash()
 
         # Test DIP8 activation once with a pre-existing quorum and once without (we don't know in which order it will activate on mainnet)

test/functional/feature_governance.py

@@ -89,17 +89,15 @@ def run_test(self):
         assert_equal(len(self.nodes[0].gobject("list-prepared")), 0)
 
         self.log.info("Check 1st superblock before v20")
-        self.generate(self.nodes[0], 3)
         self.bump_mocktime(3)
-        self.sync_blocks()
+        self.generate(self.nodes[0], 3, sync_fun=self.sync_blocks())
         assert_equal(self.nodes[0].getblockcount(), 130)
         assert_equal(self.nodes[0].getblockchaininfo()["softforks"]["v20"]["active"], False)
         self.check_superblockbudget(False)
 
         self.log.info("Check 2nd superblock before v20")
-        self.generate(self.nodes[0], 10)
         self.bump_mocktime(10)
-        self.sync_blocks()
+        self.generate(self.nodes[0], 10, sync_fun=self.sync_blocks())
         assert_equal(self.nodes[0].getblockcount(), 140)
         assert_equal(self.nodes[0].getblockchaininfo()["softforks"]["v20"]["active"], False)
         self.check_superblockbudget(False)
@@ -117,9 +115,8 @@ def run_test(self):
         p1_collateral_prepare = prepare_object(self.nodes[0], 1, uint256_to_string(0), proposal_time, 1, "Proposal_1", self.p1_amount, self.p1_payout_address)
         p2_collateral_prepare = prepare_object(self.nodes[0], 1, uint256_to_string(0), proposal_time, 1, "Proposal_2", self.p2_amount, self.p2_payout_address)
 
-        self.generate(self.nodes[0], 6)
         self.bump_mocktime(6)
-        self.sync_blocks()
+        self.generate(self.nodes[0], 6, sync_fun=self.sync_blocks())
 
         assert_equal(len(self.nodes[0].gobject("list-prepared")), 3)
         assert_equal(len(self.nodes[0].gobject("list")), 0)
@@ -165,9 +162,8 @@ def run_test(self):
         self.log.info("v20 is expected to be activate since block 160")
         assert block_count + n < 160
         for _ in range(n - 1):
-            self.generate(self.nodes[0], 1)
             self.bump_mocktime(1)
-            self.sync_blocks()
+            self.generate(self.nodes[0], 1, sync_fun=self.sync_blocks())
             self.check_superblockbudget(False)
 
         assert_equal(len(self.nodes[0].gobject("list", "valid", "triggers")), 0)
@@ -193,8 +189,8 @@ def run_test(self):
         isolated = self.nodes[payee_idx]
 
         self.log.info("Move 1 block inside the Superblock maturity window on the isolated node")
-        self.generate(isolated, 1, sync_fun=self.no_op)
         self.bump_mocktime(1)
+        self.generate(isolated, 1, sync_fun=self.no_op)
         self.log.info("The isolated 'winner' should submit new trigger and vote for it")
         self.wait_until(lambda: len(isolated.gobject("list", "valid", "triggers")) == 1, timeout=5)
         isolated_trigger_hash = list(isolated.gobject("list", "valid", "triggers").keys())[0]
@@ -203,8 +199,8 @@ def run_test(self):
         assert_equal(more_votes, False)
 
         self.log.info("Move 1 block enabling the Superblock maturity window on non-isolated nodes")
-        self.generate(self.nodes[0], 1, sync_fun=self.no_op)
         self.bump_mocktime(1)
+        self.generate(self.nodes[0], 1, sync_fun=self.no_op)
         assert_equal(self.nodes[0].getblockcount(), 150)
         assert_equal(self.nodes[0].getblockchaininfo()["softforks"]["v20"]["active"], False)
         self.check_superblockbudget(False)
@@ -214,8 +210,8 @@ def run_test(self):
         assert_equal(has_trigger, False)
 
         self.log.info("Move 1 block inside the Superblock maturity window on non-isolated nodes")
-        self.generate(self.nodes[0], 1, sync_fun=self.no_op)
         self.bump_mocktime(1)
+        self.generate(self.nodes[0], 1, sync_fun=self.no_op)
 
         self.log.info("There is now new 'winner' who should submit new trigger and vote for it")
         self.wait_until(lambda: len(self.nodes[0].gobject("list", "valid", "triggers")) == 1, timeout=5)
@@ -232,8 +228,8 @@ def run_test(self):
             assert(amount_str in payment_amounts_expected)
 
         self.log.info("Move another block inside the Superblock maturity window on non-isolated nodes")
-        self.generate(self.nodes[0], 1, sync_fun=self.no_op)
         self.bump_mocktime(1)
+        self.generate(self.nodes[0], 1, sync_fun=self.no_op)
 
         self.log.info("Every non-isolated MN should vote for the same trigger now, no new triggers should be created")
         self.wait_until(lambda: list(self.nodes[0].gobject("list", "valid", "triggers").values())[0]['YesCount'] == self.mn_count - 1, timeout=5)
@@ -268,9 +264,8 @@ def sync_gov(node):
         assert_equal(more_triggers, False)
 
         self.log.info("Move another block inside the Superblock maturity window")
-        self.generate(self.nodes[0], 1, sync_fun=self.no_op)
         self.bump_mocktime(1)
-        self.sync_blocks()
+        self.generate(self.nodes[0], 1, sync_fun=self.sync_blocks())
 
         self.log.info("Should see NO votes on both triggers now")
         self.wait_until(lambda: self.nodes[0].gobject("list", "valid", "triggers")[winning_trigger_hash]['NoCount'] == 1, timeout=5)
@@ -284,9 +279,8 @@ def sync_gov(node):
 
         self.log.info("Move another block inside the Superblock maturity window")
         with self.nodes[1].assert_debug_log(["CGovernanceManager::VoteGovernanceTriggers"]):
-            self.generate(self.nodes[0], 1, sync_fun=self.no_op)
             self.bump_mocktime(1)
-            self.sync_blocks()
+            self.generate(self.nodes[0], 1, sync_fun=self.sync_blocks())
 
         self.log.info("Vote count should not change even though MNs are allowed to vote again")
         assert_equal(before, self.nodes[1].gobject("count")["votes"])
@@ -298,9 +292,8 @@ def sync_gov(node):
 
         self.log.info("Move remaining n blocks until actual Superblock")
         for i in range(n):
-            self.generate(self.nodes[0], 1, sync_fun=self.no_op)
             self.bump_mocktime(1)
-            self.sync_blocks()
+            self.generate(self.nodes[0], 1, sync_fun=self.sync_blocks())
             # comparing to 159 because bip9 forks are active when the tip is one block behind the activation height
             self.check_superblockbudget(block_count + i + 1 >= 159)
 
@@ -310,9 +303,8 @@ def sync_gov(node):
         self.log.info("Move a few block past the recent superblock height and make sure we have no new votes")
         for _ in range(5):
             with self.nodes[1].assert_debug_log("", [f"Voting NO-FUNDING for trigger:{winning_trigger_hash} success"]):
-                self.generate(self.nodes[0], 1, sync_fun=self.no_op)
                 self.bump_mocktime(1)
-                self.sync_blocks()
+                self.generate(self.nodes[0], 1, sync_fun=self.sync_blocks())
             # Votes on both triggers should NOT change
             assert_equal(self.nodes[0].gobject("list", "valid", "triggers")[winning_trigger_hash]['NoCount'], 1)
             assert_equal(self.nodes[0].gobject("list", "valid", "triggers")[isolated_trigger_hash]['NoCount'], self.mn_count - 1)
@@ -322,31 +314,27 @@ def sync_gov(node):
 
         self.log.info("Move remaining n blocks until the next Superblock")
         for _ in range(n - 1):
-            self.generate(self.nodes[0], 1, sync_fun=self.no_op)
             self.bump_mocktime(1)
-            self.sync_blocks()
+            self.generate(self.nodes[0], 1, sync_fun=self.sync_blocks())
         self.log.info("Wait for new trigger and votes")
         self.wait_until(lambda: have_trigger_for_height(self.nodes, 180))
         self.log.info("Mine superblock")
-        self.generate(self.nodes[0], 1, sync_fun=self.no_op)
         self.bump_mocktime(1)
-        self.sync_blocks()
+        self.generate(self.nodes[0], 1, sync_fun=self.sync_blocks())
         assert_equal(self.nodes[0].getblockcount(), 180)
         assert_equal(self.nodes[0].getblockchaininfo()["softforks"]["v20"]["active"], True)
 
         self.log.info("Mine and check a couple more superblocks")
         for i in range(2):
             for _ in range(sb_cycle - 1):
-                self.generate(self.nodes[0], 1, sync_fun=self.no_op)
                 self.bump_mocktime(1)
-                self.sync_blocks()
+                self.generate(self.nodes[0], 1, sync_fun=self.sync_blocks())
             # Wait for new trigger and votes
             sb_block_height = 180 + (i + 1) * sb_cycle
             self.wait_until(lambda: have_trigger_for_height(self.nodes, sb_block_height))
             # Mine superblock
-            self.generate(self.nodes[0], 1, sync_fun=self.no_op)
             self.bump_mocktime(1)
-            self.sync_blocks()
+            self.generate(self.nodes[0], 1, sync_fun=self.sync_blocks())
             assert_equal(self.nodes[0].getblockcount(), sb_block_height)
             assert_equal(self.nodes[0].getblockchaininfo()["softforks"]["v20"]["active"], True)
             self.check_superblockbudget(True)

test/functional/feature_governance_cl.py

@@ -83,9 +83,7 @@ def run_test(self):
         p1_collateral_prepare = self.prepare_object(1, uint256_to_string(0), proposal_time, 1, "Proposal_1", self.p1_amount, self.p1_payout_address)
         self.bump_mocktime(60 * 10 + 1)
 
-        self.generate(self.nodes[0], 6, sync_fun=self.no_op)
-        self.bump_mocktime(6 * 156)
-        self.sync_blocks()
+        self.generate(self.nodes[0], 6, sync_fun=self.sync_blocks())
 
         assert_equal(len(self.nodes[0].gobject("list-prepared")), 2)
         assert_equal(len(self.nodes[0].gobject("list")), 0)
@@ -158,10 +156,9 @@ def run_test(self):
         self.log.info("Reconnect isolated node and confirm the next ChainLock will let it sync")
         self.reconnect_isolated_node(5, 0)
         assert_equal(self.nodes[5].mnsync("status")["IsSynced"], False)
-        self.generate(self.nodes[0], 1, sync_fun=self.no_op)
         # NOTE: bumping mocktime too much after recent reconnect can result in "timeout downloading block"
         self.bump_mocktime(1)
-        self.sync_blocks()
+        self.generate(self.nodes[0], 1, sync_fun=self.sync_blocks())
 
 
 if __name__ == '__main__':

test/functional/feature_llmq_connections.py

@@ -44,7 +44,7 @@ def run_test(self):
         self.wait_for_sporks_same()
 
         self.log.info("mining one block and waiting for all members to connect to each other")
-        self.generate(self.nodes[0], 1)
+        self.generate(self.nodes[0], 1, sync_fun=self.no_op)
         for mn in self.get_quorum_masternodes(q):
             self.wait_for_mnauth(mn.node, 4)
 

test/functional/feature_llmq_data_recovery.py

@@ -46,7 +46,7 @@ def restart_mn(self, mn, reindex=False, qvvec_sync=None, qdata_recovery_enabled=
         self.connect_nodes(mn.node.index, 0)
         if qdata_recovery_enabled:
             # trigger recovery threads and wait for them to start
-            self.generate(self.nodes[0], 1)
+            self.generate(self.nodes[0], 1, sync_fun=self.no_op)
 
             self.bump_mocktime(self.quorum_data_thread_request_timeout_seconds + 1)
             time.sleep(1)
@@ -177,14 +177,14 @@ def run_test(self):
         self.test_mns(llmq_test_v17, quorum_hash_recover, valid_mns=[last_resort_v17], all_mns=member_mns_recover_v17)
         # If recovery would be enabled it would trigger after the mocktime bump / mined block
         self.bump_mocktime(self.quorum_data_request_expiration_timeout + 1)
-        self.generate(node, 1)
+        self.generate(node, 1, sync_fun=self.no_op)
         time.sleep(10)
         # Make sure they are still invalid
         self.test_mns(llmq_test, quorum_hash_recover, valid_mns=[last_resort_test], all_mns=member_mns_recover_test)
         self.test_mns(llmq_test_v17, quorum_hash_recover, valid_mns=[last_resort_v17], all_mns=member_mns_recover_v17)
         # Mining a block should not result in a chainlock now because the responsible quorum shouldn't have enough
         # valid members.
-        self.wait_for_chainlocked_block(node, self.generate(node, 1)[0], False, 5)
+        self.wait_for_chainlocked_block(node, self.generate(node, 1, sync_fun=self.no_op)[0], False, 5)
         # Now restart with recovery enabled
         self.restart_mns(mns=recover_members, exclude=exclude_members, reindex=True, qdata_recovery_enabled=True)
         # Validate that all invalid members recover. Note: recover=True leads to mocktime bumps and mining while waiting

test/functional/feature_llmq_evo.py

@@ -93,7 +93,7 @@ def run_test(self):
         for i in range(self.evo_count):
             evo_info = self.dynamically_add_masternode(evo=True)
             evo_protxhash_list.append(evo_info.proTxHash)
-            self.generate(self.nodes[0], 8, sync_fun=lambda: self.sync_blocks(self.nodes))
+            self.generate(self.nodes[0], 8, sync_fun=lambda: self.sync_blocks())
 
             expectedUpdated.append(evo_info.proTxHash)
             b_i = self.nodes[0].getbestblockhash()
@@ -169,7 +169,7 @@ def test_evo_payments(self, window_analysis, mnrr_active=False):
                 current_evo = None
                 consecutive_payments = 0
 
-            self.generate(self.nodes[0], 1)
+            self.generate(self.nodes[0], 1, sync_fun=self.no_op)
             if i % 8 == 0:
                 self.sync_blocks()
 
@@ -218,7 +218,6 @@ def test_evo_is_rejected_before_v19(self):
         outputs = {collateral_address: collateral_amount, funds_address: 1}
         collateral_txid = self.nodes[0].sendmany("", outputs)
         self.generate(self.nodes[0], 8)
-        self.sync_all(self.nodes)
 
         rawtx = self.nodes[0].getrawtransaction(collateral_txid, 1)
         collateral_vout = 0

test/functional/feature_llmq_is_cl_conflicts.py

@@ -71,7 +71,7 @@ def run_test(self):
         self.mine_cycle_quorum(llmq_type_name='llmq_test_dip0024', llmq_type=103)
 
         # mine single block, wait for chainlock
-        self.generate(self.nodes[0], 1)
+        self.generate(self.nodes[0], 1, sync_fun=self.no_op)
         self.wait_for_chainlocked_block_all_nodes(self.nodes[0].getbestblockhash())
 
         self.test_chainlock_overrides_islock(False)