Merge #6725: backport: merge bitcoin#25228, bitcoin#24941, bitcoin#25356, bitcoin#25435, bitcoin#23017, bitcoin#25522, bitcoin#26414, partial bitcoin#24587, bitcoin#24637, bitcoin#24623, bitcoin#25445 (implement better tx capabilities in MiniWallet)

PastaPastaPasta · PastaPastaPasta · commit 441d42ea650f · 2025-06-20T10:00:42.000-05:00
cfa906e merge bitcoin#26414: Move tx creation to create_self_transfer_multi (Kittywhiskers Van Gogh) e167162 merge bitcoin#25522: Remove -acceptnonstdtxn=1 from feature_rbf.py (Kittywhiskers Van Gogh) a5cb9b4 partial bitcoin#25445: Return new_utxo from create_self_transfer in MiniWallet (Kittywhiskers Van Gogh) b28d90f merge bitcoin#23017: Replace MiniWallet scan_blocks with rescan_utxos (Kittywhiskers Van Gogh) ebfb239 merge bitcoin#25435: Remove from_node from create_self_transfer* MiniWallet helpers (Kittywhiskers Van Gogh) 144228b merge bitcoin#25356: Remove MiniWallet mempool_valid option (Kittywhiskers Van Gogh) 0622788 merge bitcoin#24941: support skipping mempool checks (feature_fee_estimation.py performance fix) (Kittywhiskers Van Gogh) 9c93e3a merge bitcoin#25228: add BIP-125 rule 5 testcase with default mempool (Kittywhiskers Van Gogh) b84bcad partial bitcoin#24623: Add diamond-shape prioritisetransaction test (Kittywhiskers Van Gogh) 4621320 partial bitcoin#24637: use MiniWallet for mempool_package_onemore.py (Kittywhiskers Van Gogh) a21dfd2 partial bitcoin#24587: use MiniWallet for rpc_createmultisig.py (Kittywhiskers Van Gogh) Pull request description: ## Additional Information * Dependency for #6726 * Since [bitcoin#15891](bitcoin#15891) (8ca90f3), we enforce standard transactions on regtest and regrettably, the logic introduced in [bitcoin#24637](bitcoin#24637) (`*self_transfer*()`) had a tendency to create transactions that were non-standard (see below) <details> <summary>Test failure:</summary> ``` dash@b90780fda2d1:/src/dash$ ./test/functional/mempool_package_onemore.py 2025-06-18T17:50:19.492000Z TestFramework (INFO): PRNG seed is: 8344907287561424619 2025-06-18T17:50:19.492000Z TestFramework (INFO): Initializing test directory /tmp/dash_func_test_emt8bu6u 2025-06-18T17:50:19.765000Z TestFramework (ERROR): JSONRPC error Traceback (most recent call last): File "/src/dash/test/functional/test_framework/test_framework.py", line 162, in main self.run_test() File "/src/dash/./test/functional/mempool_package_onemore.py", line 41, in run_test utxo, utxo2 = self.chain_tx([utxo], num_outputs=2) ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ File "/src/dash/./test/functional/mempool_package_onemore.py", line 28, in chain_tx return self.wallet.send_self_transfer_multi( ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ File "/src/dash/test/functional/test_framework/wallet.py", line 207, in send_self_transfer_multi txid = self.sendrawtransaction(from_node=kwargs['from_node'], tx_hex=tx.serialize().hex()) ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ File "/src/dash/test/functional/test_framework/wallet.py", line 269, in sendrawtransaction txid = from_node.sendrawtransaction(hexstring=tx_hex, maxfeerate=maxfeerate, **kwargs) ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ File "/src/dash/test/functional/test_framework/coverage.py", line 49, in __call__ return_val = self.auth_service_proxy_instance.__call__(*args, **kwargs) ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ File "/src/dash/test/functional/test_framework/authproxy.py", line 143, in __call__ raise JSONRPCException(response['error'], status) test_framework.authproxy.JSONRPCException: bad-txns-nonstandard-inputs (-26) 2025-06-18T17:50:20.266000Z TestFramework (INFO): Stopping nodes ``` </details> Two options presented themselves, either temporary relaxing `fRequireStandard` on regtest or backporting all the changes needed to make `*self_transfer*()` create standard transactions and then backporting `MiniWallet` conversions in a separate pull request. The latter approach was taken. * The correctness of this pull request can be validated by observing the CI results of [dash#6726](#6726) * The backport for [bitcoin#23017](bitcoin#23017) does not include changes to `rpc_blockchain.py` as the relevant `scan_blocks()` call was removed in the partial backport of [bitcoin#23371](bitcoin#23371) (081897c). ## Breaking Changes None expected. Affects only functional tests. ## Checklist - [x] I have performed a self-review of my own code - [x] I have commented my code, particularly in hard-to-understand areas **(note: N/A)** - [x] I have added or updated relevant unit/integration/functional/e2e tests - [x] I have made corresponding changes to the documentation **(note: N/A)** - [x] I have assigned this pull request to a milestone _(for repository code-owners and collaborators only)_ ACKs for top commit: PastaPastaPasta: utACK cfa906e UdjinM6: utACK cfa906e Tree-SHA512: 81107b6352cc673cd4d4358da0eba23f971546fae9df0f34bea5b584bfe1a3f820872444314ec65bf181158aeca1cc3880a0b6925101c953db19ecd45d28aa38
diff --git a/test/functional/feature_csv_activation.py b/test/functional/feature_csv_activation.py
@@ -120,13 +120,15 @@ def create_bip112special(self, input, txversion):
         tx.nVersion = txversion
         self.miniwallet.sign_tx(tx)
         tx.vin[0].scriptSig = CScript([-1, OP_CHECKSEQUENCEVERIFY, OP_DROP] + list(CScript(tx.vin[0].scriptSig)))
+        tx.rehash()
         return tx
 
     def create_bip112emptystack(self, input, txversion):
         tx = self.create_self_transfer_from_utxo(input)
         tx.nVersion = txversion
         self.miniwallet.sign_tx(tx)
         tx.vin[0].scriptSig = CScript([OP_CHECKSEQUENCEVERIFY] + list(CScript(tx.vin[0].scriptSig)))
+        tx.rehash()
         return tx
 
     def send_generic_input_tx(self, coinbases):
@@ -144,7 +146,6 @@ def create_bip68txs(self, bip68inputs, txversion, locktime_delta=0):
             tx.nVersion = txversion
             tx.vin[0].nSequence = locktime + locktime_delta
             self.miniwallet.sign_tx(tx)
-            tx.rehash()
             txs.append({'tx': tx, 'sdf': sdf, 'stf': stf})
 
         return txs
@@ -350,20 +351,16 @@ def run_test(self):
         # BIP 113 tests should now fail regardless of version number if nLockTime isn't satisfied by new rules
         bip113tx_v1.nLockTime = self.last_block_time - 600 * 5  # = MTP of prior block (not <) but < time put on current block
         self.miniwallet.sign_tx(bip113tx_v1)
-        bip113tx_v1.rehash()
         bip113tx_v2.nLockTime = self.last_block_time - 600 * 5  # = MTP of prior block (not <) but < time put on current block
         self.miniwallet.sign_tx(bip113tx_v2)
-        bip113tx_v2.rehash()
         for bip113tx in [bip113tx_v1, bip113tx_v2]:
             self.send_blocks([self.create_test_block([bip113tx])], success=False, reject_reason='bad-txns-nonfinal')
 
         # BIP 113 tests should now pass if the locktime is < MTP
         bip113tx_v1.nLockTime = self.last_block_time - 600 * 5 - 1  # < MTP of prior block
         self.miniwallet.sign_tx(bip113tx_v1)
-        bip113tx_v1.rehash()
         bip113tx_v2.nLockTime = self.last_block_time - 600 * 5 - 1  # < MTP of prior block
         self.miniwallet.sign_tx(bip113tx_v2)
-        bip113tx_v2.rehash()
         for bip113tx in [bip113tx_v1, bip113tx_v2]:
             self.send_blocks([self.create_test_block([bip113tx])])
             self.nodes[0].invalidateblock(self.nodes[0].getbestblockhash())
@@ -488,7 +485,6 @@ def run_test(self):
         for tx in [tx['tx'] for tx in bip112txs_vary_OP_CSV_v2 if not tx['sdf'] and tx['stf']]:
             tx.vin[0].nSequence = BASE_RELATIVE_LOCKTIME | SEQ_TYPE_FLAG
             self.miniwallet.sign_tx(tx)
-            tx.rehash()
             time_txs.append(tx)
 
         self.send_blocks([self.create_test_block(time_txs)])
diff --git a/test/functional/mempool_limit.py b/test/functional/mempool_limit.py
@@ -31,7 +31,7 @@ def set_test_params(self):
 
     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']
+            tx = miniwallet.create_self_transfer(fee_rate=0)['tx']
             for txout in txouts:
                 tx.vout.append(txout)
             tx.vout[0].nValue -= int(fee * COIN)
@@ -85,7 +85,7 @@ def run_test(self):
 
         # Deliberately try to create a tx with a fee less than the minimum mempool fee to assert that it does not get added to the mempool
         self.log.info('Create a mempool tx that will not pass mempoolminfee')
-        assert_raises_rpc_error(-26, "mempool min fee not met", miniwallet.send_self_transfer, from_node=node, fee_rate=relayfee, mempool_valid=False)
+        assert_raises_rpc_error(-26, "mempool min fee not met", miniwallet.send_self_transfer, from_node=node, fee_rate=relayfee)
 
         self.log.info('Test passing a value below the minimum (5 MB) to -maxmempool throws an error')
         self.stop_node(0)
diff --git a/test/functional/mempool_reorg.py b/test/functional/mempool_reorg.py
@@ -31,7 +31,7 @@ def run_test(self):
         self.log.info("Add 4 coinbase utxos to the miniwallet")
         # Block 76 contains the first spendable coinbase txs.
         first_block = 76
-        wallet.scan_blocks(start=first_block, num=4)
+        wallet.rescan_utxos()
 
         # Three scenarios for re-orging coinbase spends in the memory pool:
         # 1. Direct coinbase spend  :  spend_1
@@ -53,8 +53,7 @@ def run_test(self):
         utxo = wallet.get_utxo(txid=coinbase_txids[0])
         timelock_tx = wallet.create_self_transfer(
             utxo_to_spend=utxo,
-            mempool_valid=False,
-            locktime=self.nodes[0].getblockcount() + 2
+            locktime=self.nodes[0].getblockcount() + 2,
         )['hex']
 
         self.log.info("Check that the time-locked transaction is too immature to spend")
@@ -69,10 +68,8 @@ def run_test(self):
         assert_raises_rpc_error(-26, 'non-final', self.nodes[0].sendrawtransaction, timelock_tx)
 
         self.log.info("Create spend_2_1 and spend_3_1")
-        spend_2_utxo = wallet.get_utxo(txid=spend_2['txid'])
-        spend_2_1 = wallet.create_self_transfer(utxo_to_spend=spend_2_utxo)
-        spend_3_utxo = wallet.get_utxo(txid=spend_3['txid'])
-        spend_3_1 = wallet.create_self_transfer(utxo_to_spend=spend_3_utxo)
+        spend_2_1 = wallet.create_self_transfer(utxo_to_spend=spend_2["new_utxo"])
+        spend_3_1 = wallet.create_self_transfer(utxo_to_spend=spend_3["new_utxo"])
 
         self.log.info("Broadcast and mine spend_3_1")
         spend_3_1_id = self.nodes[0].sendrawtransaction(spend_3_1['hex'])
diff --git a/test/functional/mempool_spend_coinbase.py b/test/functional/mempool_spend_coinbase.py
@@ -28,19 +28,19 @@ def run_test(self):
         chain_height = 198
         self.nodes[0].invalidateblock(self.nodes[0].getblockhash(chain_height + 1))
         assert_equal(chain_height, self.nodes[0].getblockcount())
+        wallet.rescan_utxos()
 
         # Coinbase at height chain_height-100+1 ok in mempool, should
         # get mined. Coinbase at height chain_height-100+2 is
         # too immature to spend.
-        wallet.scan_blocks(start=chain_height - 100 + 1, num=1)
-        utxo_mature = wallet.get_utxo()
-        wallet.scan_blocks(start=chain_height - 100 + 2, num=1)
-        utxo_immature = wallet.get_utxo()
+        coinbase_txid = lambda h: self.nodes[0].getblock(self.nodes[0].getblockhash(h))['tx'][0]
+        utxo_mature = wallet.get_utxo(txid=coinbase_txid(chain_height - 100 + 1))
+        utxo_immature = wallet.get_utxo(txid=coinbase_txid(chain_height - 100 + 2))
 
         spend_mature_id = wallet.send_self_transfer(from_node=self.nodes[0], utxo_to_spend=utxo_mature)["txid"]
 
         # other coinbase should be too immature to spend
-        immature_tx = wallet.create_self_transfer(utxo_to_spend=utxo_immature, mempool_valid=False)
+        immature_tx = wallet.create_self_transfer(utxo_to_spend=utxo_immature)
         assert_raises_rpc_error(-26,
                                 "bad-txns-premature-spend-of-coinbase",
                                 lambda: self.nodes[0].sendrawtransaction(immature_tx['hex']))
diff --git a/test/functional/mempool_unbroadcast.py b/test/functional/mempool_unbroadcast.py
@@ -40,7 +40,7 @@ def test_broadcast(self):
             wallet_tx_hsh = node.sendtoaddress(addr, 0.0001)
 
         # generate a txn using sendrawtransaction
-        txFS = self.wallet.create_self_transfer(from_node=node)
+        txFS = self.wallet.create_self_transfer()
         rpc_tx_hsh = node.sendrawtransaction(txFS["hex"])
 
         # check transactions are in unbroadcast using rpc
diff --git a/test/functional/test_framework/util.py b/test/functional/test_framework/util.py
@@ -642,7 +642,7 @@ def mine_large_block(test_framework, mini_wallet, node):
     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 = 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())
diff --git a/test/functional/test_framework/wallet.py b/test/functional/test_framework/wallet.py
@@ -10,6 +10,7 @@
 from random import choice
 from typing import (
     Any,
+    List,
     Optional,
 )
 from test_framework.address import (
@@ -89,26 +90,34 @@ def __init__(self, test_node, *, mode=MiniWalletMode.ADDRESS_OP_TRUE):
             self._address = ADDRESS_BCRT1_P2SH_OP_TRUE
             self._scriptPubKey = bytes.fromhex(self._test_node.validateaddress(self._address)['scriptPubKey'])
 
+    def _create_utxo(self, *, txid, vout, value, height):
+        return {"txid": txid, "vout": vout, "value": value, "height": height}
+
+    def get_balance(self):
+        return sum(u['value'] for u in self._utxos)
+
     def rescan_utxos(self):
         """Drop all utxos and rescan the utxo set"""
         self._utxos = []
         res = self._test_node.scantxoutset(action="start", scanobjects=[self.get_descriptor()])
         assert_equal(True, res['success'])
         for utxo in res['unspents']:
-            self._utxos.append({'txid': utxo['txid'], 'vout': utxo['vout'], 'value': utxo['amount'], 'height': utxo['height']})
-
-    def scan_blocks(self, *, start=1, num):
-        """Scan the blocks for self._address outputs and add them to self._utxos"""
-        for i in range(start, start + num):
-            block = self._test_node.getblock(blockhash=self._test_node.getblockhash(i), verbosity=2)
-            for tx in block['tx']:
-                self.scan_tx(tx)
+            self._utxos.append(self._create_utxo(txid=utxo["txid"], vout=utxo["vout"], value=utxo["amount"], height=utxo["height"]))
 
     def scan_tx(self, tx):
-        """Scan the tx for self._scriptPubKey outputs and add them to self._utxos"""
+        """Scan the tx and adjust the internal list of owned utxos"""
+        for spent in tx["vin"]:
+            # Mark spent. This may happen when the caller has ownership of a
+            # utxo that remained in this wallet. For example, by passing
+            # mark_as_spent=False to get_utxo or by using an utxo returned by a
+            # create_self_transfer* call.
+            try:
+                self.get_utxo(txid=spent["txid"], vout=spent["vout"])
+            except StopIteration:
+                pass
         for out in tx['vout']:
             if out['scriptPubKey']['hex'] == self._scriptPubKey.hex():
-                self._utxos.append({'txid': tx['txid'], 'vout': out['n'], 'value': out['value'], 'height': 0})
+                self._utxos.append(self._create_utxo(txid=tx["txid"], vout=out["n"], value=out["value"], height=0))
 
     def sign_tx(self, tx, fixed_length=True):
         """Sign tx that has been created by MiniWallet in P2PK mode"""
@@ -124,14 +133,19 @@ def sign_tx(self, tx, fixed_length=True):
             if not fixed_length:
                 break
         tx.vin[0].scriptSig = CScript([der_sig + bytes(bytearray([SIGHASH_ALL]))])
+        tx.rehash()
 
     def generate(self, num_blocks, **kwargs):
-        """Generate blocks with coinbase outputs to the internal address, and append the outputs to the internal list"""
+        """Generate blocks with coinbase outputs to the internal address, and call rescan_utxos"""
         blocks = self._test_node.generatetodescriptor(num_blocks, self.get_descriptor(), **kwargs)
-        for b in blocks:
-            block_info = self._test_node.getblock(blockhash=b, verbosity=2)
-            cb_tx = block_info['tx'][0]
-            self._utxos.append({'txid': cb_tx['txid'], 'vout': 0, 'value': cb_tx['vout'][0]['value'], 'height': block_info['height']})
+        # Calling rescan_utxos here makes sure that after a generate the utxo
+        # set is in a clean state. For example, the wallet will update
+        # - if the caller consumed utxos, but never used them
+        # - if the caller sent a transaction that is not mined or got rbf'd
+        # - after block re-orgs
+        # - the utxo height for mined mempool txs
+        # - However, the wallet will not consider remaining mempool txs
+        self.rescan_utxos()
         return blocks
 
     def get_scriptPubKey(self):
@@ -144,7 +158,7 @@ def get_address(self):
         assert_equal(self._mode, MiniWalletMode.ADDRESS_OP_TRUE)
         return self._address
 
-    def get_utxo(self, *, txid: str = '', vout: Optional[int] = None, mark_as_spent=True):
+    def get_utxo(self, *, txid: str = '', vout: Optional[int] = None, mark_as_spent=True) -> dict:
         """
         Returns a utxo and marks it as spent (pops it from the internal list)
 
@@ -164,10 +178,10 @@ def get_utxo(self, *, txid: str = '', vout: Optional[int] = None, mark_as_spent=
         else:
             return self._utxos[index]
 
-    def send_self_transfer(self, **kwargs):
-        """Create and send a tx with the specified fee_rate. Fee may be exact or at most one satoshi higher than needed."""
+    def send_self_transfer(self, *, from_node, **kwargs):
+        """Call create_self_transfer and send the transaction."""
         tx = self.create_self_transfer(**kwargs)
-        self.sendrawtransaction(from_node=kwargs['from_node'], tx_hex=tx['hex'])
+        self.sendrawtransaction(from_node=from_node, tx_hex=tx['hex'])
         return tx
 
     def send_to(self, *, from_node, scriptPubKey, amount, fee=1000):
@@ -182,46 +196,93 @@ def send_to(self, *, from_node, scriptPubKey, amount, fee=1000):
 
         Returns a tuple (txid, n) referring to the created external utxo outpoint.
         """
-        tx = self.create_self_transfer(from_node=from_node, fee_rate=0, mempool_valid=False)['tx']
+        tx = self.create_self_transfer(fee_rate=0)["tx"]
         assert_greater_than_or_equal(tx.vout[0].nValue, amount + fee)
         tx.vout[0].nValue -= (amount + fee)           # change output -> MiniWallet
         tx.vout.append(CTxOut(amount, scriptPubKey))  # arbitrary output -> to be returned
         txid = self.sendrawtransaction(from_node=from_node, tx_hex=tx.serialize().hex())
         return txid, 1
 
-    def create_self_transfer(self, *, fee_rate=Decimal("0.003"), from_node=None, utxo_to_spend=None, mempool_valid=True, locktime=0, sequence=0):
-        """Create and return a tx with the specified fee_rate. Fee may be exact or at most one satoshi higher than needed."""
-        from_node = from_node or self._test_node
-        utxo_to_spend = utxo_to_spend or self.get_utxo()
-        if self._mode in (MiniWalletMode.RAW_OP_TRUE, MiniWalletMode.ADDRESS_OP_TRUE):
-            vsize = Decimal(85)  # anyone-can-spend
-        elif self._mode == MiniWalletMode.RAW_P2PK:
-            vsize = Decimal(168)  # P2PK (73 bytes scriptSig + 35 bytes scriptPubKey + 60 bytes other)
-        else:
-            assert False
-        send_value = int(COIN * (utxo_to_spend['value'] - fee_rate * (vsize / 1000)))
-        assert send_value > 0
+    def send_self_transfer_multi(self, *, from_node, **kwargs):
+        """Call create_self_transfer_multi and send the transaction."""
+        tx = self.create_self_transfer_multi(**kwargs)
+        self.sendrawtransaction(from_node=from_node, tx_hex=tx["hex"])
+        return tx
+
+    def create_self_transfer_multi(
+        self,
+        *,
+        utxos_to_spend: Optional[List[dict]] = None,
+        num_outputs=1,
+        amount_per_output=0,
+        locktime=0,
+        sequence=0,
+        fee_per_output=1000,
+    ):
+        """
+        Create and return a transaction that spends the given UTXOs and creates a
+        certain number of outputs with equal amounts. The output amounts can be
+        set by amount_per_output or automatically calculated with a fee_per_output.
+        """
+        utxos_to_spend = utxos_to_spend or [self.get_utxo()]
+        sequence = [sequence] * len(utxos_to_spend) if type(sequence) is int else sequence
+        assert_equal(len(utxos_to_spend), len(sequence))
 
+        # calculate output amount
+        inputs_value_total = sum([int(COIN * utxo['value']) for utxo in utxos_to_spend])
+        outputs_value_total = inputs_value_total - fee_per_output * num_outputs
+        amount_per_output = amount_per_output or (outputs_value_total // num_outputs)
+
+        # create tx
         tx = CTransaction()
-        tx.vin = [CTxIn(COutPoint(int(utxo_to_spend['txid'], 16), utxo_to_spend['vout']), nSequence=sequence)]
-        tx.vout = [CTxOut(send_value, self._scriptPubKey)]
+        tx.vin = [CTxIn(COutPoint(int(utxo_to_spend['txid'], 16), utxo_to_spend['vout']), nSequence=seq) for utxo_to_spend,seq in zip(utxos_to_spend, sequence)]
+        tx.vout = [CTxOut(amount_per_output, bytearray(self._scriptPubKey)) for _ in range(num_outputs)]
         tx.nLockTime = locktime
+
         if self._mode == MiniWalletMode.RAW_P2PK:
             self.sign_tx(tx)
         elif self._mode == MiniWalletMode.RAW_OP_TRUE:
-            tx.vin[0].scriptSig = CScript([OP_NOP] * 24)  # pad to identical size
+            for i in range(len(utxos_to_spend)):
+                tx.vin[i].scriptSig = CScript([OP_NOP] * 24)  # pad to identical size
         elif self._mode == MiniWalletMode.ADDRESS_OP_TRUE:
-            tx.vin[0].scriptSig = CScript([CScript([OP_TRUE])])
+            for i in range(len(utxos_to_spend)):
+                tx.vin[i].scriptSig = CScript([CScript([OP_TRUE])])
+        else:
+            assert False
+
+        txid = tx.rehash()
+        return {
+            "new_utxos": [self._create_utxo(
+                txid=txid,
+                vout=i,
+                value=Decimal(tx.vout[i].nValue) / COIN,
+                height=0,
+            ) for i in range(len(tx.vout))],
+            "txid": txid,
+            "hex": tx.serialize().hex(),
+            "tx": tx,
+        }
+
+    def create_self_transfer(self, *, fee_rate=Decimal("0.003"), fee=Decimal("0"), utxo_to_spend=None, locktime=0, sequence=0):
+        """Create and return a tx with the specified fee. If fee is 0, use fee_rate, where the resulting fee may be exact or at most one satoshi higher than needed."""
+        utxo_to_spend = utxo_to_spend or self.get_utxo()
+        assert fee_rate >= 0
+        assert fee >= 0
+        # calculate fee
+        if self._mode in (MiniWalletMode.RAW_OP_TRUE, MiniWalletMode.ADDRESS_OP_TRUE):
+            vsize = Decimal(85)  # anyone-can-spend
+        elif self._mode == MiniWalletMode.RAW_P2PK:
+            vsize = Decimal(168)  # P2PK (73 bytes scriptSig + 35 bytes scriptPubKey + 60 bytes other)
         else:
             assert False
-        tx_hex = tx.serialize().hex()
-
-        tx_info = from_node.testmempoolaccept([tx_hex])[0]
-        assert_equal(mempool_valid, tx_info['allowed'])
-        if mempool_valid:
-            assert_equal(len(tx_hex) // 2, vsize) # 1 byte = 2 character
-            assert_equal(tx_info['fees']['base'], utxo_to_spend['value'] - Decimal(send_value) / COIN)
-        return {'txid': tx_info['txid'], 'hex': tx_hex, 'tx': tx}
+        send_value = utxo_to_spend["value"] - (fee or (fee_rate * vsize / 1000))
+        assert send_value > 0
+
+        # create tx
+        tx = self.create_self_transfer_multi(utxos_to_spend=[utxo_to_spend], locktime=locktime, sequence=sequence, amount_per_output=int(COIN * send_value))
+        assert_equal(tx["tx"].get_vsize(), vsize)
+
+        return {"txid": tx["txid"], "hex": tx["hex"], "tx": tx["tx"], "new_utxo": tx["new_utxos"][0]}
 
     def sendrawtransaction(self, *, from_node, tx_hex, maxfeerate=0, **kwargs):
         txid = from_node.sendrawtransaction(hexstring=tx_hex, maxfeerate=maxfeerate, **kwargs)
