Merge bitcoin#22593: remove hex_str_to_bytes helper

test/functional/feature_asset_locks.py

@@ -40,8 +40,7 @@
 from test_framework.util import (
     assert_equal,
     assert_greater_than,
-    assert_greater_than_or_equal,
-    hex_str_to_bytes,
+    assert_greater_than_or_equal
 )
 from test_framework.wallet_util import bytes_to_wif
 
@@ -170,7 +169,7 @@ def create_and_check_block(self, txes, expected_error = None):
 
         cbb = create_coinbase(height, dip4_activated=True, v20_activated=True)
         gbt = node_wallet.getblocktemplate()
-        cbb.vExtraPayload = hex_str_to_bytes(gbt["coinbase_payload"])
+        cbb.vExtraPayload = bytes.fromhex(gbt["coinbase_payload"])
         cbb.rehash()
         block = create_block(tip, cbb, block_time, version=4)
         # Add quorum commitments from block template

test/functional/feature_dbcrash.py

@@ -41,7 +41,6 @@
 from test_framework.util import (
     assert_equal,
     create_confirmed_utxos,
-    hex_str_to_bytes,
 )
 
 
@@ -204,7 +203,7 @@ def generate_small_transactions(self, node, count, utxo_list):
                 continue
 
             for _ in range(3):
-                tx.vout.append(CTxOut(output_amount, hex_str_to_bytes(utxo['scriptPubKey'])))
+                tx.vout.append(CTxOut(output_amount, bytes.fromhex(utxo['scriptPubKey'])))
 
             # Sign and send the transaction to get into the mempool
             tx_signed_hex = node.signrawtransactionwithwallet(tx.serialize().hex())['hex']

test/functional/feature_llmq_chainlocks.py

@@ -15,7 +15,7 @@
 
 from test_framework.messages import CBlock, CCbTx
 from test_framework.test_framework import DashTestFramework
-from test_framework.util import assert_equal, assert_raises_rpc_error, force_finish_mnsync, hex_str_to_bytes, softfork_active
+from test_framework.util import assert_equal, assert_raises_rpc_error, force_finish_mnsync, softfork_active
 
 
 class LLMQChainLocksTest(DashTestFramework):
@@ -307,7 +307,7 @@ def test_bestCLHeightDiff(self, mn_rr_active):
         tip0_hash = self.nodes[0].generate(1)[0]
         block_hex = self.nodes[0].getblock(tip0_hash, 0)
         mal_block = CBlock()
-        mal_block.deserialize(BytesIO(hex_str_to_bytes(block_hex)))
+        mal_block.deserialize(BytesIO(bytes.fromhex(block_hex)))
         cbtx = CCbTx()
         cbtx.deserialize(BytesIO(mal_block.vtx[0].vExtraPayload))
         assert_equal(cbtx.bestCLHeightDiff, 0)
@@ -322,7 +322,7 @@ def test_bestCLHeightDiff(self, mn_rr_active):
         assert_equal(self.nodes[1].getbestblockhash(), tip1_hash)
 
         # Update the sig too and it should pass now
-        cbtx.bestCLSignature = hex_str_to_bytes(self.nodes[1].getblock(tip1_hash, 2)["tx"][0]["cbTx"]["bestCLSignature"])
+        cbtx.bestCLSignature = bytes.fromhex(self.nodes[1].getblock(tip1_hash, 2)["tx"][0]["cbTx"]["bestCLSignature"])
         mal_block.vtx[0].vExtraPayload = cbtx.serialize()
         mal_block.vtx[0].rehash()
         mal_block.hashMerkleRoot = mal_block.calc_merkle_root()
@@ -347,7 +347,7 @@ def test_bestCLHeightDiff(self, mn_rr_active):
 
         # Update the sig too and it should pass now when mn_rr is not active and fail otherwise
         old_blockhash = self.nodes[1].getblockhash(self.nodes[1].getblockcount() - 1)
-        cbtx.bestCLSignature = hex_str_to_bytes(self.nodes[1].getblock(old_blockhash, 2)["tx"][0]["cbTx"]["bestCLSignature"])
+        cbtx.bestCLSignature = bytes.fromhex(self.nodes[1].getblock(old_blockhash, 2)["tx"][0]["cbTx"]["bestCLSignature"])
         mal_block.vtx[0].vExtraPayload = cbtx.serialize()
         mal_block.vtx[0].rehash()
         mal_block.hashMerkleRoot = mal_block.calc_merkle_root()

test/functional/feature_llmq_is_cl_conflicts.py

@@ -16,7 +16,7 @@
 from test_framework.messages import CInv, hash256, msg_clsig, msg_inv, ser_string, tx_from_hex, uint256_from_str
 from test_framework.p2p import P2PInterface
 from test_framework.test_framework import DashTestFramework
-from test_framework.util import assert_equal, assert_raises_rpc_error, hex_str_to_bytes
+from test_framework.util import assert_equal, assert_raises_rpc_error
 
 
 class TestP2PConn(P2PInterface):
@@ -90,7 +90,7 @@ def test_chainlock_overrides_islock(self, test_block_conflict, mine_confllicting
         rawtx2_obj = tx_from_hex(rawtx2)
 
         rawtx1_txid = self.nodes[0].sendrawtransaction(rawtx1)
-        rawtx2_txid = hash256(hex_str_to_bytes(rawtx2))[::-1].hex()
+        rawtx2_txid = hash256(bytes.fromhex(rawtx2))[::-1].hex()
 
         # Create a chained TX on top of tx1
         inputs = []
@@ -203,8 +203,8 @@ def test_chainlock_overrides_islock_overrides_nonchainlock(self):
         rawtx1 = self.create_raw_tx(self.nodes[0], self.nodes[0], 1, 1, 100)['hex']
         rawtx2 = self.create_raw_tx(self.nodes[0], self.nodes[0], 1, 1, 100)['hex']
 
-        rawtx1_txid = hash256(hex_str_to_bytes(rawtx1))[::-1].hex()
-        rawtx2_txid = hash256(hex_str_to_bytes(rawtx2))[::-1].hex()
+        rawtx1_txid = hash256(bytes.fromhex(rawtx1))[::-1].hex()
+        rawtx2_txid = hash256(bytes.fromhex(rawtx2))[::-1].hex()
 
         # Create an ISLOCK but don't broadcast it yet
         isdlock = self.create_isdlock(rawtx2)
@@ -278,7 +278,7 @@ def create_chainlock(self, height, block):
         message_hash = block.hash
 
         recSig = self.get_recovered_sig(request_id, message_hash)
-        clsig = msg_clsig(height, block.sha256, hex_str_to_bytes(recSig['sig']))
+        clsig = msg_clsig(height, block.sha256, bytes.fromhex(recSig['sig']))
         return clsig
 
 if __name__ == '__main__':

test/functional/feature_llmq_signing.py

@@ -13,7 +13,7 @@
 from test_framework.messages import CSigShare, msg_qsigshare, uint256_to_string
 from test_framework.p2p import P2PInterface
 from test_framework.test_framework import DashTestFramework
-from test_framework.util import assert_equal, assert_raises_rpc_error, force_finish_mnsync, hex_str_to_bytes, wait_until_helper
+from test_framework.util import assert_equal, assert_raises_rpc_error, force_finish_mnsync, wait_until_helper
 
 
 class LLMQSigningTest(DashTestFramework):
@@ -89,7 +89,7 @@ def assert_sigs_nochange(hasrecsigs, isconflicting1, isconflicting2, timeout):
             sig_share.quorumMember = int(sig_share_rpc_1["quorumMember"])
             sig_share.id = int(sig_share_rpc_1["id"], 16)
             sig_share.msgHash = int(sig_share_rpc_1["msgHash"], 16)
-            sig_share.sigShare = hex_str_to_bytes(sig_share_rpc_1["signature"])
+            sig_share.sigShare = bytes.fromhex(sig_share_rpc_1["signature"])
             for mn in self.mninfo:
                 assert mn.node.getconnectioncount() == self.llmq_size
             # Get the current recovery member of the quorum

test/functional/interface_rest.py

@@ -18,7 +18,6 @@
     assert_equal,
     assert_greater_than,
     assert_greater_than_or_equal,
-    hex_str_to_bytes,
 )
 
 from test_framework.messages import BLOCK_HEADER_SIZE
@@ -156,7 +155,7 @@ def run_test(self):
 
         bin_request = b'\x01\x02'
         for txid, n in [spending, spent]:
-            bin_request += hex_str_to_bytes(txid)
+            bin_request += bytes.fromhex(txid)
             bin_request += pack("i", n)
 
         bin_response = self.test_rest_request("/getutxos", http_method='POST', req_type=ReqType.BIN, body=bin_request, ret_type=RetType.BYTES)

test/functional/rpc_addresses_deprecation.py

@@ -9,8 +9,7 @@
 from test_framework.messages import CTransaction
 from test_framework.test_framework import BitcoinTestFramework
 from test_framework.util import (
-    assert_equal,
-    hex_str_to_bytes
+    assert_equal
 )
 
 
@@ -36,8 +35,8 @@ def test_addresses_deprecation(self):
 
         # This transaction is derived from test/util/data/txcreatemultisig1.json
         tx = CTransaction()
-        tx.deserialize(BytesIO(hex_str_to_bytes(signed)))
-        tx.vout[0].scriptPubKey = hex_str_to_bytes("522102a5613bd857b7048924264d1e70e08fb2a7e6527d32b7ab1bb993ac59964ff39721021ac43c7ff740014c3b33737ede99c967e4764553d1b2b83db77c83b8715fa72d2102df2089105c77f266fa11a9d33f05c735234075f2e8780824c6b709415f9fb48553ae")
+        tx.deserialize(BytesIO(bytes.fromhex(signed)))
+        tx.vout[0].scriptPubKey = bytes.fromhex("522102a5613bd857b7048924264d1e70e08fb2a7e6527d32b7ab1bb993ac59964ff39721021ac43c7ff740014c3b33737ede99c967e4764553d1b2b83db77c83b8715fa72d2102df2089105c77f266fa11a9d33f05c735234075f2e8780824c6b709415f9fb48553ae")
         tx_signed = node.signrawtransactionwithwallet(tx.serialize().hex())['hex']
         txid = node.sendrawtransaction(hexstring=tx_signed, maxfeerate=0)
 

test/functional/rpc_decodescript.py

@@ -10,7 +10,6 @@
 from test_framework.test_framework import BitcoinTestFramework
 from test_framework.util import (
     assert_equal,
-    hex_str_to_bytes,
 )
 
 
@@ -154,23 +153,23 @@ def decoderawtransaction_asm_sighashtype(self):
         signature_2_sighash_decoded = der_signature + '[NONE|ANYONECANPAY]'
 
         # 1) P2PK scriptSig
-        txSave.vin[0].scriptSig = hex_str_to_bytes(push_signature)
+        txSave.vin[0].scriptSig = bytes.fromhex(push_signature)
         rpc_result = self.nodes[0].decoderawtransaction(txSave.serialize().hex())
         assert_equal(signature_sighash_decoded, rpc_result['vin'][0]['scriptSig']['asm'])
 
         # make sure that the sighash decodes come out correctly for a more complex / lesser used case.
-        txSave.vin[0].scriptSig = hex_str_to_bytes(push_signature_2)
+        txSave.vin[0].scriptSig = bytes.fromhex(push_signature_2)
         rpc_result = self.nodes[0].decoderawtransaction(txSave.serialize().hex())
         assert_equal(signature_2_sighash_decoded, rpc_result['vin'][0]['scriptSig']['asm'])
 
         # 2) multisig scriptSig
-        txSave.vin[0].scriptSig = hex_str_to_bytes('00' + push_signature + push_signature_2)
+        txSave.vin[0].scriptSig = bytes.fromhex('00' + push_signature + push_signature_2)
         rpc_result = self.nodes[0].decoderawtransaction(txSave.serialize().hex())
         assert_equal('0 ' + signature_sighash_decoded + ' ' + signature_2_sighash_decoded, rpc_result['vin'][0]['scriptSig']['asm'])
 
         # 3) test a scriptSig that contains more than push operations.
         # in fact, it contains an OP_RETURN with data specially crafted to cause improper decode if the code does not catch it.
-        txSave.vin[0].scriptSig = hex_str_to_bytes('6a143011020701010101010101020601010101010101')
+        txSave.vin[0].scriptSig = bytes.fromhex('6a143011020701010101010101020601010101010101')
         rpc_result = self.nodes[0].decoderawtransaction(txSave.serialize().hex())
         assert_equal('OP_RETURN 3011020701010101010101020601010101010101', rpc_result['vin'][0]['scriptSig']['asm'])
 

test/functional/rpc_mnauth.py

@@ -6,7 +6,7 @@
 from test_framework.messages import hash256
 from test_framework.p2p import P2PInterface
 from test_framework.test_framework import DashTestFramework
-from test_framework.util import assert_equal, assert_raises_rpc_error, hex_str_to_bytes
+from test_framework.util import assert_equal, assert_raises_rpc_error
 
 '''
 rpc_mnauth.py
@@ -39,7 +39,7 @@ def run_test(self):
         assert "verified_proregtx_hash" in peerinfo
         assert "verified_pubkey_hash" in peerinfo
         assert_equal(peerinfo["verified_proregtx_hash"], protx_hash)
-        assert_equal(peerinfo["verified_pubkey_hash"], hash256(hex_str_to_bytes(public_key))[::-1].hex())
+        assert_equal(peerinfo["verified_pubkey_hash"], hash256(bytes.fromhex(public_key))[::-1].hex())
         # Test some error cases
         null_hash = "0000000000000000000000000000000000000000000000000000000000000000"
         assert_raises_rpc_error(-8, "proTxHash invalid", masternode.node.mnauth,

test/functional/test_framework/address.py

@@ -12,7 +12,7 @@
 import unittest
 
 from .script import hash160, hash256, CScript
-from .util import assert_equal, hex_str_to_bytes
+from .util import assert_equal
 
 # Note unlike in bitcoin, this address isn't bech32 since we don't (at this time) support bech32.
 ADDRESS_BCRT1_UNSPENDABLE = 'yVg3NBUHNEhgDceqwVUjsZHreC5PBHnUo9'
@@ -27,7 +27,7 @@ def byte_to_base58(b, version):
     result = ''
     str = b.hex()
     str = chr(version).encode('latin-1').hex() + str
-    checksum = hash256(hex_str_to_bytes(str)).hex()
+    checksum = hash256(bytes.fromhex(str)).hex()
     str += checksum[:8]
     value = int('0x' + str, 0)
     while value > 0:
@@ -89,14 +89,14 @@ def script_to_p2sh(script, main=False):
 
 def check_key(key):
     if (type(key) is str):
-        key = hex_str_to_bytes(key)  # Assuming this is hex string
+        key = bytes.fromhex(key)  # Assuming this is hex string
     if (type(key) is bytes and (len(key) == 33 or len(key) == 65)):
         return key
     assert False
 
 def check_script(script):
     if (type(script) is str):
-        script = hex_str_to_bytes(script)  # Assuming this is hex string
+        script = bytes.fromhex(script)  # Assuming this is hex string
     if (type(script) is bytes or type(script) is CScript):
         return script
     assert False

test/functional/test_framework/blocktools.py

@@ -23,7 +23,7 @@
     uint256_to_string,
 )
 from .script import CScript, CScriptNum, CScriptOp, OP_TRUE, OP_CHECKSIG
-from .util import assert_equal, hex_str_to_bytes
+from .util import assert_equal
 from io import BytesIO
 
 MAX_BLOCK_SIGOPS = 40000
@@ -209,7 +209,7 @@ def create_transaction(node, txid, to_address, *, amount):
     """
     raw_tx = create_raw_transaction(node, txid, to_address, amount=amount)
     tx = CTransaction()
-    tx.deserialize(BytesIO(hex_str_to_bytes(raw_tx)))
+    tx.deserialize(BytesIO(bytes.fromhex(raw_tx)))
     return tx
 
 def create_raw_transaction(node, txid, to_address, *, amount):

test/functional/test_framework/messages.py

@@ -27,7 +27,7 @@
 import time
 
 from test_framework.crypto.siphash import siphash256
-from test_framework.util import hex_str_to_bytes, assert_equal
+from test_framework.util import assert_equal
 
 import dash_hash
 
@@ -214,7 +214,7 @@ def from_hex(obj, hex_string):
     Note that there is no complementary helper like e.g. `to_hex` for the
     inverse operation. To serialize a message object to a hex string, simply
     use obj.serialize().hex()"""
-    obj.deserialize(BytesIO(hex_str_to_bytes(hex_string)))
+    obj.deserialize(BytesIO(bytes.fromhex(hex_string)))
     return obj
 
 

test/functional/test_framework/script_util.py

@@ -4,7 +4,6 @@
 # file COPYING or http://www.opensource.org/licenses/mit-license.php.
 """Useful Script constants and utils."""
 from test_framework.script import CScript, hash160, OP_DUP, OP_HASH160, OP_CHECKSIG, OP_EQUAL, OP_EQUALVERIFY
-from test_framework.util import hex_str_to_bytes
 
 # To prevent a "tx-size-small" policy rule error, a transaction has to have a
 # size of at least 83 bytes (MIN_STANDARD_TX_SIZE in
@@ -44,14 +43,14 @@ def script_to_p2sh_script(script, main = False):
 
 def check_key(key):
     if isinstance(key, str):
-        key = hex_str_to_bytes(key) # Assuming this is hex string
+        key = bytes.fromhex(key) # Assuming this is hex string
     if isinstance(key, bytes) and (len(key) == 33 or len(key) == 65):
         return key
     assert False
 
 def check_script(script):
     if isinstance(script, str):
-        script = hex_str_to_bytes(script) # Assuming this is hex string
+        script = bytes.fromhex(script) # Assuming this is hex string
     if isinstance(script, bytes) or isinstance(script, CScript):
         return script
     assert False

test/functional/test_framework/test_framework.py

@@ -48,7 +48,6 @@
     force_finish_mnsync,
     get_bip9_details,
     get_datadir_path,
-    hex_str_to_bytes,
     initialize_datadir,
     p2p_port,
     set_node_times,
@@ -1577,7 +1576,7 @@ def create_isdlock(self, hextx):
 
         block_count = self.mninfo[0].node.getblockcount()
         cycle_hash = int(self.mninfo[0].node.getblockhash(block_count - (block_count % 24)), 16)
-        isdlock = msg_isdlock(1, inputs, tx.sha256, cycle_hash, hex_str_to_bytes(rec_sig['sig']))
+        isdlock = msg_isdlock(1, inputs, tx.sha256, cycle_hash, bytes.fromhex(rec_sig['sig']))
 
         return isdlock
 

test/functional/test_framework/util.py

@@ -6,7 +6,6 @@
 """Helpful routines for regression testing."""
 
 from base64 import b64encode
-from binascii import unhexlify
 from decimal import Decimal, ROUND_DOWN
 from subprocess import CalledProcessError
 import hashlib
@@ -215,10 +214,6 @@ def count_bytes(hex_string):
     return len(bytearray.fromhex(hex_string))
 
 
-def hex_str_to_bytes(hex_str):
-    return unhexlify(hex_str.encode('ascii'))
-
-
 def str_to_b64str(string):
     return b64encode(string.encode('utf-8')).decode('ascii')
 
@@ -558,7 +553,7 @@ def gen_return_txouts():
     from .messages import CTxOut
     txout = CTxOut()
     txout.nValue = 0
-    txout.scriptPubKey = hex_str_to_bytes(script_pubkey)
+    txout.scriptPubKey = bytes.fromhex(script_pubkey)
     for _ in range(128):
         txouts.append(txout)
     return txouts

test/functional/test_framework/wallet.py

@@ -26,7 +26,6 @@
 )
 from test_framework.util import (
     assert_equal,
-    hex_str_to_bytes,
     satoshi_round,
 )
 
@@ -72,7 +71,7 @@ def __init__(self, test_node, *, mode=MiniWalletMode.ADDRESS_OP_TRUE):
             self._scriptPubKey = bytes(CScript([pub_key.get_bytes(), OP_CHECKSIG]))
         elif mode == MiniWalletMode.ADDRESS_OP_TRUE:
             self._address = ADDRESS_BCRT1_P2SH_OP_TRUE
-            self._scriptPubKey = hex_str_to_bytes(self._test_node.validateaddress(self._address)['scriptPubKey'])
+            self._scriptPubKey = bytes.fromhex(self._test_node.validateaddress(self._address)['scriptPubKey'])
 
     def scan_blocks(self, *, start=1, num):
         """Scan the blocks for self._address outputs and add them to self._utxos"""