Merge 2e82af4 into merged_master (Bitcoin PR bitcoin/bitcoin#23207)

test/functional/feature_assetsdir.py

@@ -29,7 +29,7 @@ def setup_network(self, split=False):
         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 @@ def run_test(self):
 
 if __name__ == '__main__':
     AssetdirTests().main()
-

test/functional/feature_block_subsidy.py

@@ -40,7 +40,7 @@ def run_test(self):
 
         # 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 @@ def run_test(self):
         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"]:

test/functional/feature_block_v4.py

@@ -55,7 +55,7 @@ def run_test(self):
         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]

test/functional/feature_confidential_transactions.py

@@ -86,7 +86,7 @@ def test_wallet_recovery(self):
         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 @@ def test_wallet_recovery(self):
         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 @@ def run_test(self):
         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 @@ def run_test(self):
         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 @@ def run_test(self):
         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 @@ def run_test(self):
         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 @@ def run_test(self):
         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 @@ def run_test(self):
         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 @@ def run_test(self):
 
         # 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 @@ def run_test(self):
         # 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 @@ def run_test(self):
         # 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 @@ def run_test(self):
         # 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 @@ def run_test(self):
         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()
 

test/functional/feature_default_asset_name.py

@@ -34,7 +34,7 @@ def skip_test_if_missing_module(self):
     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 @@ def run_test(self):
 
         #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 @@ def run_test(self):
         #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

test/functional/feature_dynafed.py

@@ -32,11 +32,6 @@
 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 @@ def test_dynafed_activation(self):
         # 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 @@ def test_dynafed_activation(self):
             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,26 +164,26 @@ def test_illegal_proposals(self):
 
     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):
             for block in blocks:
                 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):
             validate_no_vote_op_true(self.nodes[i], block, False)
 
     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,17 +194,17 @@ def test_under_vote(self):
         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):
             validate_no_vote_op_true(self.nodes[i], block, False)
 
     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 @@ def test_four_fifth_vote(self):
         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 @@ def test_four_fifth_vote(self):
             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 @@ def test_transition_mempool_eject(self):
         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 @@ def test_transition_mempool_eject(self):
         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 @@ def assert_accepted(self, tx):
     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 @@ def test_valid_epochs(self):
         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 @@ def test_valid_epochs(self):
 
         # 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 @@ def test_valid_epochs(self):
         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 @@ def test_valid_epochs(self):
         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):