Merge bitcoin/bitcoin#24839: test: use MiniWallet for mining_prioritisetransaction.py

b167e53 test: refactor: use `create_lots_of_big_transactions` to dedup where possible (Sebastian Falbesoner)
8973eeb test: use MiniWallet for mining_prioritisetransaction.py (Sebastian Falbesoner)

Pull request description:

  This PR enables one more of the non-wallet functional tests (mining_prioritisetransaction.py) to be run even with the Bitcoin Code wallet by using the MiniWallet instead, as proposed in #20078. Note that the adapted helper function `create_lots_of_big_transactions` is currently only used in this test, i.e. there was no need to change any others.

ACKs for top commit:
  ayush933:
    tACK b167e53
  danielabrozzoni:
    tACK b167e53
  kouloumos:
    ACK b167e53
  furszy:
    ACK b167e53

Tree-SHA512: ccae20d7d414a720efdeea9c2ae399aa53a3a0e7db72bff8d0cb75d90621a7ae7c019ba68d24f9d06f7b111f87ff33bb9d8e5aa08b763e606cf10268780e205c

Author: MacroFake

test/functional/mempool_limit.py

@@ -7,12 +7,12 @@
 from decimal import Decimal
 
 from test_framework.blocktools import COINBASE_MATURITY
-from test_framework.messages import COIN
 from test_framework.test_framework import BitcoinTestFramework
 from test_framework.util import (
     assert_equal,
     assert_greater_than,
     assert_raises_rpc_error,
+    create_lots_of_big_transactions,
     gen_return_txouts,
 )
 from test_framework.wallet import MiniWallet
@@ -29,16 +29,6 @@ def set_test_params(self):
         ]]
         self.supports_cli = False
 
-    def send_large_txs(self, node, miniwallet, txouts, fee, tx_batch_size):
-        for _ in range(tx_batch_size):
-            tx = miniwallet.create_self_transfer(from_node=node, fee_rate=0, mempool_valid=False)['tx']
-            for txout in txouts:
-                tx.vout.append(txout)
-            tx.vout[0].nValue -= int(fee * COIN)
-            res = node.testmempoolaccept([tx.serialize().hex()])[0]
-            assert_equal(res['fees']['base'], fee)
-            miniwallet.sendrawtransaction(from_node=node, tx_hex=tx.serialize().hex())
-
     def run_test(self):
         txouts = gen_return_txouts()
         node = self.nodes[0]
@@ -71,7 +61,7 @@ def run_test(self):
         self.log.info("Fill up the mempool with txs with higher fee rate")
         for batch_of_txid in range(num_of_batches):
             fee = (batch_of_txid + 1) * base_fee
-            self.send_large_txs(node, miniwallet, txouts, fee, tx_batch_size)
+            create_lots_of_big_transactions(miniwallet, node, fee, tx_batch_size, txouts)
 
         self.log.info('The tx should be evicted by now')
         # The number of transactions created should be greater than the ones present in the mempool

test/functional/mining_prioritisetransaction.py

@@ -7,29 +7,31 @@
 from decimal import Decimal
 import time
 
-from test_framework.blocktools import COINBASE_MATURITY
-from test_framework.messages import COIN, MAX_BLOCK_WEIGHT
+from test_framework.messages import (
+    COIN,
+    MAX_BLOCK_WEIGHT,
+)
 from test_framework.test_framework import BitcoinTestFramework
-from test_framework.util import assert_equal, assert_raises_rpc_error, create_confirmed_utxos, create_lots_of_big_transactions, gen_return_txouts
+from test_framework.util import (
+    assert_equal,
+    assert_raises_rpc_error,
+    create_lots_of_big_transactions,
+    gen_return_txouts,
+)
 from test_framework.wallet import MiniWallet
 
 
 class PrioritiseTransactionTest(BitcoinTestFramework):
     def set_test_params(self):
-        self.setup_clean_chain = True
         self.num_nodes = 1
         self.extra_args = [[
             "-printpriority=1",
             "-acceptnonstdtxn=1",
         ]] * self.num_nodes
         self.supports_cli = False
 
-    def skip_test_if_missing_module(self):
-        self.skip_if_no_wallet()
-
     def test_diamond(self):
         self.log.info("Test diamond-shape package with priority")
-        self.generate(self.wallet, COINBASE_MATURITY + 1)
         mock_time = int(time.time())
         self.nodes[0].setmocktime(mock_time)
 
@@ -104,6 +106,7 @@ def test_diamond(self):
 
     def run_test(self):
         self.wallet = MiniWallet(self.nodes[0])
+        self.wallet.rescan_utxos()
 
         # Test `prioritisetransaction` required parameters
         assert_raises_rpc_error(-1, "prioritisetransaction", self.nodes[0].prioritisetransaction)
@@ -131,7 +134,10 @@ def run_test(self):
         self.relayfee = self.nodes[0].getnetworkinfo()['relayfee']
 
         utxo_count = 90
-        utxos = create_confirmed_utxos(self, self.relayfee, self.nodes[0], utxo_count)
+        utxos = self.wallet.send_self_transfer_multi(from_node=self.nodes[0], num_outputs=utxo_count)['new_utxos']
+        self.generate(self.wallet, 1)
+        assert_equal(len(self.nodes[0].getrawmempool()), 0)
+
         base_fee = self.relayfee*100 # our transactions are smaller than 100kb
         txids = []
 
@@ -141,7 +147,13 @@ def run_test(self):
             txids.append([])
             start_range = i * range_size
             end_range = start_range + range_size
-            txids[i] = create_lots_of_big_transactions(self.nodes[0], self.txouts, utxos[start_range:end_range], end_range - start_range, (i+1)*base_fee)
+            txids[i] = create_lots_of_big_transactions(
+                self.wallet,
+                self.nodes[0],
+                (i+1) * base_fee,
+                end_range - start_range,
+                self.txouts,
+                utxos[start_range:end_range])
 
         # Make sure that the size of each group of transactions exceeds
         # MAX_BLOCK_WEIGHT // 4 -- otherwise the test needs to be revised to
@@ -200,17 +212,9 @@ def run_test(self):
                 assert x not in mempool
 
         # Create a free transaction.  Should be rejected.
-        utxo_list = self.nodes[0].listunspent()
-        assert len(utxo_list) > 0
-        utxo = utxo_list[0]
-
-        inputs = []
-        outputs = {}
-        inputs.append({"txid" : utxo["txid"], "vout" : utxo["vout"]})
-        outputs[self.nodes[0].getnewaddress()] = utxo["amount"]
-        raw_tx = self.nodes[0].createrawtransaction(inputs, outputs)
-        tx_hex = self.nodes[0].signrawtransactionwithwallet(raw_tx)["hex"]
-        tx_id = self.nodes[0].decoderawtransaction(tx_hex)["txid"]
+        tx_res = self.wallet.create_self_transfer(from_node=self.nodes[0], fee_rate=0, mempool_valid=False)
+        tx_hex = tx_res['hex']
+        tx_id = tx_res['txid']
 
         # This will raise an exception due to min relay fee not being met
         assert_raises_rpc_error(-26, "min relay fee not met", self.nodes[0].sendrawtransaction, tx_hex)

test/functional/test_framework/util.py

@@ -553,38 +553,31 @@ def gen_return_txouts():
 
 # Create a spend of each passed-in utxo, splicing in "txouts" to each raw
 # transaction to make it large.  See gen_return_txouts() above.
-def create_lots_of_big_transactions(node, txouts, utxos, num, fee):
-    addr = node.getnewaddress()
+def create_lots_of_big_transactions(mini_wallet, node, fee, tx_batch_size, txouts, utxos=None):
+    from .messages import COIN
+    fee_sats = int(fee * COIN)
     txids = []
-    from .messages import tx_from_hex
-    for _ in range(num):
-        t = utxos.pop()
-        inputs = [{"txid": t["txid"], "vout": t["vout"]}]
-        outputs = {}
-        change = t['amount'] - fee
-        outputs[addr] = satoshi_round(change)
-        rawtx = node.createrawtransaction(inputs, outputs)
-        tx = tx_from_hex(rawtx)
-        for txout in txouts:
-            tx.vout.append(txout)
-        newtx = tx.serialize().hex()
-        signresult = node.signrawtransactionwithwallet(newtx, None, "NONE")
-        txid = node.sendrawtransaction(signresult["hex"], 0)
-        txids.append(txid)
+    use_internal_utxos = utxos is None
+    for _ in range(tx_batch_size):
+        tx = mini_wallet.create_self_transfer(
+                from_node=node,
+                utxo_to_spend=None if use_internal_utxos else utxos.pop(),
+                fee_rate=0,
+                mempool_valid=False)['tx']
+        tx.vout[0].nValue -= fee_sats
+        tx.vout.extend(txouts)
+        res = node.testmempoolaccept([tx.serialize().hex()])[0]
+        assert_equal(res['fees']['base'], fee)
+        txids.append(node.sendrawtransaction(tx.serialize().hex()))
     return txids
 
 
 def mine_large_block(test_framework, mini_wallet, node):
     # generate a 66k transaction,
     # and 14 of them is close to the 1MB block limit
     txouts = gen_return_txouts()
-    from .messages import COIN
-    fee = 100 * int(node.getnetworkinfo()["relayfee"] * COIN)
-    for _ in range(14):
-        tx = mini_wallet.create_self_transfer(from_node=node, fee_rate=0, mempool_valid=False)['tx']
-        tx.vout[0].nValue -= fee
-        tx.vout.extend(txouts)
-        mini_wallet.sendrawtransaction(from_node=node, tx_hex=tx.serialize().hex())
+    fee = 100 * node.getnetworkinfo()["relayfee"]
+    create_lots_of_big_transactions(mini_wallet, node, fee, 14, txouts)
     test_framework.generate(node, 1)