diff --git a/test/functional/p2p_compactblocks.py b/test/functional/p2p_compactblocks.py
index 9a716516eb..1f042d4f74 100755
--- a/test/functional/p2p_compactblocks.py
+++ b/test/functional/p2p_compactblocks.py
@@ -1,934 +1,934 @@
 #!/usr/bin/env python3
 # Copyright (c) 2016-2019 The Bitcoin Core developers
 # Copyright (c) 2017 The Bitcoin developers
 # Distributed under the MIT software license, see the accompanying
 # file COPYING or http://www.opensource.org/licenses/mit-license.php.
 """Test compact blocks (BIP 152).
 
 Only testing Version 1 compact blocks (txids)
 """
 
 import random
 
 from test_framework.blocktools import create_block, create_coinbase
 from test_framework.messages import (
     BlockTransactions,
     BlockTransactionsRequest,
     calculate_shortid,
     CBlock,
     CBlockHeader,
     CInv,
     COutPoint,
     CTransaction,
     CTxIn,
     CTxOut,
     FromHex,
     HeaderAndShortIDs,
     msg_block,
     msg_blocktxn,
     msg_cmpctblock,
     msg_getblocktxn,
     msg_getdata,
     msg_getheaders,
     msg_headers,
     msg_inv,
     msg_sendcmpct,
     msg_sendheaders,
     msg_tx,
     NODE_NETWORK,
     P2PHeaderAndShortIDs,
     PrefilledTransaction,
     ToHex,
 )
 from test_framework.mininode import (
     mininode_lock,
     P2PInterface,
 )
 from test_framework.script import CScript, OP_TRUE
 from test_framework.test_framework import BitcoinTestFramework
 from test_framework.txtools import pad_tx
 from test_framework.util import assert_equal, sync_blocks, wait_until
 
 # TestP2PConn: A peer we use to send messages to bitcoind, and store responses.
 
 
 class TestP2PConn(P2PInterface):
     def __init__(self):
         super().__init__()
         self.last_sendcmpct = []
         self.block_announced = False
         # Store the hashes of blocks we've seen announced.
         # This is for synchronizing the p2p message traffic,
         # so we can eg wait until a particular block is announced.
         self.announced_blockhashes = set()
 
     def on_sendcmpct(self, message):
         self.last_sendcmpct.append(message)
 
     def on_cmpctblock(self, message):
         self.block_announced = True
         self.last_message["cmpctblock"].header_and_shortids.header.calc_sha256()
         self.announced_blockhashes.add(
             self.last_message["cmpctblock"].header_and_shortids.header.sha256)
 
     def on_headers(self, message):
         self.block_announced = True
         for x in self.last_message["headers"].headers:
             x.calc_sha256()
             self.announced_blockhashes.add(x.sha256)
 
     def on_inv(self, message):
         for x in self.last_message["inv"].inv:
             if x.type == 2:
                 self.block_announced = True
                 self.announced_blockhashes.add(x.hash)
 
     # Requires caller to hold mininode_lock
     def received_block_announcement(self):
         return self.block_announced
 
     def clear_block_announcement(self):
         with mininode_lock:
             self.block_announced = False
             self.last_message.pop("inv", None)
             self.last_message.pop("headers", None)
             self.last_message.pop("cmpctblock", None)
 
     def get_headers(self, locator, hashstop):
         msg = msg_getheaders()
         msg.locator.vHave = locator
         msg.hashstop = hashstop
         self.send_message(msg)
 
     def send_header_for_blocks(self, new_blocks):
         headers_message = msg_headers()
         headers_message.headers = [CBlockHeader(b) for b in new_blocks]
         self.send_message(headers_message)
 
     def request_headers_and_sync(self, locator, hashstop=0):
         self.clear_block_announcement()
         self.get_headers(locator, hashstop)
         wait_until(self.received_block_announcement,
                    timeout=30, lock=mininode_lock)
         self.clear_block_announcement()
 
     # Block until a block announcement for a particular block hash is
     # received.
     def wait_for_block_announcement(self, block_hash, timeout=30):
         def received_hash():
             return (block_hash in self.announced_blockhashes)
         wait_until(received_hash, timeout=timeout, lock=mininode_lock)
 
     def send_await_disconnect(self, message, timeout=30):
         """Sends a message to the node and wait for disconnect.
 
         This is used when we want to send a message into the node that we expect
         will get us disconnected, eg an invalid block."""
         self.send_message(message)
         wait_until(lambda: not self.is_connected,
                    timeout=timeout, lock=mininode_lock)
 
 
 class CompactBlocksTest(BitcoinTestFramework):
     def set_test_params(self):
         self.setup_clean_chain = True
         self.num_nodes = 2
         self.extra_args = [["-acceptnonstdtxn=1"],
                            ["-txindex", "-acceptnonstdtxn=1"]]
         self.utxos = []
 
     def skip_test_if_missing_module(self):
         self.skip_if_no_wallet()
 
     def build_block_on_tip(self, node):
         height = node.getblockcount()
         tip = node.getbestblockhash()
         mtp = node.getblockheader(tip)['mediantime']
         block = create_block(
             int(tip, 16), create_coinbase(height + 1), mtp + 1)
         block.nVersion = 4
         block.solve()
         return block
 
     # Create 10 more anyone-can-spend utxo's for testing.
     def make_utxos(self):
         # Doesn't matter which node we use, just use node0.
         block = self.build_block_on_tip(self.nodes[0])
         self.test_node.send_and_ping(msg_block(block))
         assert int(self.nodes[0].getbestblockhash(), 16) == block.sha256
         self.nodes[0].generate(100)
 
         total_value = block.vtx[0].vout[0].nValue
         out_value = total_value // 10
         tx = CTransaction()
         tx.vin.append(CTxIn(COutPoint(block.vtx[0].sha256, 0), b''))
         for i in range(10):
             tx.vout.append(CTxOut(out_value, CScript([OP_TRUE])))
         tx.rehash()
 
         block2 = self.build_block_on_tip(self.nodes[0])
         block2.vtx.append(tx)
         block2.hashMerkleRoot = block2.calc_merkle_root()
         block2.solve()
         self.test_node.send_and_ping(msg_block(block2))
         assert_equal(int(self.nodes[0].getbestblockhash(), 16), block2.sha256)
         self.utxos.extend([[tx.sha256, i, out_value] for i in range(10)])
         return
 
     # Test "sendcmpct" (between peers preferring the same version):
     # - No compact block announcements unless sendcmpct is sent.
     # - If sendcmpct is sent with version > preferred_version, the message is ignored.
     # - If sendcmpct is sent with boolean 0, then block announcements are not
     #   made with compact blocks.
     # - If sendcmpct is then sent with boolean 1, then new block announcements
     #   are made with compact blocks.
     # If old_node is passed in, request compact blocks with version=preferred-1
     # and verify that it receives block announcements via compact block.
     def test_sendcmpct(self, node, test_node,
                        preferred_version, old_node=None):
         # Make sure we get a SENDCMPCT message from our peer
         def received_sendcmpct():
             return (len(test_node.last_sendcmpct) > 0)
         wait_until(received_sendcmpct, timeout=30, lock=mininode_lock)
         with mininode_lock:
             # Check that the first version received is the preferred one
             assert_equal(
                 test_node.last_sendcmpct[0].version, preferred_version)
             # And that we receive versions down to 1.
             assert_equal(test_node.last_sendcmpct[-1].version, 1)
             test_node.last_sendcmpct = []
 
         tip = int(node.getbestblockhash(), 16)
 
         def check_announcement_of_new_block(node, peer, predicate):
             peer.clear_block_announcement()
             block_hash = int(node.generate(1)[0], 16)
             peer.wait_for_block_announcement(block_hash, timeout=30)
             assert peer.block_announced
 
             with mininode_lock:
                 assert predicate(peer), (
                     "block_hash={!r}, cmpctblock={!r}, inv={!r}".format(
                         block_hash, peer.last_message.get("cmpctblock", None), peer.last_message.get("inv", None)))
 
         # We shouldn't get any block announcements via cmpctblock yet.
         check_announcement_of_new_block(
             node, test_node, lambda p: "cmpctblock" not in p.last_message)
 
         # Try one more time, this time after requesting headers.
         test_node.request_headers_and_sync(locator=[tip])
         check_announcement_of_new_block(
             node, test_node, lambda p: "cmpctblock" not in p.last_message and "inv" in p.last_message)
 
         # Test a few ways of using sendcmpct that should NOT
         # result in compact block announcements.
         # Before each test, sync the headers chain.
         test_node.request_headers_and_sync(locator=[tip])
 
         # Now try a SENDCMPCT message with too-high version
         sendcmpct = msg_sendcmpct()
         sendcmpct.version = 999  # was: preferred_version+1
         sendcmpct.announce = True
         test_node.send_and_ping(sendcmpct)
         check_announcement_of_new_block(
             node, test_node, lambda p: "cmpctblock" not in p.last_message)
 
         # Headers sync before next test.
         test_node.request_headers_and_sync(locator=[tip])
 
         # Now try a SENDCMPCT message with valid version, but announce=False
         sendcmpct.version = preferred_version
         sendcmpct.announce = False
         test_node.send_and_ping(sendcmpct)
         check_announcement_of_new_block(
             node, test_node, lambda p: "cmpctblock" not in p.last_message)
 
         # Headers sync before next test.
         test_node.request_headers_and_sync(locator=[tip])
 
         # Finally, try a SENDCMPCT message with announce=True
         sendcmpct.version = preferred_version
         sendcmpct.announce = True
         test_node.send_and_ping(sendcmpct)
         check_announcement_of_new_block(
             node, test_node, lambda p: "cmpctblock" in p.last_message)
 
         # Try one more time (no headers sync should be needed!)
         check_announcement_of_new_block(
             node, test_node, lambda p: "cmpctblock" in p.last_message)
 
         # Try one more time, after turning on sendheaders
         test_node.send_and_ping(msg_sendheaders())
         check_announcement_of_new_block(
             node, test_node, lambda p: "cmpctblock" in p.last_message)
 
         # Try one more time, after sending a version-1, announce=false message.
         sendcmpct.version = preferred_version - 1
         sendcmpct.announce = False
         test_node.send_and_ping(sendcmpct)
         check_announcement_of_new_block(
             node, test_node, lambda p: "cmpctblock" in p.last_message)
 
         # Now turn off announcements
         sendcmpct.version = preferred_version
         sendcmpct.announce = False
         test_node.send_and_ping(sendcmpct)
         check_announcement_of_new_block(
             node, test_node, lambda p: "cmpctblock" not in p.last_message and "headers" in p.last_message)
 
         if old_node is not None:
             # Verify that a peer using an older protocol version can receive
             # announcements from this node.
             sendcmpct.version = 1  # preferred_version-1
             sendcmpct.announce = True
             old_node.send_and_ping(sendcmpct)
             # Header sync
             old_node.request_headers_and_sync(locator=[tip])
             check_announcement_of_new_block(
                 node, old_node, lambda p: "cmpctblock" in p.last_message)
 
     # This test actually causes bitcoind to (reasonably!) disconnect us, so do
     # this last.
     def test_invalid_cmpctblock_message(self):
         self.nodes[0].generate(101)
         block = self.build_block_on_tip(self.nodes[0])
 
         cmpct_block = P2PHeaderAndShortIDs()
         cmpct_block.header = CBlockHeader(block)
         cmpct_block.prefilled_txn_length = 1
         # This index will be too high
         prefilled_txn = PrefilledTransaction(1, block.vtx[0])
         cmpct_block.prefilled_txn = [prefilled_txn]
         self.test_node.send_await_disconnect(msg_cmpctblock(cmpct_block))
         assert_equal(
             int(self.nodes[0].getbestblockhash(), 16), block.hashPrevBlock)
 
     # Compare the generated shortids to what we expect based on BIP 152, given
     # bitcoind's choice of nonce.
     def test_compactblock_construction(self, node, test_node):
         # Generate a bunch of transactions.
         node.generate(101)
         num_transactions = 25
         address = node.getnewaddress()
 
         for i in range(num_transactions):
             txid = node.sendtoaddress(address, 0.1)
             hex_tx = node.gettransaction(txid)["hex"]
             tx = FromHex(CTransaction(), hex_tx)
 
         # Wait until we've seen the block announcement for the resulting tip
         tip = int(node.getbestblockhash(), 16)
         test_node.wait_for_block_announcement(tip)
 
         # Make sure we will receive a fast-announce compact block
         self.request_cb_announcements(test_node, node)
 
         # Now mine a block, and look at the resulting compact block.
         test_node.clear_block_announcement()
         block_hash = int(node.generate(1)[0], 16)
 
         # Store the raw block in our internal format.
         block = FromHex(CBlock(), node.getblock(
             "{:064x}".format(block_hash), False))
         for tx in block.vtx:
             tx.calc_sha256()
         block.rehash()
 
         # Wait until the block was announced (via compact blocks)
         wait_until(test_node.received_block_announcement,
                    timeout=30, lock=mininode_lock)
 
         # Now fetch and check the compact block
         header_and_shortids = None
         with mininode_lock:
             assert "cmpctblock" in test_node.last_message
             # Convert the on-the-wire representation to absolute indexes
             header_and_shortids = HeaderAndShortIDs(
                 test_node.last_message["cmpctblock"].header_and_shortids)
         self.check_compactblock_construction_from_block(
             header_and_shortids, block_hash, block)
 
         # Now fetch the compact block using a normal non-announce getdata
         with mininode_lock:
             test_node.clear_block_announcement()
             inv = CInv(4, block_hash)  # 4 == "CompactBlock"
             test_node.send_message(msg_getdata([inv]))
 
         wait_until(test_node.received_block_announcement,
                    timeout=30, lock=mininode_lock)
 
         # Now fetch and check the compact block
         header_and_shortids = None
         with mininode_lock:
             assert "cmpctblock" in test_node.last_message
             # Convert the on-the-wire representation to absolute indexes
             header_and_shortids = HeaderAndShortIDs(
                 test_node.last_message["cmpctblock"].header_and_shortids)
         self.check_compactblock_construction_from_block(
             header_and_shortids, block_hash, block)
 
     def check_compactblock_construction_from_block(
             self, header_and_shortids, block_hash, block):
         # Check that we got the right block!
         header_and_shortids.header.calc_sha256()
         assert_equal(header_and_shortids.header.sha256, block_hash)
 
         # Make sure the prefilled_txn appears to have included the coinbase
         assert len(header_and_shortids.prefilled_txn) >= 1
         assert_equal(header_and_shortids.prefilled_txn[0].index, 0)
 
         # Check that all prefilled_txn entries match what's in the block.
         for entry in header_and_shortids.prefilled_txn:
             entry.tx.calc_sha256()
             # This checks the tx agree
             assert_equal(entry.tx.sha256, block.vtx[entry.index].sha256)
 
         # Check that the cmpctblock message announced all the transactions.
         assert_equal(len(header_and_shortids.prefilled_txn)
                      + len(header_and_shortids.shortids), len(block.vtx))
 
         # And now check that all the shortids are as expected as well.
         # Determine the siphash keys to use.
         [k0, k1] = header_and_shortids.get_siphash_keys()
 
         index = 0
         while index < len(block.vtx):
             if (len(header_and_shortids.prefilled_txn) > 0 and
                     header_and_shortids.prefilled_txn[0].index == index):
                 # Already checked prefilled transactions above
                 header_and_shortids.prefilled_txn.pop(0)
             else:
                 tx_hash = block.vtx[index].sha256
                 shortid = calculate_shortid(k0, k1, tx_hash)
                 assert_equal(shortid, header_and_shortids.shortids[0])
                 header_and_shortids.shortids.pop(0)
             index += 1
 
     # Test that bitcoind requests compact blocks when we announce new blocks
     # via header or inv, and that responding to getblocktxn causes the block
     # to be successfully reconstructed.
     def test_compactblock_requests(self, node, test_node, version):
         # Try announcing a block with an inv or header, expect a compactblock
         # request
         for announce in ["inv", "header"]:
             block = self.build_block_on_tip(node)
             with mininode_lock:
                 test_node.last_message.pop("getdata", None)
 
             if announce == "inv":
                 test_node.send_message(msg_inv([CInv(2, block.sha256)]))
                 wait_until(lambda: "getheaders" in test_node.last_message,
                            timeout=30, lock=mininode_lock)
                 test_node.send_header_for_blocks([block])
             else:
                 test_node.send_header_for_blocks([block])
             wait_until(lambda: "getdata" in test_node.last_message,
                        timeout=30, lock=mininode_lock)
             assert_equal(len(test_node.last_message["getdata"].inv), 1)
             assert_equal(test_node.last_message["getdata"].inv[0].type, 4)
             assert_equal(
                 test_node.last_message["getdata"].inv[0].hash, block.sha256)
 
             # Send back a compactblock message that omits the coinbase
             comp_block = HeaderAndShortIDs()
             comp_block.header = CBlockHeader(block)
             comp_block.nonce = 0
             [k0, k1] = comp_block.get_siphash_keys()
             coinbase_hash = block.vtx[0].sha256
             comp_block.shortids = [
                 calculate_shortid(k0, k1, coinbase_hash)]
             test_node.send_and_ping(msg_cmpctblock(comp_block.to_p2p()))
             assert_equal(int(node.getbestblockhash(), 16), block.hashPrevBlock)
             # Expect a getblocktxn message.
             with mininode_lock:
                 assert "getblocktxn" in test_node.last_message
                 absolute_indexes = test_node.last_message["getblocktxn"].block_txn_request.to_absolute(
                 )
             assert_equal(absolute_indexes, [0])  # should be a coinbase request
 
             # Send the coinbase, and verify that the tip advances.
             msg = msg_blocktxn()
             msg.block_transactions.blockhash = block.sha256
             msg.block_transactions.transactions = [block.vtx[0]]
             test_node.send_and_ping(msg)
             assert_equal(int(node.getbestblockhash(), 16), block.sha256)
 
     # Create a chain of transactions from given utxo, and add to a new block.
     # Note that num_transactions is number of transactions not including the
     # coinbase.
     def build_block_with_transactions(self, node, utxo, num_transactions):
         block = self.build_block_on_tip(node)
 
         for i in range(num_transactions):
             tx = CTransaction()
             tx.vin.append(CTxIn(COutPoint(utxo[0], utxo[1]), b''))
             tx.vout.append(CTxOut(utxo[2] - 1000, CScript([OP_TRUE])))
             pad_tx(tx)
             tx.rehash()
             utxo = [tx.sha256, 0, tx.vout[0].nValue]
             block.vtx.append(tx)
 
         ordered_txs = block.vtx
         block.vtx = [block.vtx[0]] + \
             sorted(block.vtx[1:], key=lambda tx: tx.get_id())
         block.hashMerkleRoot = block.calc_merkle_root()
         block.solve()
         return block, ordered_txs
 
     # Test that we only receive getblocktxn requests for transactions that the
     # node needs, and that responding to them causes the block to be
     # reconstructed.
     def test_getblocktxn_requests(self, node, test_node, version):
         def test_getblocktxn_response(compact_block, peer, expected_result):
             msg = msg_cmpctblock(compact_block.to_p2p())
             peer.send_and_ping(msg)
             with mininode_lock:
                 assert "getblocktxn" in peer.last_message
                 absolute_indexes = peer.last_message["getblocktxn"].block_txn_request.to_absolute(
                 )
             assert_equal(absolute_indexes, expected_result)
 
         def test_tip_after_message(node, peer, msg, tip):
             peer.send_and_ping(msg)
             assert_equal(int(node.getbestblockhash(), 16), tip)
 
         # First try announcing compactblocks that won't reconstruct, and verify
         # that we receive getblocktxn messages back.
         utxo = self.utxos.pop(0)
 
         block, ordered_txs = self.build_block_with_transactions(node, utxo, 5)
         self.utxos.append(
             [ordered_txs[-1].sha256, 0, ordered_txs[-1].vout[0].nValue])
         comp_block = HeaderAndShortIDs()
         comp_block.initialize_from_block(block)
 
         test_getblocktxn_response(comp_block, test_node, [1, 2, 3, 4, 5])
 
         msg_bt = msg_blocktxn()
         msg_bt.block_transactions = BlockTransactions(
             block.sha256, block.vtx[1:])
         test_tip_after_message(node, test_node, msg_bt, block.sha256)
 
         utxo = self.utxos.pop(0)
         block, ordered_txs = self.build_block_with_transactions(node, utxo, 5)
         self.utxos.append(
             [ordered_txs[-1].sha256, 0, ordered_txs[-1].vout[0].nValue])
 
         # Now try interspersing the prefilled transactions
         comp_block.initialize_from_block(
             block, prefill_list=[0, 1, 5])
         test_getblocktxn_response(comp_block, test_node, [2, 3, 4])
         msg_bt.block_transactions = BlockTransactions(
             block.sha256, block.vtx[2:5])
         test_tip_after_message(node, test_node, msg_bt, block.sha256)
 
         # Now try giving one transaction ahead of time.
         utxo = self.utxos.pop(0)
         block, ordered_txs = self.build_block_with_transactions(node, utxo, 5)
         self.utxos.append(
             [ordered_txs[-1].sha256, 0, ordered_txs[-1].vout[0].nValue])
         test_node.send_and_ping(msg_tx(ordered_txs[1]))
         assert ordered_txs[1].hash in node.getrawmempool()
         test_node.send_and_ping(msg_tx(ordered_txs[1]))
 
         # Prefill 4 out of the 6 transactions, and verify that only the one
         # that was not in the mempool is requested.
         prefill_list = [0, 1, 2, 3, 4, 5]
         prefill_list.remove(block.vtx.index(ordered_txs[1]))
         expected_index = block.vtx.index(ordered_txs[-1])
         prefill_list.remove(expected_index)
         comp_block.initialize_from_block(block, prefill_list=prefill_list)
         test_getblocktxn_response(comp_block, test_node, [expected_index])
 
         msg_bt.block_transactions = BlockTransactions(
             block.sha256, [ordered_txs[5]])
         test_tip_after_message(node, test_node, msg_bt, block.sha256)
 
         # Now provide all transactions to the node before the block is
         # announced and verify reconstruction happens immediately.
         utxo = self.utxos.pop(0)
         block, ordered_txs = self.build_block_with_transactions(node, utxo, 10)
         self.utxos.append(
             [ordered_txs[-1].sha256, 0, ordered_txs[-1].vout[0].nValue])
         for tx in ordered_txs[1:]:
             test_node.send_message(msg_tx(tx))
         test_node.sync_with_ping()
         # Make sure all transactions were accepted.
         mempool = node.getrawmempool()
         for tx in block.vtx[1:]:
             assert tx.hash in mempool
 
         # Clear out last request.
         with mininode_lock:
             test_node.last_message.pop("getblocktxn", None)
 
         # Send compact block
         comp_block.initialize_from_block(block, prefill_list=[0])
         test_tip_after_message(
             node, test_node, msg_cmpctblock(comp_block.to_p2p()), block.sha256)
         with mininode_lock:
             # Shouldn't have gotten a request for any transaction
             assert "getblocktxn" not in test_node.last_message
 
     # Incorrectly responding to a getblocktxn shouldn't cause the block to be
     # permanently failed.
     def test_incorrect_blocktxn_response(self, node, test_node, version):
         if (len(self.utxos) == 0):
             self.make_utxos()
         utxo = self.utxos.pop(0)
 
         block, ordered_txs = self.build_block_with_transactions(node, utxo, 10)
         self.utxos.append(
             [ordered_txs[-1].sha256, 0, ordered_txs[-1].vout[0].nValue])
         # Relay the first 5 transactions from the block in advance
         for tx in ordered_txs[1:6]:
             test_node.send_message(msg_tx(tx))
         test_node.sync_with_ping()
         # Make sure all transactions were accepted.
         mempool = node.getrawmempool()
         for tx in ordered_txs[1:6]:
             assert tx.hash in mempool
 
         # Send compact block
         comp_block = HeaderAndShortIDs()
         comp_block.initialize_from_block(block, prefill_list=[0])
         test_node.send_and_ping(msg_cmpctblock(comp_block.to_p2p()))
         absolute_indices = []
         with mininode_lock:
             assert "getblocktxn" in test_node.last_message
             absolute_indices = test_node.last_message["getblocktxn"].block_txn_request.to_absolute(
             )
         expected_indices = []
         for i in [6, 7, 8, 9, 10]:
             expected_indices.append(block.vtx.index(ordered_txs[i]))
         assert_equal(absolute_indices, sorted(expected_indices))
 
         # Now give an incorrect response.
         # Note that it's possible for bitcoind to be smart enough to know we're
         # lying, since it could check to see if the shortid matches what we're
         # sending, and eg disconnect us for misbehavior.  If that behavior
         # change was made, we could just modify this test by having a
         # different peer provide the block further down, so that we're still
         # verifying that the block isn't marked bad permanently. This is good
         # enough for now.
         msg = msg_blocktxn()
         msg.block_transactions = BlockTransactions(
             block.sha256, [ordered_txs[5]] + ordered_txs[7:])
         test_node.send_and_ping(msg)
 
         # Tip should not have updated
         assert_equal(int(node.getbestblockhash(), 16), block.hashPrevBlock)
 
         # We should receive a getdata request
         wait_until(lambda: "getdata" in test_node.last_message,
                    timeout=10, lock=mininode_lock)
         assert_equal(len(test_node.last_message["getdata"].inv), 1)
         assert test_node.last_message["getdata"].inv[0].type == 2
         assert_equal(
             test_node.last_message["getdata"].inv[0].hash, block.sha256)
 
         # Deliver the block
         test_node.send_and_ping(msg_block(block))
         assert_equal(int(node.getbestblockhash(), 16), block.sha256)
 
     def test_getblocktxn_handler(self, node, test_node, version):
         # bitcoind will not send blocktxn responses for blocks whose height is
         # more than 10 blocks deep.
         MAX_GETBLOCKTXN_DEPTH = 10
         chain_height = node.getblockcount()
         current_height = chain_height
         while (current_height >= chain_height - MAX_GETBLOCKTXN_DEPTH):
             block_hash = node.getblockhash(current_height)
             block = FromHex(CBlock(), node.getblock(block_hash, False))
 
             msg = msg_getblocktxn()
             msg.block_txn_request = BlockTransactionsRequest(
                 int(block_hash, 16), [])
             num_to_request = random.randint(1, len(block.vtx))
             msg.block_txn_request.from_absolute(
                 sorted(random.sample(range(len(block.vtx)), num_to_request)))
             test_node.send_message(msg)
             wait_until(lambda: "blocktxn" in test_node.last_message,
                        timeout=10, lock=mininode_lock)
 
             [tx.calc_sha256() for tx in block.vtx]
             with mininode_lock:
                 assert_equal(test_node.last_message["blocktxn"].block_transactions.blockhash, int(
                     block_hash, 16))
                 all_indices = msg.block_txn_request.to_absolute()
                 for index in all_indices:
                     tx = test_node.last_message["blocktxn"].block_transactions.transactions.pop(
                         0)
                     tx.calc_sha256()
                     assert_equal(tx.sha256, block.vtx[index].sha256)
                 test_node.last_message.pop("blocktxn", None)
             current_height -= 1
 
         # Next request should send a full block response, as we're past the
         # allowed depth for a blocktxn response.
         block_hash = node.getblockhash(current_height)
         msg.block_txn_request = BlockTransactionsRequest(
             int(block_hash, 16), [0])
         with mininode_lock:
             test_node.last_message.pop("block", None)
             test_node.last_message.pop("blocktxn", None)
         test_node.send_and_ping(msg)
         with mininode_lock:
             test_node.last_message["block"].block.calc_sha256()
             assert_equal(
                 test_node.last_message["block"].block.sha256, int(block_hash, 16))
             assert "blocktxn" not in test_node.last_message
 
     def test_compactblocks_not_at_tip(self, node, test_node):
         # Test that requesting old compactblocks doesn't work.
         MAX_CMPCTBLOCK_DEPTH = 5
         new_blocks = []
         for i in range(MAX_CMPCTBLOCK_DEPTH + 1):
             test_node.clear_block_announcement()
             new_blocks.append(node.generate(1)[0])
             wait_until(test_node.received_block_announcement,
                        timeout=30, lock=mininode_lock)
 
         test_node.clear_block_announcement()
         test_node.send_message(msg_getdata([CInv(4, int(new_blocks[0], 16))]))
         wait_until(lambda: "cmpctblock" in test_node.last_message,
                    timeout=30, lock=mininode_lock)
 
         test_node.clear_block_announcement()
         node.generate(1)
         wait_until(test_node.received_block_announcement,
                    timeout=30, lock=mininode_lock)
         test_node.clear_block_announcement()
         with mininode_lock:
             test_node.last_message.pop("block", None)
         test_node.send_message(msg_getdata([CInv(4, int(new_blocks[0], 16))]))
         wait_until(lambda: "block" in test_node.last_message,
                    timeout=30, lock=mininode_lock)
         with mininode_lock:
             test_node.last_message["block"].block.calc_sha256()
             assert_equal(
                 test_node.last_message["block"].block.sha256, int(new_blocks[0], 16))
 
         # Generate an old compactblock, and verify that it's not accepted.
         cur_height = node.getblockcount()
         hashPrevBlock = int(node.getblockhash(cur_height - 5), 16)
         block = self.build_block_on_tip(node)
         block.hashPrevBlock = hashPrevBlock
         block.solve()
 
         comp_block = HeaderAndShortIDs()
         comp_block.initialize_from_block(block)
         test_node.send_and_ping(msg_cmpctblock(comp_block.to_p2p()))
 
         tips = node.getchaintips()
         found = False
         for x in tips:
             if x["hash"] == block.hash:
                 assert_equal(x["status"], "headers-only")
                 found = True
                 break
         assert found
 
         # Requesting this block via getblocktxn should silently fail
         # (to avoid fingerprinting attacks).
         msg = msg_getblocktxn()
         msg.block_txn_request = BlockTransactionsRequest(block.sha256, [0])
         with mininode_lock:
             test_node.last_message.pop("blocktxn", None)
         test_node.send_and_ping(msg)
         with mininode_lock:
             assert "blocktxn" not in test_node.last_message
 
     def test_end_to_end_block_relay(self, node, listeners):
         utxo = self.utxos.pop(0)
 
         block, _ = self.build_block_with_transactions(node, utxo, 10)
 
-        [l.clear_block_announcement() for l in listeners]
+        [listener.clear_block_announcement() for listener in listeners]
 
         node.submitblock(ToHex(block))
 
-        for l in listeners:
-            wait_until(lambda: l.received_block_announcement(),
+        for listener in listeners:
+            wait_until(lambda: listener.received_block_announcement(),
                        timeout=30, lock=mininode_lock)
         with mininode_lock:
-            for l in listeners:
-                assert "cmpctblock" in l.last_message
-                l.last_message["cmpctblock"].header_and_shortids.header.calc_sha256(
+            for listener in listeners:
+                assert "cmpctblock" in listener.last_message
+                listener.last_message["cmpctblock"].header_and_shortids.header.calc_sha256(
                 )
                 assert_equal(
-                    l.last_message["cmpctblock"].header_and_shortids.header.sha256, block.sha256)
+                    listener.last_message["cmpctblock"].header_and_shortids.header.sha256, block.sha256)
 
     # Test that we don't get disconnected if we relay a compact block with valid header,
     # but invalid transactions.
     def test_invalid_tx_in_compactblock(self, node, test_node):
         assert len(self.utxos)
         utxo = self.utxos[0]
 
         block, ordered_txs = self.build_block_with_transactions(node, utxo, 5)
         block.vtx.remove(ordered_txs[3])
         block.hashMerkleRoot = block.calc_merkle_root()
         block.solve()
 
         # Now send the compact block with all transactions prefilled, and
         # verify that we don't get disconnected.
         comp_block = HeaderAndShortIDs()
         comp_block.initialize_from_block(block, prefill_list=[0, 1, 2, 3, 4])
         msg = msg_cmpctblock(comp_block.to_p2p())
         test_node.send_and_ping(msg)
 
         # Check that the tip didn't advance
         assert int(node.getbestblockhash(), 16) is not block.sha256
         test_node.sync_with_ping()
 
     # Helper for enabling cb announcements
     # Send the sendcmpct request and sync headers
     def request_cb_announcements(self, peer, node, version=1):
         tip = node.getbestblockhash()
         peer.get_headers(locator=[int(tip, 16)], hashstop=0)
 
         msg = msg_sendcmpct()
         msg.version = version
         msg.announce = True
         peer.send_and_ping(msg)
 
     def test_compactblock_reconstruction_multiple_peers(
             self, node, stalling_peer, delivery_peer):
         assert len(self.utxos)
 
         def announce_cmpct_block(node, peer):
             utxo = self.utxos.pop(0)
             block, _ = self.build_block_with_transactions(node, utxo, 5)
 
             cmpct_block = HeaderAndShortIDs()
             cmpct_block.initialize_from_block(block)
             msg = msg_cmpctblock(cmpct_block.to_p2p())
             peer.send_and_ping(msg)
             with mininode_lock:
                 assert "getblocktxn" in peer.last_message
             return block, cmpct_block
 
         block, cmpct_block = announce_cmpct_block(node, stalling_peer)
 
         for tx in block.vtx[1:]:
             delivery_peer.send_message(msg_tx(tx))
         delivery_peer.sync_with_ping()
         mempool = node.getrawmempool()
         for tx in block.vtx[1:]:
             assert tx.hash in mempool
 
         delivery_peer.send_and_ping(msg_cmpctblock(cmpct_block.to_p2p()))
         assert_equal(int(node.getbestblockhash(), 16), block.sha256)
 
         self.utxos.append(
             [block.vtx[-1].sha256, 0, block.vtx[-1].vout[0].nValue])
 
         # Now test that delivering an invalid compact block won't break relay
         block, cmpct_block = announce_cmpct_block(node, stalling_peer)
         for tx in block.vtx[1:]:
             delivery_peer.send_message(msg_tx(tx))
         delivery_peer.sync_with_ping()
 
         # TODO: modify txhash in a way that doesn't impact txid.
         delivery_peer.send_and_ping(msg_cmpctblock(cmpct_block.to_p2p()))
         # Because txhash isn't modified, we end up reconstructing the same block
         # assert int(node.getbestblockhash(), 16) != block.sha256
 
         msg = msg_blocktxn()
         msg.block_transactions.blockhash = block.sha256
         msg.block_transactions.transactions = block.vtx[1:]
         stalling_peer.send_and_ping(msg)
         assert_equal(int(node.getbestblockhash(), 16), block.sha256)
 
     def run_test(self):
         # Setup the p2p connections
         self.test_node = self.nodes[0].add_p2p_connection(TestP2PConn())
         self.ex_softfork_node = self.nodes[1].add_p2p_connection(
             TestP2PConn(), services=NODE_NETWORK)
         self.old_node = self.nodes[1].add_p2p_connection(
             TestP2PConn(), services=NODE_NETWORK)
 
         # We will need UTXOs to construct transactions in later tests.
         self.make_utxos()
 
         self.log.info("Running tests:")
 
         self.log.info("\tTesting SENDCMPCT p2p message... ")
         self.test_sendcmpct(self.nodes[0], self.test_node, 1)
         sync_blocks(self.nodes)
         self.test_sendcmpct(
             self.nodes[1], self.ex_softfork_node, 1, old_node=self.old_node)
         sync_blocks(self.nodes)
 
         self.log.info("\tTesting compactblock construction...")
         self.test_compactblock_construction(self.nodes[0], self.test_node)
         sync_blocks(self.nodes)
         self.test_compactblock_construction(
             self.nodes[1], self.ex_softfork_node)
         sync_blocks(self.nodes)
 
         self.log.info("\tTesting compactblock requests... ")
         self.test_compactblock_requests(self.nodes[0], self.test_node, 1)
         sync_blocks(self.nodes)
         self.test_compactblock_requests(
             self.nodes[1], self.ex_softfork_node, 2)
         sync_blocks(self.nodes)
 
         self.log.info("\tTesting getblocktxn requests...")
         self.test_getblocktxn_requests(self.nodes[0], self.test_node, 1)
         sync_blocks(self.nodes)
         self.test_getblocktxn_requests(self.nodes[1], self.ex_softfork_node, 2)
         sync_blocks(self.nodes)
 
         self.log.info("\tTesting getblocktxn handler...")
         self.test_getblocktxn_handler(self.nodes[0], self.test_node, 1)
         sync_blocks(self.nodes)
         self.test_getblocktxn_handler(self.nodes[1], self.ex_softfork_node, 2)
         self.test_getblocktxn_handler(self.nodes[1], self.old_node, 1)
         sync_blocks(self.nodes)
 
         self.log.info(
             "\tTesting compactblock requests/announcements not at chain tip...")
         self.test_compactblocks_not_at_tip(self.nodes[0], self.test_node)
         sync_blocks(self.nodes)
         self.test_compactblocks_not_at_tip(
             self.nodes[1], self.ex_softfork_node)
         self.test_compactblocks_not_at_tip(self.nodes[1], self.old_node)
         sync_blocks(self.nodes)
 
         self.log.info("\tTesting handling of incorrect blocktxn responses...")
         self.test_incorrect_blocktxn_response(self.nodes[0], self.test_node, 1)
         sync_blocks(self.nodes)
         self.test_incorrect_blocktxn_response(
             self.nodes[1], self.ex_softfork_node, 2)
         sync_blocks(self.nodes)
 
         # End-to-end block relay tests
         self.log.info("\tTesting end-to-end block relay...")
         self.request_cb_announcements(self.test_node, self.nodes[0])
         self.request_cb_announcements(self.old_node, self.nodes[1])
         self.request_cb_announcements(
             self.ex_softfork_node, self.nodes[1], version=2)
         self.test_end_to_end_block_relay(
             self.nodes[0], [self.ex_softfork_node, self.test_node, self.old_node])
         self.test_end_to_end_block_relay(
             self.nodes[1], [self.ex_softfork_node, self.test_node, self.old_node])
 
         self.log.info("\tTesting handling of invalid compact blocks...")
         self.test_invalid_tx_in_compactblock(self.nodes[0], self.test_node)
         self.test_invalid_tx_in_compactblock(
             self.nodes[1], self.ex_softfork_node)
         self.test_invalid_tx_in_compactblock(self.nodes[1], self.old_node)
 
         self.log.info(
             "\tTesting reconstructing compact blocks from all peers...")
         self.test_compactblock_reconstruction_multiple_peers(
             self.nodes[1], self.ex_softfork_node, self.old_node)
         sync_blocks(self.nodes)
 
         self.log.info("\tTesting invalid index in cmpctblock message...")
         self.test_invalid_cmpctblock_message()
 
 
 if __name__ == '__main__':
     CompactBlocksTest().main()
diff --git a/test/functional/test_framework/messages.py b/test/functional/test_framework/messages.py
index 7492fe1044..4bd0c19548 100755
--- a/test/functional/test_framework/messages.py
+++ b/test/functional/test_framework/messages.py
@@ -1,1476 +1,1476 @@
 #!/usr/bin/env python3
 # Copyright (c) 2010 ArtForz -- public domain half-a-node
 # Copyright (c) 2012 Jeff Garzik
 # Copyright (c) 2010-2019 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 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_LOCATOR_SZ = 101
 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)
 NODE_AVALANCHE = (1 << 24)
 
 MSG_TX = 1
 MSG_BLOCK = 2
 MSG_CMPCTBLOCK = 4
 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):
+def ser_compact_size(size):
     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)
+    if size < 253:
+        r = struct.pack("B", size)
+    elif size < 0x10000:
+        r = struct.pack("<BH", 253, size)
+    elif size < 0x100000000:
+        r = struct.pack("<BI", 254, size)
     else:
-        r = struct.pack("<BQ", 255, l)
+        r = struct.pack("<BQ", 255, size)
     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:
+def ser_vector(v, ser_function_name=None):
+    r = ser_compact_size(len(v))
+    for i in v:
         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:
+def ser_uint256_vector(v):
+    r = ser_compact_size(len(v))
+    for i in v:
         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:
+def ser_string_vector(v):
+    r = ser_compact_size(len(v))
+    for sv in v:
         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 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), 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, 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,
             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,
             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 is not 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 is not 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 is not 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 AvalanchePoll():
     __slots__ = ("round", "invs")
 
     def __init__(self, round=0, invs=None):
         self.round = round
         self.invs = invs if invs is not None else []
 
     def deserialize(self, f):
         self.round = struct.unpack("<q", f.read(8))[0]
         self.invs = deser_vector(f, CInv)
 
     def serialize(self):
         r = b""
         r += struct.pack("<q", self.round)
         r += ser_vector(self.invs)
         return r
 
     def __repr__(self):
         return "AvalanchePoll(round={}, invs={})".format(
             self.round, repr(self.invs))
 
 
 class AvalancheVote():
     __slots__ = ("error", "hash")
 
     def __init__(self, e=0, h=0):
         self.error = e
         self.hash = h
 
     def deserialize(self, f):
         self.error = struct.unpack("<i", f.read(4))[0]
         self.hash = deser_uint256(f)
 
     def serialize(self):
         r = b""
         r += struct.pack("<i", self.error)
         r += ser_uint256(self.hash)
         return r
 
     def __repr__(self):
         return "AvalancheVote(error={}, hash={:064x})".format(
             self.error, self.hash)
 
 
 class AvalancheResponse():
     __slots__ = ("round", "cooldown", "votes")
 
     def __init__(self, round=0, cooldown=0, votes=None):
         self.round = round
         self.cooldown = cooldown
         self.votes = votes if votes is not None else []
 
     def deserialize(self, f):
         self.round = struct.unpack("<q", f.read(8))[0]
         self.cooldown = struct.unpack("<i", f.read(4))[0]
         self.votes = deser_vector(f, AvalancheVote)
 
     def serialize(self):
         r = b""
         r += struct.pack("<q", self.round)
         r += struct.pack("<i", self.cooldown)
         r += ser_vector(self.votes)
         return r
 
     def get_hash(self):
         return hash256(self.serialize())
 
     def __repr__(self):
         return "AvalancheResponse(round={}, cooldown={}, votes={})".format(
             self.round, self.cooldown, repr(self.votes))
 
 
 class TCPAvalancheResponse():
     __slots__ = ("response", "sig")
 
     def __init__(self, response=AvalancheResponse(), sig=b"\0" * 64):
         self.response = response
         self.sig = sig
 
     def deserialize(self, f):
         self.response.deserialize(f)
         self.sig = f.read(64)
 
     def serialize(self):
         r = b""
         r += self.response.serialize()
         r += self.sig
         return r
 
     def __repr__(self):
         return "TCPAvalancheResponse(response={}, sig={})".format(
             repr(self.response), self.sig)
 
 
 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]
         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)
 
         self.addrFrom = CAddress()
         self.addrFrom.deserialize(f, False)
         self.nNonce = struct.unpack("<Q", f.read(8))[0]
         self.strSubVer = deser_string(f)
 
         self.nStartingHeight = struct.unpack("<i", f.read(4))[0]
 
         if self.nVersion >= 70001:
             # Relay field is optional for version 70001 onwards
             try:
                 self.nRelay = struct.unpack("<b", f.read(1))[0]
             except Exception:
                 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, 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 is not 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))
 
 
 class msg_avapoll():
     __slots__ = ("poll",)
     command = b"avapoll"
 
     def __init__(self):
         self.poll = AvalanchePoll()
 
     def deserialize(self, f):
         self.poll.deserialize(f)
 
     def serialize(self):
         r = b""
         r += self.poll.serialize()
         return r
 
     def __repr__(self):
         return "msg_avapoll(poll={})".format(repr(self.poll))
 
 
 class msg_avaresponse():
     __slots__ = ("response",)
     command = b"avaresponse"
 
     def __init__(self):
         self.response = AvalancheResponse()
 
     def deserialize(self, f):
         self.response.deserialize(f)
 
     def serialize(self):
         r = b""
         r += self.response.serialize()
         return r
 
     def __repr__(self):
         return "msg_avaresponse(response={})".format(repr(self.response))
 
 
 class msg_tcpavaresponse():
     __slots__ = ("response",)
     command = b"avaresponse"
 
     def __init__(self):
         self.response = TCPAvalancheResponse()
 
     def deserialize(self, f):
         self.response.deserialize(f)
 
     def serialize(self):
         r = b""
         r += self.response.serialize()
         return r
 
     def __repr__(self):
         return "msg_tcpavaresponse(response={})".format(repr(self.response))
diff --git a/test/functional/test_runner.py b/test/functional/test_runner.py
index b0e2f7631f..a752ef3032 100755
--- a/test/functional/test_runner.py
+++ b/test/functional/test_runner.py
@@ -1,871 +1,871 @@
 #!/usr/bin/env python3
 # Copyright (c) 2014-2019 The Bitcoin Core developers
 # Copyright (c) 2017 The Bitcoin developers
 # Distributed under the MIT software license, see the accompanying
 # file COPYING or http://www.opensource.org/licenses/mit-license.php.
 """Run regression test suite.
 
 This module calls down into individual test cases via subprocess. It will
 forward all unrecognized arguments onto the individual test scripts.
 
 Functional tests are disabled on Windows by default. Use --force to run them anyway.
 
 For a description of arguments recognized by test scripts, see
 `test/functional/test_framework/test_framework.py:BitcoinTestFramework.main`.
 
 """
 
 import argparse
 from collections import deque
 import configparser
 import datetime
 import os
 import time
 import shutil
 import sys
 import subprocess
 import tempfile
 import re
 import logging
 import xml.etree.ElementTree as ET
 import json
 import threading
 import multiprocessing
 from queue import Queue, Empty
 
 # Formatting. Default colors to empty strings.
 BOLD, GREEN, RED, GREY = ("", ""), ("", ""), ("", ""), ("", "")
 try:
     # Make sure python thinks it can write unicode to its stdout
     "\u2713".encode("utf_8").decode(sys.stdout.encoding)
     TICK = "✓ "
     CROSS = "✖ "
     CIRCLE = "○ "
 except UnicodeDecodeError:
     TICK = "P "
     CROSS = "x "
     CIRCLE = "o "
 
 if os.name != 'nt' or sys.getwindowsversion() >= (10, 0, 14393):
     if os.name == 'nt':
         import ctypes
         kernel32 = ctypes.windll.kernel32
         ENABLE_VIRTUAL_TERMINAL_PROCESSING = 4
         STD_OUTPUT_HANDLE = -11
         STD_ERROR_HANDLE = -12
         # Enable ascii color control to stdout
         stdout = kernel32.GetStdHandle(STD_OUTPUT_HANDLE)
         stdout_mode = ctypes.c_int32()
         kernel32.GetConsoleMode(stdout, ctypes.byref(stdout_mode))
         kernel32.SetConsoleMode(
             stdout, stdout_mode.value | ENABLE_VIRTUAL_TERMINAL_PROCESSING)
         # Enable ascii color control to stderr
         stderr = kernel32.GetStdHandle(STD_ERROR_HANDLE)
         stderr_mode = ctypes.c_int32()
         kernel32.GetConsoleMode(stderr, ctypes.byref(stderr_mode))
         kernel32.SetConsoleMode(
             stderr, stderr_mode.value | ENABLE_VIRTUAL_TERMINAL_PROCESSING)
     # primitive formatting on supported
     # terminal via ANSI escape sequences:
     BOLD = ('\033[0m', '\033[1m')
     GREEN = ('\033[0m', '\033[0;32m')
     RED = ('\033[0m', '\033[0;31m')
     GREY = ('\033[0m', '\033[1;30m')
 
 TEST_EXIT_PASSED = 0
 TEST_EXIT_SKIPPED = 77
 
 NON_SCRIPTS = [
     # These are python files that live in the functional tests directory, but
     # are not test scripts.
     "combine_logs.py",
     "create_cache.py",
     "test_runner.py",
 ]
 
 TEST_PARAMS = {
     # Some test can be run with additional parameters.
     # When a test is listed here, the it  will be run without parameters
     # as well as with additional parameters listed here.
     # This:
     #    example "testName" : [["--param1", "--param2"] , ["--param3"]]
     # will run the test 3 times:
     #    testName
     #    testName --param1 --param2
     #    testname --param3
     "wallet_txn_doublespend.py": [["--mineblock"]],
     "wallet_txn_clone.py": [["--mineblock"]],
     "wallet_createwallet.py": [["--usecli"]],
     "wallet_multiwallet.py": [["--usecli"]],
 }
 
 # Used to limit the number of tests, when list of tests is not provided on command line
 # When --extended is specified, we run all tests, otherwise
 # we only run a test if its execution time in seconds does not exceed
 # EXTENDED_CUTOFF
 DEFAULT_EXTENDED_CUTOFF = 40
 DEFAULT_JOBS = (multiprocessing.cpu_count() // 3) + 1
 
 
 class TestCase():
     """
     Data structure to hold and run information necessary to launch a test case.
     """
 
     def __init__(self, test_num, test_case, tests_dir,
                  tmpdir, failfast_event, flags=None):
         self.tests_dir = tests_dir
         self.tmpdir = tmpdir
         self.test_case = test_case
         self.test_num = test_num
         self.failfast_event = failfast_event
         self.flags = flags
 
     def run(self, portseed_offset):
         if self.failfast_event.is_set():
             return TestResult(self.test_num, self.test_case,
                               "", "Skipped", 0, "", "")
 
         portseed = self.test_num + portseed_offset
         portseed_arg = ["--portseed={}".format(portseed)]
         log_stdout = tempfile.SpooledTemporaryFile(max_size=2**16)
         log_stderr = tempfile.SpooledTemporaryFile(max_size=2**16)
         test_argv = self.test_case.split()
         testdir = os.path.join("{}", "{}_{}").format(
             self.tmpdir, re.sub(".py$", "", test_argv[0]), portseed)
         tmpdir_arg = ["--tmpdir={}".format(testdir)]
         time0 = time.time()
         process = subprocess.Popen([sys.executable, os.path.join(self.tests_dir, test_argv[0])] + test_argv[1:] + self.flags + portseed_arg + tmpdir_arg,
                                    universal_newlines=True,
                                    stdout=log_stdout,
                                    stderr=log_stderr)
 
         process.wait()
         log_stdout.seek(0), log_stderr.seek(0)
-        [stdout, stderr] = [l.read().decode('utf-8')
-                            for l in (log_stdout, log_stderr)]
+        [stdout, stderr] = [log.read().decode('utf-8')
+                            for log in (log_stdout, log_stderr)]
         log_stdout.close(), log_stderr.close()
         if process.returncode == TEST_EXIT_PASSED and stderr == "":
             status = "Passed"
         elif process.returncode == TEST_EXIT_SKIPPED:
             status = "Skipped"
         else:
             status = "Failed"
 
         return TestResult(self.test_num, self.test_case, testdir, status,
                           int(time.time() - time0), stdout, stderr)
 
 
 def on_ci():
     return os.getenv('TRAVIS') == 'true' or os.getenv(
         'TEAMCITY_VERSION') is not None
 
 
 def main():
     # Read config generated by configure.
     config = configparser.ConfigParser()
     configfile = os.path.join(os.path.abspath(
         os.path.dirname(__file__)), "..", "config.ini")
     config.read_file(open(configfile, encoding="utf8"))
 
     src_dir = config["environment"]["SRCDIR"]
     build_dir = config["environment"]["BUILDDIR"]
     tests_dir = os.path.join(src_dir, 'test', 'functional')
 
     # Parse arguments and pass through unrecognised args
     parser = argparse.ArgumentParser(add_help=False,
                                      usage='%(prog)s [test_runner.py options] [script options] [scripts]',
                                      description=__doc__,
                                      epilog='''
     Help text and arguments for individual test script:''',
                                      formatter_class=argparse.ArgumentDefaultsHelpFormatter)
     parser.add_argument('--combinedlogslen', '-c', type=int, default=0,
                         help='print a combined log (of length n lines) from all test nodes and test framework to the console on failure.')
     parser.add_argument('--coverage', action='store_true',
                         help='generate a basic coverage report for the RPC interface')
     parser.add_argument(
         '--exclude', '-x', help='specify a comma-separated-list of scripts to exclude.')
     parser.add_argument('--extended', action='store_true',
                         help='run the extended test suite in addition to the basic tests')
     parser.add_argument('--cutoff', type=int, default=DEFAULT_EXTENDED_CUTOFF,
                         help='set the cutoff runtime for what tests get run')
     parser.add_argument('--force', '-f', action='store_true',
                         help='run tests even on platforms where they are disabled by default (e.g. windows).')
     parser.add_argument('--help', '-h', '-?',
                         action='store_true', help='print help text and exit')
     parser.add_argument('--jobs', '-j', type=int, default=DEFAULT_JOBS,
                         help='how many test scripts to run in parallel.')
     parser.add_argument('--keepcache', '-k', action='store_true',
                         help='the default behavior is to flush the cache directory on startup. --keepcache retains the cache from the previous testrun.')
     parser.add_argument('--quiet', '-q', action='store_true',
                         help='only print results summary and failure logs')
     parser.add_argument('--tmpdirprefix', '-t',
                         default=os.path.join(build_dir, 'test', 'tmp'), help="Root directory for datadirs")
     parser.add_argument(
         '--failfast',
         action='store_true',
         help='stop execution after the first test failure')
     parser.add_argument('--junitoutput', '-J', default='junit_results.xml',
                         help="File that will store JUnit formatted test results. If no absolute path is given it is treated as relative to the temporary directory.")
     parser.add_argument('--testsuitename', '-n', default='Bitcoin ABC functional tests',
                         help="Name of the test suite, as it will appear in the logs and in the JUnit report.")
     args, unknown_args = parser.parse_known_args()
 
     # args to be passed on always start with two dashes; tests are the
     # remaining unknown args
     tests = [arg for arg in unknown_args if arg[:2] != "--"]
     passon_args = [arg for arg in unknown_args if arg[:2] == "--"]
     passon_args.append("--configfile={}".format(configfile))
 
     # Set up logging
     logging_level = logging.INFO if args.quiet else logging.DEBUG
     logging.basicConfig(format='%(message)s', level=logging_level)
     logging.info("Starting {}".format(args.testsuitename))
 
     # Create base test directory
     tmpdir = os.path.join("{}", "test_runner_₿₵_🏃_{:%Y%m%d_%H%M%S}").format(
         args.tmpdirprefix, datetime.datetime.now())
 
     # If we fixed the command-line and filename encoding issue on Windows,
     # these two lines could be removed
     if config["environment"]["EXEEXT"] == ".exe":
         tmpdir = os.path.join("{}", "test_runner_{:%Y%m%d_%H%M%S}").format(
             args.tmpdirprefix, datetime.datetime.now())
 
     os.makedirs(tmpdir)
 
     logging.debug("Temporary test directory at {}".format(tmpdir))
 
     if not os.path.isabs(args.junitoutput):
         args.junitoutput = os.path.join(tmpdir, args.junitoutput)
 
     enable_bitcoind = config["components"].getboolean("ENABLE_BITCOIND")
 
     if config["environment"]["EXEEXT"] == ".exe" and not args.force:
         # https://github.com/bitcoin/bitcoin/commit/d52802551752140cf41f0d9a225a43e84404d3e9
         # https://github.com/bitcoin/bitcoin/pull/5677#issuecomment-136646964
         print(
             "Tests currently disabled on Windows by default. Use --force option to enable")
         sys.exit(0)
 
     if not enable_bitcoind:
         print("No functional tests to run.")
         print("Rerun ./configure with --with-daemon and then make")
         sys.exit(0)
 
     # Build list of tests
     all_scripts = get_all_scripts_from_disk(tests_dir, NON_SCRIPTS)
 
     # Check all tests with parameters actually exist
     for test in TEST_PARAMS:
         if test not in all_scripts:
             print("ERROR: Test with parameter {} does not exist, check it has "
                   "not been renamed or deleted".format(test))
             sys.exit(1)
 
     if tests:
         # Individual tests have been specified. Run specified tests that exist
         # in the all_scripts list. Accept the name with or without .py
         # extension.
         individual_tests = [
             re.sub(r"\.py$", "", t) + ".py" for t in tests if not t.endswith('*')]
         test_list = []
         for t in individual_tests:
             if t in all_scripts:
                 test_list.append(t)
             else:
                 print("{}WARNING!{} Test '{}' not found in full test list.".format(
                     BOLD[1], BOLD[0], t))
 
         # Allow for wildcard at the end of the name, so a single input can
         # match multiple tests
         for test in tests:
             if test.endswith('*'):
                 test_list.extend(
                     [t for t in all_scripts if t.startswith(test[:-1])])
 
         # do not cut off explicitly specified tests
         cutoff = sys.maxsize
     else:
         # No individual tests have been specified.
         # Run all tests that do not exceed
         test_list = all_scripts
         cutoff = args.cutoff
         if args.extended:
             cutoff = sys.maxsize
 
     # Remove the test cases that the user has explicitly asked to exclude.
     if args.exclude:
         tests_excl = [re.sub(r"\.py$", "", t)
                       + (".py" if ".py" not in t else "") for t in args.exclude.split(',')]
         for exclude_test in tests_excl:
             if exclude_test in test_list:
                 test_list.remove(exclude_test)
             else:
                 print("{}WARNING!{} Test '{}' not found in current test list.".format(
                     BOLD[1], BOLD[0], exclude_test))
 
     # Update timings from build_dir only if separate build directory is used.
     # We do not want to pollute source directory.
     build_timings = None
     if (src_dir != build_dir):
         build_timings = Timings(os.path.join(build_dir, 'timing.json'))
 
     # Always use timings from scr_dir if present
     src_timings = Timings(os.path.join(
         src_dir, "test", "functional", 'timing.json'))
 
     # Add test parameters and remove long running tests if needed
     test_list = get_tests_to_run(
         test_list, TEST_PARAMS, cutoff, src_timings)
 
     if not test_list:
         print("No valid test scripts specified. Check that your test is in one "
               "of the test lists in test_runner.py, or run test_runner.py with no arguments to run all tests")
         sys.exit(0)
 
     if args.help:
         # Print help for test_runner.py, then print help of the first script
         # and exit.
         parser.print_help()
         subprocess.check_call(
             [sys.executable, os.path.join(tests_dir, test_list[0]), '-h'])
         sys.exit(0)
 
     check_script_prefixes(all_scripts)
 
     if not args.keepcache:
         shutil.rmtree(os.path.join(build_dir, "test",
                                    "cache"), ignore_errors=True)
 
     run_tests(
         test_list,
         build_dir,
         tests_dir,
         args.junitoutput,
         tmpdir,
         num_jobs=args.jobs,
         test_suite_name=args.testsuitename,
         enable_coverage=args.coverage,
         args=passon_args,
         combined_logs_len=args.combinedlogslen,
         build_timings=build_timings,
         failfast=args.failfast
     )
 
 
 def run_tests(test_list, build_dir, tests_dir, junitoutput, tmpdir, num_jobs, test_suite_name,
               enable_coverage=False, args=None, combined_logs_len=0, build_timings=None, failfast=False):
     args = args or []
 
     # Warn if bitcoind is already running (unix only)
     try:
         pidofOutput = subprocess.check_output(["pidof", "bitcoind"])
         if pidofOutput is not None and pidofOutput != b'':
             print("{}WARNING!{} There is already a bitcoind process running on this system. Tests may fail unexpectedly due to resource contention!".format(
                 BOLD[1], BOLD[0]))
     except (OSError, subprocess.SubprocessError):
         pass
 
     # Warn if there is a cache directory
     cache_dir = os.path.join(build_dir, "test", "cache")
     if os.path.isdir(cache_dir):
         print("{}WARNING!{} There is a cache directory here: {}. If tests fail unexpectedly, try deleting the cache directory.".format(
             BOLD[1], BOLD[0], cache_dir))
 
     flags = ['--cachedir={}'.format(cache_dir)] + args
 
     if enable_coverage:
         coverage = RPCCoverage()
         flags.append(coverage.flag)
         logging.debug(
             "Initializing coverage directory at {}".format(coverage.dir))
     else:
         coverage = None
 
     if len(test_list) > 1 and num_jobs > 1:
         # Populate cache
         try:
             subprocess.check_output([sys.executable, os.path.join(
                 tests_dir, 'create_cache.py')] + flags + [os.path.join("--tmpdir={}", "cache") .format(tmpdir)])
         except subprocess.CalledProcessError as e:
             sys.stdout.buffer.write(e.output)
             raise
 
     # Run Tests
     time0 = time.time()
     test_results = execute_test_processes(
         num_jobs, test_list, tests_dir, tmpdir, flags, failfast)
     runtime = int(time.time() - time0)
 
     max_len_name = len(max(test_list, key=len))
     print_results(test_results, tests_dir, max_len_name,
                   runtime, combined_logs_len)
     save_results_as_junit(test_results, junitoutput, runtime, test_suite_name)
 
     if (build_timings is not None):
         build_timings.save_timings(test_results)
 
     if coverage:
         coverage_passed = coverage.report_rpc_coverage()
 
         logging.debug("Cleaning up coverage data")
         coverage.cleanup()
     else:
         coverage_passed = True
 
     # Clear up the temp directory if all subdirectories are gone
     if not os.listdir(tmpdir):
         os.rmdir(tmpdir)
 
     all_passed = all(map(
         lambda test_result: test_result.was_successful, test_results)) and coverage_passed
 
     sys.exit(not all_passed)
 
 
 def execute_test_processes(
         num_jobs, test_list, tests_dir, tmpdir, flags, failfast=False):
     update_queue = Queue()
     job_queue = Queue()
     failfast_event = threading.Event()
     test_results = []
     poll_timeout = 10  # seconds
     # In case there is a graveyard of zombie bitcoinds, we can apply a
     # pseudorandom offset to hopefully jump over them.
     # (625 is PORT_RANGE/MAX_NODES)
     portseed_offset = int(time.time() * 1000) % 625
 
     ##
     # Define some helper functions we will need for threading.
     ##
 
     def handle_message(message, running_jobs):
         """
         handle_message handles a single message from handle_test_cases
         """
         if isinstance(message, TestCase):
             running_jobs.append((message.test_num, message.test_case))
             print("{}{}{} started".format(BOLD[1], message.test_case, BOLD[0]))
             return
 
         if isinstance(message, TestResult):
             test_result = message
 
             running_jobs.remove((test_result.num, test_result.name))
             test_results.append(test_result)
 
             if test_result.status == "Passed":
                 print("{}{}{} passed, Duration: {} s".format(
                     BOLD[1], test_result.name, BOLD[0], test_result.time))
             elif test_result.status == "Skipped":
                 print("{}{}{} skipped".format(
                     BOLD[1], test_result.name, BOLD[0]))
             else:
                 print("{}{}{} failed, Duration: {} s\n".format(
                     BOLD[1], test_result.name, BOLD[0], test_result.time))
                 print(BOLD[1] + 'stdout:' + BOLD[0])
                 print(test_result.stdout)
                 print(BOLD[1] + 'stderr:' + BOLD[0])
                 print(test_result.stderr)
 
                 if failfast:
                     logging.debug("Early exiting after test failure")
                     failfast_event.set()
             return
 
         assert False, "we should not be here"
 
     def handle_update_messages():
         """
         handle_update_messages waits for messages to be sent from handle_test_cases via the
         update_queue.  It serializes the results so we can print nice status update messages.
         """
         printed_status = False
         running_jobs = []
 
         while True:
             message = None
             try:
                 message = update_queue.get(True, poll_timeout)
                 if message is None:
                     break
 
                 # We printed a status message, need to kick to the next line
                 # before printing more.
                 if printed_status:
                     print()
                     printed_status = False
 
                 handle_message(message, running_jobs)
                 update_queue.task_done()
             except Empty:
                 if not on_ci():
                     print("Running jobs: {}".format(
                         ", ".join([j[1] for j in running_jobs])), end="\r")
                     sys.stdout.flush()
                     printed_status = True
 
     def handle_test_cases():
         """
         job_runner represents a single thread that is part of a worker pool.
         It waits for a test, then executes that test.
         It also reports start and result messages to handle_update_messages
         """
         while True:
             test = job_queue.get()
             if test is None:
                 break
             # Signal that the test is starting to inform the poor waiting
             # programmer
             update_queue.put(test)
             result = test.run(portseed_offset)
             update_queue.put(result)
             job_queue.task_done()
 
     ##
     # Setup our threads, and start sending tasks
     ##
 
     # Start our result collection thread.
     resultCollector = threading.Thread(target=handle_update_messages)
     resultCollector.daemon = True
     resultCollector.start()
 
     # Start some worker threads
     for j in range(num_jobs):
         t = threading.Thread(target=handle_test_cases)
         t.daemon = True
         t.start()
 
     # Push all our test cases into the job queue.
     for i, t in enumerate(test_list):
         job_queue.put(TestCase(i, t, tests_dir, tmpdir, failfast_event, flags))
 
     # Wait for all the jobs to be completed
     job_queue.join()
 
     # Wait for all the results to be compiled
     update_queue.join()
 
     # Flush our queues so the threads exit
     update_queue.put(None)
     for j in range(num_jobs):
         job_queue.put(None)
 
     return test_results
 
 
 def print_results(test_results, tests_dir, max_len_name,
                   runtime, combined_logs_len):
     results = "\n" + BOLD[1] + "{} | {} | {}\n\n".format(
         "TEST".ljust(max_len_name), "STATUS   ", "DURATION") + BOLD[0]
 
     test_results.sort(key=TestResult.sort_key)
     all_passed = True
     time_sum = 0
 
     for test_result in test_results:
         all_passed = all_passed and test_result.was_successful
         time_sum += test_result.time
         test_result.padding = max_len_name
         results += str(test_result)
 
         testdir = test_result.testdir
         if combined_logs_len and os.path.isdir(testdir):
             # Print the final `combinedlogslen` lines of the combined logs
             print('{}Combine the logs and print the last {} lines ...{}'.format(
                 BOLD[1], combined_logs_len, BOLD[0]))
             print('\n============')
             print('{}Combined log for {}:{}'.format(BOLD[1], testdir, BOLD[0]))
             print('============\n')
             combined_logs_args = [
                 sys.executable, os.path.join(
                     tests_dir, 'combine_logs.py'), testdir]
 
             if BOLD[0]:
                 combined_logs_args += ['--color']
                 combined_logs, _ = subprocess.Popen(
                     combined_logs_args, universal_newlines=True, stdout=subprocess.PIPE).communicate()
             print(
                 "\n".join(
                     deque(
                         combined_logs.splitlines(),
                         combined_logs_len)))
 
     status = TICK + "Passed" if all_passed else CROSS + "Failed"
     if not all_passed:
         results += RED[1]
     results += BOLD[1] + "\n{} | {} | {} s (accumulated) \n".format(
         "ALL".ljust(max_len_name), status.ljust(9), time_sum) + BOLD[0]
     if not all_passed:
         results += RED[0]
     results += "Runtime: {} s\n".format(runtime)
     print(results)
 
 
 class TestResult():
     """
     Simple data structure to store test result values and print them properly
     """
 
     def __init__(self, num, name, testdir, status, time, stdout, stderr):
         self.num = num
         self.name = name
         self.testdir = testdir
         self.status = status
         self.time = time
         self.padding = 0
         self.stdout = stdout
         self.stderr = stderr
 
     def sort_key(self):
         if self.status == "Passed":
             return 0, self.name.lower()
         elif self.status == "Failed":
             return 2, self.name.lower()
         elif self.status == "Skipped":
             return 1, self.name.lower()
 
     def __repr__(self):
         if self.status == "Passed":
             color = GREEN
             glyph = TICK
         elif self.status == "Failed":
             color = RED
             glyph = CROSS
         elif self.status == "Skipped":
             color = GREY
             glyph = CIRCLE
 
         return color[1] + "{} | {}{} | {} s\n".format(
             self.name.ljust(self.padding), glyph, self.status.ljust(7), self.time) + color[0]
 
     @property
     def was_successful(self):
         return self.status != "Failed"
 
 
 def get_all_scripts_from_disk(test_dir, non_scripts):
     """
     Return all available test script from script directory (excluding NON_SCRIPTS)
     """
     python_files = set([t for t in os.listdir(test_dir) if t[-3:] == ".py"])
     return list(python_files - set(non_scripts))
 
 
 def check_script_prefixes(all_scripts):
     """Check that no more than `EXPECTED_VIOLATION_COUNT` of the
        test scripts don't start with one of the allowed name prefixes."""
     EXPECTED_VIOLATION_COUNT = 21
 
     # LEEWAY is provided as a transition measure, so that pull-requests
     # that introduce new tests that don't conform with the naming
     # convention don't immediately cause the tests to fail.
     LEEWAY = 0
 
     good_prefixes_re = re.compile(
         "(abc_)?(example|feature|interface|mempool|mining|p2p|rpc|wallet|tool)_")
     bad_script_names = [
         script for script in all_scripts if good_prefixes_re.match(script) is None]
 
     if len(bad_script_names) < EXPECTED_VIOLATION_COUNT:
         print(
             "{}HURRAY!{} Number of functional tests violating naming convention reduced!".format(
                 BOLD[1],
                 BOLD[0]))
         print("Consider reducing EXPECTED_VIOLATION_COUNT from {} to {}".format(
             EXPECTED_VIOLATION_COUNT, len(bad_script_names)))
     elif len(bad_script_names) > EXPECTED_VIOLATION_COUNT:
         print(
             "INFO: {} tests not meeting naming conventions (expected {}):".format(len(bad_script_names), EXPECTED_VIOLATION_COUNT))
         print("  {}".format("\n  ".join(sorted(bad_script_names))))
         assert len(bad_script_names) <= EXPECTED_VIOLATION_COUNT + \
             LEEWAY, "Too many tests not following naming convention! ({} found, expected: <= {})".format(
                 len(bad_script_names), EXPECTED_VIOLATION_COUNT)
 
 
 def get_tests_to_run(test_list, test_params, cutoff, src_timings):
     """
     Returns only test that will not run longer that cutoff.
     Long running tests are returned first to favor running tests in parallel
     Timings from build directory override those from src directory
     """
 
     def get_test_time(test):
         # Return 0 if test is unknown to always run it
         return next(
             (x['time'] for x in src_timings.existing_timings if x['name'] == test), 0)
 
     # Some tests must also be run with additional parameters. Add them to the
     # list.
     tests_with_params = []
     for test_name in test_list:
         # always execute a test without parameters
         tests_with_params.append(test_name)
         params = test_params.get(test_name)
         if params is not None:
             tests_with_params.extend(
                 [test_name + " " + " ".join(p) for p in params])
 
     result = [t for t in tests_with_params if get_test_time(t) <= cutoff]
     result.sort(key=lambda x: (-get_test_time(x), x))
     return result
 
 
 class RPCCoverage():
     """
     Coverage reporting utilities for test_runner.
 
     Coverage calculation works by having each test script subprocess write
     coverage files into a particular directory. These files contain the RPC
     commands invoked during testing, as well as a complete listing of RPC
     commands per `bitcoin-cli help` (`rpc_interface.txt`).
 
     After all tests complete, the commands run are combined and diff'd against
     the complete list to calculate uncovered RPC commands.
 
     See also: test/functional/test_framework/coverage.py
 
     """
 
     def __init__(self):
         self.dir = tempfile.mkdtemp(prefix="coverage")
         self.flag = '--coveragedir={}'.format(self.dir)
 
     def report_rpc_coverage(self):
         """
         Print out RPC commands that were unexercised by tests.
 
         """
         uncovered = self._get_uncovered_rpc_commands()
 
         if uncovered:
             print("Uncovered RPC commands:")
             print("".join(("  - {}\n".format(i)) for i in sorted(uncovered)))
             return False
         else:
             print("All RPC commands covered.")
             return True
 
     def cleanup(self):
         return shutil.rmtree(self.dir)
 
     def _get_uncovered_rpc_commands(self):
         """
         Return a set of currently untested RPC commands.
 
         """
         # This is shared from `test/functional/test-framework/coverage.py`
         reference_filename = 'rpc_interface.txt'
         coverage_file_prefix = 'coverage.'
 
         coverage_ref_filename = os.path.join(self.dir, reference_filename)
         coverage_filenames = set()
         all_cmds = set()
         covered_cmds = set()
 
         if not os.path.isfile(coverage_ref_filename):
             raise RuntimeError("No coverage reference found")
 
         with open(coverage_ref_filename, 'r', encoding="utf8") as f:
             all_cmds.update([i.strip() for i in f.readlines()])
 
         for root, dirs, files in os.walk(self.dir):
             for filename in files:
                 if filename.startswith(coverage_file_prefix):
                     coverage_filenames.add(os.path.join(root, filename))
 
         for filename in coverage_filenames:
             with open(filename, 'r', encoding="utf8") as f:
                 covered_cmds.update([i.strip() for i in f.readlines()])
 
         return all_cmds - covered_cmds
 
 
 def save_results_as_junit(test_results, file_name, time, test_suite_name):
     """
     Save tests results to file in JUnit format
 
     See http://llg.cubic.org/docs/junit/ for specification of format
     """
     e_test_suite = ET.Element("testsuite",
                               {"name": "{}".format(test_suite_name),
                                "tests": str(len(test_results)),
                                # "errors":
                                "failures": str(len([t for t in test_results if t.status == "Failed"])),
                                "id": "0",
                                "skipped": str(len([t for t in test_results if t.status == "Skipped"])),
                                "time": str(time),
                                "timestamp": datetime.datetime.now().isoformat('T')
                                })
 
     for test_result in test_results:
         e_test_case = ET.SubElement(e_test_suite, "testcase",
                                     {"name": test_result.name,
                                      "classname": test_result.name,
                                      "time": str(test_result.time)
                                      }
                                     )
         if test_result.status == "Skipped":
             ET.SubElement(e_test_case, "skipped")
         elif test_result.status == "Failed":
             ET.SubElement(e_test_case, "failure")
         # no special element for passed tests
 
         ET.SubElement(e_test_case, "system-out").text = test_result.stdout
         ET.SubElement(e_test_case, "system-err").text = test_result.stderr
 
     ET.ElementTree(e_test_suite).write(
         file_name, "UTF-8", xml_declaration=True)
 
 
 class Timings():
     """
     Takes care of loading, merging and saving tests execution times.
     """
 
     def __init__(self, timing_file):
         self.timing_file = timing_file
         self.existing_timings = self.load_timings()
 
     def load_timings(self):
         if os.path.isfile(self.timing_file):
             with open(self.timing_file, encoding="utf8") as f:
                 return json.load(f)
         else:
             return []
 
     def get_merged_timings(self, new_timings):
         """
         Return new list containing existing timings updated with new timings
         Tests that do not exists are not removed
         """
 
         key = 'name'
         merged = {}
         for item in self.existing_timings + new_timings:
             if item[key] in merged:
                 merged[item[key]].update(item)
             else:
                 merged[item[key]] = item
 
         # Sort the result to preserve test ordering in file
         merged = list(merged.values())
         merged.sort(key=lambda t, key=key: t[key])
         return merged
 
     def save_timings(self, test_results):
         # we only save test that have passed - timings for failed test might be
         # wrong (timeouts or early fails)
         passed_results = [t for t in test_results if t.status == 'Passed']
         new_timings = list(map(lambda t: {'name': t.name, 'time': t.time},
                                passed_results))
         merged_timings = self.get_merged_timings(new_timings)
 
         with open(self.timing_file, 'w', encoding="utf8") as f:
             json.dump(merged_timings, f, indent=True)
 
 
 if __name__ == '__main__':
     main()
diff --git a/test/fuzz/test_runner.py b/test/fuzz/test_runner.py
index 170f0f0b1f..f1441ae838 100755
--- a/test/fuzz/test_runner.py
+++ b/test/fuzz/test_runner.py
@@ -1,133 +1,133 @@
 #!/usr/bin/env python3
 # Copyright (c) 2019 The Bitcoin Core developers
 # Distributed under the MIT software license, see the accompanying
 # file COPYING or http://www.opensource.org/licenses/mit-license.php.
 """Run fuzz test targets.
 """
 
 import argparse
 import configparser
 import logging
 import os
 import subprocess
 import sys
 
 
 def main():
     parser = argparse.ArgumentParser(
         formatter_class=argparse.ArgumentDefaultsHelpFormatter)
     parser.add_argument(
         "-l",
         "--loglevel",
         dest="loglevel",
         default="INFO",
         help="log events at this level and higher to the console. Can be set to DEBUG, INFO, WARNING, ERROR or CRITICAL. Passing --loglevel DEBUG will output all logs to console.",
     )
     parser.add_argument(
         '--export_coverage',
         action='store_true',
         help='If true, export coverage information to files in the seed corpus',
     )
     parser.add_argument(
         'seed_dir',
         help='The seed corpus to run on (must contain subfolders for each fuzz target).',
     )
     parser.add_argument(
         'target',
         nargs='*',
         help='The target(s) to run. Default is to run all targets.',
     )
 
     args = parser.parse_args()
 
     # Set up logging
     logging.basicConfig(
         format='%(message)s',
         level=int(args.loglevel) if args.loglevel.isdigit(
         ) else args.loglevel.upper(),
     )
 
     # Read config generated by configure.
     config = configparser.ConfigParser()
     configfile = os.path.abspath(os.path.dirname(__file__)) + "/../config.ini"
     config.read_file(open(configfile, encoding="utf8"))
 
     if not config["components"].getboolean("ENABLE_FUZZ"):
         logging.error("Must have fuzz targets built")
         sys.exit(1)
     test_dir = os.path.join(
         config["environment"]["BUILDDIR"], 'src', 'test', 'fuzz')
 
     # Build list of tests
     test_list_all = [
         f for f in os.listdir(test_dir)
         if os.path.isfile(os.path.join(test_dir, f)) and
         os.access(os.path.join(test_dir, f), os.X_OK)]
 
     if not test_list_all:
         logging.error("No fuzz targets found")
         sys.exit(1)
 
     logging.info("Fuzz targets found: {}".format(test_list_all))
 
     # By default run all
     args.target = args.target or test_list_all
     test_list_error = list(set(args.target).difference(set(test_list_all)))
     if test_list_error:
         logging.error(
             "Unknown fuzz targets selected: {}".format(test_list_error))
     test_list_selection = list(
         set(test_list_all).intersection(set(args.target)))
     if not test_list_selection:
         logging.error("No fuzz targets selected")
     logging.info("Fuzz targets selected: {}".format(test_list_selection))
 
     try:
         help_output = subprocess.run(
             args=[
                 os.path.join(test_dir, test_list_selection[0]),
                 '-help=1',
             ],
             timeout=1,
             check=True,
             stderr=subprocess.PIPE,
             universal_newlines=True,
         ).stderr
         if "libFuzzer" not in help_output:
             logging.error("Must be built with libFuzzer")
             sys.exit(1)
     except subprocess.TimeoutExpired:
         logging.error(
             "subprocess timed out: Currently only libFuzzer is supported")
         sys.exit(1)
 
     run_once(
         corpus=args.seed_dir,
         test_list=test_list_selection,
         test_dir=test_dir,
         export_coverage=args.export_coverage,
     )
 
 
 def run_once(*, corpus, test_list, test_dir, export_coverage):
     for t in test_list:
         args = [
             os.path.join(test_dir, t),
             '-runs=1',
             os.path.join(corpus, t),
         ]
         logging.debug('Run {} with args {}'.format(t, args))
         output = subprocess.run(
             args, check=True, stderr=subprocess.PIPE, universal_newlines=True).stderr
         logging.debug('Output: {}'.format(output))
         if not export_coverage:
             continue
-        for l in output.splitlines():
-            if 'INITED' in l:
+        for line in output.splitlines():
+            if 'INITED' in line:
                 with open(os.path.join(corpus, t + '_coverage'), 'w', encoding='utf-8') as cov_file:
-                    cov_file.write(l)
+                    cov_file.write(line)
                     break
 
 
 if __name__ == '__main__':
     main()
diff --git a/test/lint/lint-python-format.py b/test/lint/lint-python-format.py
index 1bdbe37ded..b15adf518c 100755
--- a/test/lint/lint-python-format.py
+++ b/test/lint/lint-python-format.py
@@ -1,284 +1,284 @@
 #!/usr/bin/env python3
 #
 # Copyright (c) 2019 The Bitcoin developers
 # Distributed under the MIT software license, see the accompanying
 # file COPYING or http://www.opensource.org/licenses/mit-license.php.
 #
 # Lint python format : This program checks that the old python fomatting method
 # is not being used (formatting with "string %s" % content).
 # The new "{}".format(content) or f"{} content" method should be used instead.
 # Usage of the % formatter is expected to be deprecated by python in the
 # future.
 
 import re
 import sys
 from doctest import testmod
 
 
 def is_complete(snippet):
     r"""Check if a code snippet is complete.
 
     >>> is_complete("a = [1, 2, 3]")
     True
     >>> is_complete("a = [1,")
     False
     >>> is_complete("a = [1, (")
     False
     >>> is_complete("a = [")
     False
     >>> is_complete("a = [1, {")
     False
     >>> is_complete('a = [1, 2, "%d" %    \\')
     False
     >>> is_complete('a = [1, 2, \"\"\"')
     False
     >>> is_complete('"%s" %')
     False
     """
     can_continue = [',', '(', '[', '{', '\\', '"""', '%']
     return not any(snippet.strip().endswith(end) for end in can_continue)
 
 
 def build_replacement(error):
     r"""Replace a snippet using the % formatter with a version using .format().
 
     >>> build_replacement('"test %s" % "1"')
     '"test {}".format("1")'
     >>> build_replacement('"test %s" % ("1")')
     '"test {}".format("1")'
     >>> build_replacement('"test %.2f" % 3.1415')
     '"test {:.2f}".format(3.1415)'
     >>> build_replacement('"test %s" \\\n% "1"')
     '"test {}".format("1")'
     >>> build_replacement('"test %s" %\\\n"1"')
     '"test {}".format("1")'
     >>> build_replacement('"test %s %s %s" % ("1", "2", "3")')
     '"test {} {} {}".format("1", "2", "3")'
     >>> build_replacement('"test %s %s %s" % \\\n("1", "2", "3")')
     '"test {} {} {}".format("1", "2", "3")'
     >>> build_replacement('"test %s %s %s" % \\\n("1",\n"2", "3")')
     '"test {} {} {}".format("1", "2", "3")'
     >>> build_replacement('"test %d" % 1')
     '"test {}".format(1)'
     >>> build_replacement('"test %i" % 1')
     '"test {}".format(1)'
     >>> build_replacement('"test %r" % "1"')
     '"test {!r}".format("1")'
     >>> build_replacement('"test %-10s" % "1"')
     '"test {:10s}".format("1")'
     >>> build_replacement('"test %s.%s" % ("1", "2")')
     '"test {}.{}".format("1", "2")'
     >>> build_replacement('"test %% %s %s" % ("1", "2")')
     '"test % {} {}".format("1", "2")'
     >>> build_replacement('"test %s %% %s" % ("1", "2")')
     '"test {} % {}".format("1", "2")'
     >>> build_replacement('"test %s %s %%" % ("1", "2")')
     '"test {} {} %".format("1", "2")'
     >>> build_replacement('"test %%%s%%%s%%" % ("1", "2")')
     '"test %{}%{}%".format("1", "2")'
     """
     # Inline the error snippet.
     # Replace line continuation ('\'), line breaks and their surrounding
     # spaces and indentation to a single space character
     replacement = re.sub(r"\s*\\\s+", " ", error, re.MULTILINE)
     replacement = re.sub(r"\s*(?:\r?\n|\r(?!\n))\s*",
                          " ", replacement, re.MULTILINE)
 
     # Escape the %% in 2 passes to avoid the % character to mess up with the
     # regexes
     # First change %% to \xec\xec then back \xec\xec to % (\xec is the infinity
     # symbol in extended ascii, it is unlikely to encounter it twice)
     replacement = re.sub(r"%%", "\xec\xec", replacement, re.MULTILINE)
 
     # Replace the specifiers, retaining their content.
     # E.g. %.2f => {:.2f}
     def specifier_sub(match):
         # There are some special cases to handle:
         #  - {:s} only works with strings, but %s worked with almost anything.
         #    To avoid type errors, just use {}
         #  - {:i} does not exists, it should be {:d} or better {}.
         #  - {:r} is invalid, the new syntax is {!r}
         #  - The left alignement marker (e.g. %-5s) is now the default, remove it
         specifier = match.group(1)
         specifier_converts_to_empty_brackets = ["s", "i", "d"]
         if specifier in specifier_converts_to_empty_brackets:
             return "{}"
         elif specifier == "r":
             return "{!r}"
         elif specifier.startswith("-"):
             return "{:" + specifier[1:] + "}"
         specifier = specifier.replace("i", "d")
         return "{:" + specifier + "}"
 
     (replacement, count) = re.subn(
         r"%([.-]?[0-9]*[a-zA-Z])", specifier_sub, replacement, flags=re.MULTILINE)
 
     # Replace the qualifier.
     # E.g % 42 => .format(42)
     # E.g. % (42, "my_string") => .format(42, "my_string")
     def single_qualifier_sub(match):
         qualifier = ".format(" + match.group(1).strip()
         # Where to close the parenthesis if there is a single specifier ?
         # It is whether at the end or before the first ',', ']', '}' (if
         # enclosed in a function call, a list or a dictionary).
         #
         # There is a special case to be handled when the qualifier is an array.
         # In this case, ensure there is one more ']' than '['.
         close_before = [",", "]", "}"]
         opening_count = 0
         for i, c in enumerate(qualifier):
             if c == "[":
                 opening_count += 1
             if c in close_before:
                 if(c == "]" and opening_count > 0):
                     opening_count -= 1
                     continue
                 return qualifier[:i] + ")" + qualifier[i:]
         return qualifier + ")"
 
     def multi_qualifier_sub(match):
         # The closing parenthesis is already there as we are replacing a tuple
         qualifier = ".format(" + match.group(1).strip()
         return qualifier
 
     # There are 2 possible way to write the qualifier:
     #  - If there is a single qualifier, it can be set directly.
     #    E.g.: "%s" % "string"
     #  - It can always be set as a tuple:
     #    E.g.: "%s" % ("string")
     #    E.g.: "%s %s" % ("string1", "string2")
     #
     # Solution: try to find the pattern with the opening parenthesis first, then
     # fall back to no parenthesis.
     replacement = re.sub(r"\s*(?<!%)%\s+\(([^%]+)", multi_qualifier_sub,
                          replacement, flags=re.MULTILINE)
     replacement = re.sub(r"\s*(?<!%)%\s+([^%]+)", single_qualifier_sub, replacement,
                          flags=re.MULTILINE)
 
     # Second pass of %% escaping, replace \xec\xec with %
     replacement = re.sub(r"\xec\xec", "%", replacement, re.MULTILINE)
 
     return replacement
 
 
 def find_snippets(file):
     """Find code snippets in the source file that contains the percent ('%')
     character"""
     with open(file, 'r', encoding='utf-8') as f:
         snippet_line = ""
         snippets = {}
 
         for line_number, line in enumerate(f):
             # Skip comments
             if not line.strip().startswith('#'):
                 # If we are not already in a snippet and the line contains a %
                 # character, start saving the snippet
                 if not snippet_line and '%' in line:
                     snippet_line = str(line_number + 1)
                     snippets[snippet_line] = ""
 
                 # In a snippet ?
                 # - save the line
                 # - check if the snippet is complete
                 if snippet_line:
                     snippets[snippet_line] += line
                     if is_complete(line):
                         snippet_line = ""
 
     return snippets
 
 
 def find_errors(file):
     """Extract snippets using the % symbol as a formatter with their line
     number"""
     pattern = re.compile(r"(?:\"|')\s*\\?\s+%\s+(?:\\\s+)?.+$", re.MULTILINE)
     snippets = find_snippets(file)
     return dict(
-        [(l, s) for l, s in snippets.items() if pattern.search(s) is not None])
+        [(line, snippet) for line, snippet in snippets.items() if pattern.search(snippet) is not None])
 
 
 def main(file):
     r"""Print line number and code snippets using the % formatter from the file,
     and suggest a replacement using the .format() method.
     Output format is :
     (<line number>) <original snippet>
     => <replacement snippet>
 
     >>> main("test/lint/lint-python-format-tests.txt")
     (5) "test %s" % "string"
     => "test {}".format("string")
     (6) "pi %.2f" % 3.1415
     => "pi {:.2f}".format(3.1415)
     (9) "test %s" %
         "string"
     => "test {}".format("string")
     (11) "test %s" % \
         "string"
     => "test {}".format("string")
     (13) "test %s" \
         % "string"
     => "test {}".format("string")
     (15) "test %s %s %s" \
         % ("1", "2", "3")
     => "test {} {} {}".format("1", "2", "3")
     (17) "test %s %s %s" % \
         ("1", "2", "3")
     => "test {} {} {}".format("1", "2", "3")
     (19) "test %s %s %s" \
          % ("1",
         "2", "3")
     => "test {} {} {}".format("1", "2", "3")
     (22) "test %s %s %s" \
        % ("0" \
        + "1",
       "2", "3")
     => "test {} {} {}".format("0" + "1", "2", "3")
     (31) "test %s %s %s" \
         % ("1",
         "2", "3")
     => "test {} {} {}".format("1", "2", "3")
     (42) ["test %s" % "string"]
     => ["test {}".format("string")]
     (43) {"key1":"%s" % "value1", "key2":"value2"}
     => {"key1":"{}".format("value1"), "key2":"value2"}
     (44) f("%d" % len("string"), argument2)
     => f("{}".format(len("string")), argument2)
     (45) f("%d %s" % (len("string"), "argument1"), argument2)
     => f("{} {}".format(len("string"), "argument1"), argument2)
     (46) ["test %s %s" %
         ("string1", "string2")]
     => ["test {} {}".format("string1", "string2")]
     (50) ("%s" % "string1", "%s" % "string2")
     => ("{}".format("string1"), "{}".format("string2"))
     (51) ("%s" % "string1", "%s %s" % ("string2", "string3")
     => ("{}".format("string1"), "{} {}".format("string2", "string3")
     (52) ("%s %s" % ("string1", "string2"), "%s %s" % ("string3", "string4"))
     => ("{} {}".format("string1", "string2"), "{} {}".format("string3", "string4"))
     (55) ["test %05i %% %s" %
         (len("string1"),
         "%d %-10s %%" % (len("string2"),
             "string2"))]
     => ["test {:05d} % {}".format(len("string1"), "{} {:10s} %".format(len("string2"), "string2"))]
     (73) "test %s" % an_array[0]
     => "test {}".format(an_array[0])
     (75) "test %s" % an_array[0][0]
     => "test {}".format(an_array[0][0])
     (77) ["test %s" % an_array[0]]
     => ["test {}".format(an_array[0])]
     (79) {"test":" ["test %s" % an_array[0][0]]}
     => {"test":" ["test {}".format(an_array[0][0])]}
     """
     errors = find_errors(file)
     # Python dictionnaries do not guarantee ordering, sort by line number
     for line_number, error in sorted(errors.items(),
                                      key=lambda pair: int(pair[0])):
         replacement = build_replacement(error)
         print("({}) {}".format(line_number, error.rstrip()))
         print("=> " + replacement)
 
 
 if __name__ == "__main__":
     if len(sys.argv) != 2:
         sys.exit(testmod()[1])
     else:
         main(sys.argv[1])