diff --git a/test/functional/feature_assetsdir.py b/test/functional/feature_assetsdir.py
index 0156f9122d..f83f7bbe5d 100755
--- a/test/functional/feature_assetsdir.py
+++ b/test/functional/feature_assetsdir.py
@@ -29,7 +29,7 @@ class AssetdirTests(BitcoinTestFramework):
         self.setup_nodes()
 
     def run_test(self):
-        self.nodes[0].generate(101)
+        self.generate(self.nodes[0], 101)
         self.nodes[0].syncwithvalidationinterfacequeue()
 
         #Issue two assets that we will later label using the assetdir parameter
@@ -68,4 +68,3 @@ class AssetdirTests(BitcoinTestFramework):
 
 if __name__ == '__main__':
     AssetdirTests().main()
-
diff --git a/test/functional/feature_block_subsidy.py b/test/functional/feature_block_subsidy.py
index 7129e7aaa4..1b11b53d32 100755
--- a/test/functional/feature_block_subsidy.py
+++ b/test/functional/feature_block_subsidy.py
@@ -40,7 +40,7 @@ class BlockSubsidyTest(BitcoinTestFramework):
 
         # Block will have 10 satoshi output, node 1 will ban
         addr = self.nodes[0].getnewaddress()
-        sub_block = self.nodes[0].generatetoaddress(1, addr)
+        sub_block = self.generatetoaddress(self.nodes[0], 1, addr)
         raw_coinbase = self.nodes[0].getrawtransaction(self.nodes[0].getblock(sub_block[0])["tx"][0], False, sub_block[0])
         decoded_coinbase = self.nodes[0].decoderawtransaction(raw_coinbase)
 
@@ -56,7 +56,7 @@ class BlockSubsidyTest(BitcoinTestFramework):
         assert found_ten
 
         # Block will have 0 satoshis outputs only at height 1
-        no_sub_block = self.nodes[1].generatetoaddress(1, addr)
+        no_sub_block = self.generatetoaddress(self.nodes[1], 1, addr)
         raw_coinbase = self.nodes[1].getrawtransaction(self.nodes[1].getblock(no_sub_block[0])["tx"][0], False, no_sub_block[0])
         decoded_coinbase = self.nodes[1].decoderawtransaction(raw_coinbase)
         for vout in decoded_coinbase["vout"]:
diff --git a/test/functional/feature_block_v4.py b/test/functional/feature_block_v4.py
index 20c4597c41..adffe3036a 100755
--- a/test/functional/feature_block_v4.py
+++ b/test/functional/feature_block_v4.py
@@ -55,7 +55,7 @@ class BlockV4Test(BitcoinTestFramework):
         self.log.info("Test that a version 4 block with a valid-according-to-CLTV transaction is accepted")
 
         # Generate 100 blocks so that first coinbase matures
-        generated_blocks = self.nodes[0].generate(100)
+        generated_blocks = self.generate(self.nodes[0], 100)
         spendable_coinbase_txid = self.nodes[0].getblock(generated_blocks[0])['tx'][0]
         coinbase_value = self.nodes[0].decoderawtransaction(self.nodes[0].gettransaction(spendable_coinbase_txid)["hex"])["vout"][0]["value"]
         tip = generated_blocks[-1]
diff --git a/test/functional/feature_confidential_transactions.py b/test/functional/feature_confidential_transactions.py
index 4681d698f5..259442f218 100755
--- a/test/functional/feature_confidential_transactions.py
+++ b/test/functional/feature_confidential_transactions.py
@@ -86,7 +86,7 @@ class CTTest (BitcoinTestFramework):
         assert_equal(wrong_info["ismine"], False)
 
         # Setting seed should get us more info, still not "ours" until blinding key
-        rec.generatetoaddress(1, rec.getnewaddress()) # get out of IBD
+        self.generatetoaddress(self.nodes[0], 1, rec.getnewaddress()) # get out of IBD
         rec.sethdseed(True, found_seed)
 
         wrong_blind_info = rec.getaddressinfo(blind_addr)
@@ -106,7 +106,7 @@ class CTTest (BitcoinTestFramework):
         os.remove(file_path)
 
     def test_null_rangeproof_enforcement(self):
-        self.nodes[0].generate(1)
+        self.generate(self.nodes[0], 1)
 
         # 1. Produce a transaction. This is coming out of initialfreecoins so
         #    no signatures are needed, which slightly simplifies the test
@@ -187,9 +187,9 @@ class CTTest (BitcoinTestFramework):
         node1 = 0
         node2 = 0
 
-        self.nodes[0].generate(101)
+        self.generate(self.nodes[0], 101)
         txid = self.nodes[0].sendtoaddress(self.nodes[0].getnewaddress(), node0, "", "", True)
-        self.nodes[0].generate(101)
+        self.generate(self.nodes[0], 101)
         self.sync_all()
         assert_equal(self.nodes[0].getbalance()["bitcoin"], node0)
         assert_equal(self.nodes[1].getbalance("*", 1, False, False, "bitcoin"), node1)
@@ -201,7 +201,7 @@ class CTTest (BitcoinTestFramework):
         unconfidential_address = self.nodes[2].validateaddress(address)["unconfidential"]
         value0 = 3
         self.nodes[0].sendtoaddress(unconfidential_address, value0)
-        self.nodes[0].generate(101)
+        self.generate(self.nodes[0], 101)
         self.sync_all()
 
         node0 = node0 - value0
@@ -216,7 +216,7 @@ class CTTest (BitcoinTestFramework):
         unconfidential_address2 = self.nodes[2].validateaddress(address2)["unconfidential"]
         value1 = 5
         confidential_tx_id = self.nodes[0].sendtoaddress(address2, value1)
-        self.nodes[0].generate(101)
+        self.generate(self.nodes[0], 101)
         self.sync_all()
 
         node0 = node0 - value1
@@ -244,7 +244,7 @@ class CTTest (BitcoinTestFramework):
         tx = self.nodes[0].blindrawtransaction(tx)
         tx_signed = self.nodes[0].signrawtransactionwithwallet(tx)
         raw_tx_id = self.nodes[0].sendrawtransaction(tx_signed['hex'])
-        self.nodes[0].generate(101)
+        self.generate(self.nodes[0], 101)
         self.sync_all()
 
         node0 -= (value2 + value3)
@@ -332,7 +332,7 @@ class CTTest (BitcoinTestFramework):
         tx_signed = self.nodes[0].signrawtransactionwithwallet(tx)
         txid = self.nodes[0].sendrawtransaction(tx_signed['hex'])
         decodedtx = self.nodes[0].decoderawtransaction(tx_signed["hex"])
-        self.nodes[0].generate(101)
+        self.generate(self.nodes[0], 101)
         self.sync_all()
 
         unblindfound = False
@@ -426,7 +426,7 @@ class CTTest (BitcoinTestFramework):
         assert_equal(issued["asset"], raw_details["vin"][issued["vin"]]["issuance"]["asset"])
         assert_equal(issued["token"], raw_details["vin"][issued["vin"]]["issuance"]["token"])
 
-        self.nodes[0].generate(1)
+        self.generate(self.nodes[0], 1)
         self.sync_all()
 
         issued2 = self.nodes[0].issueasset(2, 1)
@@ -483,7 +483,7 @@ class CTTest (BitcoinTestFramework):
 
         # And finally send
         self.nodes[2].sendrawtransaction(signed_assets['hex'])
-        self.nodes[2].generate(101)
+        self.generate(self.nodes[0], 101)
         self.sync_all()
 
         issuancedata = self.nodes[2].issueasset(0, Decimal('0.00000006')) #0 of asset, 6 reissuance token
@@ -493,12 +493,12 @@ class CTTest (BitcoinTestFramework):
         # node 1 needs to know about a (re)issuance to reissue itself
         self.nodes[1].importaddress(self.nodes[2].gettransaction(issuancedata["txid"])["details"][0]["address"])
         # also send some bitcoin
-        self.nodes[2].generate(1)
+        self.generate(self.nodes[2], 1)
         self.sync_all()
 
         self.nodes[1].reissueasset(issuancedata["asset"], Decimal('0.05'))
         self.nodes[2].reissueasset(issuancedata["asset"], Decimal('0.025'))
-        self.nodes[1].generate(1)
+        self.generate(self.nodes[1], 1)
         self.sync_all()
 
         # Check for value accounting when asset issuance is null but token not, ie unblinded
@@ -515,7 +515,7 @@ class CTTest (BitcoinTestFramework):
         # Check for value when receiving different assets by same address.
         self.nodes[0].sendtoaddress(unconfidential_address2, Decimal('0.00000001'), "", "", False, False, 1, "UNSET", False, test_asset)
         self.nodes[0].sendtoaddress(unconfidential_address2, Decimal('0.00000002'), "", "", False, False, 1, "UNSET", False, test_asset)
-        self.nodes[0].generate(1)
+        self.generate(self.nodes[0], 1)
         self.sync_all()
         received_by_address = self.nodes[1].listreceivedbyaddress(0, False, True)
         multi_asset_amount = [x for x in received_by_address if x['address'] == unconfidential_address2][0]['amount']
@@ -545,7 +545,7 @@ class CTTest (BitcoinTestFramework):
         # Issue new asset, to use different assets in one transaction when doing
         # partial blinding. Just to make these tests a bit more elaborate :-)
         issued3 = self.nodes[2].issueasset(1, 0)
-        self.nodes[2].generate(1)
+        self.generate(self.nodes[2], 1)
         self.sync_all()
         node2_balance = self.nodes[2].getbalance()
         assert issued3['asset'] in node2_balance
@@ -668,7 +668,7 @@ class CTTest (BitcoinTestFramework):
         stx2 = self.nodes[1].signrawtransactionwithwallet(blindtx)
         stx = self.nodes[0].signrawtransactionwithwallet(stx2['hex'])
         txid = self.nodes[2].sendrawtransaction(stx['hex'])
-        self.nodes[2].generate(1)
+        self.generate(self.nodes[2], 1)
         assert self.nodes[2].gettransaction(txid)['confirmations'] == 1
         self.sync_all()
 
diff --git a/test/functional/feature_default_asset_name.py b/test/functional/feature_default_asset_name.py
index 61857e8314..9d4005fedd 100755
--- a/test/functional/feature_default_asset_name.py
+++ b/test/functional/feature_default_asset_name.py
@@ -34,7 +34,7 @@ class NamedDefaultAssetTest(BitcoinTestFramework):
     def run_test(self):
         #Claim all anyone-can-spend coins and test that calling sendtoaddress without providing the assetlabel parameter results in the specified default pegged asset being sent.
         self.nodes[0].sendtoaddress(self.nodes[0].getnewaddress(), 21000000, "", "", True)
-        self.nodes[0].generate(101)
+        self.generate(self.nodes[0], 101)
         self.sync_all()
 
         #Check the default asset is named correctly
@@ -43,7 +43,7 @@ class NamedDefaultAssetTest(BitcoinTestFramework):
 
         #Send some of the default asset to the second node
         self.nodes[0].sendtoaddress(self.nodes[1].getnewaddress(), 1, "", "", False)
-        self.nodes[0].generate(101)
+        self.generate(self.nodes[0], 101)
         self.sync_all()
 
         #Check balances are correct and asset is named correctly
@@ -56,7 +56,7 @@ class NamedDefaultAssetTest(BitcoinTestFramework):
         #Check we send the default 'testasset' when calling 'sendmany' without needing to provide the relevant asset label
         outputs = {self.nodes[1].getnewaddress(): 1.0, self.nodes[1].getnewaddress(): 3.0}
         self.nodes[0].sendmany("", outputs)
-        self.nodes[0].generate(101)
+        self.generate(self.nodes[0], 101)
         self.sync_all()
 
         #Check balances are correct and asset is named correctly
diff --git a/test/functional/feature_dynafed.py b/test/functional/feature_dynafed.py
index fda8267cec..c51c3d53c4 100755
--- a/test/functional/feature_dynafed.py
+++ b/test/functional/feature_dynafed.py
@@ -32,11 +32,6 @@ new_extension = [initial_offline+initial_online]
 ERR_MP_INVALID_PEGOUT = "invalid-pegout-proof"
 ERR_MP_INVALID_PEGIN = "pegin-no-witness"
 
-def go_to_epoch_end(node):
-    epoch_info = node.getblockchaininfo()
-    blocks_to_mine = epoch_info["epoch_length"] - epoch_info["epoch_age"] - 1
-    node.generatetoaddress(blocks_to_mine, node.getnewaddress())
-
 def validate_no_vote_op_true(node, block, first_dynafed_active_block):
     block_info = node.getblock(block)
     dynamic_parameters = block_info["dynamic_parameters"]
@@ -64,6 +59,11 @@ def validate_no_vote_op_true(node, block, first_dynafed_active_block):
     assert not "extension_space" in dynamic_parameters["proposed"]
 
 class DynaFedTest(BitcoinTestFramework):
+    def go_to_epoch_end(self, node):
+        epoch_info = node.getblockchaininfo()
+        blocks_to_mine = epoch_info["epoch_length"] - epoch_info["epoch_age"] - 1
+        self.generatetoaddress(node, blocks_to_mine, node.getnewaddress())
+
     def set_test_params(self):
         self.setup_clean_chain = True
         self.num_nodes = 2
@@ -122,15 +122,15 @@ class DynaFedTest(BitcoinTestFramework):
         # Signaling window is in height, not time, so first block that will signal is
         # at height 1008 which is evenly disible by 144(regtest bip9 window size)
         # Giving funds to node 1 to avoid a transaction size blowup when sweeping later
-        blocks = self.nodes[0].generatetoaddress(1006, self.nodes[1].getnewaddress())
+        blocks = self.generatetoaddress(self.nodes[0], 1006, self.nodes[1].getnewaddress())
         assert_equal(self.nodes[0].getblockchaininfo()["softforks"]["dynafed"]["bip9"]["status"], "defined")
-        blocks += self.nodes[0].generatetoaddress(1, self.nodes[0].getnewaddress())
+        blocks += self.generatetoaddress(self.nodes[0], 1, self.nodes[0].getnewaddress())
         assert_equal(self.nodes[0].getblockchaininfo()["softforks"]["dynafed"]["bip9"]["status"], "started")
-        blocks += self.nodes[0].generatetoaddress(144, self.nodes[0].getnewaddress())
+        blocks += self.generatetoaddress(self.nodes[0], 144, self.nodes[0].getnewaddress())
         assert_equal(self.nodes[0].getblockchaininfo()["softforks"]["dynafed"]["bip9"]["status"], "locked_in")
 
         # Move chain forward to activation, any new blocks will be enforced
-        blocks += self.nodes[0].generatetoaddress(144, self.nodes[0].getnewaddress())
+        blocks += self.generatetoaddress(self.nodes[0], 144, self.nodes[0].getnewaddress())
         self.sync_blocks(timeout=240)
         assert_equal(self.nodes[0].getblockchaininfo()["softforks"]["dynafed"]["bip9"]["status"], "active")
 
@@ -139,7 +139,7 @@ class DynaFedTest(BitcoinTestFramework):
             assert "dynamic_parameters" not in self.nodes[0].getblock(block)
 
         # Next block is first dynamic federation block
-        block = self.nodes[0].generatetoaddress(1, self.nodes[0].getnewaddress())[0]
+        block = self.generatetoaddress(self.nodes[0], 1, self.nodes[0].getnewaddress())[0]
         self.sync_all()
         # We publish full block on BIP9 transition
         for i in range(self.num_nodes):
@@ -164,10 +164,10 @@ class DynaFedTest(BitcoinTestFramework):
 
     def test_no_vote(self):
         self.log.info("Testing no-vote epoch...")
-        go_to_epoch_end(self.nodes[0])
+        self.go_to_epoch_end(self.nodes[0])
 
         # Mine epoch_length blocks with no proposals
-        blocks = self.nodes[0].generatetoaddress(10, self.nodes[0].getnewaddress())
+        blocks = self.generatetoaddress(self.nodes[0], 10, self.nodes[0].getnewaddress())
         self.sync_all()
 
         for i in range(self.num_nodes):
@@ -175,7 +175,7 @@ class DynaFedTest(BitcoinTestFramework):
                 validate_no_vote_op_true(self.nodes[i], block, False)
 
         # Now transition using vanilla getnewblockhex, nothing changed
-        block = self.nodes[0].generatetoaddress(1, self.nodes[0].getnewaddress())[0]
+        block = self.generatetoaddress(self.nodes[0], 1, self.nodes[0].getnewaddress())[0]
         self.sync_all()
 
         for i in range(self.num_nodes):
@@ -183,7 +183,7 @@ class DynaFedTest(BitcoinTestFramework):
 
     def test_under_vote(self):
         self.log.info("Testing failed voting epoch...")
-        go_to_epoch_end(self.nodes[0])
+        self.go_to_epoch_end(self.nodes[0])
 
         # Mine 7 blocks with agreeing proposals for single-sig, falls short of 4/5 of 10
         new_signblock = self.nodes[0].getaddressinfo(self.nodes[0].getnewaddress("", "bech32"))["scriptPubKey"]
@@ -194,9 +194,9 @@ class DynaFedTest(BitcoinTestFramework):
         self.sync_all()
         assert_equal(self.nodes[0].getblockcount(), cur_height+7)
         # Now mine 3 blank blocks
-        self.nodes[0].generatetoaddress(3, self.nodes[0].getnewaddress())
+        self.generatetoaddress(self.nodes[0], 3, self.nodes[0].getnewaddress())
         # No transition will take place, generatetoaddress still works for new epoch
-        block = self.nodes[0].generatetoaddress(1, self.nodes[0].getnewaddress())[0]
+        block = self.generatetoaddress(self.nodes[0], 1, self.nodes[0].getnewaddress())[0]
         self.sync_all()
 
         for i in range(self.num_nodes):
@@ -204,7 +204,7 @@ class DynaFedTest(BitcoinTestFramework):
 
     def test_four_fifth_vote(self):
         self.log.info("Testing just-successful transition epoch...")
-        go_to_epoch_end(self.nodes[0])
+        self.go_to_epoch_end(self.nodes[0])
 
         # Mine 8 blocks with agreeing proposals for single-sig, triggering transition
         new_signblock = self.nodes[0].getaddressinfo(self.nodes[0].getnewaddress("", "bech32"))["scriptPubKey"]
@@ -226,7 +226,7 @@ class DynaFedTest(BitcoinTestFramework):
         assert_equal(self.nodes[0].getblockcount(), cur_height+8)
 
         # Now mine 1 blank block
-        self.nodes[0].generatetoaddress(1, self.nodes[0].getnewaddress())
+        self.generatetoaddress(self.nodes[0], 1, self.nodes[0].getnewaddress())
         self.sync_all()
 
         # Old parameters still enforced for next block...
@@ -239,7 +239,7 @@ class DynaFedTest(BitcoinTestFramework):
             assert_equal(fedpeg_info["current_fedpegscripts"], ["51", "51"])
 
         # Last blank block
-        self.nodes[0].generatetoaddress(1, self.nodes[0].getnewaddress())
+        self.generatetoaddress(self.nodes[0], 1, self.nodes[0].getnewaddress())
         self.sync_all()
 
         # We have now transitioned, next block must have signature
@@ -338,7 +338,7 @@ class DynaFedTest(BitcoinTestFramework):
         peg_tx = self.nodes[0].gettransaction(peg_id)["hex"]
         self.nodes[0].testmempoolaccept([peg_tx])
         # only one confirm needed in this setup, we do 10 to sync with epoch_length
-        self.nodes[0].generatetoaddress(10, self.nodes[0].getnewaddress())
+        self.generatetoaddress(self.nodes[0], 10, self.nodes[0].getnewaddress())
         proof = self.nodes[0].gettxoutproof([peg_id])
         raw_tx = self.nodes[0].gettransaction(peg_id)["hex"]
 
@@ -363,7 +363,7 @@ class DynaFedTest(BitcoinTestFramework):
         assert_equal(self.nodes[1].getrawmempool(), [])
         # Now generate an epoch of blocks on node 1 to show that non-transitions don't dump
         # PAK or peg-in transactions from mempool
-        self.nodes[1].generatetoaddress(10, self.nodes[1].getnewaddress())
+        self.generatetoaddress(self.nodes[1], 10, self.nodes[1].getnewaddress())
         self.sync_blocks()
         assert_equal(self.nodes[0].getblockchaininfo()["epoch_age"], 9)
 
@@ -457,7 +457,7 @@ class DynaFedTest(BitcoinTestFramework):
     def test_valid_epochs(self):
         self.log.info("Testing pegins and pegouts stay valid for some epochs")
         # previous test leaves us at age 9
-        self.nodes[0].generatetoaddress(1, self.nodes[0].getnewaddress())
+        self.generatetoaddress(self.nodes[0], 1, self.nodes[0].getnewaddress())
         self.sync_all()
         assert_equal(self.nodes[1].getblockchaininfo()["epoch_age"], 0)
 
@@ -494,7 +494,7 @@ class DynaFedTest(BitcoinTestFramework):
         peg_tx = self.nodes[0].gettransaction(peg_id)["hex"]
         # we need the confirmation of the peg tx, so we can't easily assert
         # that the pegin tx would be accepted at this very point
-        self.nodes[0].generatetoaddress(1, self.nodes[0].getnewaddress())
+        self.generatetoaddress(self.nodes[0], 1, self.nodes[0].getnewaddress())
         proof = self.nodes[0].gettxoutproof([peg_id])
         pegin_tx = self.nodes[0].createrawpegin(peg_tx, proof, fund_info["claim_script"])["hex"]
         pegin_tx = self.nodes[0].signrawtransactionwithwallet(pegin_tx)["hex"]
@@ -505,7 +505,7 @@ class DynaFedTest(BitcoinTestFramework):
 
         # let's generate 20 blocks to pass through 2 new epochs without there being a transition
         for _ in range(20):
-            self.nodes[0].generatetoaddress(1, self.nodes[0].getnewaddress())
+            self.generatetoaddress(self.nodes[0], 1, self.nodes[0].getnewaddress())
             self.assert_accepted(pegin_tx)
             self.assert_accepted(pegout_tx)
         assert_equal(self.nodes[0].getsidechaininfo()["current_fedpegscripts"], ["51", "51"])
@@ -546,7 +546,7 @@ class DynaFedTest(BitcoinTestFramework):
         for _ in range(9):
             self.assert_accepted(pegin_tx)
             assert_equal(self.nodes[0].testmempoolaccept([pegout_tx])[0]["reject-reason"], ERR_MP_INVALID_PEGOUT)
-            self.nodes[1].generatetoaddress(1, self.nodes[1].getnewaddress())
+            self.generatetoaddress(self.nodes[1], 1, self.nodes[1].getnewaddress())
             self.sync_blocks()
 
         # so on the last block both should not be allowed
@@ -558,12 +558,12 @@ class DynaFedTest(BitcoinTestFramework):
         self.nodes[0].invalidateblock(self.nodes[0].getbestblockhash())
         # first use the pegin tx created earlier
         pegin_txid = self.nodes[0].sendrawtransaction(pegin_tx)
-        self.nodes[0].generatetoaddress(1, self.nodes[0].getnewaddress())
+        self.generatetoaddress(self.nodes[0], 1, self.nodes[0].getnewaddress())
         assert_equal(self.nodes[0].gettransaction(pegin_txid)["confirmations"], 1)
         # make sure that using claimpegin directly also works
         self.nodes[0].invalidateblock(self.nodes[0].getbestblockhash())
         pegin_txid = self.nodes[0].claimpegin(peg_tx, proof, fund_info["claim_script"])
-        self.nodes[0].generatetoaddress(1, self.nodes[0].getnewaddress())
+        self.generatetoaddress(self.nodes[0], 1, self.nodes[0].getnewaddress())
         assert_equal(self.nodes[0].gettransaction(pegin_txid)["confirmations"], 1)
 
     def run_test(self):
diff --git a/test/functional/feature_elements_taproot_activation.py b/test/functional/feature_elements_taproot_activation.py
index 2fc477dff5..2a1eea220c 100755
--- a/test/functional/feature_elements_taproot_activation.py
+++ b/test/functional/feature_elements_taproot_activation.py
@@ -35,7 +35,7 @@ class TaprootActivationTest(BitcoinTestFramework):
 
         assert_equal(rpc.getblockcount(), 0)
 
-        blocks = rpc.generatetoaddress(activation_height - 2, rpc.getnewaddress())
+        blocks = self.generatetoaddress(rpc, activation_height - 2, rpc.getnewaddress())
         assert_equal(rpc.getblockcount(), activation_height - 2)
 
         for n, block in enumerate(blocks):
@@ -51,11 +51,11 @@ class TaprootActivationTest(BitcoinTestFramework):
         assert_equal(rpc.getblockchaininfo()["softforks"]["taproot"]["bip9"]["status"], "defined")
         # The 1023rd block does not signal, but changes the signalling state
         # to "started" from "defined"
-        blocks = rpc.generatetoaddress(1, rpc.getnewaddress())
+        blocks = self.generatetoaddress(rpc, 1, rpc.getnewaddress())
         assert_equal(rpc.getblockchaininfo()["softforks"]["taproot"]["bip9"]["status"], "started")
         assert_equal(rpc.getblockheader(blocks[0])["versionHex"], "20000000")
 
-        blocks = rpc.generatetoaddress(127, rpc.getnewaddress())
+        blocks = self.generatetoaddress(rpc, 127, rpc.getnewaddress())
         for n, block in enumerate(blocks):
             decode = rpc.getblockheader(block)
             assert_equal (decode["versionHex"], "20000004")
@@ -71,18 +71,18 @@ class TaprootActivationTest(BitcoinTestFramework):
         assert_equal(rpc.getblockchaininfo()["softforks"]["taproot"]["bip9"]["status"], "started")
 
         # Run through another 128 blocks, without failing to signal
-        blocks = rpc.generatetoaddress(127, rpc.getnewaddress())
+        blocks = self.generatetoaddress(rpc, 127, rpc.getnewaddress())
         for n, block in enumerate(blocks):
             decode = rpc.getblockheader(block)
             assert_equal (decode["versionHex"], "20000004")
         assert_equal(rpc.getblockchaininfo()["softforks"]["taproot"]["bip9"]["status"], "started")
         # The 128th block then switches from "started" to "locked_in"
-        blocks = rpc.generatetoaddress(1, rpc.getnewaddress())
+        blocks = self.generatetoaddress(rpc, 1, rpc.getnewaddress())
         assert_equal(rpc.getblockchaininfo()["softforks"]["taproot"]["bip9"]["status"], "locked_in")
         assert_equal(rpc.getblockheader(blocks[0])["versionHex"], "20000004")
 
         # Run through another 128 blocks, which will go from "locked in" to "active" regardless of signalling
-        blocks = rpc.generatetoaddress(127, rpc.getnewaddress())
+        blocks = self.generatetoaddress(rpc, 127, rpc.getnewaddress())
         for n, block in enumerate(blocks):
             decode = rpc.getblockheader(block)
             assert_equal (decode["versionHex"], "20000004")
@@ -93,14 +93,14 @@ class TaprootActivationTest(BitcoinTestFramework):
         assert_equal(rpc.getblockchaininfo()["softforks"]["taproot"]["bip9"]["status"], "active")
 
         # After the state is "active", signallng stops by default.
-        blocks = rpc.generatetoaddress(1, self.nodes[0].getnewaddress())
+        blocks = self.generatetoaddress(rpc, 1, self.nodes[0].getnewaddress())
         assert_equal(rpc.getblockchaininfo()["softforks"]["taproot"]["bip9"]["status"], "active")
         assert_equal(rpc.getblockheader(blocks[0])["versionHex"], "20000000")
 
     def run_test(self):
         # Test that regtest nodes never signal taproot by default
         self.log.info("Testing node not configured to activate taproot")
-        blocks = self.nodes[0].generatetoaddress(2500, self.nodes[0].getnewaddress())
+        blocks = self.generatetoaddress(self.nodes[0], 2500, self.nodes[0].getnewaddress())
         assert_equal(self.nodes[0].getblockcount(), 2500)
         for n, block in enumerate(blocks):
             decode = self.nodes[0].getblockheader(block)
diff --git a/test/functional/feature_fedpeg.py b/test/functional/feature_fedpeg.py
index c226c9654d..64cb93f78f 100755
--- a/test/functional/feature_fedpeg.py
+++ b/test/functional/feature_fedpeg.py
@@ -180,7 +180,7 @@ class FedPegTest(BitcoinTestFramework):
                 pegout_tested = True
                 break
         assert pegout_tested
-        sidechain.generatetoaddress(1, sidechain.getnewaddress())
+        self.generatetoaddress(self.nodes[2], 1, sidechain.getnewaddress())
         assert_equal(sidechain.gettransaction(pegout_txid)["confirmations"], 1)
 
     def run_test(self):
@@ -210,8 +210,8 @@ class FedPegTest(BitcoinTestFramework):
             node.importprivkey(privkey=node.get_deterministic_priv_key().key, label="mining")
         util.node_fastmerkle = sidechain
 
-        parent.generate(101)
-        sidechain.generate(101)
+        self.generate(parent, 101)
+        self.generate(sidechain, 101)
         self.log.info("sidechain info: {}".format(sidechain.getsidechaininfo()))
 
         addrs = sidechain.getpeginaddress()
@@ -221,7 +221,7 @@ class FedPegTest(BitcoinTestFramework):
         vout = find_vout_for_address(parent, txid1, addr)
         # 10+2 confirms required to get into mempool and confirm
         assert_equal(sidechain.getsidechaininfo()["pegin_confirmation_depth"], 10)
-        parent.generate(1)
+        self.generate(parent, 1)
         time.sleep(2)
         proof = parent.gettxoutproof([txid1])
 
@@ -244,7 +244,7 @@ class FedPegTest(BitcoinTestFramework):
             assert "Peg-in Bitcoin transaction needs more confirmations to be sent." in e.error["message"]
 
         # Second attempt simply doesn't hit mempool bar
-        parent.generate(10)
+        self.generate(parent, 10)
         try:
             pegtxid = sidechain.claimpegin(raw, proof)
             raise Exception("Peg-in should not be mature enough yet, need another block.")
@@ -266,7 +266,7 @@ class FedPegTest(BitcoinTestFramework):
             assert "Given claim_script does not match the given Bitcoin transaction." in e.error["message"]
 
         # 12 confirms allows in mempool
-        parent.generate(1)
+        self.generate(parent, 1)
 
         # Make sure that a tx with a duplicate pegin claim input gets rejected.
         raw_pegin = sidechain.createrawpegin(raw, proof)["hex"]
@@ -363,10 +363,10 @@ class FedPegTest(BitcoinTestFramework):
         # Will invalidate the block that confirms this transaction later
         for node_group in self.node_groups:
             self.sync_all(node_group)
-        blockhash = sidechain2.generate(1)
+        blockhash = self.generate(sidechain2, 1)
         for node_group in self.node_groups:
             self.sync_all(node_group)
-        sidechain.generate(5)
+        self.generate(sidechain, 5)
 
         tx1 = sidechain.gettransaction(pegtxid1)
 
@@ -410,7 +410,7 @@ class FedPegTest(BitcoinTestFramework):
         assert_raises_rpc_error(-25, "bad-txns-double-pegin", sidechain.testproposedblock, block_hex, True)
 
         # Re-enters block
-        sidechain.generate(1)
+        self.generate(sidechain, 1)
         if sidechain.gettransaction(pegtxid1)["confirmations"] != 1:
             raise Exception("Peg-in should have one confirm on side block.")
         sidechain.reconsiderblock(blockhash[0])
@@ -435,25 +435,25 @@ class FedPegTest(BitcoinTestFramework):
 
         print("Flooding mempool with a few claims")
         pegtxs = []
-        sidechain.generate(101)
+        self.generate(sidechain, 101)
 
         # Do mixture of raw peg-in and automatic peg-in tx construction
         # where raw creation is done on another node
         for i in range(n_claims):
             addrs = sidechain.getpeginaddress()
             txid = parent.sendtoaddress(addrs["mainchain_address"], 1)
-            parent.generate(1)
+            self.generate(parent, 1)
             proof = parent.gettxoutproof([txid])
             raw = parent.gettransaction(txid)["hex"]
             if i % 2 == 0:
-                parent.generate(11)
+                self.generate(parent, 11)
                 pegtxs += [sidechain.claimpegin(raw, proof)]
             else:
                 # The raw API doesn't check for the additional 2 confirmation buffer
                 # So we only get 10 confirms then send off. Miners will add to block anyways.
 
                 # Don't mature whole way yet to test signing immature peg-in input
-                parent.generate(8)
+                self.generate(parent, 8)
                 # Wallet in sidechain2 gets funds instead of sidechain
                 raw_pegin = sidechain2.createrawpegin(raw, proof, addrs["claim_script"])["hex"]
                 # First node should also be able to make a valid transaction with or without 3rd arg
@@ -464,12 +464,12 @@ class FedPegTest(BitcoinTestFramework):
                 assert signed_pegin["complete"]
                 assert "warning" in signed_pegin # warning for immature peg-in
                 # fully mature them now
-                parent.generate(1)
+                self.generate(parent, 1)
                 pegtxs += [sidechain.sendrawtransaction(signed_pegin["hex"])]
 
         for node_group in self.node_groups:
             self.sync_all(node_group)
-        sidechain2.generate(1)
+        self.generate(sidechain2, 1)
         for i, pegtxid in enumerate(pegtxs):
             if i % 2 == 0:
                 tx = sidechain.gettransaction(pegtxid)
@@ -499,7 +499,7 @@ class FedPegTest(BitcoinTestFramework):
 
         print("Test pegout Garbage valid")
         prev_txid = sidechain.sendtoaddress(sidechain.getnewaddress(), 1)
-        sidechain.generate(1)
+        self.generate(sidechain, 1)
         pegout_chain = 'a' * 64
         pegout_hex = 'b' * 500
         inputs = [{"txid": prev_txid, "vout": 0}]
@@ -524,11 +524,11 @@ class FedPegTest(BitcoinTestFramework):
         print("Now test failure to validate peg-ins based on intermittent bitcoind rpc failure")
         self.stop_node(1)
         txid = parent.sendtoaddress(addr, 1)
-        parent.generate(12)
+        self.generate(parent, 12)
         proof = parent.gettxoutproof([txid])
         raw = parent.gettransaction(txid)["hex"]
         sidechain.claimpegin(raw, proof) # stuck peg
-        sidechain.generate(1)
+        self.generate(sidechain, 1)
         print("Waiting to ensure block is being rejected by sidechain2")
         time.sleep(5)
 
@@ -542,7 +542,7 @@ class FedPegTest(BitcoinTestFramework):
         # https://github.com/ElementsProject/elements/issues/891 (sporadic
         # failures when catching up after loss of parent daemon connectivity.)
         print("Generating some blocks, to stress-test handling of parent daemon reconnection")
-        sidechain.generate(10)
+        self.generate(sidechain, 10)
 
         print("Now waiting for node to re-evaluate peg-in witness failed block... should take a few seconds")
         for node_group in self.node_groups:
@@ -615,7 +615,7 @@ class FedPegTest(BitcoinTestFramework):
         mainchain_addr = pegin_info["mainchain_address"]
         # Watch the address so we can get tx without txindex
         parent.importaddress(mainchain_addr)
-        claim_block = parent.generatetoaddress(50, mainchain_addr)[0]
+        claim_block = self.generatetoaddress(parent, 50, mainchain_addr)[0]
         for node_group in self.node_groups:
             self.sync_all(node_group)
         block_coinbase = parent.getblock(claim_block, 2)["tx"][0]
@@ -632,14 +632,14 @@ class FedPegTest(BitcoinTestFramework):
         assert_raises_rpc_error(-26, "bad-pegin-witness, Needs more confirmations.", sidechain.sendrawtransaction, signed_pegin)
 
         # 50 more blocks to allow wallet to make it succeed by relay and consensus
-        parent.generatetoaddress(50, parent.getnewaddress())
+        self.generatetoaddress(parent, 50, parent.getnewaddress())
         for node_group in self.node_groups:
             self.sync_all(node_group)
         # Wallet still doesn't want to for 2 more confirms
         assert_equal(sidechain.createrawpegin(claim_tx, claim_proof)["mature"], False)
         # But we can just shoot it off
         claim_txid = sidechain.sendrawtransaction(signed_pegin)
-        sidechain.generatetoaddress(1, sidechain.getnewaddress())
+        self.generatetoaddress(sidechain, 1, sidechain.getnewaddress())
         for node_group in self.node_groups:
             self.sync_all(node_group)
         assert_equal(sidechain.gettransaction(claim_txid)["confirmations"], 1)
@@ -652,7 +652,7 @@ class FedPegTest(BitcoinTestFramework):
         pegin_addr = addrs["mainchain_address"]
         txid_fund = parent.sendtoaddress(pegin_addr, 10)
         # 10+2 confirms required to get into mempool and confirm
-        parent.generate(11)
+        self.generate(parent, 11)
         for node_group in self.node_groups:
             self.sync_all(node_group)
         proof = parent.gettxoutproof([txid_fund])
@@ -666,7 +666,7 @@ class FedPegTest(BitcoinTestFramework):
         pegin_addr = addrs["mainchain_address"]
         txid_fund = parent.sendtoaddress(pegin_addr, 10)
         # 10+2 confirms required to get into mempool and confirm
-        parent.generate(11)
+        self.generate(parent, 11)
         for node_group in self.node_groups:
             self.sync_all(node_group)
         proof = parent.gettxoutproof([txid_fund])
@@ -678,7 +678,7 @@ class FedPegTest(BitcoinTestFramework):
         # now add an extra input and output from listunspent; we need a blinded output for this
         blind_addr = sidechain.getnewaddress("", "blech32")
         sidechain.sendtoaddress(blind_addr, 15)
-        sidechain.generate(6)
+        self.generate(sidechain, 6)
         # Make sure sidechain2 knows about the same input
         for node_group in self.node_groups:
             self.sync_all(node_group)
diff --git a/test/functional/feature_initial_reissuance_token.py b/test/functional/feature_initial_reissuance_token.py
index 71f1574f4f..2dbbf18cce 100755
--- a/test/functional/feature_initial_reissuance_token.py
+++ b/test/functional/feature_initial_reissuance_token.py
@@ -32,7 +32,7 @@ class InitialReissuanceTokenTest(BitcoinTestFramework):
         self.sync_all()
 
     def run_test(self):
-        self.nodes[0].generate(101)
+        self.generate(self.nodes[0], 101)
         self.sync_all()
 
         walletinfo = self.nodes[0].getwalletinfo()
@@ -48,7 +48,7 @@ class InitialReissuanceTokenTest(BitcoinTestFramework):
         # Claim all anyone-can-spend reissuance tokens, which also blinds the token output
         # which is required for re-issuance: https://github.com/ElementsProject/elements/issues/259
         self.nodes[0].sendtoaddress(self.nodes[0].getnewaddress(), 2, "", "", False, False, 6, "UNSET", False, token)
-        self.nodes[0].generate(101)
+        self.generate(self.nodes[0], 101)
         self.sync_all()
 
         #Check balances
@@ -58,7 +58,7 @@ class InitialReissuanceTokenTest(BitcoinTestFramework):
 
         #Reissue some of the default asset
         self.nodes[0].reissueasset("bitcoin", 1234)
-        self.nodes[0].generate(101)
+        self.generate(self.nodes[0], 101)
         self.sync_all()
 
         #Check the reissuance worked
@@ -70,12 +70,12 @@ class InitialReissuanceTokenTest(BitcoinTestFramework):
 
         #Send a reissuance token to node 2 so they can reissue the default asset
         self.nodes[0].sendtoaddress(self.nodes[1].getnewaddress(), 1, "", "", False, False, 6, "UNSET", False, token)
-        self.nodes[0].generate(101)
+        self.generate(self.nodes[0], 101)
         self.sync_all()
 
         #Reissue some of the default asset
         self.nodes[1].reissueasset("bitcoin", 1000)
-        self.nodes[1].generate(101)
+        self.generate(self.nodes[1], 101)
         self.sync_all()
 
         #Check balance is the 1 'bitcoin' sent from node 1 plus the 1000 'bitcoin' reissued by node 2
diff --git a/test/functional/feature_issuance.py b/test/functional/feature_issuance.py
index 24a9971010..e93cbfc2cc 100755
--- a/test/functional/feature_issuance.py
+++ b/test/functional/feature_issuance.py
@@ -11,7 +11,7 @@ from decimal import Decimal
 " Tests issued assets functionality including (re)issuance, and de-issuance "
 
 # Creates a raw issuance transaction based on the passed in list, checking important details after
-def process_raw_issuance(node, issuance_list):
+def process_raw_issuance(test, node, issuance_list):
     if len(issuance_list) > 5:
         raise Exception('Issuance list too long')
     # Make enough outputs for any subsequent spend
@@ -30,7 +30,7 @@ def process_raw_issuance(node, issuance_list):
     blind_tx = node.blindrawtransaction(issued_tx, False, [], issuance_list[0]["blind"])
     signed_tx = node.signrawtransactionwithwallet(blind_tx)
     tx_id = node.sendrawtransaction(signed_tx['hex'])
-    node.generate(1)
+    test.generate(node, 1)
     assert_equal(node.gettransaction(tx_id)["confirmations"], 1)
     num_issuance = 0
     decoded_tx = node.decoderawtransaction(signed_tx['hex'])
@@ -104,8 +104,11 @@ class IssuanceTest(BitcoinTestFramework):
         self.connect_nodes(1, 2)
         self.sync_all()
 
+    def raw_issuance(self, node, issuance_list):
+        process_raw_issuance(self, node, issuance_list)
+
     def run_test(self):
-        self.nodes[0].generate(105)
+        self.generate(self.nodes[0], 105)
         # Make sure test starts with no initial issuance.
         assert_equal(len(self.nodes[0].listissuances()), 0)
 
@@ -118,7 +121,7 @@ class IssuanceTest(BitcoinTestFramework):
         # Quick unblinded reissuance check, making 2*COIN total
         self.nodes[0].reissueasset(issued["asset"], 1)
 
-        self.nodes[0].generate(1)
+        self.generate(self.nodes[0], 1)
         self.sync_all()
 
         contract_hash = "deadbeee"*8
@@ -132,17 +135,17 @@ class IssuanceTest(BitcoinTestFramework):
         # Send bitcoin to node 1 and then from 1 to 2 to force node 1 to
         # spend confidential money.
         self.nodes[0].sendtoaddress(self.nodes[1].getnewaddress(), 4)
-        self.nodes[0].generate(1)
+        self.generate(self.nodes[0], 1)
         self.sync_all()
         self.nodes[1].sendtoaddress(self.nodes[2].getnewaddress(), 3, "", "", False, False, 1, "UNSET", False, "", False)
         self.sync_all()
-        self.nodes[0].generate(1)
+        self.generate(self.nodes[0], 1)
         self.sync_all()
 
         # Destroy assets
         pre_destroy_btc_balance = self.nodes[2].getwalletinfo()['balance']['bitcoin']
         self.nodes[2].destroyamount('bitcoin', 2) # Destroy 2 BTC
-        self.nodes[2].generate(1)
+        self.generate(self.nodes[2], 1)
         self.sync_all()
         assert_greater_than_or_equal(pre_destroy_btc_balance - Decimal('2'), self.nodes[2].getbalance()['bitcoin'])
 
@@ -150,14 +153,14 @@ class IssuanceTest(BitcoinTestFramework):
         assert_equal(issuedamount, Decimal('1.0'))
         self.nodes[0].destroyamount(issued["token"], issuedamount) # Destroy all reissuance tokens of one type
 
-        self.nodes[0].generate(1)
+        self.generate(self.nodes[0], 1)
         self.sync_all()
         assert issued["token"] not in self.nodes[0].getwalletinfo()['balance']
 
         # Test various issuance and auditing paths
 
         issuancedata = self.nodes[0].issueasset(Decimal('0.00000002'), Decimal('0.00000001')) #2 of asset, 1 reissuance token
-        self.nodes[1].generate(1)
+        self.generate(self.nodes[1], 1)
         self.sync_all()
         assert_equal(self.nodes[0].getwalletinfo()["balance"][issuancedata["asset"]], Decimal('0.00000002'))
         assert_equal(self.nodes[0].getwalletinfo()["balance"][issuancedata["token"]], Decimal('0.00000001'))
@@ -187,7 +190,7 @@ class IssuanceTest(BitcoinTestFramework):
         # node 1 needs to know about a (re)issuance to reissue itself
         self.nodes[1].importaddress(self.nodes[2].gettransaction(issuancedata["txid"])["details"][0]["address"])
         # also send some bitcoin
-        self.nodes[2].generate(1)
+        self.generate(self.nodes[2], 1)
         self.sync_all()
 
         assert_equal(self.nodes[2].getwalletinfo()["balance"][issuancedata["token"]], Decimal('0.00000005'))
@@ -197,7 +200,7 @@ class IssuanceTest(BitcoinTestFramework):
 
         self.sync_all()
         # Watch-only issuances won't show up in wallet until confirmed
-        self.nodes[1].generate(1)
+        self.generate(self.nodes[1], 1)
         self.sync_all()
 
         # Now have node 0 audit these issuances
@@ -263,7 +266,7 @@ class IssuanceTest(BitcoinTestFramework):
         # See: https://github.com/ElementsProject/elements/issues/473
         total_amount = self.nodes[0].getbalance()['bitcoin']
         self.nodes[0].sendtoaddress(nonblind_addr, total_amount, "", "", True)
-        self.nodes[1].generate(1)
+        self.generate(self.nodes[1], 1)
         raw_tx = self.nodes[0].createrawtransaction([], [{nonblind_addr: 1}])
         funded_tx = self.nodes[0].fundrawtransaction(raw_tx)['hex']
         issued_tx = self.nodes[2].rawissueasset(funded_tx, [{"asset_amount":1, "asset_address":nonblind_addr, "blind":False}])[0]["hex"]
@@ -274,24 +277,24 @@ class IssuanceTest(BitcoinTestFramework):
         # Make single blinded output to ensure we work around above issue
         total_amount = self.nodes[0].getbalance()['bitcoin']
         self.nodes[0].sendtoaddress(blind_addr, total_amount, "", "", True)
-        self.nodes[1].generate(1)
+        self.generate(self.nodes[1], 1)
 
         # Start with single issuance input, unblinded (makes 5 outputs for later larger issuances)
-        process_raw_issuance(self.nodes[0], [{"asset_amount": 2, "asset_address": nonblind_addr, "blind": False}])
-        process_raw_issuance(self.nodes[0], [{"asset_amount": 2, "asset_address": nonblind_addr, "blind": True}])
-        process_raw_issuance(self.nodes[0], [{"token_amount": 5, "token_address": nonblind_addr, "blind": False}])
-        process_raw_issuance(self.nodes[0], [{"asset_amount": 7, "asset_address": nonblind_addr, "token_amount":2, "token_address":nonblind_addr, "blind":False}])
-        process_raw_issuance(self.nodes[0], [{"asset_amount": 7, "asset_address": nonblind_addr, "token_amount":2, "token_address":blind_addr, "blind":False}])
-        process_raw_issuance(self.nodes[0], [{"asset_amount": 7, "asset_address": blind_addr, "token_amount":2, "token_address":nonblind_addr, "blind":False}])
-        process_raw_issuance(self.nodes[0], [{"asset_amount": 7, "asset_address": blind_addr, "token_amount":2, "token_address":blind_addr, "blind":False}])
+        self.raw_issuance(self.nodes[0], [{"asset_amount": 2, "asset_address": nonblind_addr, "blind": False}])
+        self.raw_issuance(self.nodes[0], [{"asset_amount": 2, "asset_address": nonblind_addr, "blind": True}])
+        self.raw_issuance(self.nodes[0], [{"token_amount": 5, "token_address": nonblind_addr, "blind": False}])
+        self.raw_issuance(self.nodes[0], [{"asset_amount": 7, "asset_address": nonblind_addr, "token_amount":2, "token_address":nonblind_addr, "blind":False}])
+        self.raw_issuance(self.nodes[0], [{"asset_amount": 7, "asset_address": nonblind_addr, "token_amount":2, "token_address":blind_addr, "blind":False}])
+        self.raw_issuance(self.nodes[0], [{"asset_amount": 7, "asset_address": blind_addr, "token_amount":2, "token_address":nonblind_addr, "blind":False}])
+        self.raw_issuance(self.nodes[0], [{"asset_amount": 7, "asset_address": blind_addr, "token_amount":2, "token_address":blind_addr, "blind":False}])
         # Now do multiple with some issuance outputs blind, some unblinded
-        process_raw_issuance(self.nodes[0], [{"asset_amount": 7, "asset_address": nonblind_addr, "token_amount":2, "token_address":nonblind_addr, "blind":False}, {"asset_amount":2, "asset_address":nonblind_addr, "blind":False}])
-        process_raw_issuance(self.nodes[0], [{"asset_amount": 7, "asset_address": blind_addr, "token_amount":2, "token_address":nonblind_addr, "blind":False}, {"asset_amount":2, "asset_address":nonblind_addr, "blind":False}])
+        self.raw_issuance(self.nodes[0], [{"asset_amount": 7, "asset_address": nonblind_addr, "token_amount":2, "token_address":nonblind_addr, "blind":False}, {"asset_amount":2, "asset_address":nonblind_addr, "blind":False}])
+        self.raw_issuance(self.nodes[0], [{"asset_amount": 7, "asset_address": blind_addr, "token_amount":2, "token_address":nonblind_addr, "blind":False}, {"asset_amount":2, "asset_address":nonblind_addr, "blind":False}])
         # Up to 5 issuances since we're making 5 outputs each time
-        process_raw_issuance(self.nodes[0], [{"asset_amount": 7, "asset_address": nonblind_addr, "token_amount":2, "token_address":blind_addr, "blind":False}, {"asset_amount":2, "asset_address":nonblind_addr, "blind":False}])
-        process_raw_issuance(self.nodes[0], [{"asset_amount": 1, "asset_address": nonblind_addr, "token_amount":2, "token_address":blind_addr, "blind":False}, {"asset_amount":3, "asset_address":nonblind_addr, "blind":False}, {"asset_amount":4, "asset_address":nonblind_addr, "token_amount":5, "token_address":blind_addr, "blind":False}, {"asset_amount":6, "asset_address":nonblind_addr, "token_amount":7, "token_address":blind_addr, "blind":False}, {"asset_amount":8, "asset_address":nonblind_addr, "token_amount":9, "token_address":blind_addr, "blind":False}])
+        self.raw_issuance(self.nodes[0], [{"asset_amount": 7, "asset_address": nonblind_addr, "token_amount":2, "token_address":blind_addr, "blind":False}, {"asset_amount":2, "asset_address":nonblind_addr, "blind":False}])
+        self.raw_issuance(self.nodes[0], [{"asset_amount": 1, "asset_address": nonblind_addr, "token_amount":2, "token_address":blind_addr, "blind":False}, {"asset_amount":3, "asset_address":nonblind_addr, "blind":False}, {"asset_amount":4, "asset_address":nonblind_addr, "token_amount":5, "token_address":blind_addr, "blind":False}, {"asset_amount":6, "asset_address":nonblind_addr, "token_amount":7, "token_address":blind_addr, "blind":False}, {"asset_amount":8, "asset_address":nonblind_addr, "token_amount":9, "token_address":blind_addr, "blind":False}])
         # Default "blind" value is true, omitting explicit argument for last
-        process_raw_issuance(self.nodes[0], [{"asset_amount": 1, "asset_address": nonblind_addr, "token_amount":2, "token_address":blind_addr, "blind":True}, {"asset_amount":3, "asset_address":nonblind_addr, "blind":True}, {"asset_amount":4, "asset_address":nonblind_addr, "token_amount":5, "token_address":blind_addr, "blind":True}, {"asset_amount":6, "asset_address":nonblind_addr, "token_amount":7, "token_address":blind_addr, "blind":True}, {"asset_amount":8, "asset_address":nonblind_addr, "token_amount":9, "token_address":blind_addr}])
+        self.raw_issuance(self.nodes[0], [{"asset_amount": 1, "asset_address": nonblind_addr, "token_amount":2, "token_address":blind_addr, "blind":True}, {"asset_amount":3, "asset_address":nonblind_addr, "blind":True}, {"asset_amount":4, "asset_address":nonblind_addr, "token_amount":5, "token_address":blind_addr, "blind":True}, {"asset_amount":6, "asset_address":nonblind_addr, "token_amount":7, "token_address":blind_addr, "blind":True}, {"asset_amount":8, "asset_address":nonblind_addr, "token_amount":9, "token_address":blind_addr}])
 
 
         # Make sure that fee is checked
@@ -372,7 +375,7 @@ class IssuanceTest(BitcoinTestFramework):
 
         print("Raw reissuance tests")
         issued_asset = self.nodes[0].issueasset(0, 1)
-        self.nodes[0].generate(1)
+        self.generate(self.nodes[0], 1)
         utxo_info = None
         # Find info about the token output using wallet
         for utxo in self.nodes[0].listunspent():
@@ -396,7 +399,7 @@ class IssuanceTest(BitcoinTestFramework):
         blind_tx = self.nodes[0].blindrawtransaction(reissued_tx["hex"])
         signed_tx = self.nodes[0].signrawtransactionwithwallet(blind_tx)
         tx_id = self.nodes[0].sendrawtransaction(signed_tx["hex"])
-        self.nodes[0].generate(1)
+        self.generate(self.nodes[0], 1)
         assert_equal(self.nodes[0].gettransaction(tx_id)["confirmations"], 1)
 
         # Now send reissuance token to blinded multisig, then reissue
@@ -414,7 +417,7 @@ class IssuanceTest(BitcoinTestFramework):
         self.nodes[0].importblindingkey(blinded_multisig, blinding_privkey)
         # Sending to this address must achieve blinding to reissue from this address
         self.nodes[0].sendtoaddress(blinded_multisig, self.nodes[0].getbalance()[issued_asset["token"]], "", "", False, False, 1, "UNSET", False, issued_asset["token"], False)
-        self.nodes[0].generate(1)
+        self.generate(self.nodes[0], 1)
 
         # Get that multisig output
         utxo_info = None
@@ -442,7 +445,7 @@ class IssuanceTest(BitcoinTestFramework):
         blind_tx = self.nodes[0].blindrawtransaction(reissued_tx["hex"])
         signed_tx = self.nodes[0].signrawtransactionwithwallet(blind_tx)
         tx_id = self.nodes[0].sendrawtransaction(signed_tx["hex"])
-        self.nodes[0].generate(1)
+        self.generate(self.nodes[0], 1)
         assert_equal(self.nodes[0].gettransaction(tx_id)["confirmations"], 1)
 
         # Now make transaction spending a token that had non-null contract_hash
@@ -453,7 +456,7 @@ class IssuanceTest(BitcoinTestFramework):
         blinded_tx = self.nodes[0].blindrawtransaction(issued_tx["hex"])
         signed_tx = self.nodes[0].signrawtransactionwithwallet(blinded_tx)
         tx_id = self.nodes[0].sendrawtransaction(signed_tx["hex"])
-        self.nodes[0].generate(1)
+        self.generate(self.nodes[0], 1)
         assert_equal(self.nodes[0].gettransaction(tx_id)["confirmations"], 1)
 
         utxo_info = None
@@ -479,7 +482,7 @@ class IssuanceTest(BitcoinTestFramework):
         blind_tx = self.nodes[0].blindrawtransaction(reissued_tx["hex"], False)
         signed_tx = self.nodes[0].signrawtransactionwithwallet(blind_tx)
         tx_id = self.nodes[0].sendrawtransaction(signed_tx["hex"])
-        self.nodes[0].generate(1)
+        self.generate(self.nodes[0], 1)
         assert_equal(self.nodes[0].gettransaction(tx_id)["confirmations"], 1)
 
         # Regression for one form of https://github.com/bitcoin/bitcoin/issues/20347
@@ -489,7 +492,7 @@ class IssuanceTest(BitcoinTestFramework):
         nonblind_addr = self.nodes[1].validateaddress(blind_addr)['unconfidential']
         self.nodes[0].sendtoaddress(nonblind_addr, 0.0005)
         self.sync_all()
-        self.nodes[0].generate(2)
+        self.generate(self.nodes[0], 2)
         self.sync_all()
 
         # 2. Try to do an unblinded issuance with only tokens -- the result will
diff --git a/test/functional/feature_mandatory_coinbase.py b/test/functional/feature_mandatory_coinbase.py
index 43e9dc3f8f..196bafc330 100755
--- a/test/functional/feature_mandatory_coinbase.py
+++ b/test/functional/feature_mandatory_coinbase.py
@@ -44,10 +44,10 @@ class MandatoryCoinbaseTest(BitcoinTestFramework):
 
         self.log.info("generatetoaddress: Making blocks of various kinds, checking for rejection")
         # Create valid blocks to get out of IBD and get some funds (subsidy goes to permitted addr)
-        node0.generatetoaddress(101, mandatory_address)
+        self.generatetoaddress(node0, 101, mandatory_address)
 
         # Generating for another address will not work
-        assert_raises_rpc_error(-1, "CreateNewBlock: TestBlockValidity failed: bad-coinbase-txos", node0.generatetoaddress, 1, node0.getnewaddress())
+        assert_raises_rpc_error(-1, "CreateNewBlock: TestBlockValidity failed: bad-coinbase-txos", self.generatetoaddress, node0, 1, node0.getnewaddress())
 
         # Have non-mandatory node make a template
         self.sync_all()
diff --git a/test/functional/feature_pak.py b/test/functional/feature_pak.py
index 27857c03ae..7fd05cc940 100755
--- a/test/functional/feature_pak.py
+++ b/test/functional/feature_pak.py
@@ -111,7 +111,7 @@ class PAKTest (BitcoinTestFramework):
         print(pegout_info)
         raw_node1_pegout = self.nodes[1].gettransaction(pegout_info["txid"])["hex"]
         self.sync_all() # mempool sync
-        self.nodes[1].generatetoaddress(1, self.nodes[0].getnewaddress())
+        self.generatetoaddress(self.nodes[1], 1, self.nodes[0].getnewaddress())
         self.sync_all() # block sync
         assert_greater_than(self.nodes[1].gettransaction(pegout_info["txid"])["confirmations"], 0)
 
@@ -184,7 +184,7 @@ class PAKTest (BitcoinTestFramework):
         self.sync_blocks()
 
         # Get some block subsidy and send off
-        self.nodes[1].generatetoaddress(101, self.nodes[1].getnewaddress())
+        self.generatetoaddress(self.nodes[1], 101, self.nodes[1].getnewaddress())
         wpkh_stmc = self.nodes[1].sendtomainchain("", 1)
         wpkh_txid = wpkh_stmc['txid']
 
@@ -215,7 +215,7 @@ class PAKTest (BitcoinTestFramework):
             self.nodes[1].submitblock(block)
         self.sync_blocks()
 
-        self.nodes[1].generatetoaddress(1, self.nodes[1].getnewaddress())
+        self.generatetoaddress(self.nodes[1], 1, self.nodes[1].getnewaddress())
         sh_wpkh_txid = self.nodes[1].sendtomainchain("", 1)['txid']
 
         # Make sure peg-outs look correct
@@ -244,7 +244,7 @@ class PAKTest (BitcoinTestFramework):
         assert peg_out_found
 
         # Make sure they all confirm
-        self.nodes[1].generatetoaddress(1, self.nodes[0].getnewaddress())
+        self.generatetoaddress(self.nodes[1], 1, self.nodes[0].getnewaddress())
         for tx_id in [wpkh_txid, sh_wpkh_txid]:
             assert_greater_than(self.nodes[1].gettransaction(tx_id)["confirmations"], 0)
 
@@ -270,7 +270,7 @@ class PAKTest (BitcoinTestFramework):
         assert_raises_rpc_error(-25, "bad-pak-tx", self.nodes[2].testproposedblock, bad_prop, True)
 
         # Test that subtracting fee from output works
-        self.nodes[1].generatetoaddress(101, self.nodes[1].getnewaddress())
+        self.generatetoaddress(self.nodes[1], 101, self.nodes[1].getnewaddress())
         self.nodes[1].sendtomainchain("", self.nodes[1].getbalance()["bitcoin"], True)
         assert_equal(self.nodes[1].getbalance()["bitcoin"], 0)
 
diff --git a/test/functional/feature_progress.py b/test/functional/feature_progress.py
index d0d5617248..8d106fc33c 100755
--- a/test/functional/feature_progress.py
+++ b/test/functional/feature_progress.py
@@ -42,7 +42,7 @@ class ProgressTest(BitcoinTestFramework):
         blocks = []
         for i in range(10):
             self.setmocktime(i)
-            blocks.extend(node1.generate(1))
+            blocks.extend(self.generate(node1, 1))
 
         self.setmocktime(19)
         assert_close(0.5, node1.getblockchaininfo()["verificationprogress"])
diff --git a/test/functional/feature_sighash_rangeproof.py b/test/functional/feature_sighash_rangeproof.py
index 0c3bbe7c95..c462a5b1eb 100755
--- a/test/functional/feature_sighash_rangeproof.py
+++ b/test/functional/feature_sighash_rangeproof.py
@@ -72,7 +72,7 @@ class SighashRangeproofTest(BitcoinTestFramework):
         addr = self.nodes[1].getnewaddress("", address_type)
         assert len(self.nodes[1].getaddressinfo(addr)["confidential_key"]) > 0
         self.nodes[0].sendtoaddress(addr, 1.0)
-        self.nodes[0].generate(1)
+        self.generate(self.nodes[0], 1)
         self.sync_all()
         utxo = self.nodes[1].listunspent(1, 1, [addr])[0]
         utxo_tx = tx_from_hex(self.nodes[1].getrawtransaction(utxo["txid"]))
@@ -225,7 +225,7 @@ class SighashRangeproofTest(BitcoinTestFramework):
         # - after activation, using the flag is standard (and thus also legal)
 
         # Mine come coins for node 0.
-        self.nodes[0].generate(200)
+        self.generate(self.nodes[0], 200)
         self.sync_all()
 
         # Ensure that if we use the SIGHASH_RANGEPROOF flag before it's activated,
@@ -244,9 +244,9 @@ class SighashRangeproofTest(BitcoinTestFramework):
 
         # Activate dynafed (nb of blocks taken from dynafed activation test)
         # Generate acress several calls to `generatetoaddress` to ensure no individual call times out
-        self.nodes[0].generate(503)
-        self.nodes[0].generate(503)
-        self.nodes[0].generate(1 + 144 + 144)
+        self.generate(self.nodes[0], 503)
+        self.generate(self.nodes[0], 503)
+        self.generate(self.nodes[0], 1 + 144 + 144)
         assert_equal(self.nodes[0].getblockchaininfo()["softforks"]["dynafed"]["bip9"]["status"], "active")
 
         self.sync_all()
diff --git a/test/functional/feature_txwitness.py b/test/functional/feature_txwitness.py
index 1d17f8a525..60c1502868 100755
--- a/test/functional/feature_txwitness.py
+++ b/test/functional/feature_txwitness.py
@@ -91,10 +91,10 @@ class TxWitnessTest(BitcoinTestFramework):
         self.unknown_addr = self.nodes[1].getnewaddress()
 
         # directly seed types of utxos required
-        self.nodes[0].generatetoaddress(1, legacy_addr)
-        self.nodes[0].generatetoaddress(1, p2sh_addr)
-        self.nodes[0].generatetoaddress(1, bech32_addr)
-        self.nodes[0].generatetoaddress(101, self.unknown_addr)
+        self.generatetoaddress(self.nodes[0], 1, legacy_addr)
+        self.generatetoaddress(self.nodes[0], 1, p2sh_addr)
+        self.generatetoaddress(self.nodes[0], 1, bech32_addr)
+        self.generatetoaddress(self.nodes[0], 101, self.unknown_addr)
 
         # grab utxos filtering by age
         legacy_utxo = self.nodes[0].listunspent(104, 104)[0]
@@ -109,7 +109,7 @@ class TxWitnessTest(BitcoinTestFramework):
         self.log.info("Testing bech32 UTXO")
         submitted_txids.append(self.assert_tx_format_also_signed(bech32_utxo, segwit=True))
 
-        blockhash = self.nodes[0].generate(1)[0]
+        blockhash = self.generate(self.nodes[0], 1)[0]
         hexblock = self.nodes[0].getblock(blockhash, 0)
         block_details = self.nodes[0].getblock(blockhash, 2)
         block = CBlock()
diff --git a/test/functional/mempool_package_limits.py b/test/functional/mempool_package_limits.py
index 1218ba90f3..ea093b5fa6 100755
--- a/test/functional/mempool_package_limits.py
+++ b/test/functional/mempool_package_limits.py
@@ -251,7 +251,7 @@ class MempoolPackageLimitsTest(BitcoinTestFramework):
             assert_equal(txres["package-error"], "package-mempool-limits")
 
         # Clear mempool and check that the package passes now
-        node.generate(1)
+        self.generate(node, 1)
         assert all([res["allowed"] for res in node.testmempoolaccept(rawtxs=package_hex)])
 
     def test_anc_count_limits(self):
diff --git a/test/functional/rpc_fundrawtransaction.py b/test/functional/rpc_fundrawtransaction.py
index 42a8a5a9a7..e29cec6042 100755
--- a/test/functional/rpc_fundrawtransaction.py
+++ b/test/functional/rpc_fundrawtransaction.py
@@ -1007,7 +1007,7 @@ class RawTransactionsTest(BitcoinTestFramework):
         txid = self.nodes[2].sendtoaddress(addr_info['unconfidential'], 10)
         self.sync_all()
         vout = find_vout_for_address(self.nodes[0], txid, n0_blind_addr)
-        self.nodes[0].generate(1)
+        self.generate(self.nodes[0], 1)
         self.sync_all()
 
         # An external input without solving data should result in an error
@@ -1224,7 +1224,7 @@ class RawTransactionsTest(BitcoinTestFramework):
             for i in range(0, 50):
                 outputs[recipient.getnewaddress()] = 0.1
             wallet.sendmany("", outputs)
-        self.nodes[0].generate(10)
+        self.generate(self.nodes[0], 10)
 
         # ...and try to send them all in one transaction
         # This should fail but we should not see an assertion failure.
diff --git a/test/functional/rpc_psbt.py b/test/functional/rpc_psbt.py
index 1fb99f1876..c1df62665c 100755
--- a/test/functional/rpc_psbt.py
+++ b/test/functional/rpc_psbt.py
@@ -635,7 +635,7 @@ class PSBTTest(BitcoinTestFramework):
 
         # Extractor test
         for extractor in extractors:
-            extracted = self.nodes[2].finalizepsbt(extractor['extract'], True)['hex']
+            extracted = self.n  des[2].finalizepsbt(extractor['extract'], True)['hex']
             assert_equal(extracted, extractor['result'])
 
         # Unload extra wallets
@@ -950,7 +950,7 @@ class PSBTTest(BitcoinTestFramework):
             assert_raises_rpc_error(-8, "PSBTs not compatible (different transactions)", self.nodes[0].combinepsbt, [BLINDED, bad_pset])
 
     def run_test(self):
-        self.nodes[0].generate(200)
+        self.generate(self.nodes[0], 200)
         self.sync_all()
 
         # Run all the pre-Elements, tests first with non-confidential addresses, then again with confidential addresses
diff --git a/test/functional/rpc_signrawtransaction.py b/test/functional/rpc_signrawtransaction.py
index 0b01d13400..8460f50e51 100755
--- a/test/functional/rpc_signrawtransaction.py
+++ b/test/functional/rpc_signrawtransaction.py
@@ -365,7 +365,7 @@ class SignRawTransactionsTest(BitcoinTestFramework):
         utxo_script_pk = utxo_address_info['scriptPubKey']
         utxo_amount = 0.1
         utxo_txid = self.nodes[2].sendtoaddress(utxo_address, utxo_amount)
-        self.nodes[2].generate(1)
+        self.generate(self.nodes[2], 1)
 
         tx = self.nodes[2].getrawtransaction(utxo_txid, True)
         vout = [v['n'] for v in tx['vout'] if 'scriptPubKey' in v and uc_addr == v['scriptPubKey'].get('address',[])]
@@ -408,7 +408,7 @@ class SignRawTransactionsTest(BitcoinTestFramework):
 
         # 5) The signed transaction can broadcast.
         txid = self.nodes[2].sendrawtransaction(signed_tx['hex'])
-        self.nodes[2].generate(1)
+        self.generate(self.nodes[2], 1)
 
         tx = self.nodes[2].getrawtransaction(txid, True)
         vout = [v['n'] for v in tx['vout'] if 'scriptPubKey' in v and uc_addr == v['scriptPubKey'].get('address',[])]
diff --git a/test/functional/rpc_tweakfedpeg.py b/test/functional/rpc_tweakfedpeg.py
index 51685f27e2..6b1203acb5 100755
--- a/test/functional/rpc_tweakfedpeg.py
+++ b/test/functional/rpc_tweakfedpeg.py
@@ -86,7 +86,7 @@ class TweakFedpegTest(BitcoinTestFramework):
         # Advance to dynamic federations activation, which has pubkeys
         # after OP_ELSE get tweaked except the exact liquidv1 template to
         # maintain compatibility
-        self.nodes[2].generate(433)
+        self.generate(self.nodes[2], 433)
         assert_equal(self.nodes[2].getblockchaininfo()['softforks']['dynafed']['bip9']['status'], 'active')
         assert_equal(self.nodes[2].tweakfedpegscript(claim_script)["script"], liquid_tweaked)
 
diff --git a/test/functional/test_framework/test_framework.py b/test/functional/test_framework/test_framework.py
index 72cb307980..da684b980a 100755
--- a/test/functional/test_framework/test_framework.py
+++ b/test/functional/test_framework/test_framework.py
@@ -632,19 +632,19 @@ class BitcoinTestFramework(metaclass=BitcoinTestMetaClass):
         self.sync_all()
 
     def generate(self, generator, *args, **kwargs):
-        blocks = generator.generate(*args, **kwargs)
+        blocks = generator.generate(*args, invalid_call=False, **kwargs)
         return blocks
 
     def generateblock(self, generator, *args, **kwargs):
-        blocks = generator.generateblock(*args, **kwargs)
+        blocks = generator.generateblock(*args, invalid_call=False, **kwargs)
         return blocks
 
     def generatetoaddress(self, generator, *args, **kwargs):
-        blocks = generator.generatetoaddress(*args, **kwargs)
+        blocks = generator.generatetoaddress(*args, invalid_call=False, **kwargs)
         return blocks
 
     def generatetodescriptor(self, generator, *args, **kwargs):
-        blocks = generator.generatetodescriptor(*args, **kwargs)
+        blocks = generator.generatetodescriptor(*args, invalid_call=False, **kwargs)
         return blocks
 
     def sync_blocks(self, nodes=None, wait=1, timeout=60, expect_disconnected=False):
diff --git a/test/functional/test_framework/test_node.py b/test/functional/test_framework/test_node.py
index 86af59c9c2..77610fd566 100755
--- a/test/functional/test_framework/test_node.py
+++ b/test/functional/test_framework/test_node.py
@@ -311,9 +311,21 @@ class TestNode():
             time.sleep(1.0 / poll_per_s)
         self._raise_assertion_error("Unable to retrieve cookie credentials after {}s".format(self.rpc_timeout))
 
-    def generate(self, nblocks, maxtries=1000000):
+    def generate(self, nblocks, maxtries=1000000, **kwargs):
         self.log.debug("TestNode.generate() dispatches `generate` call to `generatetoaddress`")
-        return self.generatetoaddress(nblocks=nblocks, address=self.get_deterministic_priv_key().address, maxtries=maxtries)
+        return self.generatetoaddress(nblocks=nblocks, address=self.get_deterministic_priv_key().address, maxtries=maxtries, **kwargs)
+
+    def generateblock(self, *args, invalid_call, **kwargs):
+        assert not invalid_call
+        return self.__getattr__('generateblock')(*args, **kwargs)
+
+    def generatetoaddress(self, *args, invalid_call, **kwargs):
+        assert not invalid_call
+        return self.__getattr__('generatetoaddress')(*args, **kwargs)
+
+    def generatetodescriptor(self, *args, invalid_call, **kwargs):
+        assert not invalid_call
+        return self.__getattr__('generatetodescriptor')(*args, **kwargs)
 
     def get_wallet_rpc(self, wallet_name):
         if self.use_cli:
diff --git a/test/functional/test_framework/wallet.py b/test/functional/test_framework/wallet.py
index 49e35514e7..fc001e7a45 100644
--- a/test/functional/test_framework/wallet.py
+++ b/test/functional/test_framework/wallet.py
@@ -111,9 +111,9 @@ class MiniWallet:
                 break
         tx.vin[0].scriptSig = CScript([der_sig + bytes(bytearray([SIGHASH_ALL]))])
 
-    def generate(self, num_blocks):
+    def generate(self, num_blocks, **kwargs):
         """Generate blocks with coinbase outputs to the internal address, and append the outputs to the internal list"""
-        blocks = self._test_node.generatetodescriptor(num_blocks, self.get_descriptor())
+        blocks = self._test_node.generatetodescriptor(num_blocks, self.get_descriptor(), **kwargs)
         for b in blocks:
             cb_tx = self._test_node.getblock(blockhash=b, verbosity=2)['tx'][0]
             self._utxos.append({'txid': cb_tx['txid'], 'vout': 0, 'value': cb_tx['vout'][0]['value']})
diff --git a/test/functional/wallet_balance.py b/test/functional/wallet_balance.py
index a265e076e5..8f61f412b4 100755
--- a/test/functional/wallet_balance.py
+++ b/test/functional/wallet_balance.py
@@ -297,7 +297,7 @@ class WalletTest(BitcoinTestFramework):
             assert_equal(walletinfo["unconfirmed_balance"].get(asset, 0), Decimal('0'))
 
             # Balances with confirmed issuance.
-            self.nodes[0].generatetoaddress(1, ADDRESS_WATCHONLY)
+            self.generatetoaddress(self.nodes[0], 1, ADDRESS_WATCHONLY)
             walletinfo = self.nodes[0].getwalletinfo()
             assert_equal(walletinfo["balance"].get(asset, 0), Decimal('100'))
             assert_equal(walletinfo["unconfirmed_balance"].get(asset, 0), Decimal('0'))
@@ -312,7 +312,7 @@ class WalletTest(BitcoinTestFramework):
             assert_equal(walletinfo["unconfirmed_balance"].get(asset, 0), Decimal('50'))
 
             # Balances with confirmed receive
-            self.nodes[1].generatetoaddress(1, ADDRESS_WATCHONLY)
+            self.generatetoaddress(self.nodes[1], 1, ADDRESS_WATCHONLY)
             walletinfo = self.nodes[1].getwalletinfo()
             assert_equal(walletinfo["balance"].get(asset, 0), Decimal('50'))
             assert_equal(walletinfo["unconfirmed_balance"].get(asset, 0), Decimal('0'))
diff --git a/test/functional/wallet_descriptor.py b/test/functional/wallet_descriptor.py
index 17a4c79da3..4ec44a8a6c 100755
--- a/test/functional/wallet_descriptor.py
+++ b/test/functional/wallet_descriptor.py
@@ -84,7 +84,7 @@ class WalletDescriptorTest(BitcoinTestFramework):
         send_wrpc = self.nodes[0].get_wallet_rpc("desc1")
 
         # Generate some coins
-        self.generatetoaddress(send_wrpc, COINBASE_MATURITY + 1, send_wrpc.getnewaddress())
+        self.generatetoaddress(self.nodes[0], COINBASE_MATURITY + 1, send_wrpc.getnewaddress())
 
         # Make transactions
         self.log.info("Test sending and receiving")
diff --git a/test/functional/wallet_disable.py b/test/functional/wallet_disable.py
index 118e793e9a..8640a704c5 100755
--- a/test/functional/wallet_disable.py
+++ b/test/functional/wallet_disable.py
@@ -29,7 +29,7 @@ class DisableWalletTest (BitcoinTestFramework):
         # Checking mining to an address without a wallet. Generating to a valid address should succeed
         # but generating to an invalid address will fail.
         self.generatetoaddress(self.nodes[0], 1, 'CTEsjYXANAynYYMzu5BUyvfNAVToxGh3s17kjZvELXuBG37qsfzz65vfhxEocbo55AnrvGbWBuMbJMCz')
-        assert_raises_rpc_error(-5, "Invalid address", self.nodes[0].generatetoaddress, 1, '3J98t1WpEZ73CNmQviecrnyiWrnqRhWNLy')
+        assert_raises_rpc_error(-5, "Invalid address", self.generatetoaddress, self.nodes[0], 1, '3J98t1WpEZ73CNmQviecrnyiWrnqRhWNLy')
 
 if __name__ == '__main__':
     DisableWalletTest ().main ()
diff --git a/test/functional/wallet_elements_regression_1172.py b/test/functional/wallet_elements_regression_1172.py
index 25e27c582a..d7d6edf439 100755
--- a/test/functional/wallet_elements_regression_1172.py
+++ b/test/functional/wallet_elements_regression_1172.py
@@ -47,7 +47,7 @@ class WalletCtTest(BitcoinTestFramework):
             address = self.nodes[to_idx].getaddressinfo(address)['unconfidential']
         txid = self.nodes[from_idx].sendtoaddress(address, amt)
         self.log.info(f"Sent {amt} LBTC to node {to_idx} in {txid}")
-        self.nodes[from_idx].generate(2)
+        self.generate(self.nodes[from_idx], 2)
         self.sync_all()
 
         for i in range(self.num_nodes):
@@ -57,7 +57,7 @@ class WalletCtTest(BitcoinTestFramework):
 
     def run_test(self):
         # Mine 101 blocks to get the initial coins out of IBD
-        self.nodes[0].generate(COINBASE_MATURITY + 1)
+        self.generate(self.nodes[0], COINBASE_MATURITY + 1)
         self.nodes[0].syncwithvalidationinterfacequeue()
         self.sync_all()
 
@@ -67,7 +67,7 @@ class WalletCtTest(BitcoinTestFramework):
         # Send 1 coin to a new wallet
         txid = self.nodes[0].sendtoaddress(self.nodes[1].getnewaddress(), 1)
         self.log.info(f"Sent one coin to node 1 in {txid}")
-        self.nodes[0].generate(2)
+        self.generate(self.nodes[0], 2)
         self.sync_all()
 
         # Try to send those coins to yet another wallet, sending a large enough amount
@@ -95,7 +95,7 @@ class WalletCtTest(BitcoinTestFramework):
             + [ self.nodes[2].getnewaddress() for i in range(15) ]
         txid = self.nodes[2].sendmany(amounts={address: satoshi_round(Decimal(0.00025)) for address in addresses})
         self.log.info(f"Sent many small UTXOs to nodes 1 and 2 in {txid}")
-        self.nodes[2].generate(2)
+        self.generate(self.nodes[2], 2)
         self.sync_all()
 
         self.log.info(f"Issuing some assets from node 1")
@@ -111,7 +111,7 @@ class WalletCtTest(BitcoinTestFramework):
             output_assets={addresses[i]: assets[i] for i in range(len(assets))},
         )
         self.log.info(f"Sent them to node 2 in {txid}")
-        self.nodes[1].generate(2)
+        self.generate(self.nodes[1], 2)
         self.sync_all()
         # Send them back
         addresses = [ self.nodes[1].getnewaddress() for i in range(len(assets)) ]
diff --git a/test/functional/wallet_fallbackfee.py b/test/functional/wallet_fallbackfee.py
index fe552773db..e67dac56c4 100755
--- a/test/functional/wallet_fallbackfee.py
+++ b/test/functional/wallet_fallbackfee.py
@@ -46,7 +46,7 @@ class WalletRBFTest(BitcoinTestFramework):
             addrs = self.nodes[1].getpeginaddress()
             txid = self.nodes[0].sendtoaddress(addrs["mainchain_address"], 5)
             raw = self.nodes[0].getrawtransaction(txid)
-            self.nodes[0].generate(12)
+            self.generate(self.nodes[0], 12)
             proof = self.nodes[0].gettxoutproof([txid])
             assert_raises_rpc_error(-6, "Fee estimation failed", lambda: self.nodes[1].claimpegin(raw, proof))
 
diff --git a/test/functional/wallet_importdescriptors.py b/test/functional/wallet_importdescriptors.py
index ae698b65f2..e89c7b716a 100755
--- a/test/functional/wallet_importdescriptors.py
+++ b/test/functional/wallet_importdescriptors.py
@@ -74,7 +74,7 @@ class ImportDescriptorsTest(BitcoinTestFramework):
         assert_equal(wpriv.getwalletinfo()['keypoolsize'], 0)
 
         self.log.info('Mining coins')
-        self.generatetoaddress(w0, COINBASE_MATURITY + 1, w0.getnewaddress())
+        self.generatetoaddress(self.nodes[0], COINBASE_MATURITY + 1, w0.getnewaddress())
 
         # RPC importdescriptors -----------------------------------------------
 
@@ -405,7 +405,7 @@ class ImportDescriptorsTest(BitcoinTestFramework):
                      solvable=True,
                      ismine=True)
         txid = w0.sendtoaddress(address, 49.99965520)
-        self.generatetoaddress(w0, 6, w0.getnewaddress())
+        self.generatetoaddress(self.nodes[0], 6, w0.getnewaddress())
         self.sync_blocks()
         tx = wpriv.createrawtransaction([{"txid": txid, "vout": 0}], [{w0.getnewaddress(): 49.999}, {"fee": 0.00065520}])
         signed_tx = wpriv.signrawtransactionwithwallet(tx)
diff --git a/test/functional/wallet_transactiontime_rescan.py b/test/functional/wallet_transactiontime_rescan.py
index ae9e9f8852..ca658c71da 100755
--- a/test/functional/wallet_transactiontime_rescan.py
+++ b/test/functional/wallet_transactiontime_rescan.py
@@ -63,7 +63,7 @@ class TransactionTimeRescanTest(BitcoinTestFramework):
 
         # generate some btc to create transactions and check blockcount
         initial_mine = COINBASE_MATURITY + 1
-        minernode.generatetoaddress(initial_mine, m1)
+        self.generatetoaddress(minernode, initial_mine, m1)
         assert_equal(minernode.getblockcount(), initial_mine + 200)
 
         # synchronize nodes and time
@@ -76,7 +76,7 @@ class TransactionTimeRescanTest(BitcoinTestFramework):
         miner_wallet.sendtoaddress(wo1, 10)
 
         # generate blocks and check blockcount
-        minernode.generatetoaddress(COINBASE_MATURITY, m1)
+        self.generatetoaddress(minernode, COINBASE_MATURITY, m1)
         assert_equal(minernode.getblockcount(), initial_mine + 300)
 
         # synchronize nodes and time
@@ -89,7 +89,7 @@ class TransactionTimeRescanTest(BitcoinTestFramework):
         miner_wallet.sendtoaddress(wo2, 5)
 
         # generate blocks and check blockcount
-        minernode.generatetoaddress(COINBASE_MATURITY, m1)
+        self.generatetoaddress(minernode, COINBASE_MATURITY, m1)
         assert_equal(minernode.getblockcount(), initial_mine + 400)
 
         # synchronize nodes and time
@@ -102,7 +102,7 @@ class TransactionTimeRescanTest(BitcoinTestFramework):
         miner_wallet.sendtoaddress(wo3, 1)
 
         # generate more blocks and check blockcount
-        minernode.generatetoaddress(COINBASE_MATURITY, m1)
+        self.generatetoaddress(minernode, COINBASE_MATURITY, m1)
         assert_equal(minernode.getblockcount(), initial_mine + 500)
 
         self.log.info('Check user\'s final balance and transaction count')