diff --git a/contrib/linearize/linearize-data.py b/contrib/linearize/linearize-data.py
--- a/contrib/linearize/linearize-data.py
+++ b/contrib/linearize/linearize-data.py
@@ -17,7 +17,7 @@
 import datetime
 import time
 from collections import namedtuple
-from binascii import hexlify, unhexlify
+from binascii import unhexlify
 
 settings = {}
 
@@ -69,7 +69,7 @@
     hash = calc_hdr_hash(blk_hdr)
     hash = bufreverse(hash)
     hash = wordreverse(hash)
-    hash_str = hexlify(hash).decode('utf-8')
+    hash_str = hash.hex()
     return hash_str
 
 
@@ -230,7 +230,7 @@
 
             inMagic = inhdr[:4]
             if (inMagic != self.settings['netmagic']):
-                print("Invalid magic: " + hexlify(inMagic).decode('utf-8'))
+                print("Invalid magic: " + inMagic.hex())
                 return
             inLenLE = inhdr[4:]
             su = struct.unpack("<I", inLenLE)
diff --git a/test/functional/interface_rest.py b/test/functional/interface_rest.py
--- a/test/functional/interface_rest.py
+++ b/test/functional/interface_rest.py
@@ -148,7 +148,7 @@
             "/getutxos", http_method='POST', req_type=ReqType.BIN, body=bin_request, ret_type=RetType.BYTES)
         output = BytesIO(bin_response)
         chain_height, = unpack("i", output.read(4))
-        response_hash = binascii.hexlify(output.read(32)[::-1]).decode('ascii')
+        response_hash = output.read(32)[::-1].hex()
 
         # Check if getutxo's chaintip during calculation was fine
         assert_equal(bb_hash, response_hash)
diff --git a/test/functional/interface_zmq.py b/test/functional/interface_zmq.py
--- a/test/functional/interface_zmq.py
+++ b/test/functional/interface_zmq.py
@@ -11,7 +11,6 @@
 from test_framework.messages import CTransaction
 from test_framework.util import (
     assert_equal,
-    bytes_to_hex_str,
     hash256,
 )
 
@@ -99,18 +98,17 @@
             tx = CTransaction()
             tx.deserialize(BytesIO(hex))
             tx.calc_sha256()
-            assert_equal(tx.hash, bytes_to_hex_str(txid))
+            assert_equal(tx.hash, txid.hex())
 
             # Should receive the generated block hash.
-            hash = bytes_to_hex_str(self.hashblock.receive())
+            hash = self.hashblock.receive().hex()
             assert_equal(genhashes[x], hash)
             # The block should only have the coinbase txid.
-            assert_equal([bytes_to_hex_str(txid)],
-                         self.nodes[1].getblock(hash)["tx"])
+            assert_equal([txid.hex()], self.nodes[1].getblock(hash)["tx"])
 
             # Should receive the generated raw block.
             block = self.rawblock.receive()
-            assert_equal(genhashes[x], bytes_to_hex_str(hash256(block[:80])))
+            assert_equal(genhashes[x], hash256(block[:80]).hex())
 
         self.log.info("Wait for tx from second node")
         payment_txid = self.nodes[1].sendtoaddress(
@@ -119,11 +117,11 @@
 
         # Should receive the broadcasted txid.
         txid = self.hashtx.receive()
-        assert_equal(payment_txid, bytes_to_hex_str(txid))
+        assert_equal(payment_txid, txid.hex())
 
         # Should receive the broadcasted raw transaction.
         hex = self.rawtx.receive()
-        assert_equal(payment_txid, bytes_to_hex_str(hash256(hex)))
+        assert_equal(payment_txid, hash256(hex).hex())
 
 
 if __name__ == '__main__':
diff --git a/test/functional/mempool_accept.py b/test/functional/mempool_accept.py
--- a/test/functional/mempool_accept.py
+++ b/test/functional/mempool_accept.py
@@ -24,7 +24,6 @@
 from test_framework.util import (
     assert_equal,
     assert_raises_rpc_error,
-    bytes_to_hex_str,
     hex_str_to_bytes,
     wait_until,
 )
@@ -108,8 +107,8 @@
 
         self.log.info('A transaction that conflicts with an unconfirmed tx')
         # Send the transaction that replaces the mempool transaction and opts out of replaceability
-        node.sendrawtransaction(hexstring=bytes_to_hex_str(
-            tx.serialize()), allowhighfees=True)
+        node.sendrawtransaction(
+            hexstring=tx.serialize().hex(), allowhighfees=True)
         # take original raw_tx_0
         tx.deserialize(BytesIO(hex_str_to_bytes(raw_tx_0)))
         tx.vout[0].nValue -= int(4 * fee * COIN)  # Set more fee
@@ -117,7 +116,7 @@
         self.check_mempool_result(
             result_expected=[{'txid': tx.rehash(
             ), 'allowed': False, 'reject-reason': '18: txn-mempool-conflict'}],
-            rawtxs=[bytes_to_hex_str(tx.serialize())],
+            rawtxs=[tx.serialize().hex()],
             allowhighfees=True,
         )
 
@@ -128,7 +127,7 @@
         self.check_mempool_result(
             result_expected=[
                 {'txid': tx.rehash(), 'allowed': False, 'reject-reason': 'missing-inputs'}],
-            rawtxs=[bytes_to_hex_str(tx.serialize())],
+            rawtxs=[tx.serialize().hex()],
         )
 
         self.log.info(
@@ -137,7 +136,7 @@
         # Set vout to 1, to spend the other outpoint (49 coins) of the in-chain-tx we want to double spend
         tx.vin[0].prevout.n = 1
         raw_tx_1 = node.signrawtransactionwithwallet(
-            bytes_to_hex_str(tx.serialize()))['hex']
+            tx.serialize().hex())['hex']
         txid_1 = node.sendrawtransaction(
             hexstring=raw_tx_1, allowhighfees=True)
         # Now spend both to "clearly hide" the outputs, ie. remove the coins from the utxo set by spending them
@@ -173,18 +172,18 @@
         # Reference tx should be valid on itself
         self.check_mempool_result(
             result_expected=[{'txid': tx.rehash(), 'allowed': True}],
-            rawtxs=[bytes_to_hex_str(tx.serialize())],
+            rawtxs=[tx.serialize().hex()],
         )
 
         self.log.info('A transaction with no outputs')
         tx.deserialize(BytesIO(hex_str_to_bytes(raw_tx_reference)))
         tx.vout = []
         # Skip re-signing the transaction for context independent checks from now on
-        # tx.deserialize(BytesIO(hex_str_to_bytes(node.signrawtransactionwithwallet(bytes_to_hex_str(tx.serialize()))['hex'])))
+        # tx.deserialize(BytesIO(hex_str_to_bytes(node.signrawtransactionwithwallet(tx.serialize().hex())['hex'])))
         self.check_mempool_result(
             result_expected=[{'txid': tx.rehash(
             ), 'allowed': False, 'reject-reason': '16: bad-txns-vout-empty'}],
-            rawtxs=[bytes_to_hex_str(tx.serialize())],
+            rawtxs=[tx.serialize().hex()],
         )
 
         self.log.info('A really large transaction')
@@ -194,7 +193,7 @@
         self.check_mempool_result(
             result_expected=[
                 {'txid': tx.rehash(), 'allowed': False, 'reject-reason': '16: bad-txns-oversize'}],
-            rawtxs=[bytes_to_hex_str(tx.serialize())],
+            rawtxs=[tx.serialize().hex()],
         )
 
         self.log.info('A transaction with negative output value')
@@ -203,7 +202,7 @@
         self.check_mempool_result(
             result_expected=[{'txid': tx.rehash(
             ), 'allowed': False, 'reject-reason': '16: bad-txns-vout-negative'}],
-            rawtxs=[bytes_to_hex_str(tx.serialize())],
+            rawtxs=[tx.serialize().hex()],
         )
 
         self.log.info('A transaction with too large output value')
@@ -212,7 +211,7 @@
         self.check_mempool_result(
             result_expected=[{'txid': tx.rehash(
             ), 'allowed': False, 'reject-reason': '16: bad-txns-vout-toolarge'}],
-            rawtxs=[bytes_to_hex_str(tx.serialize())],
+            rawtxs=[tx.serialize().hex()],
         )
 
         self.log.info('A transaction with too large sum of output values')
@@ -222,7 +221,7 @@
         self.check_mempool_result(
             result_expected=[{'txid': tx.rehash(
             ), 'allowed': False, 'reject-reason': '16: bad-txns-txouttotal-toolarge'}],
-            rawtxs=[bytes_to_hex_str(tx.serialize())],
+            rawtxs=[tx.serialize().hex()],
         )
 
         self.log.info('A transaction with duplicate inputs')
@@ -231,7 +230,7 @@
         self.check_mempool_result(
             result_expected=[{'txid': tx.rehash(
             ), 'allowed': False, 'reject-reason': '16: bad-txns-inputs-duplicate'}],
-            rawtxs=[bytes_to_hex_str(tx.serialize())],
+            rawtxs=[tx.serialize().hex()],
         )
 
         self.log.info('A coinbase transaction')
@@ -242,7 +241,7 @@
         self.check_mempool_result(
             result_expected=[
                 {'txid': tx.rehash(), 'allowed': False, 'reject-reason': '16: bad-tx-coinbase'}],
-            rawtxs=[bytes_to_hex_str(tx.serialize())],
+            rawtxs=[tx.serialize().hex()],
         )
 
         self.log.info('Some nonstandard transactions')
@@ -251,14 +250,14 @@
         self.check_mempool_result(
             result_expected=[
                 {'txid': tx.rehash(), 'allowed': False, 'reject-reason': '64: version'}],
-            rawtxs=[bytes_to_hex_str(tx.serialize())],
+            rawtxs=[tx.serialize().hex()],
         )
         tx.deserialize(BytesIO(hex_str_to_bytes(raw_tx_reference)))
         tx.vout[0].scriptPubKey = CScript([OP_0])  # Some non-standard script
         self.check_mempool_result(
             result_expected=[
                 {'txid': tx.rehash(), 'allowed': False, 'reject-reason': '64: scriptpubkey'}],
-            rawtxs=[bytes_to_hex_str(tx.serialize())],
+            rawtxs=[tx.serialize().hex()],
         )
         tx.deserialize(BytesIO(hex_str_to_bytes(raw_tx_reference)))
         # Some not-pushonly scriptSig
@@ -266,7 +265,7 @@
         self.check_mempool_result(
             result_expected=[{'txid': tx.rehash(
             ), 'allowed': False, 'reject-reason': '64: scriptsig-not-pushonly'}],
-            rawtxs=[bytes_to_hex_str(tx.serialize())],
+            rawtxs=[tx.serialize().hex()],
         )
         tx.deserialize(BytesIO(hex_str_to_bytes(raw_tx_reference)))
         output_p2sh_burn = CTxOut(nValue=540, scriptPubKey=CScript(
@@ -277,7 +276,7 @@
         self.check_mempool_result(
             result_expected=[
                 {'txid': tx.rehash(), 'allowed': False, 'reject-reason': '64: tx-size'}],
-            rawtxs=[bytes_to_hex_str(tx.serialize())],
+            rawtxs=[tx.serialize().hex()],
         )
         tx.deserialize(BytesIO(hex_str_to_bytes(raw_tx_reference)))
         tx.vout[0] = output_p2sh_burn
@@ -286,7 +285,7 @@
         self.check_mempool_result(
             result_expected=[
                 {'txid': tx.rehash(), 'allowed': False, 'reject-reason': '64: dust'}],
-            rawtxs=[bytes_to_hex_str(tx.serialize())],
+            rawtxs=[tx.serialize().hex()],
         )
         tx.deserialize(BytesIO(hex_str_to_bytes(raw_tx_reference)))
         tx.vout[0].scriptPubKey = CScript([OP_RETURN, b'\xff'])
@@ -294,7 +293,7 @@
         self.check_mempool_result(
             result_expected=[
                 {'txid': tx.rehash(), 'allowed': False, 'reject-reason': '64: multi-op-return'}],
-            rawtxs=[bytes_to_hex_str(tx.serialize())],
+            rawtxs=[tx.serialize().hex()],
         )
 
         self.log.info('A timelocked transaction')
@@ -305,7 +304,7 @@
         self.check_mempool_result(
             result_expected=[
                 {'txid': tx.rehash(), 'allowed': False, 'reject-reason': '64: bad-txns-nonfinal'}],
-            rawtxs=[bytes_to_hex_str(tx.serialize())],
+            rawtxs=[tx.serialize().hex()],
         )
 
         self.log.info('A transaction that is locked by BIP68 sequence logic')
@@ -316,7 +315,7 @@
         self.check_mempool_result(
             result_expected=[
                 {'txid': tx.rehash(), 'allowed': False, 'reject-reason': '64: non-BIP68-final'}],
-            rawtxs=[bytes_to_hex_str(tx.serialize())],
+            rawtxs=[tx.serialize().hex()],
             allowhighfees=True,
         )
 
diff --git a/test/functional/mining_basic.py b/test/functional/mining_basic.py
--- a/test/functional/mining_basic.py
+++ b/test/functional/mining_basic.py
@@ -23,7 +23,6 @@
 from test_framework.util import (
     assert_equal,
     assert_raises_rpc_error,
-    bytes_to_hex_str as b2x,
 )
 
 
@@ -31,7 +30,7 @@
     if rehash:
         block.hashMerkleRoot = block.calc_merkle_root()
     rsp = node.getblocktemplate(
-        {'data': b2x(block.serialize()), 'mode': 'proposal'})
+        {'data': block.serialize().hex(), 'mode': 'proposal'})
     assert_equal(rsp, expect)
 
 
@@ -47,9 +46,9 @@
             block.solve()
             result_str_2 = result_str_2 or 'duplicate-invalid'
             assert_equal(result_str_1, node.submitblock(
-                hexdata=b2x(block.serialize())))
+                hexdata=block.serialize().hex()))
             assert_equal(result_str_2, node.submitblock(
-                hexdata=b2x(block.serialize())))
+                hexdata=block.serialize().hex()))
 
         self.log.info('getmininginfo')
         mining_info = node.getmininginfo()
@@ -88,7 +87,7 @@
 
         self.log.info("submitblock: Test block decode failure")
         assert_raises_rpc_error(-22, "Block decode failed",
-                                node.submitblock, b2x(block.serialize()[:-15]))
+                                node.submitblock, block.serialize()[:-15].hex())
 
         self.log.info(
             "getblocktemplate: Test bad input hash for coinbase transaction")
@@ -99,11 +98,11 @@
 
         self.log.info("submitblock: Test invalid coinbase transaction")
         assert_raises_rpc_error(-22, "Block does not start with a coinbase",
-                                node.submitblock, b2x(bad_block.serialize()))
+                                node.submitblock, bad_block.serialize().hex())
 
         self.log.info("getblocktemplate: Test truncated final transaction")
-        assert_raises_rpc_error(-22, "Block decode failed", node.getblocktemplate,
-                                {'data': b2x(block.serialize()[:-1]), 'mode': 'proposal'})
+        assert_raises_rpc_error(-22, "Block decode failed", node.getblocktemplate, {
+                                'data': block.serialize()[:-1].hex(), 'mode': 'proposal'})
 
         self.log.info("getblocktemplate: Test duplicate transaction")
         bad_block = copy.deepcopy(block)
@@ -134,8 +133,8 @@
         bad_block_sn = bytearray(block.serialize())
         assert_equal(bad_block_sn[TX_COUNT_OFFSET], 1)
         bad_block_sn[TX_COUNT_OFFSET] += 1
-        assert_raises_rpc_error(-22, "Block decode failed", node.getblocktemplate,
-                                {'data': b2x(bad_block_sn), 'mode': 'proposal'})
+        assert_raises_rpc_error(-22, "Block decode failed", node.getblocktemplate, {
+                                'data': bad_block_sn.hex(), 'mode': 'proposal'})
 
         self.log.info("getblocktemplate: Test bad bits")
         bad_block = copy.deepcopy(block)
@@ -179,28 +178,28 @@
             return {'hash': b_hash, 'height': 202, 'branchlen': branchlen, 'status': status}
 
         assert chain_tip(block.hash) not in node.getchaintips()
-        node.submitheader(hexdata=b2x(block.serialize()))
+        node.submitheader(hexdata=block.serialize().hex())
         assert chain_tip(block.hash) in node.getchaintips()
         # Noop
-        node.submitheader(hexdata=b2x(CBlockHeader(block).serialize()))
+        node.submitheader(hexdata=CBlockHeader(block).serialize().hex())
         assert chain_tip(block.hash) in node.getchaintips()
 
         bad_block_root = copy.deepcopy(block)
         bad_block_root.hashMerkleRoot += 2
         bad_block_root.solve()
         assert chain_tip(bad_block_root.hash) not in node.getchaintips()
-        node.submitheader(hexdata=b2x(
-            CBlockHeader(bad_block_root).serialize()))
+        node.submitheader(hexdata=CBlockHeader(
+            bad_block_root).serialize().hex())
         assert chain_tip(bad_block_root.hash) in node.getchaintips()
         # Should still reject invalid blocks, even if we have the header:
-        assert_equal(node.submitblock(hexdata=b2x(
-            bad_block_root.serialize())), 'bad-txnmrklroot')
-        assert_equal(node.submitblock(hexdata=b2x(
-            bad_block_root.serialize())), 'bad-txnmrklroot')
+        assert_equal(node.submitblock(
+            hexdata=bad_block_root.serialize().hex()), 'bad-txnmrklroot')
+        assert_equal(node.submitblock(
+            hexdata=bad_block_root.serialize().hex()), 'bad-txnmrklroot')
         assert chain_tip(bad_block_root.hash) in node.getchaintips()
         # We know the header for this invalid block, so should just return early without error:
-        node.submitheader(hexdata=b2x(
-            CBlockHeader(bad_block_root).serialize()))
+        node.submitheader(hexdata=CBlockHeader(
+            bad_block_root).serialize().hex())
         assert chain_tip(bad_block_root.hash) in node.getchaintips()
 
         bad_block_lock = copy.deepcopy(block)
@@ -208,23 +207,23 @@
         bad_block_lock.vtx[0].rehash()
         bad_block_lock.hashMerkleRoot = bad_block_lock.calc_merkle_root()
         bad_block_lock.solve()
-        assert_equal(node.submitblock(hexdata=b2x(
-            bad_block_lock.serialize())), 'bad-txns-nonfinal')
-        assert_equal(node.submitblock(hexdata=b2x(
-            bad_block_lock.serialize())), 'duplicate-invalid')
+        assert_equal(node.submitblock(
+            hexdata=bad_block_lock.serialize().hex()), 'bad-txns-nonfinal')
+        assert_equal(node.submitblock(
+            hexdata=bad_block_lock.serialize().hex()), 'duplicate-invalid')
         # Build a "good" block on top of the submitted bad block
         bad_block2 = copy.deepcopy(block)
         bad_block2.hashPrevBlock = bad_block_lock.sha256
         bad_block2.solve()
         assert_raises_rpc_error(-25, 'bad-prevblk', lambda: node.submitheader(
-            hexdata=b2x(CBlockHeader(bad_block2).serialize())))
+            hexdata=CBlockHeader(bad_block2).serialize().hex()))
 
         # Should reject invalid header right away
         bad_block_time = copy.deepcopy(block)
         bad_block_time.nTime = 1
         bad_block_time.solve()
         assert_raises_rpc_error(-25, 'time-too-old', lambda: node.submitheader(
-            hexdata=b2x(CBlockHeader(bad_block_time).serialize())))
+            hexdata=CBlockHeader(bad_block_time).serialize().hex()))
 
         # Should ask for the block from a p2p node, if they announce the header as well:
         node.add_p2p_connection(P2PDataStore())
@@ -238,15 +237,15 @@
         # Building a few blocks should give the same results
         node.generate(10)
         assert_raises_rpc_error(-25, 'time-too-old', lambda: node.submitheader(
-            hexdata=b2x(CBlockHeader(bad_block_time).serialize())))
+            hexdata=CBlockHeader(bad_block_time).serialize().hex()))
         assert_raises_rpc_error(-25, 'bad-prevblk', lambda: node.submitheader(
-            hexdata=b2x(CBlockHeader(bad_block2).serialize())))
-        node.submitheader(hexdata=b2x(CBlockHeader(block).serialize()))
-        node.submitheader(hexdata=b2x(
-            CBlockHeader(bad_block_root).serialize()))
+            hexdata=CBlockHeader(bad_block2).serialize().hex()))
+        node.submitheader(hexdata=CBlockHeader(block).serialize().hex())
+        node.submitheader(hexdata=CBlockHeader(
+            bad_block_root).serialize().hex())
         # valid
-        assert_equal(node.submitblock(hexdata=b2x(
-            block.serialize())), 'duplicate')
+        assert_equal(node.submitblock(
+            hexdata=block.serialize().hex()), 'duplicate')
 
 
 if __name__ == '__main__':
diff --git a/test/functional/rpc_decodescript.py b/test/functional/rpc_decodescript.py
--- a/test/functional/rpc_decodescript.py
+++ b/test/functional/rpc_decodescript.py
@@ -6,7 +6,7 @@
 
 from test_framework.messages import CTransaction, FromHex, ToHex
 from test_framework.test_framework import BitcoinTestFramework
-from test_framework.util import assert_equal, bytes_to_hex_str, hex_str_to_bytes
+from test_framework.util import assert_equal, hex_str_to_bytes
 
 
 class DecodeScriptTest(BitcoinTestFramework):
@@ -169,8 +169,7 @@
         # some more full transaction tests of varying specific scriptSigs. used instead of
         # tests in decodescript_script_sig because the decodescript RPC is specifically
         # for working on scriptPubKeys (argh!).
-        push_signature = bytes_to_hex_str(
-            txSave.vin[0].scriptSig)[2:(0x48 * 2 + 4)]
+        push_signature = txSave.vin[0].scriptSig.hex()[2:(0x48 * 2 + 4)]
         signature = push_signature[2:]
         der_signature = signature[:-2]
         signature_sighash_decoded = der_signature + '[ALL]'
diff --git a/test/functional/rpc_rawtransaction.py b/test/functional/rpc_rawtransaction.py
--- a/test/functional/rpc_rawtransaction.py
+++ b/test/functional/rpc_rawtransaction.py
@@ -25,7 +25,6 @@
     assert_raises_rpc_error,
     connect_nodes_bi,
     hex_str_to_bytes,
-    bytes_to_hex_str,
 )
 
 
@@ -147,7 +146,7 @@
             inputs=[{'txid': txid, 'vout': 9}], outputs={address: 99}))))
         assert_equal(len(tx.vout), 1)
         assert_equal(
-            bytes_to_hex_str(tx.serialize()),
+            tx.serialize().hex(),
             self.nodes[2].createrawtransaction(
                 inputs=[{'txid': txid, 'vout': 9}], outputs=[{address: 99}]),
         )
@@ -156,7 +155,7 @@
                        {'txid': txid, 'vout': 9}], outputs=OrderedDict([(address, 99), (address2, 99)])))))
         assert_equal(len(tx.vout), 2)
         assert_equal(
-            bytes_to_hex_str(tx.serialize()),
+            tx.serialize().hex(),
             self.nodes[2].createrawtransaction(inputs=[{'txid': txid, 'vout': 9}], outputs=[
                                                {address: 99}, {address2: 99}]),
         )
@@ -165,7 +164,7 @@
                        {'txid': txid, 'vout': 9}], outputs=multidict([('data', '99'), ('data', '99')])))))
         assert_equal(len(tx.vout), 2)
         assert_equal(
-            bytes_to_hex_str(tx.serialize()),
+            tx.serialize().hex(),
             self.nodes[2].createrawtransaction(inputs=[{'txid': txid, 'vout': 9}], outputs=[
                                                {'data': '99'}, {'data': '99'}]),
         )
@@ -174,7 +173,7 @@
                        {'txid': txid, 'vout': 9}], outputs=multidict([(address, 99), ('data', '99'), ('data', '99')])))))
         assert_equal(len(tx.vout), 3)
         assert_equal(
-            bytes_to_hex_str(tx.serialize()),
+            tx.serialize().hex(),
             self.nodes[2].createrawtransaction(inputs=[{'txid': txid, 'vout': 9}], outputs=[
                                                {address: 99}, {'data': '99'}, {'data': '99'}]),
         )
diff --git a/test/functional/test_framework/address.py b/test/functional/test_framework/address.py
--- a/test/functional/test_framework/address.py
+++ b/test/functional/test_framework/address.py
@@ -5,16 +5,16 @@
 """Encode and decode BASE58, P2PKH and P2SH addresses."""
 
 from .script import CScript, hash160, hash256
-from .util import bytes_to_hex_str, hex_str_to_bytes
+from .util import hex_str_to_bytes
 
 chars = '123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz'
 
 
 def byte_to_base58(b, version):
     result = ''
-    str = bytes_to_hex_str(b)
-    str = bytes_to_hex_str(chr(version).encode('latin-1')) + str
-    checksum = bytes_to_hex_str(hash256(hex_str_to_bytes(str)))
+    str = b.hex()
+    str = chr(version).encode('latin-1').hex() + str
+    checksum = hash256(hex_str_to_bytes(str)).hex()
     str += checksum[:8]
     value = int('0x' + str, 0)
     while value > 0:
diff --git a/test/functional/test_framework/messages.py b/test/functional/test_framework/messages.py
--- a/test/functional/test_framework/messages.py
+++ b/test/functional/test_framework/messages.py
@@ -28,7 +28,7 @@
 import time
 
 from test_framework.siphash import siphash256
-from test_framework.util import bytes_to_hex_str, hex_str_to_bytes
+from test_framework.util import hex_str_to_bytes
 
 MIN_VERSION_SUPPORTED = 60001
 # past bip-31 for ping/pong
@@ -198,7 +198,7 @@
 
 
 def ToHex(obj):
-    return bytes_to_hex_str(obj.serialize())
+    return obj.serialize().hex()
 
 # Objects that map to bitcoind objects, which can be serialized/deserialized
 
@@ -334,7 +334,7 @@
 
     def __repr__(self):
         return "CTxIn(prevout={} scriptSig={} nSequence={})".format(
-            repr(self.prevout), bytes_to_hex_str(self.scriptSig), self.nSequence)
+            repr(self.prevout), self.scriptSig.hex(), self.nSequence)
 
 
 class CTxOut:
@@ -356,8 +356,7 @@
 
     def __repr__(self):
         return "CTxOut(nValue={}.{:08d} scriptPubKey={})".format(
-            self.nValue // COIN, self.nValue % COIN,
-            bytes_to_hex_str(self.scriptPubKey))
+            self.nValue // COIN, self.nValue % COIN, self.scriptPubKey.hex())
 
 
 class CTransaction:
diff --git a/test/functional/test_framework/netutil.py b/test/functional/test_framework/netutil.py
--- a/test/functional/test_framework/netutil.py
+++ b/test/functional/test_framework/netutil.py
@@ -8,7 +8,7 @@
 """
 
 import array
-from binascii import unhexlify, hexlify
+from binascii import unhexlify
 import fcntl
 import os
 import socket
@@ -149,7 +149,7 @@
         addr = sub[0] + ([0] * nullbytes) + sub[1]
     else:
         raise ValueError('Could not parse address {}'.format(addr))
-    return hexlify(bytearray(addr)).decode('ascii')
+    return bytearray(addr).hex()
 
 
 def test_ipv6_local():
diff --git a/test/functional/test_framework/script.py b/test/functional/test_framework/script.py
--- a/test/functional/test_framework/script.py
+++ b/test/functional/test_framework/script.py
@@ -8,7 +8,6 @@
 """
 
 from .bignum import bn2vch
-from binascii import hexlify
 import hashlib
 import struct
 
@@ -558,7 +557,7 @@
     def __repr__(self):
         def _repr(o):
             if isinstance(o, bytes):
-                return "x('{}')".format(hexlify(o).decode('ascii'))
+                return "x('{}')".format(o.hex())
             else:
                 return repr(o)
 
diff --git a/test/functional/test_framework/util.py b/test/functional/test_framework/util.py
--- a/test/functional/test_framework/util.py
+++ b/test/functional/test_framework/util.py
@@ -5,7 +5,7 @@
 """Helpful routines for regression testing."""
 
 from base64 import b64encode
-from binascii import hexlify, unhexlify
+from binascii import unhexlify
 from decimal import Decimal, ROUND_DOWN
 import hashlib
 import inspect
@@ -215,8 +215,8 @@
     return len(bytearray.fromhex(hex_string))
 
 
-def bytes_to_hex_str(byte_str):
-    return hexlify(byte_str).decode('ascii')
+def b_2_x(byte_str):
+    return byte_str.hex()
 
 
 def hash256(byte_str):