diff --git a/qa/rpc-tests/httpbasics.py b/qa/rpc-tests/httpbasics.py
index b2ea84b4f..b1a4623bd 100755
--- a/qa/rpc-tests/httpbasics.py
+++ b/qa/rpc-tests/httpbasics.py
@@ -37,45 +37,45 @@ class HTTPBasicsTest (BitcoinTestFramework):
         conn = httplib.HTTPConnection(url.hostname, url.port)
         conn.connect()
         conn.request('POST', '/', '{"method": "getbestblockhash"}', headers)
-        out1 = conn.getresponse().read();
+        out1 = conn.getresponse().read()
         assert_equal('"error":null' in out1, True)
-        assert_equal(conn.sock!=None, True) #according to http/1.1 connection must still be open!
+        assert_equal(conn.sock!=None, True) # according to http/1.1 connection must still be open!
 
-        #send 2nd request without closing connection
+        # send 2nd request without closing connection
         conn.request('POST', '/', '{"method": "getchaintips"}', headers)
-        out2 = conn.getresponse().read();
+        out2 = conn.getresponse().read()
         assert_equal('"error":null' in out2, True) # must also response with a correct json-rpc message
-        assert_equal(conn.sock!=None, True) #according to http/1.1 connection must still be open!
+        assert_equal(conn.sock!=None, True) # 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
+        # same should be if we add keep-alive because this should be the std. behaviour
         headers = {"Authorization": "Basic " + base64.b64encode(authpair), "Connection": "keep-alive"}
 
         conn = httplib.HTTPConnection(url.hostname, url.port)
         conn.connect()
         conn.request('POST', '/', '{"method": "getbestblockhash"}', headers)
-        out1 = conn.getresponse().read();
+        out1 = conn.getresponse().read()
         assert_equal('"error":null' in out1, True)
-        assert_equal(conn.sock!=None, True) #according to http/1.1 connection must still be open!
+        assert_equal(conn.sock!=None, True) # according to http/1.1 connection must still be open!
 
-        #send 2nd request without closing connection
+        # send 2nd request without closing connection
         conn.request('POST', '/', '{"method": "getchaintips"}', headers)
-        out2 = conn.getresponse().read();
+        out2 = conn.getresponse().read()
         assert_equal('"error":null' in out2, True) # must also response with a correct json-rpc message
-        assert_equal(conn.sock!=None, True) #according to http/1.1 connection must still be open!
+        assert_equal(conn.sock!=None, True) # according to http/1.1 connection must still be open!
         conn.close()
 
-        #now do the same with "Connection: close"
+        # now do the same with "Connection: close"
         headers = {"Authorization": "Basic " + base64.b64encode(authpair), "Connection":"close"}
 
         conn = httplib.HTTPConnection(url.hostname, url.port)
         conn.connect()
         conn.request('POST', '/', '{"method": "getbestblockhash"}', headers)
-        out1 = conn.getresponse().read();
+        out1 = conn.getresponse().read()
         assert_equal('"error":null' in out1, True)
-        assert_equal(conn.sock!=None, False) #now the connection must be closed after the response
+        assert_equal(conn.sock!=None, False) # now the connection must be closed after the response
 
-        #node1 (2nd node) is running with disabled keep-alive option
+        # node1 (2nd node) is running with disabled keep-alive option
         urlNode1 = urlparse.urlparse(self.nodes[1].url)
         authpair = urlNode1.username + ':' + urlNode1.password
         headers = {"Authorization": "Basic " + base64.b64encode(authpair)}
@@ -83,10 +83,10 @@ class HTTPBasicsTest (BitcoinTestFramework):
         conn = httplib.HTTPConnection(urlNode1.hostname, urlNode1.port)
         conn.connect()
         conn.request('POST', '/', '{"method": "getbestblockhash"}', headers)
-        out1 = conn.getresponse().read();
+        out1 = conn.getresponse().read()
         assert_equal('"error":null' in out1, True)
 
-        #node2 (third node) is running with standard keep-alive parameters which means keep-alive is on
+        # node2 (third node) is running with standard keep-alive parameters which means keep-alive is on
         urlNode2 = urlparse.urlparse(self.nodes[2].url)
         authpair = urlNode2.username + ':' + urlNode2.password
         headers = {"Authorization": "Basic " + base64.b64encode(authpair)}
@@ -94,9 +94,9 @@ class HTTPBasicsTest (BitcoinTestFramework):
         conn = httplib.HTTPConnection(urlNode2.hostname, urlNode2.port)
         conn.connect()
         conn.request('POST', '/', '{"method": "getbestblockhash"}', headers)
-        out1 = conn.getresponse().read();
+        out1 = conn.getresponse().read()
         assert_equal('"error":null' in out1, True)
-        assert_equal(conn.sock!=None, True) #connection must be closed because bitcoind should use keep-alive by default
+        assert_equal(conn.sock!=None, True) # connection must be closed because bitcoind should use keep-alive by default
 
 if __name__ == '__main__':
-    HTTPBasicsTest ().main ()
+    HTTPBasicsTest().main()
diff --git a/qa/rpc-tests/invalidateblock.py b/qa/rpc-tests/invalidateblock.py
index 9e9917b89..5cbd1ea98 100755
--- a/qa/rpc-tests/invalidateblock.py
+++ b/qa/rpc-tests/invalidateblock.py
@@ -14,19 +14,17 @@ from test_framework.util import initialize_chain_clean, start_node, \
 import time
 
 class InvalidateTest(BitcoinTestFramework):
-    
-        
     def setup_chain(self):
         print("Initializing test directory "+self.options.tmpdir)
         initialize_chain_clean(self.options.tmpdir, 3)
-                 
+
     def setup_network(self):
         self.nodes = []
-        self.is_network_split = False 
+        self.is_network_split = False
         self.nodes.append(start_node(0, self.options.tmpdir, ["-debug"]))
         self.nodes.append(start_node(1, self.options.tmpdir, ["-debug"]))
         self.nodes.append(start_node(2, self.options.tmpdir, ["-debug"]))
-        
+
     def run_test(self):
         print "Make sure we repopulate setBlockIndexCandidates after InvalidateBlock:"
         print "Mine 4 blocks on Node 0"
diff --git a/qa/rpc-tests/invalidblockrequest.py b/qa/rpc-tests/invalidblockrequest.py
index 0ef353628..05b33d772 100755
--- a/qa/rpc-tests/invalidblockrequest.py
+++ b/qa/rpc-tests/invalidblockrequest.py
@@ -25,7 +25,7 @@ re-requested.
 # Use the ComparisonTestFramework with 1 node: only use --testbinary.
 class InvalidBlockRequestTest(ComparisonTestFramework):
 
-    ''' Can either run this test as 1 node with expected answers, or two and compare them. 
+    ''' Can either run this test as 1 node with expected answers, or two and compare them.
         Change the "outcome" variable from each TestInstance object to only do the comparison. '''
     def __init__(self):
         self.num_nodes = 1
diff --git a/qa/rpc-tests/maxblocksinflight.py b/qa/rpc-tests/maxblocksinflight.py
index 227679b69..beef3d2ea 100755
--- a/qa/rpc-tests/maxblocksinflight.py
+++ b/qa/rpc-tests/maxblocksinflight.py
@@ -61,7 +61,7 @@ class TestManager(NodeConnCB):
                         current_invs = []
                 if len(current_invs) > 0:
                     self.connection.send_message(msg_inv(current_invs))
-                
+
                 # Wait and see how many blocks were requested
                 time.sleep(2)
 
@@ -80,7 +80,7 @@ class TestManager(NodeConnCB):
         self.disconnectOkay = True
         self.connection.disconnect_node()
 
-        
+
 class MaxBlocksInFlightTest(BitcoinTestFramework):
     def add_options(self, parser):
         parser.add_option("--testbinary", dest="testbinary",
diff --git a/qa/rpc-tests/rawtransactions.py b/qa/rpc-tests/rawtransactions.py
index 82dbb7b26..dc919f028 100755
--- a/qa/rpc-tests/rawtransactions.py
+++ b/qa/rpc-tests/rawtransactions.py
@@ -117,9 +117,9 @@ class RawTransactionsTest(BitcoinTestFramework):
         self.nodes[0].generate(1)
         self.sync_all()
 
-        #THIS IS A INCOMPLETE FEATURE
-        #NODE2 HAS TWO OF THREE KEY AND THE FUNDS SHOULD BE SPENDABLE AND COUNT AT BALANCE CALCULATION
-        assert_equal(self.nodes[2].getbalance(), bal) #for now, assume the funds of a 2of3 multisig tx are not marked as spendable
+        # THIS IS A INCOMPLETE FEATURE
+        # NODE2 HAS TWO OF THREE KEY AND THE FUNDS SHOULD BE SPENDABLE AND COUNT AT BALANCE CALCULATION
+        assert_equal(self.nodes[2].getbalance(), bal) # for now, assume the funds of a 2of3 multisig tx are not marked as spendable
 
         txDetails = self.nodes[0].gettransaction(txId, True)
         rawTx = self.nodes[0].decoderawtransaction(txDetails['hex'])
@@ -134,10 +134,10 @@ class RawTransactionsTest(BitcoinTestFramework):
         outputs = { self.nodes[0].getnewaddress() : 2.199 }
         rawTx = self.nodes[2].createrawtransaction(inputs, outputs)
         rawTxPartialSigned = self.nodes[1].signrawtransaction(rawTx, inputs)
-        assert_equal(rawTxPartialSigned['complete'], False) #node1 only has one key, can't comp. sign the tx
-        
+        assert_equal(rawTxPartialSigned['complete'], False) # node1 only has one key, can't comp. sign the tx
+
         rawTxSigned = self.nodes[2].signrawtransaction(rawTx, inputs)
-        assert_equal(rawTxSigned['complete'], True) #node2 can sign the tx compl., own two of three keys
+        assert_equal(rawTxSigned['complete'], True) # node2 can sign the tx compl., own two of three keys
         self.nodes[2].sendrawtransaction(rawTxSigned['hex'])
         rawTx = self.nodes[0].decoderawtransaction(rawTxSigned['hex'])
         self.sync_all()
diff --git a/qa/rpc-tests/receivedby.py b/qa/rpc-tests/receivedby.py
index e928aec8b..59f7bf258 100755
--- a/qa/rpc-tests/receivedby.py
+++ b/qa/rpc-tests/receivedby.py
@@ -11,8 +11,8 @@ from decimal import Decimal
 
 def get_sub_array_from_array(object_array, to_match):
     '''
-        Finds and returns a sub array from an array of arrays.
-        to_match should be a unique idetifier of a sub array
+    Finds and returns a sub array from an array of arrays.
+    to_match should be a unique idetifier of a sub array
     '''
     for item in object_array:
         all_match = True
@@ -25,12 +25,12 @@ def get_sub_array_from_array(object_array, to_match):
     return []
 
 def check_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
-        """
+    '''
+    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 == True:
         expected = { }
     num_matched = 0
@@ -61,49 +61,49 @@ class ReceivedByTest(BitcoinTestFramework):
         txid = self.nodes[0].sendtoaddress(addr, 0.1)
         self.sync_all()
 
-        #Check not listed in listreceivedbyaddress because has 0 confirmations
+        # Check not listed in listreceivedbyaddress because has 0 confirmations
         check_array_result(self.nodes[1].listreceivedbyaddress(),
                            {"address":addr},
                            { },
                            True)
-        #Bury Tx under 10 block so it will be returned by listreceivedbyaddress
+        # Bury Tx under 10 block so it will be returned by listreceivedbyaddress
         self.nodes[1].generate(10)
         self.sync_all()
         check_array_result(self.nodes[1].listreceivedbyaddress(),
                            {"address":addr},
                            {"address":addr, "account":"", "amount":Decimal("0.1"), "confirmations":10, "txids":[txid,]})
-        #With min confidence < 10
+        # With min confidence < 10
         check_array_result(self.nodes[1].listreceivedbyaddress(5),
                            {"address":addr},
                            {"address":addr, "account":"", "amount":Decimal("0.1"), "confirmations":10, "txids":[txid,]})
-        #With min confidence > 10, should not find Tx
+        # With min confidence > 10, should not find Tx
         check_array_result(self.nodes[1].listreceivedbyaddress(11),{"address":addr},{ },True)
 
-        #Empty Tx
+        # Empty Tx
         addr = self.nodes[1].getnewaddress()
         check_array_result(self.nodes[1].listreceivedbyaddress(0,True),
                            {"address":addr},
                            {"address":addr, "account":"", "amount":0, "confirmations":0, "txids":[]})
 
         '''
-            getreceivedbyaddress Test
+        getreceivedbyaddress Test
         '''
         # Send from node 0 to 1
         addr = self.nodes[1].getnewaddress()
         txid = self.nodes[0].sendtoaddress(addr, 0.1)
         self.sync_all()
 
-        #Check balance is 0 because of 0 confirmations
+        # Check balance is 0 because of 0 confirmations
         balance = self.nodes[1].getreceivedbyaddress(addr)
         if balance != Decimal("0.0"):
             raise AssertionError("Wrong balance returned by getreceivedbyaddress, %0.2f"%(balance))
 
-        #Check balance is 0.1
+        # Check balance is 0.1
         balance = self.nodes[1].getreceivedbyaddress(addr,0)
         if balance != Decimal("0.1"):
             raise AssertionError("Wrong balance returned by getreceivedbyaddress, %0.2f"%(balance))
 
-        #Bury Tx under 10 block so it will be returned by the default getreceivedbyaddress
+        # Bury Tx under 10 block so it will be returned by the default getreceivedbyaddress
         self.nodes[1].generate(10)
         self.sync_all()
         balance = self.nodes[1].getreceivedbyaddress(addr)
@@ -111,9 +111,9 @@ class ReceivedByTest(BitcoinTestFramework):
             raise AssertionError("Wrong balance returned by getreceivedbyaddress, %0.2f"%(balance))
 
         '''
-            listreceivedbyaccount + getreceivedbyaccount Test
+        listreceivedbyaccount + getreceivedbyaccount Test
         '''
-        #set pre-state
+        # set pre-state
         addrArr = self.nodes[1].getnewaddress()
         account = self.nodes[1].getaccount(addrArr)
         received_by_account_json = get_sub_array_from_array(self.nodes[1].listreceivedbyaccount(),{"account":account})
@@ -146,7 +146,7 @@ class ReceivedByTest(BitcoinTestFramework):
         if balance != balance_by_account + Decimal("0.1"):
             raise AssertionError("Wrong balance returned by getreceivedbyaccount, %0.2f"%(balance))
 
-        #Create a new account named "mynewaccount" that has a 0 balance
+        # Create a new account named "mynewaccount" that has a 0 balance
         self.nodes[1].getaccountaddress("mynewaccount")
         received_by_account_json = get_sub_array_from_array(self.nodes[1].listreceivedbyaccount(0,True),{"account":"mynewaccount"})
         if len(received_by_account_json) == 0:
diff --git a/qa/rpc-tests/rest.py b/qa/rpc-tests/rest.py
index 35d7aa5d1..b14ec765d 100755
--- a/qa/rpc-tests/rest.py
+++ b/qa/rpc-tests/rest.py
@@ -7,7 +7,6 @@
 # Test REST interface
 #
 
-
 from test_framework.test_framework import BitcoinTestFramework
 from test_framework.util import assert_equal, assert_greater_than, \
     initialize_chain_clean, start_nodes, connect_nodes_bi
@@ -34,7 +33,7 @@ def deser_uint256(f):
         r += t << (i * 32)
     return r
 
-#allows simple http get calls
+# allows simple http get calls
 def http_get_call(host, port, path, response_object = 0):
     conn = httplib.HTTPConnection(host, port)
     conn.request('GET', path)
@@ -44,7 +43,7 @@ def http_get_call(host, port, path, response_object = 0):
 
     return conn.getresponse().read()
 
-#allows simple http post calls with a request body
+# allows simple http post calls with a request body
 def http_post_call(host, port, path, requestdata = '', response_object = 0):
     conn = httplib.HTTPConnection(host, port)
     conn.request('POST', path, requestdata)
@@ -86,7 +85,7 @@ class RESTTest (BitcoinTestFramework):
         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
+        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")
@@ -121,13 +120,13 @@ class RESTTest (BitcoinTestFramework):
         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
+        # 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
+        # make sure there is no utox in the response because this oupoint has been spent
         assert_equal(len(json_obj['utxos']), 0)
 
-        #check bitmap
+        # check bitmap
         assert_equal(json_obj['bitmap'], "0")
 
 
@@ -140,7 +139,7 @@ class RESTTest (BitcoinTestFramework):
         assert_equal(len(json_obj['utxos']), 1)
         assert_equal(json_obj['bitmap'], "10")
 
-        #test binary response
+        # test binary response
         bb_hash = self.nodes[0].getbestblockhash()
 
         binaryRequest = b'\x01\x02'
@@ -156,8 +155,8 @@ class RESTTest (BitcoinTestFramework):
         chainHeight = struct.unpack("i", output.read(4))[0]
         hashFromBinResponse = hex(deser_uint256(output))[2:].zfill(65).rstrip("L")
 
-        assert_equal(bb_hash, hashFromBinResponse) #check if getutxo's chaintip during calculation was fine
-        assert_equal(chainHeight, 102) #chain height must be 102
+        assert_equal(bb_hash, hashFromBinResponse) # check if getutxo's chaintip during calculation was fine
+        assert_equal(chainHeight, 102) # chain height must be 102
 
 
         ############################
@@ -178,41 +177,41 @@ class RESTTest (BitcoinTestFramework):
         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
+        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
+        assert_equal(len(json_obj['utxos']), 1) # there should be a outpoint because it has just added to the mempool
 
-        #do some invalid requests
+        # 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, 500) #must be a 500 because we send a invalid json request
+        assert_equal(response.status, 500) # must be a 500 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, 500) #must be a 500 because we send a invalid bin request
+        assert_equal(response.status, 500) # must be a 500 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, 500) #must be a 500 because we send a invalid bin request
+        assert_equal(response.status, 500) # must be a 500 because we send a invalid bin request
 
-        #test limits
+        # 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, 500) #must be a 500 because we exceeding the limits
+        assert_equal(response.status, 500) # must be a 500 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 500 because we exceeding the limits
+        assert_equal(response.status, 200) # must be a 500 because we exceeding the limits
 
-        self.nodes[0].generate(1) #generate block to not affect upcoming tests
+        self.nodes[0].generate(1) # generate block to not affect upcoming tests
         self.sync_all()
 
         ################
@@ -266,10 +265,10 @@ class RESTTest (BitcoinTestFramework):
         assert_equal(response_header_json.status, 200)
         response_header_json_str = response_header_json.read()
         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
+        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
+        # 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'])
@@ -283,14 +282,14 @@ class RESTTest (BitcoinTestFramework):
         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
+        # 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()
         json_obj = json.loads(response_header_json_str)
-        assert_equal(len(json_obj), 5) #now we should have 5 header objects
+        assert_equal(len(json_obj), 5) # now we should have 5 header objects
 
         # do tx test
         tx_hash = block_json_obj['tx'][0]['txid'];
@@ -330,20 +329,20 @@ class RESTTest (BitcoinTestFramework):
         newblockhash = self.nodes[1].generate(1)
         self.sync_all()
 
-        #check if the 3 tx show up in the new block
+        # 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
+            if not 'coinbase' in tx['vin'][0]: # exclude coinbase
                 assert_equal(tx['txid'] in txs, True)
 
-        #check the same but without tx details
+        # 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
+        # test rest bestblock
         bb_hash = self.nodes[0].getbestblockhash()
 
         json_string = http_get_call(url.hostname, url.port, '/rest/chaininfo.json')
@@ -351,4 +350,4 @@ class RESTTest (BitcoinTestFramework):
         assert_equal(json_obj['bestblockhash'], bb_hash)
 
 if __name__ == '__main__':
-    RESTTest ().main ()
+    RESTTest().main()
diff --git a/qa/rpc-tests/rpcbind_test.py b/qa/rpc-tests/rpcbind_test.py
index 676a4bf32..72e14d655 100755
--- a/qa/rpc-tests/rpcbind_test.py
+++ b/qa/rpc-tests/rpcbind_test.py
@@ -5,7 +5,7 @@
 
 # Test for -rpcbind, as well as -rpcallowip and -rpcconnect
 
-# Add python-bitcoinrpc to module search path:
+# Dependency: python-bitcoinrpc
 
 from test_framework.util import assert_equal, check_json_precision, \
     initialize_chain, start_nodes, stop_nodes, wait_bitcoinds, \
diff --git a/qa/rpc-tests/test_framework/blockstore.py b/qa/rpc-tests/test_framework/blockstore.py
index 1fa981631..fc157f718 100644
--- a/qa/rpc-tests/test_framework/blockstore.py
+++ b/qa/rpc-tests/test_framework/blockstore.py
@@ -13,7 +13,7 @@ class BlockStore(object):
     def __init__(self, datadir):
         self.blockDB = dbm.open(datadir + "/blocks", 'c')
         self.currentBlock = 0L
-    
+
     def close(self):
         self.blockDB.close()
 
diff --git a/qa/rpc-tests/zapwallettxes.py b/qa/rpc-tests/zapwallettxes.py
index c0c4e3646..5da4ba125 100755
--- a/qa/rpc-tests/zapwallettxes.py
+++ b/qa/rpc-tests/zapwallettxes.py
@@ -29,56 +29,56 @@ class ZapWalletTXesTest (BitcoinTestFramework):
         self.sync_all()
         self.nodes[1].generate(101)
         self.sync_all()
-        
+
         assert_equal(self.nodes[0].getbalance(), 40)
-        
+
         txid0 = self.nodes[0].sendtoaddress(self.nodes[2].getnewaddress(), 11)
         txid1 = self.nodes[0].sendtoaddress(self.nodes[2].getnewaddress(), 10)
         self.sync_all()
         self.nodes[0].generate(1)
         self.sync_all()
-        
+
         txid2 = self.nodes[0].sendtoaddress(self.nodes[2].getnewaddress(), 11)
         txid3 = self.nodes[0].sendtoaddress(self.nodes[2].getnewaddress(), 5)
-        
+
         tx0 = self.nodes[0].gettransaction(txid0)
-        assert_equal(tx0['txid'], txid0) #tx0 must be available (confirmed)
-        
+        assert_equal(tx0['txid'], txid0) # tx0 must be available (confirmed)
+
         tx1 = self.nodes[0].gettransaction(txid1)
-        assert_equal(tx1['txid'], txid1) #tx1 must be available (confirmed)
-        
+        assert_equal(tx1['txid'], txid1) # tx1 must be available (confirmed)
+
         tx2 = self.nodes[0].gettransaction(txid2)
-        assert_equal(tx2['txid'], txid2) #tx2 must be available (unconfirmed)
-        
+        assert_equal(tx2['txid'], txid2) # tx2 must be available (unconfirmed)
+
         tx3 = self.nodes[0].gettransaction(txid3)
-        assert_equal(tx3['txid'], txid3) #tx3 must be available (unconfirmed)
-        
-        #restart bitcoind
+        assert_equal(tx3['txid'], txid3) # tx3 must be available (unconfirmed)
+
+        # restart zcashd
         self.nodes[0].stop()
         bitcoind_processes[0].wait()
         self.nodes[0] = start_node(0,self.options.tmpdir)
-        
+
         tx3 = self.nodes[0].gettransaction(txid3)
-        assert_equal(tx3['txid'], txid3) #tx must be available (unconfirmed)
-        
+        assert_equal(tx3['txid'], txid3) # tx must be available (unconfirmed)
+
         self.nodes[0].stop()
         bitcoind_processes[0].wait()
-        
-        #restart bitcoind with zapwallettxes
+
+        # restart zcashd with zapwallettxes
         self.nodes[0] = start_node(0,self.options.tmpdir, ["-zapwallettxes=1"])
-        
+
         aException = False
         try:
             tx3 = self.nodes[0].gettransaction(txid3)
         except JSONRPCException,e:
             print e
             aException = True
-        
-        assert_equal(aException, True) #there must be a expection because the unconfirmed wallettx0 must be gone by now
+
+        assert_equal(aException, True) # there must be a expection because the unconfirmed wallettx0 must be gone by now
 
         tx0 = self.nodes[0].gettransaction(txid0)
-        assert_equal(tx0['txid'], txid0) #tx0 (confirmed) must still be available because it was confirmed
+        assert_equal(tx0['txid'], txid0) # tx0 (confirmed) must still be available because it was confirmed
 
 
 if __name__ == '__main__':
-    ZapWalletTXesTest ().main ()
+    ZapWalletTXesTest().main()
diff --git a/qa/rpc-tests/zmq_test.py b/qa/rpc-tests/zmq_test.py
index b895c628c..d70e73114 100755
--- a/qa/rpc-tests/zmq_test.py
+++ b/qa/rpc-tests/zmq_test.py
@@ -13,7 +13,7 @@ from test_framework.util import assert_equal, bytes_to_hex_str, start_nodes
 import zmq
 import struct
 
-class ZMQTest (BitcoinTestFramework):
+class ZMQTest(BitcoinTestFramework):
 
     port = 28332
 
@@ -44,7 +44,7 @@ class ZMQTest (BitcoinTestFramework):
         nseq = msg[2]
         [nseq] # hush pyflakes
         msgSequence = struct.unpack('<I', msg[-1])[-1]
-        assert_equal(msgSequence, 0) #must be sequence 0 on hashtx
+        assert_equal(msgSequence, 0) # must be sequence 0 on hashtx
 
         msg = self.zmqSubSocket.recv_multipart()
         topic = msg[0]