merge bitcoin#24839: use MiniWallet for mining_prioritisetransaction.py

kwvg · kwvg · commit 6add1c4c8147 · 2025-06-21T21:49:12.000Z
includes changes to util.py, mining_prioritisetransaction.py from bitcoin#25435 (fa8421b) and changes to util.py from bitcoin#25356 (fa779de) due to OOO backport needed for correctness
diff --git a/test/functional/mempool_limit.py b/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(fee_rate=0)['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
diff --git a/test/functional/mining_prioritisetransaction.py b/test/functional/mining_prioritisetransaction.py
@@ -6,29 +6,31 @@
 
 from decimal import Decimal
 
-from test_framework.blocktools import COINBASE_MATURITY
-from test_framework.messages import COIN, MAX_BLOCK_SIZE
+from test_framework.messages import (
+    COIN,
+    MAX_BLOCK_SIZE,
+)
 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 = 2
+        self.num_nodes = 1
         self.extra_args = [[
             "-printpriority=1",
             "-datacarriersize=100000",
         ]] * 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)
         self.nodes[0].setmocktime(self.mocktime)
 
         #      tx_a
@@ -83,7 +85,6 @@ def test_diamond(self):
 
         self.log.info("Test priority while txs are not in mempool")
         self.restart_node(0, extra_args=["-nopersistmempool"])
-        self.connect_nodes(0, 1)
         self.nodes[0].setmocktime(self.mocktime)
         assert_equal(self.nodes[0].getmempoolinfo()["size"], 0)
         self.nodes[0].prioritisetransaction(txid=txid_b, fee_delta=int(fee_delta_b * COIN))
@@ -100,10 +101,10 @@ def test_diamond(self):
 
         # Use default extra_args
         self.restart_node(0)
-        self.connect_nodes(0, 1)
 
     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)
@@ -127,7 +128,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 = []
 
@@ -137,7 +141,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_SIZE -- otherwise the test needs to be revised to
@@ -196,17 +206,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(fee_rate=0)
+        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)
diff --git a/test/functional/test_framework/util.py b/test/functional/test_framework/util.py
@@ -614,38 +614,30 @@ 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(
+            utxo_to_spend=None if use_internal_utxos else utxos.pop(),
+            fee_rate=0,
+        )['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(fee_rate=0)['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)
 
 
