diff --git a/test/functional/interface_bitcoin_cli.py b/test/functional/interface_bitcoin_cli.py
index e5a032c8e..6b1652213 100755
--- a/test/functional/interface_bitcoin_cli.py
+++ b/test/functional/interface_bitcoin_cli.py
@@ -1,47 +1,51 @@
 #!/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 bitcoin-cli"""
 from test_framework.test_framework import BitcoinTestFramework
-from test_framework.util import assert_equal, assert_raises_process_error, get_auth_cookie
+from test_framework.util import (
+    assert_equal,
+    assert_raises_process_error,
+    get_auth_cookie,
+)
 
 
 class TestBitcoinCli(BitcoinTestFramework):
 
     def set_test_params(self):
         self.setup_clean_chain = True
         self.num_nodes = 1
 
     def run_test(self):
         """Main test logic"""
 
         self.log.info(
             "Compare responses from gewalletinfo RPC and `bitcoin-cli getwalletinfo`")
         cli_response = self.nodes[0].cli.getwalletinfo()
         rpc_response = self.nodes[0].getwalletinfo()
         assert_equal(cli_response, rpc_response)
 
         self.log.info(
             "Compare responses from getblockchaininfo RPC and `bitcoin-cli getblockchaininfo`")
         cli_response = self.nodes[0].cli.getblockchaininfo()
         rpc_response = self.nodes[0].getblockchaininfo()
         assert_equal(cli_response, rpc_response)
 
         user, password = get_auth_cookie(self.nodes[0].datadir)
 
         self.log.info("Test -stdinrpcpass option")
         assert_equal(0, self.nodes[0].cli(
             '-rpcuser={}'.format(user), '-stdinrpcpass', input=password).getblockcount())
         assert_raises_process_error(1, "incorrect rpcuser or rpcpassword", self.nodes[0].cli(
             '-rpcuser={}'.format(user), '-stdinrpcpass', input="foo").echo)
 
         self.log.info("Test -stdin and -stdinrpcpass")
         assert_equal(["foo", "bar"], self.nodes[0].cli('-rpcuser={}'.format(user),
                                                        '-stdin', '-stdinrpcpass', input=password + "\nfoo\nbar").echo())
         assert_raises_process_error(1, "incorrect rpcuser or rpcpassword", self.nodes[0].cli(
             '-rpcuser={}'.format(user), '-stdin', '-stdinrpcpass', input="foo").echo)
 
 
 if __name__ == '__main__':
     TestBitcoinCli().main()
diff --git a/test/functional/interface_http.py b/test/functional/interface_http.py
index 7e63c8749..54d3652b8 100755
--- a/test/functional/interface_http.py
+++ b/test/functional/interface_http.py
@@ -1,175 +1,175 @@
 #!/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 rpc http basics
 #
 
-from test_framework.test_framework import BitcoinTestFramework
-from test_framework.util import *
-
 import http.client
 import urllib.parse
 
+from test_framework.test_framework import BitcoinTestFramework
+from test_framework.util import assert_equal, str_to_b64str
+
 
 class HTTPBasicsTest (BitcoinTestFramework):
     def set_test_params(self):
         self.num_nodes = 3
 
     def setup_network(self):
         self.extra_args = [["-rpccorsdomain=null"], [], []]
         self.setup_nodes()
 
     def run_test(self):
 
         #
         # lowlevel check for http persistent connection #
         #
         url = urllib.parse.urlparse(self.nodes[0].url)
         authpair = url.username + ':' + url.password
         headers = {"Authorization": "Basic " + str_to_b64str(authpair)}
 
         conn = http.client.HTTPConnection(url.hostname, url.port)
         conn.connect()
         conn.request('POST', '/', '{"method": "getbestblockhash"}', headers)
         out1 = conn.getresponse().read()
         assert(b'"error":null' in out1)
         assert(conn.sock != None)
         # according to http/1.1 connection must still be open!
 
         # send 2nd request without closing connection
         conn.request('POST', '/', '{"method": "getchaintips"}', headers)
         out1 = conn.getresponse().read()
         assert(b'"error":null' in out1)
         # must also response with a correct json-rpc message
         assert(conn.sock != None)
         # according to http/1.1 connection must still be open!
         conn.close()
 
         # same should be if we add keep-alive because this should be the std.
         # behaviour
         headers = {"Authorization": "Basic " +
                    str_to_b64str(authpair), "Connection": "keep-alive"}
 
         conn = http.client.HTTPConnection(url.hostname, url.port)
         conn.connect()
         conn.request('POST', '/', '{"method": "getbestblockhash"}', headers)
         out1 = conn.getresponse().read()
         assert(b'"error":null' in out1)
         assert(conn.sock != None)
         # according to http/1.1 connection must still be open!
 
         # send 2nd request without closing connection
         conn.request('POST', '/', '{"method": "getchaintips"}', headers)
         out1 = conn.getresponse().read()
         assert(b'"error":null' in out1)
         # must also response with a correct json-rpc message
         assert(conn.sock != None)
         # according to http/1.1 connection must still be open!
         conn.close()
 
         # now do the same with "Connection: close"
         headers = {"Authorization": "Basic " +
                    str_to_b64str(authpair), "Connection": "close"}
 
         conn = http.client.HTTPConnection(url.hostname, url.port)
         conn.connect()
         conn.request('POST', '/', '{"method": "getbestblockhash"}', headers)
         out1 = conn.getresponse().read()
         assert(b'"error":null' in out1)
         assert(conn.sock == None)
         # now the connection must be closed after the response
 
         # node1 (2nd node) is running with disabled keep-alive option
         urlNode1 = urllib.parse.urlparse(self.nodes[1].url)
         authpair = urlNode1.username + ':' + urlNode1.password
         headers = {"Authorization": "Basic " + str_to_b64str(authpair)}
 
         conn = http.client.HTTPConnection(urlNode1.hostname, urlNode1.port)
         conn.connect()
         conn.request('POST', '/', '{"method": "getbestblockhash"}', headers)
         out1 = conn.getresponse().read()
         assert(b'"error":null' in out1)
 
         # node2 (third node) is running with standard keep-alive parameters
         # which means keep-alive is on
         urlNode2 = urllib.parse.urlparse(self.nodes[2].url)
         authpair = urlNode2.username + ':' + urlNode2.password
         headers = {"Authorization": "Basic " + str_to_b64str(authpair)}
 
         conn = http.client.HTTPConnection(urlNode2.hostname, urlNode2.port)
         conn.connect()
         conn.request('POST', '/', '{"method": "getbestblockhash"}', headers)
         out1 = conn.getresponse().read()
         assert(b'"error":null' in out1)
         assert(conn.sock != None)
         # connection must be closed because bitcoind should use
         # keep-alive by default
 
         # Check excessive request size
         conn = http.client.HTTPConnection(urlNode2.hostname, urlNode2.port)
         conn.connect()
         conn.request('GET', '/' + ('x' * 1000), '', headers)
         out1 = conn.getresponse()
         assert_equal(out1.status, http.client.NOT_FOUND)
 
         conn = http.client.HTTPConnection(urlNode2.hostname, urlNode2.port)
         conn.connect()
         conn.request('GET', '/' + ('x' * 10000), '', headers)
         out1 = conn.getresponse()
         assert_equal(out1.status, http.client.BAD_REQUEST)
 
         # Check Standard CORS request
         origin = "null"
 
         conn = http.client.HTTPConnection(url.hostname, url.port)
         conn.connect()
         authpair = url.username + ':' + url.password
         headers = {"Authorization": "Basic " + str_to_b64str(authpair),
                    "Origin": origin}
         conn.request('POST', '/', '{"method": "getbestblockhash"}', headers)
         out1 = conn.getresponse()
         assert_equal(out1.status, http.client.OK)
         assert_equal(out1.headers["Access-Control-Allow-Origin"], origin)
         assert_equal(out1.headers["Access-Control-Allow-Credentials"], "true")
         assert_equal(out1.headers["Access-Control-Expose-Headers"],
                      "WWW-Authenticate")
         assert(b'"error":null' in out1.read())
 
         # Check Pre-flight CORS request
         corsheaders = {"Origin": origin,
                        "Access-Control-Request-Method": "POST"}
         conn.request('OPTIONS', '/', None, corsheaders)
         out1 = conn.getresponse()
         assert_equal(out1.status, http.client.OK)
         assert_equal(out1.headers["Access-Control-Allow-Origin"], origin)
         assert_equal(out1.headers["Access-Control-Allow-Credentials"], "true")
         assert_equal(out1.headers["Access-Control-Allow-Methods"], "POST")
         assert_equal(out1.headers["Access-Control-Allow-Headers"],
                      "authorization,content-type")
         assert_equal(b'', out1.read())
 
         # Check Standard CORS request to node without CORS, expected failure
         conn = http.client.HTTPConnection(urlNode2.hostname, urlNode2.port)
         conn.connect()
         authpair = url.username + ':' + url.password
         headers = {"Authorization": "Basic " + str_to_b64str(authpair),
                    "Origin": origin}
         conn.request('POST', '/', '{"method": "getbestblockhash"}', headers)
         out1 = conn.getresponse()
         assert_equal(out1.status, http.client.UNAUTHORIZED)
         assert_equal(b'', out1.read())
 
         # Check Pre-flight CORS request to node without CORS, expected failure
         corsheaders = {"Origin": origin,
                        "Access-Control-Request-Method": "POST"}
         conn.request('OPTIONS', '/', None, corsheaders)
         out1 = conn.getresponse()
         assert_equal(out1.status, http.client.METHOD_NOT_ALLOWED)
         assert_equal(b'JSONRPC server handles only POST requests', out1.read())
 
 
 if __name__ == '__main__':
     HTTPBasicsTest().main()
diff --git a/test/functional/interface_rest.py b/test/functional/interface_rest.py
index c826648a2..57d7a45fe 100755
--- a/test/functional/interface_rest.py
+++ b/test/functional/interface_rest.py
@@ -1,392 +1,398 @@
 #!/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 REST interface
 #
 
-
-from test_framework.test_framework import BitcoinTestFramework
-from test_framework.util import *
-from struct import *
-from io import BytesIO
 from codecs import encode
-
+from decimal import Decimal
 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,
+    connect_nodes_bi,
+    hex_str_to_bytes,
+)
+
 
 def deser_uint256(f):
     r = 0
     for i in range(8):
         t = unpack(b"<I", f.read(4))[0]
         r += t << (i * 32)
     return r
 
 # allows simple http get calls
 
 
 def http_get_call(host, port, path, response_object=0):
     conn = http.client.HTTPConnection(host, port)
     conn.request('GET', path)
 
     if response_object:
         return conn.getresponse()
 
     return conn.getresponse().read().decode('utf-8')
 
 # allows simple http post calls with a request body
 
 
 def http_post_call(host, port, path, requestdata='', response_object=0):
     conn = http.client.HTTPConnection(host, port)
     conn.request('POST', path, requestdata)
 
     if response_object:
         return conn.getresponse()
 
     return conn.getresponse().read()
 
 
 class RESTTest (BitcoinTestFramework):
     FORMAT_SEPARATOR = "."
 
     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):
         url = urllib.parse.urlparse(self.nodes[0].url)
         self.log.info("Mining blocks...")
 
         self.nodes[0].generate(1)
         self.sync_all()
         self.nodes[2].generate(100)
         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[2].generate(1)
         self.sync_all()
         bb_hash = self.nodes[0].getbestblockhash()
 
         assert_equal(self.nodes[1].getbalance(), Decimal("0.1"))
         # balance now should be 0.1 on node 1
 
         # load the latest 0.1 tx over the REST API
         json_string = http_get_call(
             url.hostname, url.port, '/rest/tx/' + txid + self.FORMAT_SEPARATOR + "json")
         json_obj = json.loads(json_string)
         vintx = json_obj['vin'][0]['txid']
         # get the vin to later check for utxo (should be spent by then)
         # get n of 0.1 outpoint
         n = 0
         for vout in json_obj['vout']:
             if vout['value'] == 0.1:
                 n = vout['n']
 
         #
         # GETUTXOS: query a unspent outpoint #
         #
         json_request = '/checkmempool/' + txid + '-' + str(n)
         json_string = http_get_call(
             url.hostname, url.port, '/rest/getutxos' + json_request + self.FORMAT_SEPARATOR + 'json')
         json_obj = json.loads(json_string)
 
         # 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'], 0.1)
 
         #
         # GETUTXOS: now query a already spent outpoint #
         #
         json_request = '/checkmempool/' + vintx + '-0'
         json_string = http_get_call(
             url.hostname, url.port, '/rest/getutxos' + json_request + self.FORMAT_SEPARATOR + 'json')
         json_obj = json.loads(json_string)
 
         # check chainTip response
         assert_equal(json_obj['chaintipHash'], bb_hash)
 
         # make sure there is no utox in the response because this oupoint has
         # been spent
         assert_equal(len(json_obj['utxos']), 0)
 
         # check bitmap
         assert_equal(json_obj['bitmap'], "0")
 
         #
         # GETUTXOS: now check both with the same request #
         #
         json_request = '/checkmempool/' + \
             txid + '-' + str(n) + '/' + vintx + '-0'
         json_string = http_get_call(
             url.hostname, url.port, '/rest/getutxos' + json_request + self.FORMAT_SEPARATOR + 'json')
         json_obj = json.loads(json_string)
         assert_equal(len(json_obj['utxos']), 1)
         assert_equal(json_obj['bitmap'], "10")
 
         # test binary response
         bb_hash = self.nodes[0].getbestblockhash()
 
         binaryRequest = b'\x01\x02'
         binaryRequest += hex_str_to_bytes(txid)
         binaryRequest += pack("i", n)
         binaryRequest += hex_str_to_bytes(vintx)
         binaryRequest += pack("i", 0)
 
         bin_response = http_post_call(
             url.hostname, url.port, '/rest/getutxos' + self.FORMAT_SEPARATOR + 'bin', binaryRequest)
         output = BytesIO()
         output.write(bin_response)
         output.seek(0)
         chainHeight = unpack("i", output.read(4))[0]
         hashFromBinResponse = hex(deser_uint256(output))[2:].zfill(64)
 
         assert_equal(bb_hash, hashFromBinResponse)
         # check if getutxo's chaintip during calculation was fine
         assert_equal(chainHeight, 102)  # chain height must be 102
 
         #
         # GETUTXOS: mempool checks #
         #
 
         # do a tx and don't sync
         txid = self.nodes[0].sendtoaddress(self.nodes[1].getnewaddress(), 0.1)
         json_string = http_get_call(
             url.hostname, url.port, '/rest/tx/' + txid + self.FORMAT_SEPARATOR + "json")
         json_obj = json.loads(json_string)
         vintx = json_obj['vin'][0]['txid']
         # get the vin to later check for utxo (should be spent by then)
         # get n of 0.1 outpoint
         n = 0
         for vout in json_obj['vout']:
             if vout['value'] == 0.1:
                 n = vout['n']
 
         json_request = '/' + txid + '-' + str(n)
         json_string = http_get_call(
             url.hostname, url.port, '/rest/getutxos' + json_request + self.FORMAT_SEPARATOR + 'json')
         json_obj = json.loads(json_string)
         assert_equal(len(json_obj['utxos']), 0)
         # there should be a outpoint because it has just added to
         # the mempool
 
         json_request = '/checkmempool/' + txid + '-' + str(n)
         json_string = http_get_call(
             url.hostname, url.port, '/rest/getutxos' + json_request + self.FORMAT_SEPARATOR + 'json')
         json_obj = json.loads(json_string)
         assert_equal(len(json_obj['utxos']), 1)
         # there should be a outpoint because it has just added to
         # the mempool
 
         # do some invalid requests
         json_request = '{"checkmempool'
         response = http_post_call(
             url.hostname, url.port, '/rest/getutxos' + self.FORMAT_SEPARATOR + 'json', json_request, True)
         assert_equal(response.status, 400)
         # must be a 400 because we send a invalid json request
 
         json_request = '{"checkmempool'
         response = http_post_call(
             url.hostname, url.port, '/rest/getutxos' + self.FORMAT_SEPARATOR + 'bin', json_request, True)
         assert_equal(response.status, 400)
         # must be a 400 because we send a invalid bin request
 
         response = http_post_call(
             url.hostname, url.port, '/rest/getutxos/checkmempool' + self.FORMAT_SEPARATOR + 'bin', '', True)
         assert_equal(response.status, 400)
         # must be a 400 because we send a invalid bin request
 
         # test limits
         json_request = '/checkmempool/'
         for x in range(0, 20):
             json_request += txid + '-' + str(n) + '/'
         json_request = json_request.rstrip("/")
         response = http_post_call(
             url.hostname, url.port, '/rest/getutxos' + json_request + self.FORMAT_SEPARATOR + 'json', '', True)
         assert_equal(response.status, 400)
         # must be a 400 because we exceeding the limits
 
         json_request = '/checkmempool/'
         for x in range(0, 15):
             json_request += txid + '-' + str(n) + '/'
         json_request = json_request.rstrip("/")
         response = http_post_call(
             url.hostname, url.port, '/rest/getutxos' + json_request + self.FORMAT_SEPARATOR + 'json', '', True)
         assert_equal(response.status, 200)
         # must be a 200 because we are within the limits
 
         self.nodes[0].generate(
             1)  # generate block to not affect upcoming tests
         self.sync_all()
 
         #
         # /rest/block/ #
         #
 
         # check binary format
         response = http_get_call(
             url.hostname, url.port, '/rest/block/' + bb_hash + self.FORMAT_SEPARATOR + "bin", True)
         assert_equal(response.status, 200)
         assert_greater_than(int(response.getheader('content-length')), 80)
         response_str = response.read()
 
         # compare with block header
         response_header = http_get_call(
             url.hostname, url.port, '/rest/headers/1/' + bb_hash + self.FORMAT_SEPARATOR + "bin", True)
         assert_equal(response_header.status, 200)
         assert_equal(int(response_header.getheader('content-length')), 80)
         response_header_str = response_header.read()
         assert_equal(response_str[0:80], response_header_str)
 
         # check block hex format
         response_hex = http_get_call(
             url.hostname, url.port, '/rest/block/' + bb_hash + self.FORMAT_SEPARATOR + "hex", True)
         assert_equal(response_hex.status, 200)
         assert_greater_than(int(response_hex.getheader('content-length')), 160)
         response_hex_str = response_hex.read()
         assert_equal(
             encode(response_str, "hex_codec")[0:160], response_hex_str[0:160])
 
         # compare with hex block header
         response_header_hex = http_get_call(
             url.hostname, url.port, '/rest/headers/1/' + bb_hash + self.FORMAT_SEPARATOR + "hex", True)
         assert_equal(response_header_hex.status, 200)
         assert_greater_than(
             int(response_header_hex.getheader('content-length')), 160)
         response_header_hex_str = response_header_hex.read()
         assert_equal(response_hex_str[0:160], response_header_hex_str[0:160])
         assert_equal(encode(response_header_str, "hex_codec")[
                      0:160], response_header_hex_str[0:160])
 
         # check json format
         block_json_string = http_get_call(
             url.hostname, url.port, '/rest/block/' + bb_hash + self.FORMAT_SEPARATOR + 'json')
         block_json_obj = json.loads(block_json_string)
         assert_equal(block_json_obj['hash'], bb_hash)
 
         # compare with json block header
         response_header_json = http_get_call(
             url.hostname, url.port, '/rest/headers/1/' + bb_hash + self.FORMAT_SEPARATOR + "json", True)
         assert_equal(response_header_json.status, 200)
         response_header_json_str = response_header_json.read().decode('utf-8')
         json_obj = json.loads(response_header_json_str, parse_float=Decimal)
         assert_equal(len(json_obj), 1)
         # ensure that there is one header in the json response
         assert_equal(json_obj[0]['hash'], bb_hash)
         # request/response hash should be the same
 
         # compare with normal RPC block response
         rpc_block_json = self.nodes[0].getblock(bb_hash)
         assert_equal(json_obj[0]['hash'],               rpc_block_json['hash'])
         assert_equal(
             json_obj[0]['confirmations'],      rpc_block_json['confirmations'])
         assert_equal(
             json_obj[0]['height'],             rpc_block_json['height'])
         assert_equal(
             json_obj[0]['version'],            rpc_block_json['version'])
         assert_equal(
             json_obj[0]['merkleroot'],         rpc_block_json['merkleroot'])
         assert_equal(json_obj[0]['time'],               rpc_block_json['time'])
         assert_equal(
             json_obj[0]['nonce'],              rpc_block_json['nonce'])
         assert_equal(json_obj[0]['bits'],               rpc_block_json['bits'])
         assert_equal(
             json_obj[0]['difficulty'],         rpc_block_json['difficulty'])
         assert_equal(
             json_obj[0]['chainwork'],          rpc_block_json['chainwork'])
         assert_equal(
             json_obj[0]['previousblockhash'],  rpc_block_json['previousblockhash'])
 
         # see if we can get 5 headers in one response
         self.nodes[1].generate(5)
         self.sync_all()
         response_header_json = http_get_call(
             url.hostname, url.port, '/rest/headers/5/' + bb_hash + self.FORMAT_SEPARATOR + "json", True)
         assert_equal(response_header_json.status, 200)
         response_header_json_str = response_header_json.read().decode('utf-8')
         json_obj = json.loads(response_header_json_str)
         assert_equal(len(json_obj), 5)  # now we should have 5 header objects
 
         # do tx test
         tx_hash = block_json_obj['tx'][0]['txid']
         json_string = http_get_call(
             url.hostname, url.port, '/rest/tx/' + tx_hash + self.FORMAT_SEPARATOR + "json")
         json_obj = json.loads(json_string)
         assert_equal(json_obj['txid'], tx_hash)
 
         # check hex format response
         hex_string = http_get_call(
             url.hostname, url.port, '/rest/tx/' + tx_hash + self.FORMAT_SEPARATOR + "hex", True)
         assert_equal(hex_string.status, 200)
         assert_greater_than(int(response.getheader('content-length')), 10)
 
         # check block tx details
         # let's make 3 tx and mine them on node 1
         txs = []
         txs.append(self.nodes[0].sendtoaddress(
             self.nodes[2].getnewaddress(), 11))
         txs.append(self.nodes[0].sendtoaddress(
             self.nodes[2].getnewaddress(), 11))
         txs.append(self.nodes[0].sendtoaddress(
             self.nodes[2].getnewaddress(), 11))
         self.sync_all()
 
         # check that there are exactly 3 transactions in the TX memory pool
         # before generating the block
         json_string = http_get_call(
             url.hostname, url.port, '/rest/mempool/info' + self.FORMAT_SEPARATOR + 'json')
         json_obj = json.loads(json_string)
         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_string = http_get_call(
             url.hostname, url.port, '/rest/mempool/contents' + self.FORMAT_SEPARATOR + 'json')
         json_obj = json.loads(json_string)
         for tx in txs:
             assert_equal(tx in json_obj, True)
 
         # 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_string = http_get_call(
             url.hostname, url.port, '/rest/block/' + newblockhash[0] + self.FORMAT_SEPARATOR + 'json')
         json_obj = json.loads(json_string)
         for tx in json_obj['tx']:
             if not 'coinbase' in tx['vin'][0]:  # exclude coinbase
                 assert_equal(tx['txid'] in txs, True)
 
         # check the same but without tx details
         json_string = http_get_call(
             url.hostname, url.port, '/rest/block/notxdetails/' + newblockhash[0] + self.FORMAT_SEPARATOR + 'json')
         json_obj = json.loads(json_string)
         for tx in txs:
             assert_equal(tx in json_obj['tx'], True)
 
         # test rest bestblock
         bb_hash = self.nodes[0].getbestblockhash()
 
         json_string = http_get_call(
             url.hostname, url.port, '/rest/chaininfo.json')
         json_obj = json.loads(json_string)
         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 31dac7381..27b088565 100755
--- a/test/functional/interface_zmq.py
+++ b/test/functional/interface_zmq.py
@@ -1,162 +1,163 @@
 #!/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 API."""
 import configparser
 import os
 import struct
 
 from test_framework.test_framework import BitcoinTestFramework, SkipTest
-from test_framework.util import (assert_equal,
-                                 bytes_to_hex_str,
-                                 hash256,
-                                 )
+from test_framework.util import (
+    assert_equal,
+    bytes_to_hex_str,
+    hash256,
+)
 
 
 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()
         if not self.options.configfile:
             self.options.configfile = os.path.dirname(
                 __file__) + "/../config.ini"
         config.read_file(open(self.options.configfile))
 
         if not config["components"].getboolean("ENABLE_ZMQ"):
             raise SkipTest("bitcoind has not been built with zmq enabled.")
 
         self.zmqContext = zmq.Context()
         self.zmqSubSocket = self.zmqContext.socket(zmq.SUB)
         self.zmqSubSocket.set(zmq.RCVTIMEO, 60000)
         self.zmqSubSocket.setsockopt(zmq.SUBSCRIBE, b"hashblock")
         self.zmqSubSocket.setsockopt(zmq.SUBSCRIBE, b"hashtx")
         self.zmqSubSocket.setsockopt(zmq.SUBSCRIBE, b"rawblock")
         self.zmqSubSocket.setsockopt(zmq.SUBSCRIBE, b"rawtx")
         ip_address = "tcp://127.0.0.1:28332"
         self.zmqSubSocket.connect(ip_address)
         self.extra_args = [['-zmqpubhashblock={}'.format(ip_address),
                             '-zmqpubhashtx={}'.format(ip_address),
                             '-zmqpubrawblock={}'.format(ip_address),
                             '-zmqpubrawtx={}'.format(ip_address)], []]
         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.zmqContext.destroy(linger=None)
 
     def _zmq_test(self):
         genhashes = self.nodes[0].generate(1)
         self.sync_all()
 
         self.log.info("Wait for tx")
         msg = self.zmqSubSocket.recv_multipart()
         topic = msg[0]
         assert_equal(topic, b"hashtx")
         txhash = msg[1]
         msgSequence = struct.unpack('<I', msg[-1])[-1]
         assert_equal(msgSequence, 0)  # must be sequence 0 on hashtx
 
         # rawtx
         msg = self.zmqSubSocket.recv_multipart()
         topic = msg[0]
         assert_equal(topic, b"rawtx")
         body = msg[1]
         msgSequence = struct.unpack('<I', msg[-1])[-1]
         assert_equal(msgSequence, 0)  # must be sequence 0 on rawtx
 
         # Check that the rawtx hashes to the hashtx
         assert_equal(hash256(body), txhash)
 
         self.log.info("Wait for block")
         msg = self.zmqSubSocket.recv_multipart()
         topic = msg[0]
         assert_equal(topic, b"hashblock")
         body = msg[1]
         msgSequence = struct.unpack('<I', msg[-1])[-1]
         assert_equal(msgSequence, 0)  # must be sequence 0 on hashblock
         blkhash = bytes_to_hex_str(body)
         # blockhash from generate must be equal to the hash received over zmq
         assert_equal(genhashes[0], blkhash)
 
         # rawblock
         msg = self.zmqSubSocket.recv_multipart()
         topic = msg[0]
         assert_equal(topic, b"rawblock")
         body = msg[1]
         msgSequence = struct.unpack('<I', msg[-1])[-1]
         assert_equal(msgSequence, 0)  # must be sequence 0 on rawblock
 
         # Check the hash of the rawblock's header matches generate
         assert_equal(genhashes[0], bytes_to_hex_str(hash256(body[:80])))
 
         self.log.info("Generate 10 blocks (and 10 coinbase txes)")
         n = 10
         genhashes = self.nodes[1].generate(n)
         self.sync_all()
 
         zmqHashes = []
         zmqRawHashed = []
         blockcount = 0
         for x in range(n * 4):
             msg = self.zmqSubSocket.recv_multipart()
             topic = msg[0]
             body = msg[1]
             if topic == b"hashblock":
                 zmqHashes.append(bytes_to_hex_str(body))
                 msgSequence = struct.unpack('<I', msg[-1])[-1]
                 assert_equal(msgSequence, blockcount + 1)
                 blockcount += 1
             if topic == b"rawblock":
                 zmqRawHashed.append(bytes_to_hex_str(hash256(body[:80])))
                 msgSequence = struct.unpack('<I', msg[-1])[-1]
                 assert_equal(msgSequence, blockcount)
 
         for x in range(n):
             # blockhash from generate must be equal to the hash received over zmq
             assert_equal(genhashes[x], zmqHashes[x])
             assert_equal(genhashes[x], zmqRawHashed[x])
 
         self.log.info("Wait for tx from second node")
         # test tx from a second node
         hashRPC = self.nodes[1].sendtoaddress(
             self.nodes[0].getnewaddress(), 1.0)
         self.sync_all()
 
         # now we should receive a zmq msg because the tx was broadcast
         msg = self.zmqSubSocket.recv_multipart()
         topic = msg[0]
         assert_equal(topic, b"hashtx")
         body = msg[1]
         hashZMQ = bytes_to_hex_str(body)
         msgSequence = struct.unpack('<I', msg[-1])[-1]
         assert_equal(msgSequence, blockcount + 1)
 
         msg = self.zmqSubSocket.recv_multipart()
         topic = msg[0]
         assert_equal(topic, b"rawtx")
         body = msg[1]
         hashedZMQ = bytes_to_hex_str(hash256(body))
         msgSequence = struct.unpack('<I', msg[-1])[-1]
         assert_equal(msgSequence, blockcount + 1)
         # txid from sendtoaddress must be equal to the hash received over zmq
         assert_equal(hashRPC, hashZMQ)
         assert_equal(hashRPC, hashedZMQ)
 
 
 if __name__ == '__main__':
     ZMQTest().main()