diff --git a/contrib/linearize/linearize-data.py b/contrib/linearize/linearize-data.py
index 48fc8a0a78..f3d38be19f 100755
--- a/contrib/linearize/linearize-data.py
+++ b/contrib/linearize/linearize-data.py
@@ -1,339 +1,339 @@
 #!/usr/bin/env python3
 #
 # linearize-data.py: Construct a linear, no-fork version of the chain.
 #
 # Copyright (c) 2013-2016 The Bitcoin Core developers
 # Distributed under the MIT software license, see the accompanying
 # file COPYING or http://www.opensource.org/licenses/mit-license.php.
 #
 
 from __future__ import print_function, division
 import struct
 import re
 import os
 import os.path
 import sys
 import hashlib
 import datetime
 import time
 from collections import namedtuple
-from binascii import hexlify, unhexlify
+from binascii import unhexlify
 
 settings = {}
 
 
 def hex_switchEndian(s):
     """ Switches the endianness of a hex string (in pairs of hex chars) """
     pairList = [s[i:i + 2].encode() for i in range(0, len(s), 2)]
     return b''.join(pairList[::-1]).decode()
 
 
 def uint32(x):
     return x & 0xffffffff
 
 
 def bytereverse(x):
     return uint32((((x) << 24) | (((x) << 8) & 0x00ff0000) |
                    (((x) >> 8) & 0x0000ff00) | ((x) >> 24)))
 
 
 def bufreverse(in_buf):
     out_words = []
     for i in range(0, len(in_buf), 4):
         word = struct.unpack('@I', in_buf[i:i + 4])[0]
         out_words.append(struct.pack('@I', bytereverse(word)))
     return b''.join(out_words)
 
 
 def wordreverse(in_buf):
     out_words = []
     for i in range(0, len(in_buf), 4):
         out_words.append(in_buf[i:i + 4])
     out_words.reverse()
     return b''.join(out_words)
 
 
 def calc_hdr_hash(blk_hdr):
     hash1 = hashlib.sha256()
     hash1.update(blk_hdr)
     hash1_o = hash1.digest()
 
     hash2 = hashlib.sha256()
     hash2.update(hash1_o)
     hash2_o = hash2.digest()
 
     return hash2_o
 
 
 def calc_hash_str(blk_hdr):
     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
 
 
 def get_blk_dt(blk_hdr):
     members = struct.unpack("<I", blk_hdr[68:68 + 4])
     nTime = members[0]
     dt = datetime.datetime.fromtimestamp(nTime)
     dt_ym = datetime.datetime(dt.year, dt.month, 1)
     return (dt_ym, nTime)
 
 # When getting the list of block hashes, undo any byte reversals.
 
 
 def get_block_hashes(settings):
     blkindex = []
     f = open(settings['hashlist'], "r", encoding="utf8")
     for line in f:
         line = line.rstrip()
         if settings['rev_hash_bytes'] == 'true':
             line = hex_switchEndian(line)
         blkindex.append(line)
 
     print("Read " + str(len(blkindex)) + " hashes")
 
     return blkindex
 
 # The block map shouldn't give or receive byte-reversed hashes.
 
 
 def mkblockmap(blkindex):
     blkmap = {}
     for height, hash in enumerate(blkindex):
         blkmap[hash] = height
     return blkmap
 
 
 # Block header and extent on disk
 BlockExtent = namedtuple(
     'BlockExtent', ['fn', 'offset', 'inhdr', 'blkhdr', 'size'])
 
 
 class BlockDataCopier:
     def __init__(self, settings, blkindex, blkmap):
         self.settings = settings
         self.blkindex = blkindex
         self.blkmap = blkmap
 
         self.inFn = 0
         self.inF = None
         self.outFn = 0
         self.outsz = 0
         self.outF = None
         self.outFname = None
         self.blkCountIn = 0
         self.blkCountOut = 0
 
         self.lastDate = datetime.datetime(2000, 1, 1)
         self.highTS = 1408893517 - 315360000
         self.timestampSplit = False
         self.fileOutput = True
         self.setFileTime = False
         self.maxOutSz = settings['max_out_sz']
         if 'output' in settings:
             self.fileOutput = False
         if settings['file_timestamp'] != 0:
             self.setFileTime = True
         if settings['split_timestamp'] != 0:
             self.timestampSplit = True
         # Extents and cache for out-of-order blocks
         self.blockExtents = {}
         self.outOfOrderData = {}
         self.outOfOrderSize = 0  # running total size for items in outOfOrderData
 
     def writeBlock(self, inhdr, blk_hdr, rawblock):
         blockSizeOnDisk = len(inhdr) + len(blk_hdr) + len(rawblock)
         if not self.fileOutput and ((self.outsz + blockSizeOnDisk) > self.maxOutSz):
             self.outF.close()
             if self.setFileTime:
                 os.utime(self.outFname, (int(time.time()), self.highTS))
             self.outF = None
             self.outFname = None
             self.outFn = self.outFn + 1
             self.outsz = 0
 
         (blkDate, blkTS) = get_blk_dt(blk_hdr)
         if self.timestampSplit and (blkDate > self.lastDate):
             print("New month " + blkDate.strftime("%Y-%m") + " @ " + self.hash_str)
             self.lastDate = blkDate
             if self.outF:
                 self.outF.close()
                 if self.setFileTime:
                     os.utime(self.outFname, (int(time.time()), self.highTS))
                 self.outF = None
                 self.outFname = None
                 self.outFn = self.outFn + 1
                 self.outsz = 0
 
         if not self.outF:
             if self.fileOutput:
                 self.outFname = self.settings['output_file']
             else:
                 self.outFname = os.path.join(
                     self.settings['output'], "blk{:05d}.dat".format(self.outFn))
             print("Output file " + self.outFname)
             self.outF = open(self.outFname, "wb")
 
         self.outF.write(inhdr)
         self.outF.write(blk_hdr)
         self.outF.write(rawblock)
         self.outsz = self.outsz + len(inhdr) + len(blk_hdr) + len(rawblock)
 
         self.blkCountOut = self.blkCountOut + 1
         if blkTS > self.highTS:
             self.highTS = blkTS
 
         if (self.blkCountOut % 1000) == 0:
             print('{} blocks scanned, {} blocks written (of {}, {:.1f}% complete)'.format(
                 self.blkCountIn, self.blkCountOut, len(self.blkindex), 100.0 * self.blkCountOut / len(self.blkindex)))
 
     def inFileName(self, fn):
         return os.path.join(self.settings['input'], "blk{:05d}.dat".format(fn))
 
     def fetchBlock(self, extent):
         '''Fetch block contents from disk given extents'''
         with open(self.inFileName(extent.fn), "rb") as f:
             f.seek(extent.offset)
             return f.read(extent.size)
 
     def copyOneBlock(self):
         '''Find the next block to be written in the input, and copy it to the output.'''
         extent = self.blockExtents.pop(self.blkCountOut)
         if self.blkCountOut in self.outOfOrderData:
             # If the data is cached, use it from memory and remove from the cache
             rawblock = self.outOfOrderData.pop(self.blkCountOut)
             self.outOfOrderSize -= len(rawblock)
         else:  # Otherwise look up data on disk
             rawblock = self.fetchBlock(extent)
 
         self.writeBlock(extent.inhdr, extent.blkhdr, rawblock)
 
     def run(self):
         while self.blkCountOut < len(self.blkindex):
             if not self.inF:
                 fname = self.inFileName(self.inFn)
                 print("Input file " + fname)
                 try:
                     self.inF = open(fname, "rb")
                 except IOError:
                     print("Premature end of block data")
                     return
 
             inhdr = self.inF.read(8)
             if (not inhdr or (inhdr[0] == "\0")):
                 self.inF.close()
                 self.inF = None
                 self.inFn = self.inFn + 1
                 continue
 
             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)
             inLen = su[0] - 80  # length without header
             blk_hdr = self.inF.read(80)
             inExtent = BlockExtent(
                 self.inFn, self.inF.tell(), inhdr, blk_hdr, inLen)
 
             self.hash_str = calc_hash_str(blk_hdr)
             if not self.hash_str in blkmap:
                 # Because blocks can be written to files out-of-order as of 0.10, the script
                 # may encounter blocks it doesn't know about. Treat as debug output.
                 if settings['debug_output'] == 'true':
                     print("Skipping unknown block " + self.hash_str)
                 self.inF.seek(inLen, os.SEEK_CUR)
                 continue
 
             blkHeight = self.blkmap[self.hash_str]
             self.blkCountIn += 1
 
             if self.blkCountOut == blkHeight:
                 # If in-order block, just copy
                 rawblock = self.inF.read(inLen)
                 self.writeBlock(inhdr, blk_hdr, rawblock)
 
                 # See if we can catch up to prior out-of-order blocks
                 while self.blkCountOut in self.blockExtents:
                     self.copyOneBlock()
 
             else:  # If out-of-order, skip over block data for now
                 self.blockExtents[blkHeight] = inExtent
                 if self.outOfOrderSize < self.settings['out_of_order_cache_sz']:
                     # If there is space in the cache, read the data
                     # Reading the data in file sequence instead of seeking and fetching it later is preferred,
                     # but we don't want to fill up memory
                     self.outOfOrderData[blkHeight] = self.inF.read(inLen)
                     self.outOfOrderSize += inLen
                 else:  # If no space in cache, seek forward
                     self.inF.seek(inLen, os.SEEK_CUR)
 
         print("Done ({} blocks written)".format((self.blkCountOut)))
 
 
 if __name__ == '__main__':
     if len(sys.argv) != 2:
         print("Usage: linearize-data.py CONFIG-FILE")
         sys.exit(1)
 
     f = open(sys.argv[1], encoding="utf8")
     for line in f:
         # skip comment lines
         m = re.search(r'^\s*#', line)
         if m:
             continue
 
         # parse key=value lines
         m = re.search(r'^(\w+)\s*=\s*(\S.*)$', line)
         if m is None:
             continue
         settings[m.group(1)] = m.group(2)
     f.close()
 
     # Force hash byte format setting to be lowercase to make comparisons easier.
     # Also place upfront in case any settings need to know about it.
     if 'rev_hash_bytes' not in settings:
         settings['rev_hash_bytes'] = 'false'
     settings['rev_hash_bytes'] = settings['rev_hash_bytes'].lower()
 
     if 'netmagic' not in settings:
         settings['netmagic'] = 'f9beb4d9'
     if 'genesis' not in settings:
         settings['genesis'] = '000000000019d6689c085ae165831e934ff763ae46a2a6c172b3f1b60a8ce26f'
     if 'input' not in settings:
         settings['input'] = 'input'
     if 'hashlist' not in settings:
         settings['hashlist'] = 'hashlist.txt'
     if 'file_timestamp' not in settings:
         settings['file_timestamp'] = 0
     if 'split_timestamp' not in settings:
         settings['split_timestamp'] = 0
     if 'max_out_sz' not in settings:
         settings['max_out_sz'] = 1000 * 1000 * 1000
     if 'out_of_order_cache_sz' not in settings:
         settings['out_of_order_cache_sz'] = 100 * 1000 * 1000
     if 'debug_output' not in settings:
         settings['debug_output'] = 'false'
 
     settings['max_out_sz'] = int(settings['max_out_sz'])
     settings['split_timestamp'] = int(settings['split_timestamp'])
     settings['file_timestamp'] = int(settings['file_timestamp'])
     settings['netmagic'] = unhexlify(settings['netmagic'].encode('utf-8'))
     settings['out_of_order_cache_sz'] = int(settings['out_of_order_cache_sz'])
     settings['debug_output'] = settings['debug_output'].lower()
 
     if 'output_file' not in settings and 'output' not in settings:
         print("Missing output file / directory")
         sys.exit(1)
 
     blkindex = get_block_hashes(settings)
     blkmap = mkblockmap(blkindex)
 
     # Block hash map won't be byte-reversed. Neither should the genesis hash.
     if not settings['genesis'] in blkmap:
         print("Genesis block not found in hashlist")
     else:
         BlockDataCopier(settings, blkindex, blkmap).run()
diff --git a/test/functional/interface_rest.py b/test/functional/interface_rest.py
index 4f0eaf7471..b6935dcd0e 100755
--- a/test/functional/interface_rest.py
+++ b/test/functional/interface_rest.py
@@ -1,333 +1,333 @@
 #!/usr/bin/env python3
 # Copyright (c) 2014-2016 The Bitcoin Core developers
 # Distributed under the MIT software license, see the accompanying
 # file COPYING or http://www.opensource.org/licenses/mit-license.php.
 """Test the REST API."""
 
 import binascii
 from decimal import Decimal
 from enum import Enum
 import http.client
 from io import BytesIO
 import json
 from struct import pack, unpack
 import urllib.parse
 
 from test_framework.test_framework import BitcoinTestFramework
 from test_framework.util import (
     assert_equal,
     assert_greater_than,
     assert_greater_than_or_equal,
     hex_str_to_bytes,
 )
 
 
 class ReqType(Enum):
     JSON = 1
     BIN = 2
     HEX = 3
 
 
 class RetType(Enum):
     OBJ = 1
     BYTES = 2
     JSON = 3
 
 
 def filter_output_indices_by_value(vouts, value):
     for vout in vouts:
         if vout['value'] == value:
             yield vout['n']
 
 
 class RESTTest (BitcoinTestFramework):
     def set_test_params(self):
         self.setup_clean_chain = True
         self.num_nodes = 2
         self.extra_args = [["-rest"], []]
 
     def test_rest_request(self, uri, http_method='GET', req_type=ReqType.JSON, body='', status=200, ret_type=RetType.JSON):
         rest_uri = '/rest' + uri
         if req_type == ReqType.JSON:
             rest_uri += '.json'
         elif req_type == ReqType.BIN:
             rest_uri += '.bin'
         elif req_type == ReqType.HEX:
             rest_uri += '.hex'
 
         conn = http.client.HTTPConnection(self.url.hostname, self.url.port)
         self.log.debug('{} {} {}'.format(http_method, rest_uri, body))
         if http_method == 'GET':
             conn.request('GET', rest_uri)
         elif http_method == 'POST':
             conn.request('POST', rest_uri, body)
         resp = conn.getresponse()
 
         assert_equal(resp.status, status)
 
         if ret_type == RetType.OBJ:
             return resp
         elif ret_type == RetType.BYTES:
             return resp.read()
         elif ret_type == RetType.JSON:
             return json.loads(resp.read().decode('utf-8'), parse_float=Decimal)
 
     def run_test(self):
         self.url = urllib.parse.urlparse(self.nodes[0].url)
         self.log.info("Mine blocks and send Bitcoin Cash to node 1")
 
         # Random address so node1's balance doesn't increase
         not_related_address = "2MxqoHEdNQTyYeX1mHcbrrpzgojbosTpCvJ"
 
         self.nodes[0].generate(1)
         self.sync_all()
         self.nodes[1].generatetoaddress(100, not_related_address)
         self.sync_all()
 
         assert_equal(self.nodes[0].getbalance(), 50)
 
         txid = self.nodes[0].sendtoaddress(self.nodes[1].getnewaddress(), 0.1)
         self.sync_all()
         self.nodes[1].generatetoaddress(1, not_related_address)
         self.sync_all()
         bb_hash = self.nodes[0].getbestblockhash()
 
         assert_equal(self.nodes[1].getbalance(), Decimal("0.1"))
 
         self.log.info("Load the transaction using the /tx URI")
 
         json_obj = self.test_rest_request("/tx/{}".format(txid))
         # Get the vin to later check for utxo (should be spent by then)
         spent = (json_obj['vin'][0]['txid'], json_obj['vin'][0]['vout'])
         # Get n of 0.1 outpoint
         n, = filter_output_indices_by_value(json_obj['vout'], Decimal('0.1'))
         spending = (txid, n)
 
         self.log.info("Query an unspent TXO using the /getutxos URI")
 
         json_obj = self.test_rest_request("/getutxos/{}-{}".format(*spending))
 
         # Check chainTip response
         assert_equal(json_obj['chaintipHash'], bb_hash)
 
         # Make sure there is one utxo
         assert_equal(len(json_obj['utxos']), 1)
         assert_equal(json_obj['utxos'][0]['value'], Decimal('0.1'))
 
         self.log.info("Query a spent TXO using the /getutxos URI")
 
         json_obj = self.test_rest_request("/getutxos/{}-{}".format(*spent))
 
         # Check chainTip response
         assert_equal(json_obj['chaintipHash'], bb_hash)
 
         # Make sure there is no utxo in the response because this outpoint has
         # been spent
         assert_equal(len(json_obj['utxos']), 0)
 
         # Check bitmap
         assert_equal(json_obj['bitmap'], "0")
 
         self.log.info("Query two TXOs using the /getutxos URI")
 
         json_obj = self.test_rest_request(
             "/getutxos/{}-{}/{}-{}".format(*(spending + spent)))
 
         assert_equal(len(json_obj['utxos']), 1)
         assert_equal(json_obj['bitmap'], "10")
 
         self.log.info(
             "Query the TXOs using the /getutxos URI with a binary response")
 
         bin_request = b'\x01\x02'
         for txid, n in [spending, spent]:
             bin_request += hex_str_to_bytes(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)
         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)
         # Chain height must be 102
         assert_equal(chain_height, 102)
 
         self.log.info("Test the /getutxos URI with and without /checkmempool")
         # Create a transaction, check that it's found with /checkmempool, but
         # not found without. Then confirm the transaction and check that it's
         # found with or without /checkmempool.
 
         # Do a tx and don't sync
         txid = self.nodes[0].sendtoaddress(self.nodes[1].getnewaddress(), 0.1)
         json_obj = self.test_rest_request("/tx/{}".format(txid))
         # Get the spent output to later check for utxo (should be spent by then)
         spent = (json_obj['vin'][0]['txid'], json_obj['vin'][0]['vout'])
         # Get n of 0.1 outpoint
         n, = filter_output_indices_by_value(json_obj['vout'], Decimal('0.1'))
         spending = (txid, n)
 
         json_obj = self.test_rest_request("/getutxos/{}-{}".format(*spending))
         assert_equal(len(json_obj['utxos']), 0)
 
         json_obj = self.test_rest_request(
             "/getutxos/checkmempool/{}-{}".format(*spending))
         assert_equal(len(json_obj['utxos']), 1)
 
         json_obj = self.test_rest_request("/getutxos/{}-{}".format(*spent))
         assert_equal(len(json_obj['utxos']), 1)
 
         json_obj = self.test_rest_request(
             "/getutxos/checkmempool/{}-{}".format(*spent))
         assert_equal(len(json_obj['utxos']), 0)
 
         self.nodes[0].generate(1)
         self.sync_all()
 
         json_obj = self.test_rest_request("/getutxos/{}-{}".format(*spending))
         assert_equal(len(json_obj['utxos']), 1)
 
         json_obj = self.test_rest_request(
             "/getutxos/checkmempool/{}-{}".format(*spending))
         assert_equal(len(json_obj['utxos']), 1)
 
         # Do some invalid requests
         self.test_rest_request("/getutxos", http_method='POST', req_type=ReqType.JSON,
                                body='{"checkmempool', status=400, ret_type=RetType.OBJ)
         self.test_rest_request("/getutxos", http_method='POST', req_type=ReqType.BIN,
                                body='{"checkmempool', status=400, ret_type=RetType.OBJ)
         self.test_rest_request("/getutxos/checkmempool", http_method='POST',
                                req_type=ReqType.JSON, status=400, ret_type=RetType.OBJ)
 
         # Test limits
         long_uri = '/'.join(["{}-{}".format(txid, n_) for n_ in range(20)])
         self.test_rest_request("/getutxos/checkmempool/{}".format(long_uri),
                                http_method='POST', status=400, ret_type=RetType.OBJ)
 
         long_uri = '/'.join(['{}-{}'.format(txid, n_) for n_ in range(15)])
         self.test_rest_request(
             "/getutxos/checkmempool/{}".format(long_uri), http_method='POST', status=200)
 
         # Generate block to not affect upcoming tests
         self.nodes[0].generate(
             1)
         self.sync_all()
 
         self.log.info("Test the /block and /headers URIs")
         bb_hash = self.nodes[0].getbestblockhash()
 
         # Check binary format
         response = self.test_rest_request(
             "/block/{}".format(bb_hash), req_type=ReqType.BIN, ret_type=RetType.OBJ)
         assert_greater_than(int(response.getheader('content-length')), 80)
         response_bytes = response.read()
 
         # Compare with block header
         response_header = self.test_rest_request(
             "/headers/1/{}".format(bb_hash), req_type=ReqType.BIN, ret_type=RetType.OBJ)
         assert_equal(int(response_header.getheader('content-length')), 80)
         response_header_bytes = response_header.read()
         assert_equal(response_bytes[0:80], response_header_bytes)
 
         # Check block hex format
         response_hex = self.test_rest_request(
             "/block/{}".format(bb_hash), req_type=ReqType.HEX, ret_type=RetType.OBJ)
         assert_greater_than(int(response_hex.getheader('content-length')), 160)
         response_hex_bytes = response_hex.read().strip(b'\n')
         assert_equal(binascii.hexlify(response_bytes), response_hex_bytes)
 
         # Compare with hex block header
         response_header_hex = self.test_rest_request(
             "/headers/1/{}".format(bb_hash), req_type=ReqType.HEX, ret_type=RetType.OBJ)
         assert_greater_than(
             int(response_header_hex.getheader('content-length')), 160)
         response_header_hex_bytes = response_header_hex.read(160)
         assert_equal(binascii.hexlify(
             response_bytes[:80]), response_header_hex_bytes)
 
         # Check json format
         block_json_obj = self.test_rest_request("/block/{}".format(bb_hash))
         assert_equal(block_json_obj['hash'], bb_hash)
 
         # Compare with json block header
         json_obj = self.test_rest_request("/headers/1/{}".format(bb_hash))
         # Ensure that there is one header in the json response
         assert_equal(len(json_obj), 1)
         # Request/response hash should be the same
         assert_equal(json_obj[0]['hash'], bb_hash)
 
         # Compare with normal RPC block response
         rpc_block_json = self.nodes[0].getblock(bb_hash)
         for key in ['hash', 'confirmations', 'height', 'version', 'merkleroot', 'time', 'nonce', 'bits', 'difficulty', 'chainwork', 'previousblockhash']:
             assert_equal(json_obj[0][key], rpc_block_json[key])
 
         # See if we can get 5 headers in one response
         self.nodes[1].generate(5)
         self.sync_all()
         json_obj = self.test_rest_request("/headers/5/{}".format(bb_hash))
         # Now we should have 5 header objects
         assert_equal(len(json_obj), 5)
 
         self.log.info("Test the /tx URI")
 
         tx_hash = block_json_obj['tx'][0]['txid']
         json_obj = self.test_rest_request("/tx/{}".format(tx_hash))
         assert_equal(json_obj['txid'], tx_hash)
 
         # Check hex format response
         hex_response = self.test_rest_request(
             "/tx/{}".format(tx_hash), req_type=ReqType.HEX, ret_type=RetType.OBJ)
         assert_greater_than_or_equal(
             int(hex_response.getheader('content-length')), json_obj['size']*2)
 
         self.log.info("Test tx inclusion in the /mempool and /block URIs")
 
         # Make 3 tx and mine them on node 1
         txs = []
         txs.append(self.nodes[0].sendtoaddress(not_related_address, 11))
         txs.append(self.nodes[0].sendtoaddress(not_related_address, 11))
         txs.append(self.nodes[0].sendtoaddress(not_related_address, 11))
         self.sync_all()
 
         # Check that there are exactly 3 transactions in the TX memory pool
         # before generating the block
         json_obj = self.test_rest_request("/mempool/info")
         assert_equal(json_obj['size'], 3)
         # The size of the memory pool should be greater than 3x ~100 bytes
         assert_greater_than(json_obj['bytes'], 300)
 
         # Check that there are our submitted transactions in the TX memory pool
         json_obj = self.test_rest_request("/mempool/contents")
         for i, tx in enumerate(txs):
             assert tx in json_obj
             assert_equal(json_obj[tx]['spentby'], txs[i + 1:i + 2])
             assert_equal(json_obj[tx]['depends'], txs[i - 1:i])
 
         # Now mine the transactions
         newblockhash = self.nodes[1].generate(1)
         self.sync_all()
 
         # Check if the 3 tx show up in the new block
         json_obj = self.test_rest_request("/block/{}".format(newblockhash[0]))
         non_coinbase_txs = {tx['txid']
                             for tx in json_obj['tx'] if 'coinbase' not in tx['vin'][0]}
         assert_equal(non_coinbase_txs, set(txs))
 
         # Check the same but without tx details
         json_obj = self.test_rest_request(
             "/block/notxdetails/{}".format(newblockhash[0]))
         for tx in txs:
             assert tx in json_obj['tx']
 
         self.log.info("Test the /chaininfo URI")
 
         bb_hash = self.nodes[0].getbestblockhash()
 
         json_obj = self.test_rest_request("/chaininfo")
         assert_equal(json_obj['bestblockhash'], bb_hash)
 
 
 if __name__ == '__main__':
     RESTTest().main()
diff --git a/test/functional/interface_zmq.py b/test/functional/interface_zmq.py
index 8aa56d54f5..b9ade789da 100755
--- a/test/functional/interface_zmq.py
+++ b/test/functional/interface_zmq.py
@@ -1,130 +1,128 @@
 #!/usr/bin/env python3
 # Copyright (c) 2015-2016 The Bitcoin Core developers
 # Distributed under the MIT software license, see the accompanying
 # file COPYING or http://www.opensource.org/licenses/mit-license.php.
 """Test the ZMQ notification interface."""
 import configparser
 import struct
 from io import BytesIO
 
 from test_framework.test_framework import BitcoinTestFramework, SkipTest
 from test_framework.messages import CTransaction
 from test_framework.util import (
     assert_equal,
-    bytes_to_hex_str,
     hash256,
 )
 
 
 class ZMQSubscriber:
     def __init__(self, socket, topic):
         self.sequence = 0
         self.socket = socket
         self.topic = topic
 
         import zmq
         self.socket.setsockopt(zmq.SUBSCRIBE, self.topic)
 
     def receive(self):
         topic, body, seq = self.socket.recv_multipart()
         # Topic should match the subscriber topic.
         assert_equal(topic, self.topic)
         # Sequence should be incremental.
         assert_equal(struct.unpack('<I', seq)[-1], self.sequence)
         self.sequence += 1
         return body
 
 
 class ZMQTest (BitcoinTestFramework):
     def set_test_params(self):
         self.num_nodes = 2
 
     def setup_nodes(self):
         # Try to import python3-zmq. Skip this test if the import fails.
         try:
             import zmq
         except ImportError:
             raise SkipTest("python3-zmq module not available.")
 
         # Check that bitcoin has been built with ZMQ enabled.
         config = configparser.ConfigParser()
         config.read_file(open(self.options.configfile, encoding='utf-8'))
 
         if not config["components"].getboolean("ENABLE_ZMQ"):
             raise SkipTest("bitcoind has not been built with zmq enabled.")
 
         # Initialize ZMQ context and socket.
         # All messages are received in the same socket which means that this
         # test fails if the publishing order changes.
         # Note that the publishing order is not defined in the documentation and
         # is subject to change.
         address = "tcp://127.0.0.1:28332"
         self.zmq_context = zmq.Context()
         socket = self.zmq_context.socket(zmq.SUB)
         socket.set(zmq.RCVTIMEO, 60000)
         socket.connect(address)
 
         # Subscribe to all available topics.
         self.hashblock = ZMQSubscriber(socket, b"hashblock")
         self.hashtx = ZMQSubscriber(socket, b"hashtx")
         self.rawblock = ZMQSubscriber(socket, b"rawblock")
         self.rawtx = ZMQSubscriber(socket, b"rawtx")
 
         self.extra_args = [["-zmqpub{}={}".format(sub.topic.decode(), address) for sub in [
             self.hashblock, self.hashtx, self.rawblock, self.rawtx]], []]
         self.add_nodes(self.num_nodes, self.extra_args)
         self.start_nodes()
 
     def run_test(self):
         try:
             self._zmq_test()
         finally:
             # Destroy the ZMQ context.
             self.log.debug("Destroying ZMQ context")
             self.zmq_context.destroy(linger=None)
 
     def _zmq_test(self):
         num_blocks = 5
         self.log.info(
             "Generate {0} blocks (and {0} coinbase txes)".format(num_blocks))
         genhashes = self.nodes[0].generate(num_blocks)
         self.sync_all()
 
         for x in range(num_blocks):
             # Should receive the coinbase txid.
             txid = self.hashtx.receive()
 
             # Should receive the coinbase raw transaction.
             hex = self.rawtx.receive()
             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(
             self.nodes[0].getnewaddress(), 1.0)
         self.sync_all()
 
         # 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__':
     ZMQTest().main()
diff --git a/test/functional/mempool_accept.py b/test/functional/mempool_accept.py
index 72add6a2d5..b41d8d5eff 100755
--- a/test/functional/mempool_accept.py
+++ b/test/functional/mempool_accept.py
@@ -1,325 +1,324 @@
 #!/usr/bin/env python3
 # Copyright (c) 2017 The Bitcoin Core developers
 # Distributed under the MIT software license, see the accompanying
 # file COPYING or http://www.opensource.org/licenses/mit-license.php.
 """Test mempool acceptance of raw transactions."""
 
 from io import BytesIO
 from test_framework.test_framework import BitcoinTestFramework
 from test_framework.messages import (
     COIN,
     COutPoint,
     CTransaction,
     CTxOut,
     MAX_BLOCK_BASE_SIZE,
 )
 from test_framework.script import (
     hash160,
     CScript,
     OP_0,
     OP_EQUAL,
     OP_HASH160,
     OP_RETURN,
 )
 from test_framework.util import (
     assert_equal,
     assert_raises_rpc_error,
-    bytes_to_hex_str,
     hex_str_to_bytes,
     wait_until,
 )
 
 
 class MempoolAcceptanceTest(BitcoinTestFramework):
     def set_test_params(self):
         self.num_nodes = 1
         self.extra_args = [[
             '-checkmempool',
             '-txindex',
             '-reindex',  # Need reindex for txindex
             '-acceptnonstdtxn=0',  # Try to mimic main-net
         ]] * self.num_nodes
 
     def check_mempool_result(self, result_expected, *args, **kwargs):
         """Wrapper to check result of testmempoolaccept on node_0's mempool"""
         result_test = self.nodes[0].testmempoolaccept(*args, **kwargs)
         assert_equal(result_expected, result_test)
         # Must not change mempool state
         assert_equal(self.nodes[0].getmempoolinfo()['size'], self.mempool_size)
 
     def run_test(self):
         node = self.nodes[0]
 
         self.log.info('Start with empty mempool, and 200 blocks')
         self.mempool_size = 0
         wait_until(lambda: node.getblockcount() == 200)
         assert_equal(node.getmempoolinfo()['size'], self.mempool_size)
 
         self.log.info('Should not accept garbage to testmempoolaccept')
         assert_raises_rpc_error(-3, 'Expected type array, got string',
                                 lambda: node.testmempoolaccept(rawtxs='ff00baar'))
         assert_raises_rpc_error(-8, 'Array must contain exactly one raw transaction for now',
                                 lambda: node.testmempoolaccept(rawtxs=['ff00baar', 'ff22']))
         assert_raises_rpc_error(-22, 'TX decode failed',
                                 lambda: node.testmempoolaccept(rawtxs=['ff00baar']))
 
         self.log.info('A transaction already in the blockchain')
         coin = node.listunspent()[0]  # Pick a random coin(base) to spend
         raw_tx_in_block = node.signrawtransactionwithwallet(node.createrawtransaction(
             inputs=[{'txid': coin['txid'], 'vout': coin['vout']}],
             outputs=[{node.getnewaddress(): 0.3}, {node.getnewaddress(): 49}],
         ))['hex']
         txid_in_block = node.sendrawtransaction(
             hexstring=raw_tx_in_block, allowhighfees=True)
         node.generate(1)
         self.check_mempool_result(
             result_expected=[{'txid': txid_in_block, 'allowed': False,
                               'reject-reason': '18: txn-already-known'}],
             rawtxs=[raw_tx_in_block],
         )
 
         self.log.info('A transaction not in the mempool')
         fee = 0.00000700
         raw_tx_0 = node.signrawtransactionwithwallet(node.createrawtransaction(
             inputs=[{"txid": txid_in_block, "vout": 0,
                      "sequence": 0xfffffffd}],
             outputs=[{node.getnewaddress(): 0.3 - fee}],
         ))['hex']
         tx = CTransaction()
         tx.deserialize(BytesIO(hex_str_to_bytes(raw_tx_0)))
         txid_0 = tx.rehash()
         self.check_mempool_result(
             result_expected=[{'txid': txid_0, 'allowed': True}],
             rawtxs=[raw_tx_0],
         )
 
         self.log.info('A transaction in the mempool')
         node.sendrawtransaction(hexstring=raw_tx_0)
         self.mempool_size = 1
         self.check_mempool_result(
             result_expected=[{'txid': txid_0, 'allowed': False,
                               'reject-reason': '18: txn-already-in-mempool'}],
             rawtxs=[raw_tx_0],
         )
 
         # Removed RBF test
         # self.log.info('A transaction that replaces a mempool transaction')
         # ...
 
         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
         # skip re-signing the tx
         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,
         )
 
         self.log.info('A transaction with missing inputs, that never existed')
         tx.deserialize(BytesIO(hex_str_to_bytes(raw_tx_0)))
         tx.vin[0].prevout = COutPoint(hash=int('ff' * 32, 16), n=14)
         # skip re-signing the tx
         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(
             'A transaction with missing inputs, that existed once in the past')
         tx.deserialize(BytesIO(hex_str_to_bytes(raw_tx_0)))
         # 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
         raw_tx_spend_both = node.signrawtransactionwithwallet(node.createrawtransaction(
             inputs=[
                 {'txid': txid_0, 'vout': 0},
                 {'txid': txid_1, 'vout': 0},
             ],
             outputs=[{node.getnewaddress(): 0.1}]
         ))['hex']
         txid_spend_both = node.sendrawtransaction(
             hexstring=raw_tx_spend_both, allowhighfees=True)
         node.generate(1)
         self.mempool_size = 0
         # Now see if we can add the coins back to the utxo set by sending the exact txs again
         self.check_mempool_result(
             result_expected=[
                 {'txid': txid_0, 'allowed': False, 'reject-reason': 'missing-inputs'}],
             rawtxs=[raw_tx_0],
         )
         self.check_mempool_result(
             result_expected=[
                 {'txid': txid_1, 'allowed': False, 'reject-reason': 'missing-inputs'}],
             rawtxs=[raw_tx_1],
         )
 
         self.log.info('Create a signed "reference" tx for later use')
         raw_tx_reference = node.signrawtransactionwithwallet(node.createrawtransaction(
             inputs=[{'txid': txid_spend_both, 'vout': 0}],
             outputs=[{node.getnewaddress(): 0.05}],
         ))['hex']
         tx.deserialize(BytesIO(hex_str_to_bytes(raw_tx_reference)))
         # 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')
         tx.deserialize(BytesIO(hex_str_to_bytes(raw_tx_reference)))
         tx.vin = [tx.vin[0]] * (1 + MAX_BLOCK_BASE_SIZE //
                                 len(tx.vin[0].serialize()))
         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')
         tx.deserialize(BytesIO(hex_str_to_bytes(raw_tx_reference)))
         tx.vout[0].nValue *= -1
         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')
         tx.deserialize(BytesIO(hex_str_to_bytes(raw_tx_reference)))
         tx.vout[0].nValue = 21000000 * COIN + 1
         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')
         tx.deserialize(BytesIO(hex_str_to_bytes(raw_tx_reference)))
         tx.vout = [tx.vout[0]] * 2
         tx.vout[0].nValue = 21000000 * COIN
         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')
         tx.deserialize(BytesIO(hex_str_to_bytes(raw_tx_reference)))
         tx.vin = [tx.vin[0]] * 2
         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')
         # Pick the input of the first tx we signed, so it has to be a coinbase tx
         raw_tx_coinbase_spent = node.getrawtransaction(
             txid=node.decoderawtransaction(hexstring=raw_tx_in_block)['vin'][0]['txid'])
         tx.deserialize(BytesIO(hex_str_to_bytes(raw_tx_coinbase_spent)))
         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')
         tx.deserialize(BytesIO(hex_str_to_bytes(raw_tx_reference)))
         tx.nVersion = 3  # A version currently non-standard
         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
         tx.vin[0].scriptSig = CScript([OP_HASH160])
         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(
             [OP_HASH160, hash160(b'burn'), OP_EQUAL]))
         # Use enough outputs to make the tx too large for our policy
         num_scripts = 100000 // len(output_p2sh_burn.serialize())
         tx.vout = [output_p2sh_burn] * num_scripts
         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
         # Make output smaller, such that it is dust for our policy
         tx.vout[0].nValue -= 1
         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'])
         tx.vout = [tx.vout[0]] * 2
         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')
         tx.deserialize(BytesIO(hex_str_to_bytes(raw_tx_reference)))
         # Should be non-max, so locktime is not ignored
         tx.vin[0].nSequence -= 1
         tx.nLockTime = node.getblockcount() + 1
         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')
         tx.deserialize(BytesIO(hex_str_to_bytes(raw_tx_reference)))
         # We could include it in the second block mined from now, but not the very next one
         tx.vin[0].nSequence = 2
         # Can skip re-signing the tx because of early rejection
         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,
         )
 
 
 if __name__ == '__main__':
     MempoolAcceptanceTest().main()
diff --git a/test/functional/mining_basic.py b/test/functional/mining_basic.py
index 6c0294f449..a9a1715e79 100755
--- a/test/functional/mining_basic.py
+++ b/test/functional/mining_basic.py
@@ -1,253 +1,252 @@
 #!/usr/bin/env python3
 # Copyright (c) 2014-2016 The Bitcoin Core developers
 # Distributed under the MIT software license, see the accompanying
 # file COPYING or http://www.opensource.org/licenses/mit-license.php.
 """Test mining RPCs
 
 - getmininginfo
 - getblocktemplate proposal mode
 - submitblock"""
 
 import copy
 from decimal import Decimal
 
 from test_framework.blocktools import create_coinbase
 from test_framework.messages import (
     CBlock,
     CBlockHeader,
 )
 from test_framework.mininode import (
     P2PDataStore,
 )
 from test_framework.test_framework import BitcoinTestFramework
 from test_framework.util import (
     assert_equal,
     assert_raises_rpc_error,
-    bytes_to_hex_str as b2x,
 )
 
 
 def assert_template(node, block, expect, rehash=True):
     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)
 
 
 class MiningTest(BitcoinTestFramework):
     def set_test_params(self):
         self.num_nodes = 2
         self.setup_clean_chain = False
 
     def run_test(self):
         node = self.nodes[0]
 
         def assert_submitblock(block, result_str_1, result_str_2=None):
             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()
         assert_equal(mining_info['blocks'], 200)
         assert_equal(mining_info['chain'], 'regtest')
         assert_equal(mining_info['currentblocksize'], 0)
         assert_equal(mining_info['currentblocktx'], 0)
         assert_equal(mining_info['difficulty'],
                      Decimal('4.656542373906925E-10'))
         assert_equal(mining_info['networkhashps'],
                      Decimal('0.003333333333333334'))
         assert_equal(mining_info['pooledtx'], 0)
 
         # Mine a block to leave initial block download
         node.generate(1)
         tmpl = node.getblocktemplate()
         self.log.info("getblocktemplate: Test capability advertised")
         assert 'proposal' in tmpl['capabilities']
         assert 'coinbasetxn' not in tmpl
 
         coinbase_tx = create_coinbase(height=int(tmpl["height"]) + 1)
         # sequence numbers must not be max for nLockTime to have effect
         coinbase_tx.vin[0].nSequence = 2 ** 32 - 2
         coinbase_tx.rehash()
 
         block = CBlock()
         block.nVersion = tmpl["version"]
         block.hashPrevBlock = int(tmpl["previousblockhash"], 16)
         block.nTime = tmpl["curtime"]
         block.nBits = int(tmpl["bits"], 16)
         block.nNonce = 0
         block.vtx = [coinbase_tx]
 
         self.log.info("getblocktemplate: Test valid block")
         assert_template(node, block, None)
 
         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")
         bad_block = copy.deepcopy(block)
         bad_block.vtx[0].vin[0].prevout.hash += 1
         bad_block.vtx[0].rehash()
         assert_template(node, bad_block, 'bad-cb-missing')
 
         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)
         bad_block.vtx.append(bad_block.vtx[0])
         assert_template(node, bad_block, 'bad-txns-duplicate')
         assert_submitblock(bad_block, 'bad-txns-duplicate',
                            'bad-txns-duplicate')
 
         self.log.info("getblocktemplate: Test invalid transaction")
         bad_block = copy.deepcopy(block)
         bad_tx = copy.deepcopy(bad_block.vtx[0])
         bad_tx.vin[0].prevout.hash = 255
         bad_tx.rehash()
         bad_block.vtx.append(bad_tx)
         assert_template(node, bad_block, 'bad-txns-inputs-missingorspent')
         assert_submitblock(bad_block, 'bad-txns-inputs-missingorspent')
 
         self.log.info("getblocktemplate: Test nonfinal transaction")
         bad_block = copy.deepcopy(block)
         bad_block.vtx[0].nLockTime = 2 ** 32 - 1
         bad_block.vtx[0].rehash()
         assert_template(node, bad_block, 'bad-txns-nonfinal')
         assert_submitblock(bad_block, 'bad-txns-nonfinal')
 
         self.log.info("getblocktemplate: Test bad tx count")
         # The tx count is immediately after the block header
         TX_COUNT_OFFSET = 80
         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)
         bad_block.nBits = 469762303  # impossible in the real world
         assert_template(node, bad_block, 'bad-diffbits')
 
         self.log.info("getblocktemplate: Test bad merkle root")
         bad_block = copy.deepcopy(block)
         bad_block.hashMerkleRoot += 1
         assert_template(node, bad_block, 'bad-txnmrklroot', False)
         assert_submitblock(bad_block, 'bad-txnmrklroot', 'bad-txnmrklroot')
 
         self.log.info("getblocktemplate: Test bad timestamps")
         bad_block = copy.deepcopy(block)
         bad_block.nTime = 2 ** 31 - 1
         assert_template(node, bad_block, 'time-too-new')
         assert_submitblock(bad_block, 'time-too-new', 'time-too-new')
         bad_block.nTime = 0
         assert_template(node, bad_block, 'time-too-old')
         assert_submitblock(bad_block, 'time-too-old', 'time-too-old')
 
         self.log.info("getblocktemplate: Test not best block")
         bad_block = copy.deepcopy(block)
         bad_block.hashPrevBlock = 123
         assert_template(node, bad_block, 'inconclusive-not-best-prevblk')
         assert_submitblock(bad_block, 'prev-blk-not-found',
                            'prev-blk-not-found')
 
         self.log.info('submitheader tests')
         assert_raises_rpc_error(-22, 'Block header decode failed',
                                 lambda: node.submitheader(hexdata='xx' * 80))
         assert_raises_rpc_error(-22, 'Block header decode failed',
                                 lambda: node.submitheader(hexdata='ff' * 78))
         assert_raises_rpc_error(-25, 'Must submit previous header',
                                 lambda: node.submitheader(hexdata='ff' * 80))
 
         block.nTime += 1
         block.solve()
 
         def chain_tip(b_hash, *, status='headers-only', branchlen=1):
             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)
         bad_block_lock.vtx[0].nLockTime = 2**32 - 1
         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())
         # Drop the first getheaders
         node.p2p.wait_for_getheaders(timeout=5)
         node.p2p.send_blocks_and_test(blocks=[block], node=node)
         # Must be active now:
         assert chain_tip(block.hash, status='active',
                          branchlen=0) in node.getchaintips()
 
         # 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__':
     MiningTest().main()
diff --git a/test/functional/rpc_decodescript.py b/test/functional/rpc_decodescript.py
index e1b94d717b..43b613e195 100755
--- a/test/functional/rpc_decodescript.py
+++ b/test/functional/rpc_decodescript.py
@@ -1,217 +1,216 @@
 #!/usr/bin/env python3
 # Copyright (c) 2015-2016 The Bitcoin Core developers
 # Distributed under the MIT software license, see the accompanying
 # file COPYING or http://www.opensource.org/licenses/mit-license.php.
 """Test decoding scripts via decodescript RPC command."""
 
 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):
     def set_test_params(self):
         self.setup_clean_chain = True
         self.num_nodes = 1
 
     def decodescript_script_sig(self):
         signature = '304502207fa7a6d1e0ee81132a269ad84e68d695483745cde8b541e3bf630749894e342a022100c1f7ab20e13e22fb95281a870f3dcf38d782e53023ee313d741ad0cfbc0c509001'
         push_signature = '48' + signature
         public_key = '03b0da749730dc9b4b1f4a14d6902877a92541f5368778853d9c4a0cb7802dcfb2'
         push_public_key = '21' + public_key
 
         # below are test cases for all of the standard transaction types
 
         # 1) P2PK scriptSig
         # the scriptSig of a public key scriptPubKey simply pushes a signature
         # onto the stack
         rpc_result = self.nodes[0].decodescript(push_signature)
         assert_equal(signature, rpc_result['asm'])
 
         # 2) P2PKH scriptSig
         rpc_result = self.nodes[0].decodescript(
             push_signature + push_public_key)
         assert_equal(signature + ' ' + public_key, rpc_result['asm'])
 
         # 3) multisig scriptSig
         # this also tests the leading portion of a P2SH multisig scriptSig
         # OP_0 <A sig> <B sig>
         rpc_result = self.nodes[0].decodescript(
             '00' + push_signature + push_signature)
         assert_equal('0 ' + signature + ' ' + signature, rpc_result['asm'])
 
         # 4) P2SH scriptSig
         # an empty P2SH redeemScript is valid and makes for a very simple test case.
         # thus, such a spending scriptSig would just need to pass the outer redeemScript
         # hash test and leave true on the top of the stack.
         rpc_result = self.nodes[0].decodescript('5100')
         assert_equal('1 0', rpc_result['asm'])
 
         # 5) null data scriptSig - no such thing because null data scripts can not be spent.
         # thus, no test case for that standard transaction type is here.
 
     def decodescript_script_pub_key(self):
         public_key = '03b0da749730dc9b4b1f4a14d6902877a92541f5368778853d9c4a0cb7802dcfb2'
         push_public_key = '21' + public_key
         public_key_hash = '11695b6cd891484c2d49ec5aa738ec2b2f897777'
         push_public_key_hash = '14' + public_key_hash
 
         # below are test cases for all of the standard transaction types
 
         # 1) P2PK scriptPubKey
         # <pubkey> OP_CHECKSIG
         rpc_result = self.nodes[0].decodescript(push_public_key + 'ac')
         assert_equal(public_key + ' OP_CHECKSIG', rpc_result['asm'])
 
         # 2) P2PKH scriptPubKey
         # OP_DUP OP_HASH160 <PubKeyHash> OP_EQUALVERIFY OP_CHECKSIG
         rpc_result = self.nodes[0].decodescript(
             '76a9' + push_public_key_hash + '88ac')
         assert_equal('OP_DUP OP_HASH160 ' + public_key_hash +
                      ' OP_EQUALVERIFY OP_CHECKSIG', rpc_result['asm'])
 
         # 3) multisig scriptPubKey
         # <m> <A pubkey> <B pubkey> <C pubkey> <n> OP_CHECKMULTISIG
         # just imagine that the pub keys used below are different.
         # for our purposes here it does not matter that they are the same even
         # though it is unrealistic.
         rpc_result = self.nodes[0].decodescript(
             '52' + push_public_key + push_public_key + push_public_key + '53ae')
         assert_equal('2 ' + public_key + ' ' + public_key + ' ' +
                      public_key + ' 3 OP_CHECKMULTISIG', rpc_result['asm'])
 
         # 4) P2SH scriptPubKey
         # OP_HASH160 <Hash160(redeemScript)> OP_EQUAL.
         # push_public_key_hash here should actually be the hash of a redeem script.
         # but this works the same for purposes of this test.
         rpc_result = self.nodes[0].decodescript(
             'a9' + push_public_key_hash + '87')
         assert_equal(
             'OP_HASH160 ' + public_key_hash + ' OP_EQUAL', rpc_result['asm'])
 
         # 5) null data scriptPubKey
         # use a signature look-alike here to make sure that we do not decode random data as a signature.
         # this matters if/when signature sighash decoding comes along.
         # would want to make sure that no such decoding takes place in this
         # case.
         signature_imposter = '48304502207fa7a6d1e0ee81132a269ad84e68d695483745cde8b541e3bf630749894e342a022100c1f7ab20e13e22fb95281a870f3dcf38d782e53023ee313d741ad0cfbc0c509001'
         # OP_RETURN <data>
         rpc_result = self.nodes[0].decodescript('6a' + signature_imposter)
         assert_equal('OP_RETURN ' + signature_imposter[2:], rpc_result['asm'])
 
         # 6) a CLTV redeem script. redeem scripts are in-effect scriptPubKey scripts, so adding a test here.
         # OP_NOP2 is also known as OP_CHECKLOCKTIMEVERIFY.
         # just imagine that the pub keys used below are different.
         # for our purposes here it does not matter that they are the same even though it is unrealistic.
         #
         # OP_IF
         #   <receiver-pubkey> OP_CHECKSIGVERIFY
         # OP_ELSE
         #   <lock-until> OP_CHECKLOCKTIMEVERIFY OP_DROP
         # OP_ENDIF
         # <sender-pubkey> OP_CHECKSIG
         #
         # lock until block 500,000
         rpc_result = self.nodes[0].decodescript(
             '63' + push_public_key + 'ad670320a107b17568' + push_public_key + 'ac')
         assert_equal('OP_IF ' + public_key + ' OP_CHECKSIGVERIFY OP_ELSE 500000 OP_CHECKLOCKTIMEVERIFY OP_DROP OP_ENDIF ' +
                      public_key + ' OP_CHECKSIG', rpc_result['asm'])
 
     def decoderawtransaction_asm_sighashtype(self):
         """Test decoding scripts via RPC command "decoderawtransaction".
 
         This test is in with the "decodescript" tests because they are testing the same "asm" script decodes.
         """
 
         # this test case uses a random plain vanilla mainnet transaction with a
         # single P2PKH input and output
         tx = '0100000001696a20784a2c70143f634e95227dbdfdf0ecd51647052e70854512235f5986ca010000008a47304402207174775824bec6c2700023309a168231ec80b82c6069282f5133e6f11cbb04460220570edc55c7c5da2ca687ebd0372d3546ebc3f810516a002350cac72dfe192dfb014104d3f898e6487787910a690410b7a917ef198905c27fb9d3b0a42da12aceae0544fc7088d239d9a48f2828a15a09e84043001f27cc80d162cb95404e1210161536ffffffff0100e1f505000000001976a914eb6c6e0cdb2d256a32d97b8df1fc75d1920d9bca88ac00000000'
         rpc_result = self.nodes[0].decoderawtransaction(tx)
         assert_equal(
             '304402207174775824bec6c2700023309a168231ec80b82c6069282f5133e6f11cbb04460220570edc55c7c5da2ca687ebd0372d3546ebc3f810516a002350cac72dfe192dfb[ALL] 04d3f898e6487787910a690410b7a917ef198905c27fb9d3b0a42da12aceae0544fc7088d239d9a48f2828a15a09e84043001f27cc80d162cb95404e1210161536', rpc_result['vin'][0]['scriptSig']['asm'])
 
         # this test case uses a mainnet transaction that has a P2SH input and both P2PKH and P2SH outputs.
         # it's from James D'Angelo's awesome introductory videos about multisig: https://www.youtube.com/watch?v=zIbUSaZBJgU and https://www.youtube.com/watch?v=OSA1pwlaypc
         # verify that we have not altered scriptPubKey decoding.
         tx = '01000000018d1f5635abd06e2c7e2ddf58dc85b3de111e4ad6e0ab51bb0dcf5e84126d927300000000fdfe0000483045022100ae3b4e589dfc9d48cb82d41008dc5fa6a86f94d5c54f9935531924602730ab8002202f88cf464414c4ed9fa11b773c5ee944f66e9b05cc1e51d97abc22ce098937ea01483045022100b44883be035600e9328a01b66c7d8439b74db64187e76b99a68f7893b701d5380220225bf286493e4c4adcf928c40f785422572eb232f84a0b83b0dea823c3a19c75014c695221020743d44be989540d27b1b4bbbcfd17721c337cb6bc9af20eb8a32520b393532f2102c0120a1dda9e51a938d39ddd9fe0ebc45ea97e1d27a7cbd671d5431416d3dd87210213820eb3d5f509d7438c9eeecb4157b2f595105e7cd564b3cdbb9ead3da41eed53aeffffffff02611e0000000000001976a914dc863734a218bfe83ef770ee9d41a27f824a6e5688acee2a02000000000017a9142a5edea39971049a540474c6a99edf0aa4074c588700000000'
         rpc_result = self.nodes[0].decoderawtransaction(tx)
         assert_equal(
             '8e3730608c3b0bb5df54f09076e196bc292a8e39a78e73b44b6ba08c78f5cbb0', rpc_result['txid'])
         assert_equal(
             '0 3045022100ae3b4e589dfc9d48cb82d41008dc5fa6a86f94d5c54f9935531924602730ab8002202f88cf464414c4ed9fa11b773c5ee944f66e9b05cc1e51d97abc22ce098937ea[ALL] 3045022100b44883be035600e9328a01b66c7d8439b74db64187e76b99a68f7893b701d5380220225bf286493e4c4adcf928c40f785422572eb232f84a0b83b0dea823c3a19c75[ALL] 5221020743d44be989540d27b1b4bbbcfd17721c337cb6bc9af20eb8a32520b393532f2102c0120a1dda9e51a938d39ddd9fe0ebc45ea97e1d27a7cbd671d5431416d3dd87210213820eb3d5f509d7438c9eeecb4157b2f595105e7cd564b3cdbb9ead3da41eed53ae', rpc_result['vin'][0]['scriptSig']['asm'])
         assert_equal(
             'OP_DUP OP_HASH160 dc863734a218bfe83ef770ee9d41a27f824a6e56 OP_EQUALVERIFY OP_CHECKSIG',
             rpc_result['vout'][0]['scriptPubKey']['asm'])
         assert_equal(
             'OP_HASH160 2a5edea39971049a540474c6a99edf0aa4074c58 OP_EQUAL',
             rpc_result['vout'][1]['scriptPubKey']['asm'])
         txSave = FromHex(CTransaction(), tx)
 
         # make sure that a specifically crafted op_return value will not pass
         # all the IsDERSignature checks and then get decoded as a sighash type
         tx = '01000000015ded05872fdbda629c7d3d02b194763ce3b9b1535ea884e3c8e765d42e316724020000006b48304502204c10d4064885c42638cbff3585915b322de33762598321145ba033fc796971e2022100bb153ad3baa8b757e30a2175bd32852d2e1cb9080f84d7e32fcdfd667934ef1b012103163c0ff73511ea1743fb5b98384a2ff09dd06949488028fd819f4d83f56264efffffffff0200000000000000000b6a0930060201000201000180380100000000001976a9141cabd296e753837c086da7a45a6c2fe0d49d7b7b88ac00000000'
         rpc_result = self.nodes[0].decoderawtransaction(tx)
         assert_equal('OP_RETURN 300602010002010001',
                      rpc_result['vout'][0]['scriptPubKey']['asm'])
 
         # verify that we have not altered scriptPubKey processing even of a
         # specially crafted P2PKH pubkeyhash and P2SH redeem script hash that
         # is made to pass the der signature checks
         tx = '01000000018d1f5635abd06e2c7e2ddf58dc85b3de111e4ad6e0ab51bb0dcf5e84126d927300000000fdfe0000483045022100ae3b4e589dfc9d48cb82d41008dc5fa6a86f94d5c54f9935531924602730ab8002202f88cf464414c4ed9fa11b773c5ee944f66e9b05cc1e51d97abc22ce098937ea01483045022100b44883be035600e9328a01b66c7d8439b74db64187e76b99a68f7893b701d5380220225bf286493e4c4adcf928c40f785422572eb232f84a0b83b0dea823c3a19c75014c695221020743d44be989540d27b1b4bbbcfd17721c337cb6bc9af20eb8a32520b393532f2102c0120a1dda9e51a938d39ddd9fe0ebc45ea97e1d27a7cbd671d5431416d3dd87210213820eb3d5f509d7438c9eeecb4157b2f595105e7cd564b3cdbb9ead3da41eed53aeffffffff02611e0000000000001976a914301102070101010101010102060101010101010188acee2a02000000000017a91430110207010101010101010206010101010101018700000000'
         rpc_result = self.nodes[0].decoderawtransaction(tx)
         assert_equal(
             'OP_DUP OP_HASH160 3011020701010101010101020601010101010101 OP_EQUALVERIFY OP_CHECKSIG',
             rpc_result['vout'][0]['scriptPubKey']['asm'])
         assert_equal(
             'OP_HASH160 3011020701010101010101020601010101010101 OP_EQUAL',
             rpc_result['vout'][1]['scriptPubKey']['asm'])
 
         # 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]'
         signature_2 = der_signature + '82'
         push_signature_2 = '48' + signature_2
         signature_2_sighash_decoded = der_signature + '[NONE|ANYONECANPAY]'
 
         # 1) P2PK scriptSig
         txSave.vin[0].scriptSig = hex_str_to_bytes(push_signature)
         rpc_result = self.nodes[0].decoderawtransaction(ToHex(txSave))
         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)
         rpc_result = self.nodes[0].decoderawtransaction(ToHex(txSave))
         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)
         rpc_result = self.nodes[0].decoderawtransaction(ToHex(txSave))
         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')
         rpc_result = self.nodes[0].decoderawtransaction(ToHex(txSave))
         assert_equal('OP_RETURN 3011020701010101010101020601010101010101',
                      rpc_result['vin'][0]['scriptSig']['asm'])
 
     def run_test(self):
         self.decodescript_script_sig()
         self.decodescript_script_pub_key()
         self.decoderawtransaction_asm_sighashtype()
 
 
 if __name__ == '__main__':
     DecodeScriptTest().main()
diff --git a/test/functional/rpc_rawtransaction.py b/test/functional/rpc_rawtransaction.py
index b9b51f2388..0ef394f708 100755
--- a/test/functional/rpc_rawtransaction.py
+++ b/test/functional/rpc_rawtransaction.py
@@ -1,497 +1,496 @@
 #!/usr/bin/env python3
 # Copyright (c) 2014-2017 The Bitcoin Core developers
 # Distributed under the MIT software license, see the accompanying
 # file COPYING or http://www.opensource.org/licenses/mit-license.php.
 """Test the rawtranscation RPCs.
 
 Test the following RPCs:
    - createrawtransaction
    - signrawtransactionwithwallet
    - sendrawtransaction
    - decoderawtransaction
    - getrawtransaction
 """
 
 from decimal import Decimal
 
 from collections import OrderedDict
 from io import BytesIO
 from test_framework.messages import CTransaction, ToHex
 from test_framework.test_framework import BitcoinTestFramework
 from test_framework.txtools import pad_raw_tx
 from test_framework.util import (
     assert_equal,
     assert_greater_than,
     assert_raises_rpc_error,
     connect_nodes_bi,
     hex_str_to_bytes,
-    bytes_to_hex_str,
 )
 
 
 class multidict(dict):
     """Dictionary that allows duplicate keys.
     Constructed with a list of (key, value) tuples. When dumped by the json module,
     will output invalid json with repeated keys, eg:
     >>> json.dumps(multidict([(1,2),(1,2)])
     '{"1": 2, "1": 2}'
     Used to test calls to rpc methods with repeated keys in the json object."""
 
     def __init__(self, x):
         dict.__init__(self, x)
         self.x = x
 
     def items(self):
         return self.x
 
 
 # Create one-input, one-output, no-fee transaction:
 class RawTransactionsTest(BitcoinTestFramework):
     def set_test_params(self):
         self.setup_clean_chain = True
         self.num_nodes = 3
 
     def setup_network(self, split=False):
         super().setup_network()
         connect_nodes_bi(self.nodes[0], self.nodes[2])
 
     def run_test(self):
         self.log.info(
             'prepare some coins for multiple *rawtransaction commands')
         self.nodes[2].generate(1)
         self.sync_all()
         self.nodes[0].generate(101)
         self.sync_all()
         self.nodes[0].sendtoaddress(self.nodes[2].getnewaddress(), 1.5)
         self.nodes[0].sendtoaddress(self.nodes[2].getnewaddress(), 1.0)
         self.nodes[0].sendtoaddress(self.nodes[2].getnewaddress(), 5.0)
         self.sync_all()
         self.nodes[0].generate(5)
         self.sync_all()
 
         self.log.info(
             'Test getrawtransaction on genesis block coinbase returns an error')
         block = self.nodes[0].getblock(self.nodes[0].getblockhash(0))
         assert_raises_rpc_error(-5, "The genesis block coinbase is not considered an ordinary transaction",
                                 self.nodes[0].getrawtransaction, block['merkleroot'])
 
         self.log.info(
             'Check parameter types and required parameters of createrawtransaction')
         # Test `createrawtransaction` required parameters
         assert_raises_rpc_error(-1, "createrawtransaction",
                                 self.nodes[0].createrawtransaction)
         assert_raises_rpc_error(-1, "createrawtransaction",
                                 self.nodes[0].createrawtransaction, [])
 
         # Test `createrawtransaction` invalid extra parameters
         assert_raises_rpc_error(-1, "createrawtransaction",
                                 self.nodes[0].createrawtransaction, [], {}, 0, 'foo')
 
         # Test `createrawtransaction` invalid `inputs`
         txid = '1d1d4e24ed99057e84c3f80fd8fbec79ed9e1acee37da269356ecea000000000'
         assert_raises_rpc_error(-3, "Expected type array",
                                 self.nodes[0].createrawtransaction, 'foo', {})
         assert_raises_rpc_error(-1, "JSON value is not an object as expected",
                                 self.nodes[0].createrawtransaction, ['foo'], {})
         assert_raises_rpc_error(-8, "txid must be hexadecimal string",
                                 self.nodes[0].createrawtransaction, [{}], {})
         assert_raises_rpc_error(-8, "txid must be hexadecimal string",
                                 self.nodes[0].createrawtransaction, [{'txid': 'foo'}], {})
         assert_raises_rpc_error(-8, "Invalid parameter, missing vout key",
                                 self.nodes[0].createrawtransaction, [{'txid': txid}], {})
         assert_raises_rpc_error(-8, "Invalid parameter, vout must be a number",
                                 self.nodes[0].createrawtransaction, [{'txid': txid, 'vout': 'foo'}], {})
         assert_raises_rpc_error(-8, "Invalid parameter, vout must be positive",
                                 self.nodes[0].createrawtransaction, [{'txid': txid, 'vout': -1}], {})
         assert_raises_rpc_error(-8, "Invalid parameter, sequence number is out of range",
                                 self.nodes[0].createrawtransaction, [{'txid': txid, 'vout': 0, 'sequence': -1}], {})
 
         # Test `createrawtransaction` invalid `outputs`
         address = self.nodes[0].getnewaddress()
         address2 = self.nodes[0].getnewaddress()
         assert_raises_rpc_error(-1, "JSON value is not an array as expected",
                                 self.nodes[0].createrawtransaction, [], 'foo')
         # Should not throw for backwards compatibility
         self.nodes[0].createrawtransaction(inputs=[], outputs={})
         self.nodes[0].createrawtransaction(inputs=[], outputs=[])
         assert_raises_rpc_error(-8, "Data must be hexadecimal string",
                                 self.nodes[0].createrawtransaction, [], {'data': 'foo'})
         assert_raises_rpc_error(-5, "Invalid Bitcoin address",
                                 self.nodes[0].createrawtransaction, [], {'foo': 0})
         assert_raises_rpc_error(-3, "Invalid amount",
                                 self.nodes[0].createrawtransaction, [], {address: 'foo'})
         assert_raises_rpc_error(-3, "Amount out of range",
                                 self.nodes[0].createrawtransaction, [], {address: -1})
         assert_raises_rpc_error(-8, "Invalid parameter, duplicated address: {}".format(
             address), self.nodes[0].createrawtransaction, [], multidict([(address, 1), (address, 1)]))
         assert_raises_rpc_error(-8, "Invalid parameter, duplicated address: {}".format(
             address), self.nodes[0].createrawtransaction, [], [{address: 1}, {address: 1}])
         assert_raises_rpc_error(-8, "Invalid parameter, key-value pair must contain exactly one key",
                                 self.nodes[0].createrawtransaction, [], [{'a': 1, 'b': 2}])
         assert_raises_rpc_error(-8, "Invalid parameter, key-value pair not an object as expected",
                                 self.nodes[0].createrawtransaction, [], [['key-value pair1'], ['2']])
 
         # Test `createrawtransaction` invalid `locktime`
         assert_raises_rpc_error(-3, "Expected type number",
                                 self.nodes[0].createrawtransaction, [], {}, 'foo')
         assert_raises_rpc_error(-8, "Invalid parameter, locktime out of range",
                                 self.nodes[0].createrawtransaction, [], {}, -1)
         assert_raises_rpc_error(-8, "Invalid parameter, locktime out of range",
                                 self.nodes[0].createrawtransaction, [], {}, 4294967296)
 
         self.log.info(
             'Check that createrawtransaction accepts an array and object as outputs')
         tx = CTransaction()
         # One output
         tx.deserialize(BytesIO(hex_str_to_bytes(self.nodes[2].createrawtransaction(
             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}]),
         )
         # Two outputs
         tx.deserialize(BytesIO(hex_str_to_bytes(self.nodes[2].createrawtransaction(inputs=[
                        {'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}]),
         )
         # Two data outputs
         tx.deserialize(BytesIO(hex_str_to_bytes(self.nodes[2].createrawtransaction(inputs=[
                        {'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'}]),
         )
         # Multiple mixed outputs
         tx.deserialize(BytesIO(hex_str_to_bytes(self.nodes[2].createrawtransaction(inputs=[
                        {'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'}]),
         )
 
         self.log.info('sendrawtransaction with missing input')
         # won't exists
         inputs = [
             {'txid': "1d1d4e24ed99057e84c3f80fd8fbec79ed9e1acee37da269356ecea000000000", 'vout': 1}]
         outputs = {self.nodes[0].getnewaddress(): 4.998}
         rawtx = self.nodes[2].createrawtransaction(inputs, outputs)
         rawtx = pad_raw_tx(rawtx)
         rawtx = self.nodes[2].signrawtransactionwithwallet(rawtx)
 
         # This will raise an exception since there are missing inputs
         assert_raises_rpc_error(
             -25, "Missing inputs", self.nodes[2].sendrawtransaction, rawtx['hex'])
 
         #####################################
         # getrawtransaction with block hash #
         #####################################
 
         # make a tx by sending then generate 2 blocks; block1 has the tx in it
         tx = self.nodes[2].sendtoaddress(self.nodes[1].getnewaddress(), 1)
         block1, block2 = self.nodes[2].generate(2)
         self.sync_all()
         # We should be able to get the raw transaction by providing the correct block
         gottx = self.nodes[0].getrawtransaction(tx, True, block1)
         assert_equal(gottx['txid'], tx)
         assert_equal(gottx['in_active_chain'], True)
         # We should not have the 'in_active_chain' flag when we don't provide a block
         gottx = self.nodes[0].getrawtransaction(tx, True)
         assert_equal(gottx['txid'], tx)
         assert 'in_active_chain' not in gottx
         # We should not get the tx if we provide an unrelated block
         assert_raises_rpc_error(-5, "No such transaction found",
                                 self.nodes[0].getrawtransaction, tx, True, block2)
         # An invalid block hash should raise the correct errors
         assert_raises_rpc_error(-8, "parameter 3 must be hexadecimal",
                                 self.nodes[0].getrawtransaction, tx, True, True)
         assert_raises_rpc_error(-8, "parameter 3 must be hexadecimal",
                                 self.nodes[0].getrawtransaction, tx, True, "foobar")
         assert_raises_rpc_error(-8, "parameter 3 must be of length 64",
                                 self.nodes[0].getrawtransaction, tx, True, "abcd1234")
         assert_raises_rpc_error(-5, "Block hash not found", self.nodes[0].getrawtransaction,
                                 tx, True, "0000000000000000000000000000000000000000000000000000000000000000")
         # Undo the blocks and check in_active_chain
         self.nodes[0].invalidateblock(block1)
         gottx = self.nodes[0].getrawtransaction(
             txid=tx, verbose=True, blockhash=block1)
         assert_equal(gottx['in_active_chain'], False)
         self.nodes[0].reconsiderblock(block1)
         assert_equal(self.nodes[0].getbestblockhash(), block2)
 
         #
         # RAW TX MULTISIG TESTS #
         #
         # 2of2 test
         addr1 = self.nodes[2].getnewaddress()
         addr2 = self.nodes[2].getnewaddress()
 
         addr1Obj = self.nodes[2].getaddressinfo(addr1)
         addr2Obj = self.nodes[2].getaddressinfo(addr2)
 
         # Tests for createmultisig and addmultisigaddress
         assert_raises_rpc_error(-5, "Invalid public key",
                                 self.nodes[0].createmultisig, 1, ["01020304"])
         # createmultisig can only take public keys
         self.nodes[0].createmultisig(
             2, [addr1Obj['pubkey'], addr2Obj['pubkey']])
         # addmultisigaddress can take both pubkeys and addresses so long as they are in the wallet, which is tested here.
         assert_raises_rpc_error(-5, "Invalid public key",
                                 self.nodes[0].createmultisig, 2, [addr1Obj['pubkey'], addr1])
 
         mSigObj = self.nodes[2].addmultisigaddress(
             2, [addr1Obj['pubkey'], addr1])['address']
 
         # use balance deltas instead of absolute values
         bal = self.nodes[2].getbalance()
 
         # send 1.2 BCH to msig adr
         txId = self.nodes[0].sendtoaddress(mSigObj, 1.2)
         self.sync_all()
         self.nodes[0].generate(1)
         self.sync_all()
         # node2 has both keys of the 2of2 ms addr., tx should affect the
         # balance
         assert_equal(self.nodes[2].getbalance(), bal + Decimal('1.20000000'))
 
         # 2of3 test from different nodes
         bal = self.nodes[2].getbalance()
         addr1 = self.nodes[1].getnewaddress()
         addr2 = self.nodes[2].getnewaddress()
         addr3 = self.nodes[2].getnewaddress()
 
         addr1Obj = self.nodes[1].getaddressinfo(addr1)
         addr2Obj = self.nodes[2].getaddressinfo(addr2)
         addr3Obj = self.nodes[2].getaddressinfo(addr3)
 
         mSigObj = self.nodes[2].addmultisigaddress(
             2, [addr1Obj['pubkey'], addr2Obj['pubkey'], addr3Obj['pubkey']])['address']
 
         txId = self.nodes[0].sendtoaddress(mSigObj, 2.2)
         decTx = self.nodes[0].gettransaction(txId)
         rawTx = self.nodes[0].decoderawtransaction(decTx['hex'])
         self.sync_all()
         self.nodes[0].generate(1)
         self.sync_all()
 
         # THIS IS AN INCOMPLETE FEATURE
         # NODE2 HAS TWO OF THREE KEY AND THE FUNDS SHOULD BE SPENDABLE AND
         # COUNT AT BALANCE CALCULATION
         # for now, assume the funds of a 2of3 multisig tx are not marked as
         # spendable
         assert_equal(self.nodes[2].getbalance(), bal)
 
         txDetails = self.nodes[0].gettransaction(txId, True)
         rawTx = self.nodes[0].decoderawtransaction(txDetails['hex'])
         vout = False
         for outpoint in rawTx['vout']:
             if outpoint['value'] == Decimal('2.20000000'):
                 vout = outpoint
                 break
 
         bal = self.nodes[0].getbalance()
         inputs = [{
             "txid": txId,
             "vout": vout['n'],
             "scriptPubKey": vout['scriptPubKey']['hex'],
             "amount": vout['value'],
         }]
         outputs = {self.nodes[0].getnewaddress(): 2.19}
         rawTx = self.nodes[2].createrawtransaction(inputs, outputs)
         rawTxPartialSigned = self.nodes[1].signrawtransactionwithwallet(
             rawTx, inputs)
         # node1 only has one key, can't comp. sign the tx
         assert_equal(rawTxPartialSigned['complete'], False)
 
         rawTxSigned = self.nodes[2].signrawtransactionwithwallet(rawTx, inputs)
         # node2 can sign the tx compl., own two of three keys
         assert_equal(rawTxSigned['complete'], True)
         self.nodes[2].sendrawtransaction(rawTxSigned['hex'])
         rawTx = self.nodes[0].decoderawtransaction(rawTxSigned['hex'])
         self.sync_all()
         self.nodes[0].generate(1)
         self.sync_all()
         assert_equal(self.nodes[0].getbalance(), bal + Decimal(
             '50.00000000') + Decimal('2.19000000'))  # block reward + tx
 
         rawTxBlock = self.nodes[0].getblock(self.nodes[0].getbestblockhash())
 
         # 2of2 test for combining transactions
         bal = self.nodes[2].getbalance()
         addr1 = self.nodes[1].getnewaddress()
         addr2 = self.nodes[2].getnewaddress()
 
         addr1Obj = self.nodes[1].getaddressinfo(addr1)
         addr2Obj = self.nodes[2].getaddressinfo(addr2)
 
         self.nodes[1].addmultisigaddress(
             2, [addr1Obj['pubkey'], addr2Obj['pubkey']])['address']
         mSigObj = self.nodes[2].addmultisigaddress(
             2, [addr1Obj['pubkey'], addr2Obj['pubkey']])['address']
         mSigObjValid = self.nodes[2].getaddressinfo(mSigObj)
 
         txId = self.nodes[0].sendtoaddress(mSigObj, 2.2)
         decTx = self.nodes[0].gettransaction(txId)
         rawTx2 = self.nodes[0].decoderawtransaction(decTx['hex'])
         self.sync_all()
         self.nodes[0].generate(1)
         self.sync_all()
 
         # the funds of a 2of2 multisig tx should not be marked as spendable
         assert_equal(self.nodes[2].getbalance(), bal)
 
         txDetails = self.nodes[0].gettransaction(txId, True)
         rawTx2 = self.nodes[0].decoderawtransaction(txDetails['hex'])
         vout = False
         for outpoint in rawTx2['vout']:
             if outpoint['value'] == Decimal('2.20000000'):
                 vout = outpoint
                 break
 
         bal = self.nodes[0].getbalance()
         inputs = [{"txid": txId, "vout": vout['n'], "scriptPubKey": vout['scriptPubKey']
                    ['hex'], "redeemScript": mSigObjValid['hex'], "amount": vout['value']}]
         outputs = {self.nodes[0].getnewaddress(): 2.19}
         rawTx2 = self.nodes[2].createrawtransaction(inputs, outputs)
         rawTxPartialSigned1 = self.nodes[1].signrawtransactionwithwallet(
             rawTx2, inputs)
         self.log.debug(rawTxPartialSigned1)
         # node1 only has one key, can't comp. sign the tx
         assert_equal(rawTxPartialSigned1['complete'], False)
 
         rawTxPartialSigned2 = self.nodes[2].signrawtransactionwithwallet(
             rawTx2, inputs)
         self.log.debug(rawTxPartialSigned2)
         # node2 only has one key, can't comp. sign the tx
         assert_equal(rawTxPartialSigned2['complete'], False)
         rawTxComb = self.nodes[2].combinerawtransaction(
             [rawTxPartialSigned1['hex'], rawTxPartialSigned2['hex']])
         self.log.debug(rawTxComb)
         self.nodes[2].sendrawtransaction(rawTxComb)
         rawTx2 = self.nodes[0].decoderawtransaction(rawTxComb)
         self.sync_all()
         self.nodes[0].generate(1)
         self.sync_all()
         assert_equal(self.nodes[0].getbalance(
         ), bal+Decimal('50.00000000')+Decimal('2.19000000'))  # block reward + tx
 
         # getrawtransaction tests
         # 1. valid parameters - only supply txid
         txHash = rawTx["hash"]
         assert_equal(
             self.nodes[0].getrawtransaction(txHash), rawTxSigned['hex'])
 
         # 2. valid parameters - supply txid and 0 for non-verbose
         assert_equal(
             self.nodes[0].getrawtransaction(txHash, 0), rawTxSigned['hex'])
 
         # 3. valid parameters - supply txid and False for non-verbose
         assert_equal(self.nodes[0].getrawtransaction(
             txHash, False), rawTxSigned['hex'])
 
         # 4. valid parameters - supply txid and 1 for verbose.
         # We only check the "hex" field of the output so we don't need to
         # update this test every time the output format changes.
         assert_equal(self.nodes[0].getrawtransaction(
             txHash, 1)["hex"], rawTxSigned['hex'])
 
         # 5. valid parameters - supply txid and True for non-verbose
         assert_equal(self.nodes[0].getrawtransaction(
             txHash, True)["hex"], rawTxSigned['hex'])
 
         # 6. invalid parameters - supply txid and string "Flase"
         assert_raises_rpc_error(
             -1, "not a boolean", self.nodes[0].getrawtransaction, txHash, "False")
 
         # 7. invalid parameters - supply txid and empty array
         assert_raises_rpc_error(
             -1, "not a boolean", self.nodes[0].getrawtransaction, txHash, [])
 
         # 8. invalid parameters - supply txid and empty dict
         assert_raises_rpc_error(
             -1, "not a boolean", self.nodes[0].getrawtransaction, txHash, {})
 
         # Sanity checks on verbose getrawtransaction output
         rawTxOutput = self.nodes[0].getrawtransaction(txHash, True)
         assert_equal(rawTxOutput["hex"], rawTxSigned["hex"])
         assert_equal(rawTxOutput["txid"], txHash)
         assert_equal(rawTxOutput["hash"], txHash)
         assert_greater_than(rawTxOutput["size"], 300)
         assert_equal(rawTxOutput["version"], 0x02)
         assert_equal(rawTxOutput["locktime"], 0)
         assert_equal(len(rawTxOutput["vin"]), 1)
         assert_equal(len(rawTxOutput["vout"]), 1)
         assert_equal(rawTxOutput["blockhash"], rawTxBlock["hash"])
         assert_equal(rawTxOutput["confirmations"], 3)
         assert_equal(rawTxOutput["time"], rawTxBlock["time"])
         assert_equal(rawTxOutput["blocktime"], rawTxBlock["time"])
 
         inputs = [
             {'txid': "1d1d4e24ed99057e84c3f80fd8fbec79ed9e1acee37da269356ecea000000000", 'sequence': 1000}]
         outputs = {self.nodes[0].getnewaddress(): 1}
         assert_raises_rpc_error(
             -8, 'Invalid parameter, missing vout key',
             self.nodes[0].createrawtransaction, inputs, outputs)
 
         inputs[0]['vout'] = "1"
         assert_raises_rpc_error(
             -8, 'Invalid parameter, vout must be a number',
             self.nodes[0].createrawtransaction, inputs, outputs)
 
         inputs[0]['vout'] = -1
         assert_raises_rpc_error(
             -8, 'Invalid parameter, vout must be positive',
             self.nodes[0].createrawtransaction, inputs, outputs)
 
         inputs[0]['vout'] = 1
         rawtx = self.nodes[0].createrawtransaction(inputs, outputs)
         decrawtx = self.nodes[0].decoderawtransaction(rawtx)
         assert_equal(decrawtx['vin'][0]['sequence'], 1000)
 
         # 9. invalid parameters - sequence number out of range
         inputs[0]['sequence'] = -1
         assert_raises_rpc_error(
             -8, 'Invalid parameter, sequence number is out of range',
             self.nodes[0].createrawtransaction, inputs, outputs)
 
         # 10. invalid parameters - sequence number out of range
         inputs[0]['sequence'] = 4294967296
         assert_raises_rpc_error(
             -8, 'Invalid parameter, sequence number is out of range',
             self.nodes[0].createrawtransaction, inputs, outputs)
 
         inputs[0]['sequence'] = 4294967294
         rawtx = self.nodes[0].createrawtransaction(inputs, outputs)
         decrawtx = self.nodes[0].decoderawtransaction(rawtx)
         assert_equal(decrawtx['vin'][0]['sequence'], 4294967294)
 
         ####################################
         # TRANSACTION VERSION NUMBER TESTS #
         ####################################
 
         # Test the minimum transaction version number that fits in a signed 32-bit integer.
         tx = CTransaction()
         tx.nVersion = -0x80000000
         rawtx = ToHex(tx)
         decrawtx = self.nodes[0].decoderawtransaction(rawtx)
         assert_equal(decrawtx['version'], -0x80000000)
 
         # Test the maximum transaction version number that fits in a signed 32-bit integer.
         tx = CTransaction()
         tx.nVersion = 0x7fffffff
         rawtx = ToHex(tx)
         decrawtx = self.nodes[0].decoderawtransaction(rawtx)
         assert_equal(decrawtx['version'], 0x7fffffff)
 
 
 if __name__ == '__main__':
     RawTransactionsTest().main()
diff --git a/test/functional/test_framework/address.py b/test/functional/test_framework/address.py
index 814c55ee05..b4c50e4307 100644
--- a/test/functional/test_framework/address.py
+++ b/test/functional/test_framework/address.py
@@ -1,66 +1,66 @@
 #!/usr/bin/env python3
 # Copyright (c) 2016 The Bitcoin Core developers
 # Distributed under the MIT software license, see the accompanying
 # file COPYING or http://www.opensource.org/licenses/mit-license.php.
 """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:
         result = chars[value % 58] + result
         value //= 58
     while (str[:2] == '00'):
         result = chars[0] + result
         str = str[2:]
     return result
 
 # TODO: def base58_decode
 
 
 def keyhash_to_p2pkh(hash, main=False):
     assert (len(hash) == 20)
     version = 0 if main else 111
     return byte_to_base58(hash, version)
 
 
 def scripthash_to_p2sh(hash, main=False):
     assert (len(hash) == 20)
     version = 5 if main else 196
     return byte_to_base58(hash, version)
 
 
 def key_to_p2pkh(key, main=False):
     key = check_key(key)
     return keyhash_to_p2pkh(hash160(key), main)
 
 
 def script_to_p2sh(script, main=False):
     script = check_script(script)
     return scripthash_to_p2sh(hash160(script), main)
 
 
 def check_key(key):
     if (type(key) is str):
         key = hex_str_to_bytes(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
     if (type(script) is bytes or type(script) is CScript):
         return script
     assert(False)
diff --git a/test/functional/test_framework/messages.py b/test/functional/test_framework/messages.py
index 39faa9c8fd..c51ae829e3 100755
--- a/test/functional/test_framework/messages.py
+++ b/test/functional/test_framework/messages.py
@@ -1,1331 +1,1330 @@
 #!/usr/bin/env python3
 # Copyright (c) 2010 ArtForz -- public domain half-a-node
 # Copyright (c) 2012 Jeff Garzik
 # Copyright (c) 2010-2017 The Bitcoin Core developers
 # Distributed under the MIT software license, see the accompanying
 # file COPYING or http://www.opensource.org/licenses/mit-license.php.
 """Bitcoin test framework primitive and message structures
 
 CBlock, CTransaction, CBlockHeader, CTxIn, CTxOut, etc....:
     data structures that should map to corresponding structures in
     bitcoin/primitives
 
 msg_block, msg_tx, msg_headers, etc.:
     data structures that represent network messages
 
 ser_*, deser_*: functions that handle serialization/deserialization.
 
 Classes use __slots__ to ensure extraneous attributes aren't accidentally added
 by tests, compromising their intended effect.
 """
 from codecs import encode
 import copy
 import hashlib
 from io import BytesIO
 import random
 import socket
 import struct
 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
 MY_VERSION = 70014
 MY_SUBVERSION = b"/python-mininode-tester:0.0.3/"
 # from version 70001 onwards, fRelay should be appended to version messages (BIP37)
 MY_RELAY = 1
 
 MAX_INV_SZ = 50000
 MAX_BLOCK_BASE_SIZE = 1000000
 
 # 1 BCH in satoshis
 COIN = 100000000
 
 NODE_NETWORK = (1 << 0)
 # NODE_GETUTXO = (1 << 1)
 NODE_BLOOM = (1 << 2)
 # NODE_WITNESS = (1 << 3)
 NODE_XTHIN = (1 << 4)
 NODE_BITCOIN_CASH = (1 << 5)
 NODE_NETWORK_LIMITED = (1 << 10)
 
 MSG_TX = 1
 MSG_BLOCK = 2
 MSG_TYPE_MASK = 0xffffffff >> 2
 
 # Serialization/deserialization tools
 
 
 def sha256(s):
     return hashlib.new('sha256', s).digest()
 
 
 def ripemd160(s):
     return hashlib.new('ripemd160', s).digest()
 
 
 def hash256(s):
     return sha256(sha256(s))
 
 
 def ser_compact_size(l):
     r = b""
     if l < 253:
         r = struct.pack("B", l)
     elif l < 0x10000:
         r = struct.pack("<BH", 253, l)
     elif l < 0x100000000:
         r = struct.pack("<BI", 254, l)
     else:
         r = struct.pack("<BQ", 255, l)
     return r
 
 
 def deser_compact_size(f):
     nit = struct.unpack("<B", f.read(1))[0]
     if nit == 253:
         nit = struct.unpack("<H", f.read(2))[0]
     elif nit == 254:
         nit = struct.unpack("<I", f.read(4))[0]
     elif nit == 255:
         nit = struct.unpack("<Q", f.read(8))[0]
     return nit
 
 
 def deser_string(f):
     nit = deser_compact_size(f)
     return f.read(nit)
 
 
 def ser_string(s):
     return ser_compact_size(len(s)) + s
 
 
 def deser_uint256(f):
     r = 0
     for i in range(8):
         t = struct.unpack("<I", f.read(4))[0]
         r += t << (i * 32)
     return r
 
 
 def ser_uint256(u):
     rs = b""
     for i in range(8):
         rs += struct.pack("<I", u & 0xFFFFFFFF)
         u >>= 32
     return rs
 
 
 def uint256_from_str(s):
     r = 0
     t = struct.unpack("<IIIIIIII", s[:32])
     for i in range(8):
         r += t[i] << (i * 32)
     return r
 
 
 def uint256_from_compact(c):
     nbytes = (c >> 24) & 0xFF
     v = (c & 0xFFFFFF) << (8 * (nbytes - 3))
     return v
 
 
 def deser_vector(f, c):
     nit = deser_compact_size(f)
     r = []
     for i in range(nit):
         t = c()
         t.deserialize(f)
         r.append(t)
     return r
 
 
 # ser_function_name: Allow for an alternate serialization function on the
 # entries in the vector.
 def ser_vector(l, ser_function_name=None):
     r = ser_compact_size(len(l))
     for i in l:
         if ser_function_name:
             r += getattr(i, ser_function_name)()
         else:
             r += i.serialize()
     return r
 
 
 def deser_uint256_vector(f):
     nit = deser_compact_size(f)
     r = []
     for i in range(nit):
         t = deser_uint256(f)
         r.append(t)
     return r
 
 
 def ser_uint256_vector(l):
     r = ser_compact_size(len(l))
     for i in l:
         r += ser_uint256(i)
     return r
 
 
 def deser_string_vector(f):
     nit = deser_compact_size(f)
     r = []
     for i in range(nit):
         t = deser_string(f)
         r.append(t)
     return r
 
 
 def ser_string_vector(l):
     r = ser_compact_size(len(l))
     for sv in l:
         r += ser_string(sv)
     return r
 
 
 # Deserialize from a hex string representation (eg from RPC)
 
 
 def FromHex(obj, hex_string):
     obj.deserialize(BytesIO(hex_str_to_bytes(hex_string)))
     return obj
 
 # Convert a binary-serializable object to hex (eg for submission via RPC)
 
 
 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
 
 
 class CAddress:
     __slots__ = ("ip", "nServices", "pchReserved", "port", "time")
 
     def __init__(self):
         self.time = 0
         self.nServices = 1
         self.pchReserved = b"\x00" * 10 + b"\xff" * 2
         self.ip = "0.0.0.0"
         self.port = 0
 
     def deserialize(self, f, with_time=True):
         if with_time:
             self.time = struct.unpack("<i", f.read(4))[0]
         self.nServices = struct.unpack("<Q", f.read(8))[0]
         self.pchReserved = f.read(12)
         self.ip = socket.inet_ntoa(f.read(4))
         self.port = struct.unpack(">H", f.read(2))[0]
 
     def serialize(self, with_time=True):
         r = b""
         if with_time:
             r += struct.pack("<i", self.time)
         r += struct.pack("<Q", self.nServices)
         r += self.pchReserved
         r += socket.inet_aton(self.ip)
         r += struct.pack(">H", self.port)
         return r
 
     def __repr__(self):
         return "CAddress(nServices={} ip={} port={})".format(
             self.nServices, self.ip, self.port)
 
 
 class CInv:
     __slots__ = ("hash", "type")
 
     typemap = {
         0: "Error",
         1: "TX",
         2: "Block",
         4: "CompactBlock"
     }
 
     def __init__(self, t=0, h=0):
         self.type = t
         self.hash = h
 
     def deserialize(self, f):
         self.type = struct.unpack("<i", f.read(4))[0]
         self.hash = deser_uint256(f)
 
     def serialize(self):
         r = b""
         r += struct.pack("<i", self.type)
         r += ser_uint256(self.hash)
         return r
 
     def __repr__(self):
         return "CInv(type={} hash={:064x})".format(
             self.typemap[self.type], self.hash)
 
 
 class CBlockLocator:
     __slots__ = ("nVersion", "vHave")
 
     def __init__(self):
         self.nVersion = MY_VERSION
         self.vHave = []
 
     def deserialize(self, f):
         self.nVersion = struct.unpack("<i", f.read(4))[0]
         self.vHave = deser_uint256_vector(f)
 
     def serialize(self):
         r = b""
         r += struct.pack("<i", self.nVersion)
         r += ser_uint256_vector(self.vHave)
         return r
 
     def __repr__(self):
         return "CBlockLocator(nVersion={} vHave={})".format(
             self.nVersion, repr(self.vHave))
 
 
 class COutPoint:
     __slots__ = ("hash", "n")
 
     def __init__(self, hash=0, n=0):
         self.hash = hash
         self.n = n
 
     def deserialize(self, f):
         self.hash = deser_uint256(f)
         self.n = struct.unpack("<I", f.read(4))[0]
 
     def serialize(self):
         r = b""
         r += ser_uint256(self.hash)
         r += struct.pack("<I", self.n)
         return r
 
     def __repr__(self):
         return "COutPoint(hash={:064x} n={})".format(self.hash, self.n)
 
 
 class CTxIn:
     __slots__ = ("nSequence", "prevout", "scriptSig")
 
     def __init__(self, outpoint=None, scriptSig=b"", nSequence=0):
         if outpoint is None:
             self.prevout = COutPoint()
         else:
             self.prevout = outpoint
         self.scriptSig = scriptSig
         self.nSequence = nSequence
 
     def deserialize(self, f):
         self.prevout = COutPoint()
         self.prevout.deserialize(f)
         self.scriptSig = deser_string(f)
         self.nSequence = struct.unpack("<I", f.read(4))[0]
 
     def serialize(self):
         r = b""
         r += self.prevout.serialize()
         r += ser_string(self.scriptSig)
         r += struct.pack("<I", self.nSequence)
         return r
 
     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:
     __slots__ = ("nValue", "scriptPubKey")
 
     def __init__(self, nValue=0, scriptPubKey=b""):
         self.nValue = nValue
         self.scriptPubKey = scriptPubKey
 
     def deserialize(self, f):
         self.nValue = struct.unpack("<q", f.read(8))[0]
         self.scriptPubKey = deser_string(f)
 
     def serialize(self):
         r = b""
         r += struct.pack("<q", self.nValue)
         r += ser_string(self.scriptPubKey)
         return r
 
     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:
     __slots__ = ("hash", "nLockTime", "nVersion", "sha256", "vin", "vout")
 
     def __init__(self, tx=None):
         if tx is None:
             self.nVersion = 1
             self.vin = []
             self.vout = []
             self.nLockTime = 0
             self.sha256 = None
             self.hash = None
         else:
             self.nVersion = tx.nVersion
             self.vin = copy.deepcopy(tx.vin)
             self.vout = copy.deepcopy(tx.vout)
             self.nLockTime = tx.nLockTime
             self.sha256 = tx.sha256
             self.hash = tx.hash
 
     def deserialize(self, f):
         self.nVersion = struct.unpack("<i", f.read(4))[0]
         self.vin = deser_vector(f, CTxIn)
         self.vout = deser_vector(f, CTxOut)
         self.nLockTime = struct.unpack("<I", f.read(4))[0]
         self.sha256 = None
         self.hash = None
 
     def billable_size(self):
         """
         Returns the size used for billing the against the transaction
         """
         return len(self.serialize())
 
     def serialize(self):
         r = b""
         r += struct.pack("<i", self.nVersion)
         r += ser_vector(self.vin)
         r += ser_vector(self.vout)
         r += struct.pack("<I", self.nLockTime)
         return r
 
     # Recalculate the txid
     def rehash(self):
         self.sha256 = None
         self.calc_sha256()
         return self.hash
 
     # self.sha256 and self.hash -- those are expected to be the txid.
     def calc_sha256(self):
         if self.sha256 is None:
             self.sha256 = uint256_from_str(hash256(self.serialize()))
         self.hash = encode(
             hash256(self.serialize())[::-1], 'hex_codec').decode('ascii')
 
     def get_id(self):
         # For now, just forward the hash.
         self.calc_sha256()
         return self.hash
 
     def is_valid(self):
         self.calc_sha256()
         for tout in self.vout:
             if tout.nValue < 0 or tout.nValue > 21000000 * COIN:
                 return False
         return True
 
     def __repr__(self):
         return "CTransaction(nVersion={} vin={} vout={} nLockTime={})".format(
             self.nVersion, repr(self.vin), repr(self.vout), self.nLockTime)
 
 
 class CBlockHeader:
     __slots__ = ("hash", "hashMerkleRoot", "hashPrevBlock", "nBits", "nNonce",
                  "nTime", "nVersion", "sha256")
 
     def __init__(self, header=None):
         if header is None:
             self.set_null()
         else:
             self.nVersion = header.nVersion
             self.hashPrevBlock = header.hashPrevBlock
             self.hashMerkleRoot = header.hashMerkleRoot
             self.nTime = header.nTime
             self.nBits = header.nBits
             self.nNonce = header.nNonce
             self.sha256 = header.sha256
             self.hash = header.hash
             self.calc_sha256()
 
     def set_null(self):
         self.nVersion = 1
         self.hashPrevBlock = 0
         self.hashMerkleRoot = 0
         self.nTime = 0
         self.nBits = 0
         self.nNonce = 0
         self.sha256 = None
         self.hash = None
 
     def deserialize(self, f):
         self.nVersion = struct.unpack("<i", f.read(4))[0]
         self.hashPrevBlock = deser_uint256(f)
         self.hashMerkleRoot = deser_uint256(f)
         self.nTime = struct.unpack("<I", f.read(4))[0]
         self.nBits = struct.unpack("<I", f.read(4))[0]
         self.nNonce = struct.unpack("<I", f.read(4))[0]
         self.sha256 = None
         self.hash = None
 
     def serialize(self):
         r = b""
         r += struct.pack("<i", self.nVersion)
         r += ser_uint256(self.hashPrevBlock)
         r += ser_uint256(self.hashMerkleRoot)
         r += struct.pack("<I", self.nTime)
         r += struct.pack("<I", self.nBits)
         r += struct.pack("<I", self.nNonce)
         return r
 
     def calc_sha256(self):
         if self.sha256 is None:
             r = b""
             r += struct.pack("<i", self.nVersion)
             r += ser_uint256(self.hashPrevBlock)
             r += ser_uint256(self.hashMerkleRoot)
             r += struct.pack("<I", self.nTime)
             r += struct.pack("<I", self.nBits)
             r += struct.pack("<I", self.nNonce)
             self.sha256 = uint256_from_str(hash256(r))
             self.hash = encode(hash256(r)[::-1], 'hex_codec').decode('ascii')
 
     def rehash(self):
         self.sha256 = None
         self.calc_sha256()
         return self.sha256
 
     def __repr__(self):
         return "CBlockHeader(nVersion={} hashPrevBlock={:064x} hashMerkleRoot={:064x} nTime={} nBits={:08x} nNonce={:08x})".format(
             self.nVersion, self.hashPrevBlock, self.hashMerkleRoot,
             time.ctime(self.nTime), self.nBits, self.nNonce)
 
 
 class CBlock(CBlockHeader):
     __slots__ = ("vtx",)
 
     def __init__(self, header=None):
         super(CBlock, self).__init__(header)
         self.vtx = []
 
     def deserialize(self, f):
         super(CBlock, self).deserialize(f)
         self.vtx = deser_vector(f, CTransaction)
 
     def serialize(self):
         r = b""
         r += super(CBlock, self).serialize()
         r += ser_vector(self.vtx)
         return r
 
     # Calculate the merkle root given a vector of transaction hashes
     def get_merkle_root(self, hashes):
         while len(hashes) > 1:
             newhashes = []
             for i in range(0, len(hashes), 2):
                 i2 = min(i + 1, len(hashes) - 1)
                 newhashes.append(hash256(hashes[i] + hashes[i2]))
             hashes = newhashes
         return uint256_from_str(hashes[0])
 
     def calc_merkle_root(self):
         hashes = []
         for tx in self.vtx:
             tx.calc_sha256()
             hashes.append(ser_uint256(tx.sha256))
         return self.get_merkle_root(hashes)
 
     def is_valid(self):
         self.calc_sha256()
         target = uint256_from_compact(self.nBits)
         if self.sha256 > target:
             return False
         for tx in self.vtx:
             if not tx.is_valid():
                 return False
         if self.calc_merkle_root() != self.hashMerkleRoot:
             return False
         return True
 
     def solve(self):
         self.rehash()
         target = uint256_from_compact(self.nBits)
         while self.sha256 > target:
             self.nNonce += 1
             self.rehash()
 
     def __repr__(self):
         return "CBlock(nVersion={} hashPrevBlock={:064x} hashMerkleRoot={:064x} nTime={} nBits={:08x} nNonce={:08x} vtx={})".format(
             self.nVersion, self.hashPrevBlock, self.hashMerkleRoot,
             time.ctime(self.nTime), self.nBits, self.nNonce, repr(self.vtx))
 
 
 class PrefilledTransaction:
     __slots__ = ("index", "tx")
 
     def __init__(self, index=0, tx=None):
         self.index = index
         self.tx = tx
 
     def deserialize(self, f):
         self.index = deser_compact_size(f)
         self.tx = CTransaction()
         self.tx.deserialize(f)
 
     def serialize(self):
         r = b""
         r += ser_compact_size(self.index)
         r += self.tx.serialize()
         return r
 
     def __repr__(self):
         return "PrefilledTransaction(index={}, tx={})".format(
             self.index, repr(self.tx))
 
 
 # This is what we send on the wire, in a cmpctblock message.
 class P2PHeaderAndShortIDs:
     __slots__ = ("header", "nonce", "prefilled_txn", "prefilled_txn_length",
                  "shortids", "shortids_length")
 
     def __init__(self):
         self.header = CBlockHeader()
         self.nonce = 0
         self.shortids_length = 0
         self.shortids = []
         self.prefilled_txn_length = 0
         self.prefilled_txn = []
 
     def deserialize(self, f):
         self.header.deserialize(f)
         self.nonce = struct.unpack("<Q", f.read(8))[0]
         self.shortids_length = deser_compact_size(f)
         for i in range(self.shortids_length):
             # shortids are defined to be 6 bytes in the spec, so append
             # two zero bytes and read it in as an 8-byte number
             self.shortids.append(
                 struct.unpack("<Q", f.read(6) + b'\x00\x00')[0])
         self.prefilled_txn = deser_vector(f, PrefilledTransaction)
         self.prefilled_txn_length = len(self.prefilled_txn)
 
     def serialize(self):
         r = b""
         r += self.header.serialize()
         r += struct.pack("<Q", self.nonce)
         r += ser_compact_size(self.shortids_length)
         for x in self.shortids:
             # We only want the first 6 bytes
             r += struct.pack("<Q", x)[0:6]
         r += ser_vector(self.prefilled_txn)
         return r
 
     def __repr__(self):
         return "P2PHeaderAndShortIDs(header={}, nonce={}, shortids_length={}, shortids={}, prefilled_txn_length={}, prefilledtxn={}".format(
             repr(self.header), self.nonce, self.shortids_length,
             repr(self.shortids), self.prefilled_txn_length,
             repr(self.prefilled_txn))
 
 # Calculate the BIP 152-compact blocks shortid for a given transaction hash
 
 
 def calculate_shortid(k0, k1, tx_hash):
     expected_shortid = siphash256(k0, k1, tx_hash)
     expected_shortid &= 0x0000ffffffffffff
     return expected_shortid
 
 
 # This version gets rid of the array lengths, and reinterprets the differential
 # encoding into indices that can be used for lookup.
 class HeaderAndShortIDs:
     __slots__ = ("header", "nonce", "prefilled_txn", "shortids")
 
     def __init__(self, p2pheaders_and_shortids=None):
         self.header = CBlockHeader()
         self.nonce = 0
         self.shortids = []
         self.prefilled_txn = []
 
         if p2pheaders_and_shortids != None:
             self.header = p2pheaders_and_shortids.header
             self.nonce = p2pheaders_and_shortids.nonce
             self.shortids = p2pheaders_and_shortids.shortids
             last_index = -1
             for x in p2pheaders_and_shortids.prefilled_txn:
                 self.prefilled_txn.append(
                     PrefilledTransaction(x.index + last_index + 1, x.tx))
                 last_index = self.prefilled_txn[-1].index
 
     def to_p2p(self):
         ret = P2PHeaderAndShortIDs()
         ret.header = self.header
         ret.nonce = self.nonce
         ret.shortids_length = len(self.shortids)
         ret.shortids = self.shortids
         ret.prefilled_txn_length = len(self.prefilled_txn)
         ret.prefilled_txn = []
         last_index = -1
         for x in self.prefilled_txn:
             ret.prefilled_txn.append(
                 PrefilledTransaction(x.index - last_index - 1, x.tx))
             last_index = x.index
         return ret
 
     def get_siphash_keys(self):
         header_nonce = self.header.serialize()
         header_nonce += struct.pack("<Q", self.nonce)
         hash_header_nonce_as_str = sha256(header_nonce)
         key0 = struct.unpack("<Q", hash_header_nonce_as_str[0:8])[0]
         key1 = struct.unpack("<Q", hash_header_nonce_as_str[8:16])[0]
         return [key0, key1]
 
     # Version 2 compact blocks use wtxid in shortids (rather than txid)
     def initialize_from_block(self, block, nonce=0, prefill_list=[0]):
         self.header = CBlockHeader(block)
         self.nonce = nonce
         self.prefilled_txn = [PrefilledTransaction(i, block.vtx[i])
                               for i in prefill_list]
         self.shortids = []
         [k0, k1] = self.get_siphash_keys()
         for i in range(len(block.vtx)):
             if i not in prefill_list:
                 tx_hash = block.vtx[i].sha256
                 self.shortids.append(calculate_shortid(k0, k1, tx_hash))
 
     def __repr__(self):
         return "HeaderAndShortIDs(header={}, nonce={}, shortids={}, prefilledtxn={}".format(
             repr(self.header), self.nonce, repr(self.shortids),
             repr(self.prefilled_txn))
 
 
 class BlockTransactionsRequest:
     __slots__ = ("blockhash", "indexes")
 
     def __init__(self, blockhash=0, indexes=None):
         self.blockhash = blockhash
         self.indexes = indexes if indexes != None else []
 
     def deserialize(self, f):
         self.blockhash = deser_uint256(f)
         indexes_length = deser_compact_size(f)
         for i in range(indexes_length):
             self.indexes.append(deser_compact_size(f))
 
     def serialize(self):
         r = b""
         r += ser_uint256(self.blockhash)
         r += ser_compact_size(len(self.indexes))
         for x in self.indexes:
             r += ser_compact_size(x)
         return r
 
     # helper to set the differentially encoded indexes from absolute ones
     def from_absolute(self, absolute_indexes):
         self.indexes = []
         last_index = -1
         for x in absolute_indexes:
             self.indexes.append(x - last_index - 1)
             last_index = x
 
     def to_absolute(self):
         absolute_indexes = []
         last_index = -1
         for x in self.indexes:
             absolute_indexes.append(x + last_index + 1)
             last_index = absolute_indexes[-1]
         return absolute_indexes
 
     def __repr__(self):
         return "BlockTransactionsRequest(hash={:064x} indexes={})".format(
             self.blockhash, repr(self.indexes))
 
 
 class BlockTransactions:
     __slots__ = ("blockhash", "transactions")
 
     def __init__(self, blockhash=0, transactions=None):
         self.blockhash = blockhash
         self.transactions = transactions if transactions != None else []
 
     def deserialize(self, f):
         self.blockhash = deser_uint256(f)
         self.transactions = deser_vector(f, CTransaction)
 
     def serialize(self):
         r = b""
         r += ser_uint256(self.blockhash)
         r += ser_vector(self.transactions)
         return r
 
     def __repr__(self):
         return "BlockTransactions(hash={:064x} transactions={})".format(
             self.blockhash, repr(self.transactions))
 
 
 class CPartialMerkleTree:
     __slots__ = ("fBad", "nTransactions", "vBits", "vHash")
 
     def __init__(self):
         self.nTransactions = 0
         self.vHash = []
         self.vBits = []
         self.fBad = False
 
     def deserialize(self, f):
         self.nTransactions = struct.unpack("<i", f.read(4))[0]
         self.vHash = deser_uint256_vector(f)
         vBytes = deser_string(f)
         self.vBits = []
         for i in range(len(vBytes) * 8):
             self.vBits.append(vBytes[i // 8] & (1 << (i % 8)) != 0)
 
     def serialize(self):
         r = b""
         r += struct.pack("<i", self.nTransactions)
         r += ser_uint256_vector(self.vHash)
         vBytesArray = bytearray([0x00] * ((len(self.vBits) + 7) // 8))
         for i in range(len(self.vBits)):
             vBytesArray[i // 8] |= self.vBits[i] << (i % 8)
         r += ser_string(bytes(vBytesArray))
         return r
 
     def __repr__(self):
         return "CPartialMerkleTree(nTransactions={}, vHash={}, vBits={})".format(self.nTransactions, repr(self.vHash), repr(self.vBits))
 
 
 class CMerkleBlock:
     __slots__ = ("header", "txn")
 
     def __init__(self):
         self.header = CBlockHeader()
         self.txn = CPartialMerkleTree()
 
     def deserialize(self, f):
         self.header.deserialize(f)
         self.txn.deserialize(f)
 
     def serialize(self):
         r = b""
         r += self.header.serialize()
         r += self.txn.serialize()
         return r
 
     def __repr__(self):
         return "CMerkleBlock(header={}, txn={})".format(repr(self.header), repr(self.txn))
 
 
 # Objects that correspond to messages on the wire
 
 
 class msg_version:
     __slots__ = ("addrFrom", "addrTo", "nNonce", "nRelay", "nServices",
                  "nStartingHeight", "nTime", "nVersion", "strSubVer")
     command = b"version"
 
     def __init__(self):
         self.nVersion = MY_VERSION
         self.nServices = 1
         self.nTime = int(time.time())
         self.addrTo = CAddress()
         self.addrFrom = CAddress()
         self.nNonce = random.getrandbits(64)
         self.strSubVer = MY_SUBVERSION
         self.nStartingHeight = -1
         self.nRelay = MY_RELAY
 
     def deserialize(self, f):
         self.nVersion = struct.unpack("<i", f.read(4))[0]
         if self.nVersion == 10300:
             self.nVersion = 300
         self.nServices = struct.unpack("<Q", f.read(8))[0]
         self.nTime = struct.unpack("<q", f.read(8))[0]
         self.addrTo = CAddress()
         self.addrTo.deserialize(f, False)
 
         if self.nVersion >= 106:
             self.addrFrom = CAddress()
             self.addrFrom.deserialize(f, False)
             self.nNonce = struct.unpack("<Q", f.read(8))[0]
             self.strSubVer = deser_string(f)
         else:
             self.addrFrom = None
             self.nNonce = None
             self.strSubVer = None
             self.nStartingHeight = None
 
         if self.nVersion >= 209:
             self.nStartingHeight = struct.unpack("<i", f.read(4))[0]
         else:
             self.nStartingHeight = None
 
         if self.nVersion >= 70001:
             # Relay field is optional for version 70001 onwards
             try:
                 self.nRelay = struct.unpack("<b", f.read(1))[0]
             except:
                 self.nRelay = 0
         else:
             self.nRelay = 0
 
     def serialize(self):
         r = b""
         r += struct.pack("<i", self.nVersion)
         r += struct.pack("<Q", self.nServices)
         r += struct.pack("<q", self.nTime)
         r += self.addrTo.serialize(False)
         r += self.addrFrom.serialize(False)
         r += struct.pack("<Q", self.nNonce)
         r += ser_string(self.strSubVer)
         r += struct.pack("<i", self.nStartingHeight)
         r += struct.pack("<b", self.nRelay)
         return r
 
     def __repr__(self):
         return 'msg_version(nVersion={} nServices={} nTime={} addrTo={} addrFrom={} nNonce=0x{:016X} strSubVer={} nStartingHeight={} nRelay={})'.format(
             self.nVersion, self.nServices, time.ctime(self.nTime),
             repr(self.addrTo), repr(self.addrFrom), self.nNonce,
             self.strSubVer, self.nStartingHeight, self.nRelay)
 
 
 class msg_verack:
     __slots__ = ()
     command = b"verack"
 
     def __init__(self):
         pass
 
     def deserialize(self, f):
         pass
 
     def serialize(self):
         return b""
 
     def __repr__(self):
         return "msg_verack()"
 
 
 class msg_addr:
     __slots__ = ("addrs",)
     command = b"addr"
 
     def __init__(self):
         self.addrs = []
 
     def deserialize(self, f):
         self.addrs = deser_vector(f, CAddress)
 
     def serialize(self):
         return ser_vector(self.addrs)
 
     def __repr__(self):
         return "msg_addr(addrs={})".format(repr(self.addrs))
 
 
 class msg_inv:
     __slots__ = ("inv",)
     command = b"inv"
 
     def __init__(self, inv=None):
         if inv is None:
             self.inv = []
         else:
             self.inv = inv
 
     def deserialize(self, f):
         self.inv = deser_vector(f, CInv)
 
     def serialize(self):
         return ser_vector(self.inv)
 
     def __repr__(self):
         return "msg_inv(inv={})".format(repr(self.inv))
 
 
 class msg_getdata:
     __slots__ = ("inv",)
     command = b"getdata"
 
     def __init__(self, inv=None):
         self.inv = inv if inv != None else []
 
     def deserialize(self, f):
         self.inv = deser_vector(f, CInv)
 
     def serialize(self):
         return ser_vector(self.inv)
 
     def __repr__(self):
         return "msg_getdata(inv={})".format(repr(self.inv))
 
 
 class msg_getblocks:
     __slots__ = ("locator", "hashstop")
     command = b"getblocks"
 
     def __init__(self):
         self.locator = CBlockLocator()
         self.hashstop = 0
 
     def deserialize(self, f):
         self.locator = CBlockLocator()
         self.locator.deserialize(f)
         self.hashstop = deser_uint256(f)
 
     def serialize(self):
         r = b""
         r += self.locator.serialize()
         r += ser_uint256(self.hashstop)
         return r
 
     def __repr__(self):
         return "msg_getblocks(locator={} hashstop={:064x})".format(
             repr(self.locator), self.hashstop)
 
 
 class msg_tx:
     __slots__ = ("tx",)
     command = b"tx"
 
     def __init__(self, tx=CTransaction()):
         self.tx = tx
 
     def deserialize(self, f):
         self.tx.deserialize(f)
 
     def serialize(self):
         return self.tx.serialize()
 
     def __repr__(self):
         return "msg_tx(tx={})".format(repr(self.tx))
 
 
 class msg_block:
     __slots__ = ("block",)
     command = b"block"
 
     def __init__(self, block=None):
         if block is None:
             self.block = CBlock()
         else:
             self.block = block
 
     def deserialize(self, f):
         self.block.deserialize(f)
 
     def serialize(self):
         return self.block.serialize()
 
     def __repr__(self):
         return "msg_block(block={})".format(repr(self.block))
 
 
 # for cases where a user needs tighter control over what is sent over the wire
 # note that the user must supply the name of the command, and the data
 
 
 class msg_generic:
     __slots__ = ("command", "data")
 
     def __init__(self, command, data=None):
         self.command = command
         self.data = data
 
     def serialize(self):
         return self.data
 
     def __repr__(self):
         return "msg_generic()"
 
 
 class msg_getaddr:
     __slots__ = ()
     command = b"getaddr"
 
     def __init__(self):
         pass
 
     def deserialize(self, f):
         pass
 
     def serialize(self):
         return b""
 
     def __repr__(self):
         return "msg_getaddr()"
 
 
 class msg_ping:
     __slots__ = ("nonce",)
     command = b"ping"
 
     def __init__(self, nonce=0):
         self.nonce = nonce
 
     def deserialize(self, f):
         self.nonce = struct.unpack("<Q", f.read(8))[0]
 
     def serialize(self):
         r = b""
         r += struct.pack("<Q", self.nonce)
         return r
 
     def __repr__(self):
         return "msg_ping(nonce={:08x})".format(self.nonce)
 
 
 class msg_pong:
     __slots__ = ("nonce",)
     command = b"pong"
 
     def __init__(self, nonce=0):
         self.nonce = nonce
 
     def deserialize(self, f):
         self.nonce = struct.unpack("<Q", f.read(8))[0]
 
     def serialize(self):
         r = b""
         r += struct.pack("<Q", self.nonce)
         return r
 
     def __repr__(self):
         return "msg_pong(nonce={:08x})".format(self.nonce)
 
 
 class msg_mempool:
     __slots__ = ()
     command = b"mempool"
 
     def __init__(self):
         pass
 
     def deserialize(self, f):
         pass
 
     def serialize(self):
         return b""
 
     def __repr__(self):
         return "msg_mempool()"
 
 
 class msg_notfound:
     __slots__ = ("vec", )
     command = b"notfound"
 
     def __init__(self, vec=None):
         self.vec = vec or []
 
     def deserialize(self, f):
         self.vec = deser_vector(f, CInv)
 
     def serialize(self):
         return ser_vector(self.vec)
 
     def __repr__(self):
         return "msg_notfound(vec={})".format(repr(self.vec))
 
 
 class msg_sendheaders:
     __slots__ = ()
     command = b"sendheaders"
 
     def __init__(self):
         pass
 
     def deserialize(self, f):
         pass
 
     def serialize(self):
         return b""
 
     def __repr__(self):
         return "msg_sendheaders()"
 
 
 # getheaders message has
 # number of entries
 # vector of hashes
 # hash_stop (hash of last desired block header, 0 to get as many as possible)
 class msg_getheaders:
     __slots__ = ("hashstop", "locator",)
     command = b"getheaders"
 
     def __init__(self):
         self.locator = CBlockLocator()
         self.hashstop = 0
 
     def deserialize(self, f):
         self.locator = CBlockLocator()
         self.locator.deserialize(f)
         self.hashstop = deser_uint256(f)
 
     def serialize(self):
         r = b""
         r += self.locator.serialize()
         r += ser_uint256(self.hashstop)
         return r
 
     def __repr__(self):
         return "msg_getheaders(locator={}, stop={:064x})".format(
             repr(self.locator), self.hashstop)
 
 
 # headers message has
 # <count> <vector of block headers>
 class msg_headers:
     __slots__ = ("headers",)
     command = b"headers"
 
     def __init__(self, headers=None):
         self.headers = headers if headers is not None else []
 
     def deserialize(self, f):
         # comment in bitcoind indicates these should be deserialized as blocks
         blocks = deser_vector(f, CBlock)
         for x in blocks:
             self.headers.append(CBlockHeader(x))
 
     def serialize(self):
         blocks = [CBlock(x) for x in self.headers]
         return ser_vector(blocks)
 
     def __repr__(self):
         return "msg_headers(headers={})".format(repr(self.headers))
 
 
 class msg_reject:
     __slots__ = ("code", "data", "message", "reason")
     command = b"reject"
     REJECT_MALFORMED = 1
 
     def __init__(self):
         self.message = b""
         self.code = 0
         self.reason = b""
         self.data = 0
 
     def deserialize(self, f):
         self.message = deser_string(f)
         self.code = struct.unpack("<B", f.read(1))[0]
         self.reason = deser_string(f)
         if (self.code != self.REJECT_MALFORMED and
                 (self.message == b"block" or self.message == b"tx")):
             self.data = deser_uint256(f)
 
     def serialize(self):
         r = ser_string(self.message)
         r += struct.pack("<B", self.code)
         r += ser_string(self.reason)
         if (self.code != self.REJECT_MALFORMED and
                 (self.message == b"block" or self.message == b"tx")):
             r += ser_uint256(self.data)
         return r
 
     def __repr__(self):
         return "msg_reject: {} {} {} [{:064x}]".format(
             self.message, self.code, self.reason, self.data)
 
 
 class msg_feefilter:
     __slots__ = ("feerate",)
     command = b"feefilter"
 
     def __init__(self, feerate=0):
         self.feerate = feerate
 
     def deserialize(self, f):
         self.feerate = struct.unpack("<Q", f.read(8))[0]
 
     def serialize(self):
         r = b""
         r += struct.pack("<Q", self.feerate)
         return r
 
     def __repr__(self):
         return "msg_feefilter(feerate={:08x})".format(self.feerate)
 
 
 class msg_sendcmpct:
     __slots__ = ("announce", "version")
     command = b"sendcmpct"
 
     def __init__(self):
         self.announce = False
         self.version = 1
 
     def deserialize(self, f):
         self.announce = struct.unpack("<?", f.read(1))[0]
         self.version = struct.unpack("<Q", f.read(8))[0]
 
     def serialize(self):
         r = b""
         r += struct.pack("<?", self.announce)
         r += struct.pack("<Q", self.version)
         return r
 
     def __repr__(self):
         return "msg_sendcmpct(announce={}, version={})".format(
             self.announce, self.version)
 
 
 class msg_cmpctblock:
     __slots__ = ("header_and_shortids",)
     command = b"cmpctblock"
 
     def __init__(self, header_and_shortids=None):
         self.header_and_shortids = header_and_shortids
 
     def deserialize(self, f):
         self.header_and_shortids = P2PHeaderAndShortIDs()
         self.header_and_shortids.deserialize(f)
 
     def serialize(self):
         r = b""
         r += self.header_and_shortids.serialize()
         return r
 
     def __repr__(self):
         return "msg_cmpctblock(HeaderAndShortIDs={})".format(
             repr(self.header_and_shortids))
 
 
 class msg_getblocktxn:
     __slots__ = ("block_txn_request",)
     command = b"getblocktxn"
 
     def __init__(self):
         self.block_txn_request = None
 
     def deserialize(self, f):
         self.block_txn_request = BlockTransactionsRequest()
         self.block_txn_request.deserialize(f)
 
     def serialize(self):
         r = b""
         r += self.block_txn_request.serialize()
         return r
 
     def __repr__(self):
         return "msg_getblocktxn(block_txn_request={})".format(
             repr(self.block_txn_request))
 
 
 class msg_blocktxn:
     __slots__ = ("block_transactions",)
     command = b"blocktxn"
 
     def __init__(self):
         self.block_transactions = BlockTransactions()
 
     def deserialize(self, f):
         self.block_transactions.deserialize(f)
 
     def serialize(self):
         r = b""
         r += self.block_transactions.serialize()
         return r
 
     def __repr__(self):
         return "msg_blocktxn(block_transactions={})".format(
             repr(self.block_transactions))
diff --git a/test/functional/test_framework/netutil.py b/test/functional/test_framework/netutil.py
index 6343eac3b3..ab55db102a 100644
--- a/test/functional/test_framework/netutil.py
+++ b/test/functional/test_framework/netutil.py
@@ -1,168 +1,168 @@
 #!/usr/bin/env python3
 # Copyright (c) 2014-2016 The Bitcoin Core developers
 # Distributed under the MIT software license, see the accompanying
 # file COPYING or http://www.opensource.org/licenses/mit-license.php.
 """Linux network utilities.
 
 Roughly based on http://voorloopnul.com/blog/a-python-netstat-in-less-than-100-lines-of-code/ by Ricardo Pascal
 """
 
 import array
-from binascii import unhexlify, hexlify
+from binascii import unhexlify
 import fcntl
 import os
 import socket
 import struct
 import sys
 
 # STATE_ESTABLISHED = '01'
 # STATE_SYN_SENT = '02'
 # STATE_SYN_RECV = '03'
 # STATE_FIN_WAIT1 = '04'
 # STATE_FIN_WAIT2 = '05'
 # STATE_TIME_WAIT = '06'
 # STATE_CLOSE = '07'
 # STATE_CLOSE_WAIT = '08'
 # STATE_LAST_ACK = '09'
 STATE_LISTEN = '0A'
 # STATE_CLOSING = '0B'
 
 
 def get_socket_inodes(pid):
     '''
     Get list of socket inodes for process pid.
     '''
     base = '/proc/{}/fd'.format(pid)
     inodes = []
     for item in os.listdir(base):
         target = os.readlink(os.path.join(base, item))
         if target.startswith('socket:'):
             inodes.append(int(target[8:-1]))
     return inodes
 
 
 def _remove_empty(array):
     return [x for x in array if x != '']
 
 
 def _convert_ip_port(array):
     host, port = array.split(':')
     # convert host from mangled-per-four-bytes form as used by kernel
     host = unhexlify(host)
     host_out = ''
     for x in range(0, len(host) // 4):
         (val,) = struct.unpack('=I', host[x * 4:(x + 1) * 4])
         host_out += '{:08x}'.format(val)
 
     return host_out, int(port, 16)
 
 
 def netstat(typ='tcp'):
     '''
     Function to return a list with status of tcp connections at linux systems
     To get pid of all network process running on system, you must run this script
     as superuser
     '''
     with open('/proc/net/' + typ, 'r', encoding='utf8') as f:
         content = f.readlines()
         content.pop(0)
     result = []
     for line in content:
         # Split lines and remove empty spaces.
         line_array = _remove_empty(line.split(' '))
         tcp_id = line_array[0]
         l_addr = _convert_ip_port(line_array[1])
         r_addr = _convert_ip_port(line_array[2])
         state = line_array[3]
         # Need the inode to match with process pid.
         inode = int(line_array[9])
         nline = [tcp_id, l_addr, r_addr, state, inode]
         result.append(nline)
     return result
 
 
 def get_bind_addrs(pid):
     '''
     Get bind addresses as (host,port) tuples for process pid.
     '''
     inodes = get_socket_inodes(pid)
     bind_addrs = []
     for conn in netstat('tcp') + netstat('tcp6'):
         if conn[3] == STATE_LISTEN and conn[4] in inodes:
             bind_addrs.append(conn[1])
     return bind_addrs
 
 # from: http://code.activestate.com/recipes/439093/
 
 
 def all_interfaces():
     '''
     Return all interfaces that are up
     '''
     is_64bits = sys.maxsize > 2**32
     struct_size = 40 if is_64bits else 32
     s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
     max_possible = 8  # initial value
     while True:
         bytes = max_possible * struct_size
         names = array.array('B', b'\0' * bytes)
         outbytes = struct.unpack('iL', fcntl.ioctl(
             s.fileno(),
             0x8912,  # SIOCGIFCONF
             struct.pack('iL', bytes, names.buffer_info()[0])
         ))[0]
         if outbytes == bytes:
             max_possible *= 2
         else:
             break
     namestr = names.tobytes()
     return [(namestr[i:i + 16].split(b'\0', 1)[0],
              socket.inet_ntoa(namestr[i + 20:i + 24]))
             for i in range(0, outbytes, struct_size)]
 
 
 def addr_to_hex(addr):
     '''
     Convert string IPv4 or IPv6 address to binary address as returned by
     get_bind_addrs.
     Very naive implementation that certainly doesn't work for all IPv6 variants.
     '''
     if '.' in addr:  # IPv4
         addr = [int(x) for x in addr.split('.')]
     elif ':' in addr:  # IPv6
         sub = [[], []]  # prefix, suffix
         x = 0
         addr = addr.split(':')
         for i, comp in enumerate(addr):
             if comp == '':
                 # skip empty component at beginning or end
                 if i == 0 or i == (len(addr) - 1):
                     continue
                 x += 1  # :: skips to suffix
                 assert(x < 2)
             else:  # two bytes per component
                 val = int(comp, 16)
                 sub[x].append(val >> 8)
                 sub[x].append(val & 0xff)
         nullbytes = 16 - len(sub[0]) - len(sub[1])
         assert((x == 0 and nullbytes == 0) or (x == 1 and nullbytes > 0))
         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():
     '''
     Check for (local) IPv6 support.
     '''
     import socket
     # By using SOCK_DGRAM this will not actually make a connection, but it will
     # fail if there is no route to IPv6 localhost.
     have_ipv6 = True
     try:
         s = socket.socket(socket.AF_INET6, socket.SOCK_DGRAM)
         s.connect(('::1', 0))
     except socket.error:
         have_ipv6 = False
     return have_ipv6
diff --git a/test/functional/test_framework/script.py b/test/functional/test_framework/script.py
index 65546c2569..c2621b9d48 100644
--- a/test/functional/test_framework/script.py
+++ b/test/functional/test_framework/script.py
@@ -1,725 +1,724 @@
 #!/usr/bin/env python3
 # Copyright (c) 2015-2016 The Bitcoin Core developers
 # Distributed under the MIT software license, see the accompanying
 # file COPYING or http://www.opensource.org/licenses/mit-license.php.
 """Functionality to build scripts, as well as SignatureHash().
 
 This file is modified from python-bitcoinlib.
 """
 
 from .bignum import bn2vch
-from binascii import hexlify
 import hashlib
 import struct
 
 from .messages import (
     CTransaction,
     CTxOut,
     hash256,
     ser_string,
     ser_uint256,
     sha256,
     uint256_from_str,
 )
 
 
 MAX_SCRIPT_ELEMENT_SIZE = 520
 
 OPCODE_NAMES = {}
 
 
 def hash160(s):
     return hashlib.new('ripemd160', sha256(s)).digest()
 
 
 _opcode_instances = []
 
 
 class CScriptOp(int):
     """A single script opcode"""
     __slots__ = ()
 
     @staticmethod
     def encode_op_pushdata(d):
         """Encode a PUSHDATA op, returning bytes"""
         if len(d) < 0x4c:
             # OP_PUSHDATA
             return b'' + bytes([len(d)]) + d
         elif len(d) <= 0xff:
             # OP_PUSHDATA1
             return b'\x4c' + bytes([len(d)]) + d
         elif len(d) <= 0xffff:
             return b'\x4d' + struct.pack(b'<H', len(d)) + d  # OP_PUSHDATA2
         elif len(d) <= 0xffffffff:
             return b'\x4e' + struct.pack(b'<I', len(d)) + d  # OP_PUSHDATA4
         else:
             raise ValueError("Data too long to encode in a PUSHDATA op")
 
     @staticmethod
     def encode_op_n(n):
         """Encode a small integer op, returning an opcode"""
         if not (0 <= n <= 16):
             raise ValueError(
                 'Integer must be in range 0 <= n <= 16, got {}'.format(n))
 
         if n == 0:
             return OP_0
         else:
             return CScriptOp(OP_1 + n - 1)
 
     def decode_op_n(self):
         """Decode a small integer opcode, returning an integer"""
         if self == OP_0:
             return 0
 
         if not (self == OP_0 or OP_1 <= self <= OP_16):
             raise ValueError('op {!r} is not an OP_N'.format(self))
 
         return int(self - OP_1 + 1)
 
     def is_small_int(self):
         """Return true if the op pushes a small integer to the stack"""
         if 0x51 <= self <= 0x60 or self == 0:
             return True
         else:
             return False
 
     def __str__(self):
         return repr(self)
 
     def __repr__(self):
         if self in OPCODE_NAMES:
             return OPCODE_NAMES[self]
         else:
             return 'CScriptOp(0x{:x})'.format(self)
 
     def __new__(cls, n):
         try:
             return _opcode_instances[n]
         except IndexError:
             assert len(_opcode_instances) == n
             _opcode_instances.append(super(CScriptOp, cls).__new__(cls, n))
             return _opcode_instances[n]
 
 
 # Populate opcode instance table
 for n in range(0xff + 1):
     CScriptOp(n)
 
 
 # push value
 OP_0 = CScriptOp(0x00)
 OP_FALSE = OP_0
 OP_PUSHDATA1 = CScriptOp(0x4c)
 OP_PUSHDATA2 = CScriptOp(0x4d)
 OP_PUSHDATA4 = CScriptOp(0x4e)
 OP_1NEGATE = CScriptOp(0x4f)
 OP_RESERVED = CScriptOp(0x50)
 OP_1 = CScriptOp(0x51)
 OP_TRUE = OP_1
 OP_2 = CScriptOp(0x52)
 OP_3 = CScriptOp(0x53)
 OP_4 = CScriptOp(0x54)
 OP_5 = CScriptOp(0x55)
 OP_6 = CScriptOp(0x56)
 OP_7 = CScriptOp(0x57)
 OP_8 = CScriptOp(0x58)
 OP_9 = CScriptOp(0x59)
 OP_10 = CScriptOp(0x5a)
 OP_11 = CScriptOp(0x5b)
 OP_12 = CScriptOp(0x5c)
 OP_13 = CScriptOp(0x5d)
 OP_14 = CScriptOp(0x5e)
 OP_15 = CScriptOp(0x5f)
 OP_16 = CScriptOp(0x60)
 
 # control
 OP_NOP = CScriptOp(0x61)
 OP_VER = CScriptOp(0x62)
 OP_IF = CScriptOp(0x63)
 OP_NOTIF = CScriptOp(0x64)
 OP_VERIF = CScriptOp(0x65)
 OP_VERNOTIF = CScriptOp(0x66)
 OP_ELSE = CScriptOp(0x67)
 OP_ENDIF = CScriptOp(0x68)
 OP_VERIFY = CScriptOp(0x69)
 OP_RETURN = CScriptOp(0x6a)
 
 # stack ops
 OP_TOALTSTACK = CScriptOp(0x6b)
 OP_FROMALTSTACK = CScriptOp(0x6c)
 OP_2DROP = CScriptOp(0x6d)
 OP_2DUP = CScriptOp(0x6e)
 OP_3DUP = CScriptOp(0x6f)
 OP_2OVER = CScriptOp(0x70)
 OP_2ROT = CScriptOp(0x71)
 OP_2SWAP = CScriptOp(0x72)
 OP_IFDUP = CScriptOp(0x73)
 OP_DEPTH = CScriptOp(0x74)
 OP_DROP = CScriptOp(0x75)
 OP_DUP = CScriptOp(0x76)
 OP_NIP = CScriptOp(0x77)
 OP_OVER = CScriptOp(0x78)
 OP_PICK = CScriptOp(0x79)
 OP_ROLL = CScriptOp(0x7a)
 OP_ROT = CScriptOp(0x7b)
 OP_SWAP = CScriptOp(0x7c)
 OP_TUCK = CScriptOp(0x7d)
 
 # splice ops
 OP_CAT = CScriptOp(0x7e)
 OP_SPLIT = CScriptOp(0x7f)
 OP_NUM2BIN = CScriptOp(0x80)
 OP_BIN2NUM = CScriptOp(0x81)
 OP_SIZE = CScriptOp(0x82)
 
 # bit logic
 OP_INVERT = CScriptOp(0x83)
 OP_AND = CScriptOp(0x84)
 OP_OR = CScriptOp(0x85)
 OP_XOR = CScriptOp(0x86)
 OP_EQUAL = CScriptOp(0x87)
 OP_EQUALVERIFY = CScriptOp(0x88)
 OP_RESERVED1 = CScriptOp(0x89)
 OP_RESERVED2 = CScriptOp(0x8a)
 
 # numeric
 OP_1ADD = CScriptOp(0x8b)
 OP_1SUB = CScriptOp(0x8c)
 OP_2MUL = CScriptOp(0x8d)
 OP_2DIV = CScriptOp(0x8e)
 OP_NEGATE = CScriptOp(0x8f)
 OP_ABS = CScriptOp(0x90)
 OP_NOT = CScriptOp(0x91)
 OP_0NOTEQUAL = CScriptOp(0x92)
 
 OP_ADD = CScriptOp(0x93)
 OP_SUB = CScriptOp(0x94)
 OP_MUL = CScriptOp(0x95)
 OP_DIV = CScriptOp(0x96)
 OP_MOD = CScriptOp(0x97)
 OP_LSHIFT = CScriptOp(0x98)
 OP_RSHIFT = CScriptOp(0x99)
 
 OP_BOOLAND = CScriptOp(0x9a)
 OP_BOOLOR = CScriptOp(0x9b)
 OP_NUMEQUAL = CScriptOp(0x9c)
 OP_NUMEQUALVERIFY = CScriptOp(0x9d)
 OP_NUMNOTEQUAL = CScriptOp(0x9e)
 OP_LESSTHAN = CScriptOp(0x9f)
 OP_GREATERTHAN = CScriptOp(0xa0)
 OP_LESSTHANOREQUAL = CScriptOp(0xa1)
 OP_GREATERTHANOREQUAL = CScriptOp(0xa2)
 OP_MIN = CScriptOp(0xa3)
 OP_MAX = CScriptOp(0xa4)
 
 OP_WITHIN = CScriptOp(0xa5)
 
 # crypto
 OP_RIPEMD160 = CScriptOp(0xa6)
 OP_SHA1 = CScriptOp(0xa7)
 OP_SHA256 = CScriptOp(0xa8)
 OP_HASH160 = CScriptOp(0xa9)
 OP_HASH256 = CScriptOp(0xaa)
 OP_CODESEPARATOR = CScriptOp(0xab)
 OP_CHECKSIG = CScriptOp(0xac)
 OP_CHECKSIGVERIFY = CScriptOp(0xad)
 OP_CHECKMULTISIG = CScriptOp(0xae)
 OP_CHECKMULTISIGVERIFY = CScriptOp(0xaf)
 
 # expansion
 OP_NOP1 = CScriptOp(0xb0)
 OP_CHECKLOCKTIMEVERIFY = CScriptOp(0xb1)
 OP_CHECKSEQUENCEVERIFY = CScriptOp(0xb2)
 OP_NOP4 = CScriptOp(0xb3)
 OP_NOP5 = CScriptOp(0xb4)
 OP_NOP6 = CScriptOp(0xb5)
 OP_NOP7 = CScriptOp(0xb6)
 OP_NOP8 = CScriptOp(0xb7)
 OP_NOP9 = CScriptOp(0xb8)
 OP_NOP10 = CScriptOp(0xb9)
 
 # more crypto
 OP_CHECKDATASIG = CScriptOp(0xba)
 OP_CHECKDATASIGVERIFY = CScriptOp(0xbb)
 
 # multi-byte opcodes
 OP_PREFIX_BEGIN = CScriptOp(0xf0)
 OP_PREFIX_END = CScriptOp(0xf7)
 
 # template matching params
 OP_SMALLINTEGER = CScriptOp(0xfa)
 OP_PUBKEYS = CScriptOp(0xfb)
 OP_PUBKEYHASH = CScriptOp(0xfd)
 OP_PUBKEY = CScriptOp(0xfe)
 
 OP_INVALIDOPCODE = CScriptOp(0xff)
 
 OPCODE_NAMES.update({
     OP_0: 'OP_0',
     OP_PUSHDATA1: 'OP_PUSHDATA1',
     OP_PUSHDATA2: 'OP_PUSHDATA2',
     OP_PUSHDATA4: 'OP_PUSHDATA4',
     OP_1NEGATE: 'OP_1NEGATE',
     OP_RESERVED: 'OP_RESERVED',
     OP_1: 'OP_1',
     OP_2: 'OP_2',
     OP_3: 'OP_3',
     OP_4: 'OP_4',
     OP_5: 'OP_5',
     OP_6: 'OP_6',
     OP_7: 'OP_7',
     OP_8: 'OP_8',
     OP_9: 'OP_9',
     OP_10: 'OP_10',
     OP_11: 'OP_11',
     OP_12: 'OP_12',
     OP_13: 'OP_13',
     OP_14: 'OP_14',
     OP_15: 'OP_15',
     OP_16: 'OP_16',
     OP_NOP: 'OP_NOP',
     OP_VER: 'OP_VER',
     OP_IF: 'OP_IF',
     OP_NOTIF: 'OP_NOTIF',
     OP_VERIF: 'OP_VERIF',
     OP_VERNOTIF: 'OP_VERNOTIF',
     OP_ELSE: 'OP_ELSE',
     OP_ENDIF: 'OP_ENDIF',
     OP_VERIFY: 'OP_VERIFY',
     OP_RETURN: 'OP_RETURN',
     OP_TOALTSTACK: 'OP_TOALTSTACK',
     OP_FROMALTSTACK: 'OP_FROMALTSTACK',
     OP_2DROP: 'OP_2DROP',
     OP_2DUP: 'OP_2DUP',
     OP_3DUP: 'OP_3DUP',
     OP_2OVER: 'OP_2OVER',
     OP_2ROT: 'OP_2ROT',
     OP_2SWAP: 'OP_2SWAP',
     OP_IFDUP: 'OP_IFDUP',
     OP_DEPTH: 'OP_DEPTH',
     OP_DROP: 'OP_DROP',
     OP_DUP: 'OP_DUP',
     OP_NIP: 'OP_NIP',
     OP_OVER: 'OP_OVER',
     OP_PICK: 'OP_PICK',
     OP_ROLL: 'OP_ROLL',
     OP_ROT: 'OP_ROT',
     OP_SWAP: 'OP_SWAP',
     OP_TUCK: 'OP_TUCK',
     OP_CAT: 'OP_CAT',
     OP_SPLIT: 'OP_SPLIT',
     OP_NUM2BIN: 'OP_NUM2BIN',
     OP_BIN2NUM: 'OP_BIN2NUM',
     OP_SIZE: 'OP_SIZE',
     OP_INVERT: 'OP_INVERT',
     OP_AND: 'OP_AND',
     OP_OR: 'OP_OR',
     OP_XOR: 'OP_XOR',
     OP_EQUAL: 'OP_EQUAL',
     OP_EQUALVERIFY: 'OP_EQUALVERIFY',
     OP_RESERVED1: 'OP_RESERVED1',
     OP_RESERVED2: 'OP_RESERVED2',
     OP_1ADD: 'OP_1ADD',
     OP_1SUB: 'OP_1SUB',
     OP_2MUL: 'OP_2MUL',
     OP_2DIV: 'OP_2DIV',
     OP_NEGATE: 'OP_NEGATE',
     OP_ABS: 'OP_ABS',
     OP_NOT: 'OP_NOT',
     OP_0NOTEQUAL: 'OP_0NOTEQUAL',
     OP_ADD: 'OP_ADD',
     OP_SUB: 'OP_SUB',
     OP_MUL: 'OP_MUL',
     OP_DIV: 'OP_DIV',
     OP_MOD: 'OP_MOD',
     OP_LSHIFT: 'OP_LSHIFT',
     OP_RSHIFT: 'OP_RSHIFT',
     OP_BOOLAND: 'OP_BOOLAND',
     OP_BOOLOR: 'OP_BOOLOR',
     OP_NUMEQUAL: 'OP_NUMEQUAL',
     OP_NUMEQUALVERIFY: 'OP_NUMEQUALVERIFY',
     OP_NUMNOTEQUAL: 'OP_NUMNOTEQUAL',
     OP_LESSTHAN: 'OP_LESSTHAN',
     OP_GREATERTHAN: 'OP_GREATERTHAN',
     OP_LESSTHANOREQUAL: 'OP_LESSTHANOREQUAL',
     OP_GREATERTHANOREQUAL: 'OP_GREATERTHANOREQUAL',
     OP_MIN: 'OP_MIN',
     OP_MAX: 'OP_MAX',
     OP_WITHIN: 'OP_WITHIN',
     OP_RIPEMD160: 'OP_RIPEMD160',
     OP_SHA1: 'OP_SHA1',
     OP_SHA256: 'OP_SHA256',
     OP_HASH160: 'OP_HASH160',
     OP_HASH256: 'OP_HASH256',
     OP_CODESEPARATOR: 'OP_CODESEPARATOR',
     OP_CHECKSIG: 'OP_CHECKSIG',
     OP_CHECKSIGVERIFY: 'OP_CHECKSIGVERIFY',
     OP_CHECKMULTISIG: 'OP_CHECKMULTISIG',
     OP_CHECKMULTISIGVERIFY: 'OP_CHECKMULTISIGVERIFY',
     OP_CHECKDATASIG: 'OP_CHECKDATASIG',
     OP_CHECKDATASIGVERIFY: 'OP_CHECKDATASIGVERIFY',
     OP_NOP1: 'OP_NOP1',
     OP_CHECKLOCKTIMEVERIFY: 'OP_CHECKLOCKTIMEVERIFY',
     OP_CHECKSEQUENCEVERIFY: 'OP_CHECKSEQUENCEVERIFY',
     OP_NOP4: 'OP_NOP4',
     OP_NOP5: 'OP_NOP5',
     OP_NOP6: 'OP_NOP6',
     OP_NOP7: 'OP_NOP7',
     OP_NOP8: 'OP_NOP8',
     OP_NOP9: 'OP_NOP9',
     OP_NOP10: 'OP_NOP10',
     OP_SMALLINTEGER: 'OP_SMALLINTEGER',
     OP_PUBKEYS: 'OP_PUBKEYS',
     OP_PUBKEYHASH: 'OP_PUBKEYHASH',
     OP_PUBKEY: 'OP_PUBKEY',
     OP_INVALIDOPCODE: 'OP_INVALIDOPCODE',
 })
 
 
 class CScriptInvalidError(Exception):
     """Base class for CScript exceptions"""
     pass
 
 
 class CScriptTruncatedPushDataError(CScriptInvalidError):
     """Invalid pushdata due to truncation"""
 
     def __init__(self, msg, data):
         self.data = data
         super(CScriptTruncatedPushDataError, self).__init__(msg)
 
 
 # This is used, eg, for blockchain heights in coinbase scripts (bip34)
 class CScriptNum:
     __slots__ = ("value",)
 
     def __init__(self, d=0):
         self.value = d
 
     @staticmethod
     def encode(obj):
         r = bytearray(0)
         if obj.value == 0:
             return bytes(r)
         neg = obj.value < 0
         absvalue = -obj.value if neg else obj.value
         while (absvalue):
             r.append(absvalue & 0xff)
             absvalue >>= 8
         if r[-1] & 0x80:
             r.append(0x80 if neg else 0)
         elif neg:
             r[-1] |= 0x80
         return bytes([len(r)]) + r
 
 
 class CScript(bytes):
     """Serialized script
 
     A bytes subclass, so you can use this directly whenever bytes are accepted.
     Note that this means that indexing does *not* work - you'll get an index by
     byte rather than opcode. This format was chosen for efficiency so that the
     general case would not require creating a lot of little CScriptOP objects.
 
     iter(script) however does iterate by opcode.
     """
     __slots__ = ()
 
     @classmethod
     def __coerce_instance(cls, other):
         # Coerce other into bytes
         if isinstance(other, CScriptOp):
             other = bytes([other])
         elif isinstance(other, CScriptNum):
             if (other.value == 0):
                 other = bytes([CScriptOp(OP_0)])
             else:
                 other = CScriptNum.encode(other)
         elif isinstance(other, int):
             if 0 <= other <= 16:
                 other = bytes([CScriptOp.encode_op_n(other)])
             elif other == -1:
                 other = bytes([OP_1NEGATE])
             else:
                 other = CScriptOp.encode_op_pushdata(bn2vch(other))
         elif isinstance(other, (bytes, bytearray)):
             other = CScriptOp.encode_op_pushdata(other)
         return other
 
     def __add__(self, other):
         # Do the coercion outside of the try block so that errors in it are
         # noticed.
         other = self.__coerce_instance(other)
 
         try:
             # bytes.__add__ always returns bytes instances unfortunately
             return CScript(super(CScript, self).__add__(other))
         except TypeError:
             raise TypeError(
                 'Can not add a {!r} instance to a CScript'.format(other.__class__))
 
     def join(self, iterable):
         # join makes no sense for a CScript()
         raise NotImplementedError
 
     def __new__(cls, value=b''):
         if isinstance(value, bytes) or isinstance(value, bytearray):
             return super(CScript, cls).__new__(cls, value)
         else:
             def coerce_iterable(iterable):
                 for instance in iterable:
                     yield cls.__coerce_instance(instance)
             # Annoyingly on both python2 and python3 bytes.join() always
             # returns a bytes instance even when subclassed.
             return super(CScript, cls).__new__(cls, b''.join(coerce_iterable(value)))
 
     def raw_iter(self):
         """Raw iteration
 
         Yields tuples of (opcode, data, sop_idx) so that the different possible
         PUSHDATA encodings can be accurately distinguished, as well as
         determining the exact opcode byte indexes. (sop_idx)
         """
         i = 0
         while i < len(self):
             sop_idx = i
             opcode = self[i]
             i += 1
 
             if opcode > OP_PUSHDATA4:
                 yield (opcode, None, sop_idx)
             else:
                 datasize = None
                 pushdata_type = None
                 if opcode < OP_PUSHDATA1:
                     pushdata_type = 'PUSHDATA({})'.format(opcode)
                     datasize = opcode
 
                 elif opcode == OP_PUSHDATA1:
                     pushdata_type = 'PUSHDATA1'
                     if i >= len(self):
                         raise CScriptInvalidError(
                             'PUSHDATA1: missing data length')
                     datasize = self[i]
                     i += 1
 
                 elif opcode == OP_PUSHDATA2:
                     pushdata_type = 'PUSHDATA2'
                     if i + 1 >= len(self):
                         raise CScriptInvalidError(
                             'PUSHDATA2: missing data length')
                     datasize = self[i] + (self[i + 1] << 8)
                     i += 2
 
                 elif opcode == OP_PUSHDATA4:
                     pushdata_type = 'PUSHDATA4'
                     if i + 3 >= len(self):
                         raise CScriptInvalidError(
                             'PUSHDATA4: missing data length')
                     datasize = self[i] + (self[i + 1] << 8) + \
                         (self[i + 2] << 16) + (self[i + 3] << 24)
                     i += 4
 
                 else:
                     assert False  # shouldn't happen
 
                 data = bytes(self[i:i + datasize])
 
                 # Check for truncation
                 if len(data) < datasize:
                     raise CScriptTruncatedPushDataError(
                         '{}: truncated data'.format(pushdata_type, data))
 
                 i += datasize
 
                 yield (opcode, data, sop_idx)
 
     def __iter__(self):
         """'Cooked' iteration
 
         Returns either a CScriptOP instance, an integer, or bytes, as
         appropriate.
 
         See raw_iter() if you need to distinguish the different possible
         PUSHDATA encodings.
         """
         for (opcode, data, sop_idx) in self.raw_iter():
             if data is not None:
                 yield data
             else:
                 opcode = CScriptOp(opcode)
 
                 if opcode.is_small_int():
                     yield opcode.decode_op_n()
                 else:
                     yield CScriptOp(opcode)
 
     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)
 
         ops = []
         i = iter(self)
         while True:
             op = None
             try:
                 op = _repr(next(i))
             except CScriptTruncatedPushDataError as err:
                 op = '{}...<ERROR: {}>'.format(_repr(err.data), err)
                 break
             except CScriptInvalidError as err:
                 op = '<ERROR: {}>'.format(err)
                 break
             except StopIteration:
                 break
             finally:
                 if op is not None:
                     ops.append(op)
 
         return "CScript([{}])".format(', '.join(ops))
 
     def GetSigOpCount(self, fAccurate):
         """Get the SigOp count.
 
         fAccurate - Accurately count CHECKMULTISIG, see BIP16 for details.
 
         Note that this is consensus-critical.
         """
         n = 0
         lastOpcode = OP_INVALIDOPCODE
         for (opcode, data, sop_idx) in self.raw_iter():
             if opcode in (OP_CHECKSIG, OP_CHECKSIGVERIFY):
                 n += 1
             elif opcode in (OP_CHECKMULTISIG, OP_CHECKMULTISIGVERIFY):
                 if fAccurate and (OP_1 <= lastOpcode <= OP_16):
                     n += opcode.decode_op_n()
                 else:
                     n += 20
             lastOpcode = opcode
         return n
 
 
 SIGHASH_ALL = 1
 SIGHASH_NONE = 2
 SIGHASH_SINGLE = 3
 SIGHASH_FORKID = 0x40
 SIGHASH_ANYONECANPAY = 0x80
 
 
 def FindAndDelete(script, sig):
     """Consensus critical, see FindAndDelete() in Satoshi codebase"""
     r = b''
     last_sop_idx = sop_idx = 0
     skip = True
     for (opcode, data, sop_idx) in script.raw_iter():
         if not skip:
             r += script[last_sop_idx:sop_idx]
         last_sop_idx = sop_idx
         if script[sop_idx:sop_idx + len(sig)] == sig:
             skip = True
         else:
             skip = False
     if not skip:
         r += script[last_sop_idx:]
     return CScript(r)
 
 
 def SignatureHash(script, txTo, inIdx, hashtype):
     """Consensus-correct SignatureHash
 
     Returns (hash, err) to precisely match the consensus-critical behavior of
     the SIGHASH_SINGLE bug. (inIdx is *not* checked for validity)
     """
     HASH_ONE = b'\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
 
     if inIdx >= len(txTo.vin):
         return (HASH_ONE, "inIdx {} out of range ({})".format(inIdx, len(txTo.vin)))
     txtmp = CTransaction(txTo)
 
     for txin in txtmp.vin:
         txin.scriptSig = b''
     txtmp.vin[inIdx].scriptSig = FindAndDelete(
         script, CScript([OP_CODESEPARATOR]))
 
     if (hashtype & 0x1f) == SIGHASH_NONE:
         txtmp.vout = []
 
         for i in range(len(txtmp.vin)):
             if i != inIdx:
                 txtmp.vin[i].nSequence = 0
 
     elif (hashtype & 0x1f) == SIGHASH_SINGLE:
         outIdx = inIdx
         if outIdx >= len(txtmp.vout):
             return (HASH_ONE, "outIdx {} out of range ({})".format(outIdx, len(txtmp.vout)))
 
         tmp = txtmp.vout[outIdx]
         txtmp.vout = []
         for i in range(outIdx):
             txtmp.vout.append(CTxOut(-1))
         txtmp.vout.append(tmp)
 
         for i in range(len(txtmp.vin)):
             if i != inIdx:
                 txtmp.vin[i].nSequence = 0
 
     if hashtype & SIGHASH_ANYONECANPAY:
         tmp = txtmp.vin[inIdx]
         txtmp.vin = []
         txtmp.vin.append(tmp)
 
     s = txtmp.serialize()
     s += struct.pack(b"<I", hashtype)
 
     hash = hash256(s)
 
     return (hash, None)
 
 # TODO: Allow cached hashPrevouts/hashSequence/hashOutputs to be provided.
 # Performance optimization probably not necessary for python tests, however.
 
 
 def SignatureHashForkId(script, txTo, inIdx, hashtype, amount):
 
     hashPrevouts = 0
     hashSequence = 0
     hashOutputs = 0
 
     if not (hashtype & SIGHASH_ANYONECANPAY):
         serialize_prevouts = bytes()
         for i in txTo.vin:
             serialize_prevouts += i.prevout.serialize()
         hashPrevouts = uint256_from_str(hash256(serialize_prevouts))
 
     if (not (hashtype & SIGHASH_ANYONECANPAY) and (hashtype & 0x1f) != SIGHASH_SINGLE and (hashtype & 0x1f) != SIGHASH_NONE):
         serialize_sequence = bytes()
         for i in txTo.vin:
             serialize_sequence += struct.pack("<I", i.nSequence)
         hashSequence = uint256_from_str(hash256(serialize_sequence))
 
     if ((hashtype & 0x1f) != SIGHASH_SINGLE and (hashtype & 0x1f) != SIGHASH_NONE):
         serialize_outputs = bytes()
         for o in txTo.vout:
             serialize_outputs += o.serialize()
         hashOutputs = uint256_from_str(hash256(serialize_outputs))
     elif ((hashtype & 0x1f) == SIGHASH_SINGLE and inIdx < len(txTo.vout)):
         serialize_outputs = txTo.vout[inIdx].serialize()
         hashOutputs = uint256_from_str(hash256(serialize_outputs))
 
     ss = bytes()
     ss += struct.pack("<i", txTo.nVersion)
     ss += ser_uint256(hashPrevouts)
     ss += ser_uint256(hashSequence)
     ss += txTo.vin[inIdx].prevout.serialize()
     ss += ser_string(script)
     ss += struct.pack("<q", amount)
     ss += struct.pack("<I", txTo.vin[inIdx].nSequence)
     ss += ser_uint256(hashOutputs)
     ss += struct.pack("<i", txTo.nLockTime)
     ss += struct.pack("<I", hashtype)
 
     return hash256(ss)
diff --git a/test/functional/test_framework/util.py b/test/functional/test_framework/util.py
index 0150c3d6fb..9b363a21ad 100644
--- a/test/functional/test_framework/util.py
+++ b/test/functional/test_framework/util.py
@@ -1,648 +1,648 @@
 #!/usr/bin/env python3
 # Copyright (c) 2014-2016 The Bitcoin Core developers
 # Distributed under the MIT software license, see the accompanying
 # file COPYING or http://www.opensource.org/licenses/mit-license.php.
 """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
 import json
 import logging
 import os
 import random
 import re
 from subprocess import CalledProcessError
 import time
 
 from . import coverage
 from .authproxy import AuthServiceProxy, JSONRPCException
 
 logger = logging.getLogger("TestFramework.utils")
 
 # Assert functions
 ##################
 
 
 def assert_fee_amount(fee, tx_size, fee_per_kB, wiggleroom=2):
     """
     Assert the fee was in range
 
     wiggleroom defines an amount that the test expects the wallet to be off by
     when estimating fees.  This can be due to the dummy signature that is added
     during fee calculation, or due to the wallet funding transactions using the
     ceiling of the calculated fee.
     """
     target_fee = round(tx_size * fee_per_kB / 1000, 8)
     if fee < (tx_size - wiggleroom) * fee_per_kB / 1000:
         raise AssertionError(
             "Fee of {} BCH too low! (Should be {} BCH)".format(str(fee), str(target_fee)))
     if fee > (tx_size + wiggleroom) * fee_per_kB / 1000:
         raise AssertionError(
             "Fee of {} BCH too high! (Should be {} BCH)".format(str(fee), str(target_fee)))
 
 
 def assert_equal(thing1, thing2, *args):
     if thing1 != thing2 or any(thing1 != arg for arg in args):
         raise AssertionError("not({})".format(" == ".join(str(arg)
                                                           for arg in (thing1, thing2) + args)))
 
 
 def assert_greater_than(thing1, thing2):
     if thing1 <= thing2:
         raise AssertionError("{} <= {}".format(str(thing1), str(thing2)))
 
 
 def assert_greater_than_or_equal(thing1, thing2):
     if thing1 < thing2:
         raise AssertionError("{} < {}".format(str(thing1), str(thing2)))
 
 
 def assert_raises(exc, fun, *args, **kwds):
     assert_raises_message(exc, None, fun, *args, **kwds)
 
 
 def assert_raises_message(exc, message, fun, *args, **kwds):
     try:
         fun(*args, **kwds)
     except JSONRPCException:
         raise AssertionError(
             "Use assert_raises_rpc_error() to test RPC failures")
     except exc as e:
         if message is not None and message not in e.error['message']:
             raise AssertionError(
                 "Expected substring not found:" + e.error['message'])
     except Exception as e:
         raise AssertionError(
             "Unexpected exception raised: " + type(e).__name__)
     else:
         raise AssertionError("No exception raised")
 
 
 def assert_raises_process_error(returncode, output, fun, *args, **kwds):
     """Execute a process and asserts the process return code and output.
 
     Calls function `fun` with arguments `args` and `kwds`. Catches a CalledProcessError
     and verifies that the return code and output are as expected. Throws AssertionError if
     no CalledProcessError was raised or if the return code and output are not as expected.
 
     Args:
         returncode (int): the process return code.
         output (string): [a substring of] the process output.
         fun (function): the function to call. This should execute a process.
         args*: positional arguments for the function.
         kwds**: named arguments for the function.
     """
     try:
         fun(*args, **kwds)
     except CalledProcessError as e:
         if returncode != e.returncode:
             raise AssertionError(
                 "Unexpected returncode {}".format(e.returncode))
         if output not in e.output:
             raise AssertionError("Expected substring not found:" + e.output)
     else:
         raise AssertionError("No exception raised")
 
 
 def assert_raises_rpc_error(code, message, fun, *args, **kwds):
     """Run an RPC and verify that a specific JSONRPC exception code and message is raised.
 
     Calls function `fun` with arguments `args` and `kwds`. Catches a JSONRPCException
     and verifies that the error code and message are as expected. Throws AssertionError if
     no JSONRPCException was raised or if the error code/message are not as expected.
 
     Args:
         code (int), optional: the error code returned by the RPC call (defined
             in src/rpc/protocol.h). Set to None if checking the error code is not required.
         message (string), optional: [a substring of] the error string returned by the
             RPC call. Set to None if checking the error string is not required.
         fun (function): the function to call. This should be the name of an RPC.
         args*: positional arguments for the function.
         kwds**: named arguments for the function.
     """
     assert try_rpc(code, message, fun, *args, **kwds), "No exception raised"
 
 
 def try_rpc(code, message, fun, *args, **kwds):
     """Tries to run an rpc command.
 
     Test against error code and message if the rpc fails.
     Returns whether a JSONRPCException was raised."""
     try:
         fun(*args, **kwds)
     except JSONRPCException as e:
         # JSONRPCException was thrown as expected. Check the code and message values are correct.
         if (code is not None) and (code != e.error["code"]):
             raise AssertionError(
                 "Unexpected JSONRPC error code {}".format(e.error["code"]))
         if (message is not None) and (message not in e.error['message']):
             raise AssertionError(
                 "Expected substring not found:" + e.error['message'])
         return True
     except Exception as e:
         raise AssertionError(
             "Unexpected exception raised: " + type(e).__name__)
     else:
         return False
 
 
 def assert_is_hex_string(string):
     try:
         int(string, 16)
     except Exception as e:
         raise AssertionError(
             "Couldn't interpret {!r} as hexadecimal; raised: {}".format(string, e))
 
 
 def assert_is_hash_string(string, length=64):
     if not isinstance(string, str):
         raise AssertionError(
             "Expected a string, got type {!r}".format(type(string)))
     elif length and len(string) != length:
         raise AssertionError(
             "String of length {} expected; got {}".format(length, len(string)))
     elif not re.match('[abcdef0-9]+$', string):
         raise AssertionError(
             "String {!r} contains invalid characters for a hash.".format(string))
 
 
 def assert_array_result(object_array, to_match, expected, should_not_find=False):
     """
     Pass in array of JSON objects, a dictionary with key/value pairs
     to match against, and another dictionary with expected key/value
     pairs.
     If the should_not_find flag is true, to_match should not be found
     in object_array
     """
     if should_not_find:
         assert_equal(expected, {})
     num_matched = 0
     for item in object_array:
         all_match = True
         for key, value in to_match.items():
             if item[key] != value:
                 all_match = False
         if not all_match:
             continue
         elif should_not_find:
             num_matched = num_matched + 1
         for key, value in expected.items():
             if item[key] != value:
                 raise AssertionError("{} : expected {}={}".format(
                     str(item), str(key), str(value)))
             num_matched = num_matched + 1
     if num_matched == 0 and not should_not_find:
         raise AssertionError("No objects matched {}".format(str(to_match)))
     if num_matched > 0 and should_not_find:
         raise AssertionError("Objects were found {}".format(str(to_match)))
 
 # Utility functions
 ###################
 
 
 def check_json_precision():
     """Make sure json library being used does not lose precision converting BCH values"""
     n = Decimal("20000000.00000003")
     satoshis = int(json.loads(json.dumps(float(n))) * 1.0e8)
     if satoshis != 2000000000000003:
         raise RuntimeError("JSON encode/decode loses precision")
 
 
 def count_bytes(hex_string):
     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):
     sha256 = hashlib.sha256()
     sha256.update(byte_str)
     sha256d = hashlib.sha256()
     sha256d.update(sha256.digest())
     return sha256d.digest()[::-1]
 
 
 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')
 
 
 def satoshi_round(amount):
     return Decimal(amount).quantize(Decimal('0.00000001'), rounding=ROUND_DOWN)
 
 
 def wait_until(predicate, *, attempts=float('inf'), timeout=float('inf'), lock=None):
     if attempts == float('inf') and timeout == float('inf'):
         timeout = 60
     attempt = 0
     time_end = time.time() + timeout
 
     while attempt < attempts and time.time() < time_end:
         if lock:
             with lock:
                 if predicate():
                     return
         else:
             if predicate():
                 return
         attempt += 1
         time.sleep(0.05)
 
     # Print the cause of the timeout
     predicate_source = inspect.getsourcelines(predicate)
     logger.error("wait_until() failed. Predicate: {}".format(predicate_source))
     if attempt >= attempts:
         raise AssertionError("Predicate {} not true after {} attempts".format(
             predicate_source, attempts))
     elif time.time() >= time_end:
         raise AssertionError(
             "Predicate {} not true after {} seconds".format(predicate_source, timeout))
     raise RuntimeError('Unreachable')
 
 # RPC/P2P connection constants and functions
 ############################################
 
 
 # The maximum number of nodes a single test can spawn
 MAX_NODES = 8
 # Don't assign rpc or p2p ports lower than this
 PORT_MIN = 11000
 # The number of ports to "reserve" for p2p and rpc, each
 PORT_RANGE = 5000
 
 
 class PortSeed:
     # Must be initialized with a unique integer for each process
     n = None
 
 
 def get_rpc_proxy(url, node_number, timeout=None, coveragedir=None):
     """
     Args:
         url (str): URL of the RPC server to call
         node_number (int): the node number (or id) that this calls to
 
     Kwargs:
         timeout (int): HTTP timeout in seconds
 
     Returns:
         AuthServiceProxy. convenience object for making RPC calls.
 
     """
     proxy_kwargs = {}
     if timeout is not None:
         proxy_kwargs['timeout'] = timeout
 
     proxy = AuthServiceProxy(url, **proxy_kwargs)
     proxy.url = url  # store URL on proxy for info
 
     coverage_logfile = coverage.get_filename(
         coveragedir, node_number) if coveragedir else None
 
     return coverage.AuthServiceProxyWrapper(proxy, coverage_logfile)
 
 
 def p2p_port(n):
     assert(n <= MAX_NODES)
     return PORT_MIN + n + (MAX_NODES * PortSeed.n) % (PORT_RANGE - 1 - MAX_NODES)
 
 
 def rpc_port(n):
     return PORT_MIN + PORT_RANGE + n + (MAX_NODES * PortSeed.n) % (PORT_RANGE - 1 - MAX_NODES)
 
 
 def rpc_url(datadir, host, port):
     rpc_u, rpc_p = get_auth_cookie(datadir)
     if host == None:
         host = '127.0.0.1'
     return "http://{}:{}@{}:{}".format(rpc_u, rpc_p, host, int(port))
 
 # Node functions
 ################
 
 
 def initialize_datadir(dirname, n):
     datadir = get_datadir_path(dirname, n)
     if not os.path.isdir(datadir):
         os.makedirs(datadir)
     with open(os.path.join(datadir, "bitcoin.conf"), 'w', encoding='utf8') as f:
         f.write("regtest=1\n")
         f.write("[regtest]\n")
         f.write("port=" + str(p2p_port(n)) + "\n")
         f.write("rpcport=" + str(rpc_port(n)) + "\n")
         f.write("server=1\n")
         f.write("keypool=1\n")
         f.write("discover=0\n")
         f.write("listenonion=0\n")
         f.write("usecashaddr=1\n")
         os.makedirs(os.path.join(datadir, 'stderr'), exist_ok=True)
         os.makedirs(os.path.join(datadir, 'stdout'), exist_ok=True)
     return datadir
 
 
 def get_datadir_path(dirname, n):
     return os.path.join(dirname, "node" + str(n))
 
 
 def append_config(datadir, options):
     with open(os.path.join(datadir, "bitcoin.conf"), 'a', encoding='utf8') as f:
         for option in options:
             f.write(option + "\n")
 
 
 def get_auth_cookie(datadir):
     user = None
     password = None
     if os.path.isfile(os.path.join(datadir, "bitcoin.conf")):
         with open(os.path.join(datadir, "bitcoin.conf"), 'r', encoding='utf8') as f:
             for line in f:
                 if line.startswith("rpcuser="):
                     assert user is None  # Ensure that there is only one rpcuser line
                     user = line.split("=")[1].strip("\n")
                 if line.startswith("rpcpassword="):
                     assert password is None  # Ensure that there is only one rpcpassword line
                     password = line.split("=")[1].strip("\n")
     if os.path.isfile(os.path.join(datadir, "regtest", ".cookie")):
         with open(os.path.join(datadir, "regtest", ".cookie"), 'r', encoding="ascii") as f:
             userpass = f.read()
             split_userpass = userpass.split(':')
             user = split_userpass[0]
             password = split_userpass[1]
     if user is None or password is None:
         raise ValueError("No RPC credentials")
     return user, password
 
 
 # If a cookie file exists in the given datadir, delete it.
 def delete_cookie_file(datadir):
     if os.path.isfile(os.path.join(datadir, "regtest", ".cookie")):
         logger.debug("Deleting leftover cookie file")
         os.remove(os.path.join(datadir, "regtest", ".cookie"))
 
 
 def set_node_times(nodes, t):
     for node in nodes:
         node.setmocktime(t)
 
 
 def disconnect_nodes(from_node, to_node):
     for peer_id in [peer['id'] for peer in from_node.getpeerinfo() if to_node.name in peer['subver']]:
         try:
             from_node.disconnectnode(nodeid=peer_id)
         except JSONRPCException as e:
             # If this node is disconnected between calculating the peer id
             # and issuing the disconnect, don't worry about it.
             # This avoids a race condition if we're mass-disconnecting peers.
             if e.error['code'] != -29:  # RPC_CLIENT_NODE_NOT_CONNECTED
                 raise
 
     # wait to disconnect
     wait_until(lambda: [peer['id'] for peer in from_node.getpeerinfo(
     ) if to_node.name in peer['subver']] == [], timeout=5)
 
 
 def connect_nodes(from_node, to_node):
     host = to_node.host
     if host == None:
         host = '127.0.0.1'
     ip_port = host + ':' + str(to_node.p2p_port)
     from_node.addnode(ip_port, "onetry")
     # poll until version handshake complete to avoid race conditions
     # with transaction relaying
     wait_until(lambda: all(peer['version'] !=
                            0 for peer in from_node.getpeerinfo()))
 
 
 def connect_nodes_bi(a, b):
     connect_nodes(a, b)
     connect_nodes(b, a)
 
 
 def sync_blocks(rpc_connections, *, wait=1, timeout=60):
     """
     Wait until everybody has the same tip.
 
     sync_blocks needs to be called with an rpc_connections set that has least
     one node already synced to the latest, stable tip, otherwise there's a
     chance it might return before all nodes are stably synced.
     """
     stop_time = time.time() + timeout
     while time.time() <= stop_time:
         best_hash = [x.getbestblockhash() for x in rpc_connections]
         if best_hash.count(best_hash[0]) == len(rpc_connections):
             return
         time.sleep(wait)
     raise AssertionError("Block sync timed out:{}".format(
         "".join("\n  {!r}".format(b) for b in best_hash)))
 
 
 def sync_mempools(rpc_connections, *, wait=1, timeout=60, flush_scheduler=True):
     """
     Wait until everybody has the same transactions in their memory
     pools
     """
     stop_time = time.time() + timeout
     while time.time() <= stop_time:
         pool = [set(r.getrawmempool()) for r in rpc_connections]
         if pool.count(pool[0]) == len(rpc_connections):
             if flush_scheduler:
                 for r in rpc_connections:
                     r.syncwithvalidationinterfacequeue()
             return
         time.sleep(wait)
     raise AssertionError("Mempool sync timed out:{}".format(
         "".join("\n  {!r}".format(m) for m in pool)))
 
 # Transaction/Block functions
 #############################
 
 
 def find_output(node, txid, amount):
     """
     Return index to output of txid with value amount
     Raises exception if there is none.
     """
     txdata = node.getrawtransaction(txid, 1)
     for i in range(len(txdata["vout"])):
         if txdata["vout"][i]["value"] == amount:
             return i
     raise RuntimeError("find_output txid {} : {} not found".format(
         txid, str(amount)))
 
 
 def gather_inputs(from_node, amount_needed, confirmations_required=1):
     """
     Return a random set of unspent txouts that are enough to pay amount_needed
     """
     assert(confirmations_required >= 0)
     utxo = from_node.listunspent(confirmations_required)
     random.shuffle(utxo)
     inputs = []
     total_in = Decimal("0.00000000")
     while total_in < amount_needed and len(utxo) > 0:
         t = utxo.pop()
         total_in += t["amount"]
         inputs.append(
             {"txid": t["txid"], "vout": t["vout"], "address": t["address"]})
     if total_in < amount_needed:
         raise RuntimeError("Insufficient funds: need {}, have {}".format(
             amount_needed, total_in))
     return (total_in, inputs)
 
 
 def make_change(from_node, amount_in, amount_out, fee):
     """
     Create change output(s), return them
     """
     outputs = {}
     amount = amount_out + fee
     change = amount_in - amount
     if change > amount * 2:
         # Create an extra change output to break up big inputs
         change_address = from_node.getnewaddress()
         # Split change in two, being careful of rounding:
         outputs[change_address] = Decimal(
             change / 2).quantize(Decimal('0.00000001'), rounding=ROUND_DOWN)
         change = amount_in - amount - outputs[change_address]
     if change > 0:
         outputs[from_node.getnewaddress()] = change
     return outputs
 
 
 def send_zeropri_transaction(from_node, to_node, amount, fee):
     """
     Create&broadcast a zero-priority transaction.
     Returns (txid, hex-encoded-txdata)
     Ensures transaction is zero-priority by first creating a send-to-self,
     then using its output
     """
 
     # Create a send-to-self with confirmed inputs:
     self_address = from_node.getnewaddress()
     (total_in, inputs) = gather_inputs(from_node, amount + fee * 2)
     outputs = make_change(from_node, total_in, amount + fee, fee)
     outputs[self_address] = float(amount + fee)
 
     self_rawtx = from_node.createrawtransaction(inputs, outputs)
     self_signresult = from_node.signrawtransactionwithwallet(self_rawtx)
     self_txid = from_node.sendrawtransaction(self_signresult["hex"], True)
 
     vout = find_output(from_node, self_txid, amount + fee)
     # Now immediately spend the output to create a 1-input, 1-output
     # zero-priority transaction:
     inputs = [{"txid": self_txid, "vout": vout}]
     outputs = {to_node.getnewaddress(): float(amount)}
 
     rawtx = from_node.createrawtransaction(inputs, outputs)
     signresult = from_node.signrawtransactionwithwallet(rawtx)
     txid = from_node.sendrawtransaction(signresult["hex"], True)
 
     return (txid, signresult["hex"])
 
 
 def random_zeropri_transaction(nodes, amount, min_fee, fee_increment, fee_variants):
     """
     Create a random zero-priority transaction.
     Returns (txid, hex-encoded-transaction-data, fee)
     """
     from_node = random.choice(nodes)
     to_node = random.choice(nodes)
     fee = min_fee + fee_increment * random.randint(0, fee_variants)
     (txid, txhex) = send_zeropri_transaction(from_node, to_node, amount, fee)
     return (txid, txhex, fee)
 
 
 def random_transaction(nodes, amount, min_fee, fee_increment, fee_variants):
     """
     Create a random transaction.
     Returns (txid, hex-encoded-transaction-data, fee)
     """
     from_node = random.choice(nodes)
     to_node = random.choice(nodes)
     fee = min_fee + fee_increment * random.randint(0, fee_variants)
 
     (total_in, inputs) = gather_inputs(from_node, amount + fee)
     outputs = make_change(from_node, total_in, amount, fee)
     outputs[to_node.getnewaddress()] = float(amount)
 
     rawtx = from_node.createrawtransaction(inputs, outputs)
     signresult = from_node.signrawtransactionwithwallet(rawtx)
     txid = from_node.sendrawtransaction(signresult["hex"], True)
 
     return (txid, signresult["hex"], fee)
 
 # Create large OP_RETURN txouts that can be appended to a transaction
 # to make it large (helper for constructing large transactions).
 
 
 def gen_return_txouts():
     # Some pre-processing to create a bunch of OP_RETURN txouts to insert into transactions we create
     # So we have big transactions (and therefore can't fit very many into each block)
     # create one script_pubkey
     script_pubkey = "6a4d0200"  # OP_RETURN OP_PUSH2 512 bytes
     for i in range(512):
         script_pubkey = script_pubkey + "01"
     # concatenate 128 txouts of above script_pubkey which we'll insert before
     # the txout for change
     txouts = "81"
     for k in range(128):
         # add txout value
         txouts = txouts + "0000000000000000"
         # add length of script_pubkey
         txouts = txouts + "fd0402"
         # add script_pubkey
         txouts = txouts + script_pubkey
     return txouts
 
 
 def create_tx(node, coinbase, to_address, amount):
     inputs = [{"txid": coinbase, "vout": 0}]
     outputs = {to_address: amount}
     rawtx = node.createrawtransaction(inputs, outputs)
     signresult = node.signrawtransactionwithwallet(rawtx)
     assert_equal(signresult["complete"], True)
     return signresult["hex"]
 
 # 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()
     txids = []
     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)
         newtx = rawtx[0:92]
         newtx = newtx + txouts
         newtx = newtx + rawtx[94:]
         signresult = node.signrawtransactionwithwallet(
             newtx, None, "NONE|FORKID")
         txid = node.sendrawtransaction(signresult["hex"], True)
         txids.append(txid)
     return txids
 
 
 def find_vout_for_address(node, txid, addr):
     """
     Locate the vout index of the given transaction sending to the
     given address. Raises runtime error exception if not found.
     """
     tx = node.getrawtransaction(txid, True)
     for i in range(len(tx["vout"])):
         if any([addr == a for a in tx["vout"][i]["scriptPubKey"]["addresses"]]):
             return i
     raise RuntimeError(
         "Vout not found for address: txid={}, addr={}".format(txid, addr))