diff --git a/test/functional/abc_p2p_compactblocks.py b/test/functional/abc_p2p_compactblocks.py
index 3ab6cf8ef..854989d85 100755
--- a/test/functional/abc_p2p_compactblocks.py
+++ b/test/functional/abc_p2p_compactblocks.py
@@ -1,346 +1,343 @@
 #!/usr/bin/env python3
 # Copyright (c) 2015-2016 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.
 """
 This test checks simple acceptance of bigger blocks via p2p.
 It is derived from the much more complex p2p-fullblocktest.
 The intention is that small tests can be derived from this one, or
 this one can be extended, to cover the checks done for bigger blocks
 (e.g. sigops limits).
 """
 
 import random
 import time
 from collections import deque
 
 from test_framework.blocktools import (
     create_block,
     create_coinbase,
     make_conform_to_ctor,
 )
 from test_framework.cdefs import ONE_MEGABYTE
 from test_framework.messages import (
     COutPoint,
     CTransaction,
     CTxIn,
     CTxOut,
     HeaderAndShortIDs,
     msg_cmpctblock,
     msg_sendcmpct,
     ser_compact_size,
 )
 from test_framework.p2p import P2PDataStore, P2PInterface, p2p_lock
 from test_framework.script import OP_RETURN, OP_TRUE, CScript
 from test_framework.test_framework import BitcoinTestFramework
 from test_framework.txtools import pad_tx
 from test_framework.util import assert_equal
 
 
 class PreviousSpendableOutput():
 
     def __init__(self, tx=CTransaction(), n=-1):
         self.tx = tx
         # the output we're spending
         self.n = n
 
 
 # TestP2PConn: A peer we use to send messages to bitcoind, and store responses.
 class TestP2PConn(P2PInterface):
 
     def __init__(self):
         self.last_sendcmpct = None
         self.last_cmpctblock = None
         self.last_getheaders = None
         self.last_headers = None
         super().__init__()
 
     def on_sendcmpct(self, message):
         self.last_sendcmpct = message
 
     def on_cmpctblock(self, message):
         self.last_cmpctblock = message
         self.last_cmpctblock.header_and_shortids.header.calc_sha256()
 
     def on_getheaders(self, message):
         self.last_getheaders = message
 
     def on_headers(self, message):
         self.last_headers = message
         for x in self.last_headers.headers:
             x.calc_sha256()
 
     def clear_block_data(self):
         with p2p_lock:
             self.last_sendcmpct = None
             self.last_cmpctblock = None
 
 
 class FullBlockTest(BitcoinTestFramework):
 
     def set_test_params(self):
         self.num_nodes = 1
         self.setup_clean_chain = True
         self.block_heights = {}
         self.tip = None
         self.blocks = {}
         self.excessive_block_size = 16 * ONE_MEGABYTE
         self.extra_args = [['-whitelist=noban@127.0.0.1',
                             '-limitancestorcount=999999',
                             '-limitancestorsize=999999',
                             '-limitdescendantcount=999999',
                             '-limitdescendantsize=999999',
                             '-maxmempool=99999',
                             '-excessiveblocksize={}'.format(
                                 self.excessive_block_size),
                             '-acceptnonstdtxn=1']]
         # UBSAN will cause this test to timeout without this.
         self.rpc_timeout = 180
 
     def add_options(self, parser):
         super().add_options(parser)
         parser.add_argument(
             "--runbarelyexpensive", dest="runbarelyexpensive", default=True)
 
     def add_transactions_to_block(self, block, tx_list):
         [tx.rehash() for tx in tx_list]
         block.vtx.extend(tx_list)
 
     def next_block(self, number, spend=None, script=CScript(
             [OP_TRUE]), block_size=0, extra_txns=0):
         if self.tip is None:
             base_block_hash = self.genesis_hash
             block_time = int(time.time()) + 1
         else:
             base_block_hash = self.tip.sha256
             block_time = self.tip.nTime + 1
         # First create the coinbase
         height = self.block_heights[base_block_hash] + 1
         coinbase = create_coinbase(height)
         coinbase.rehash()
         if spend is None:
             # We need to have something to spend to fill the block.
             assert_equal(block_size, 0)
             block = create_block(base_block_hash, coinbase, block_time)
         else:
             # all but one satoshi to fees
             coinbase.vout[0].nValue += spend.tx.vout[spend.n].nValue - 1
             coinbase.rehash()
             block = create_block(base_block_hash, coinbase, block_time)
 
             # Make sure we have plenty enough to spend going forward.
             spendable_outputs = deque([spend])
 
             def get_base_transaction():
                 # Create the new transaction
                 tx = CTransaction()
                 # Spend from one of the spendable outputs
                 spend = spendable_outputs.popleft()
                 tx.vin.append(CTxIn(COutPoint(spend.tx.sha256, spend.n)))
                 # Add spendable outputs
                 for i in range(4):
                     tx.vout.append(CTxOut(0, CScript([OP_TRUE])))
                     spendable_outputs.append(PreviousSpendableOutput(tx, i))
                 pad_tx(tx)
                 return tx
 
             tx = get_base_transaction()
 
             # Make it the same format as transaction added for padding and save the size.
             # It's missing the padding output, so we add a constant to account
             # for it.
             tx.rehash()
 
             # If a specific script is required, add it.
             if script is not None:
                 tx.vout.append(CTxOut(1, script))
 
             # Put some random data into the first transaction of the chain to
             # randomize ids.
             tx.vout.append(
                 CTxOut(0, CScript([random.randint(0, 256), OP_RETURN])))
 
             # Add the transaction to the block
             self.add_transactions_to_block(block, [tx])
 
             # Add transaction until we reach the expected transaction count
             for _ in range(extra_txns):
                 self.add_transactions_to_block(block, [get_base_transaction()])
 
             # If we have a block size requirement, just fill
             # the block until we get there
             current_block_size = len(block.serialize())
             overage_bytes = 0
             while current_block_size < block_size:
                 # We will add a new transaction. That means the size of
                 # the field enumerating how many transaction go in the block
                 # may change.
                 current_block_size -= len(ser_compact_size(len(block.vtx)))
                 current_block_size += len(ser_compact_size(len(block.vtx) + 1))
 
                 # Add padding to fill the block.
                 left_to_fill = block_size - current_block_size
 
                 # Don't go over the 1 mb limit for a txn
                 if left_to_fill > 500000:
                     # Make sure we eat up non-divisible by 100 amounts quickly
                     # Also keep transaction less than 1 MB
                     left_to_fill = 500000 + left_to_fill % 100
 
                 # Create the new transaction
                 tx = get_base_transaction()
                 pad_tx(tx, left_to_fill - overage_bytes)
                 if len(tx.serialize()) + current_block_size > block_size:
                     # Our padding was too big try again
                     overage_bytes += 1
                     continue
 
                 # Add the tx to the list of transactions to be included
                 # in the block.
                 self.add_transactions_to_block(block, [tx])
                 current_block_size += len(tx.serialize())
 
             # Now that we added a bunch of transaction, we need to recompute
             # the merkle root.
             make_conform_to_ctor(block)
             block.hashMerkleRoot = block.calc_merkle_root()
 
         # Check that the block size is what's expected
         if block_size > 0:
             assert_equal(len(block.serialize()), block_size)
 
         # Do PoW, which is cheap on regnet
         block.solve()
         self.tip = block
         self.block_heights[block.sha256] = height
         assert number not in self.blocks
         self.blocks[number] = block
         return block
 
     def run_test(self):
         node = self.nodes[0]
         default_p2p = node.add_p2p_connection(P2PDataStore())
         test_p2p = node.add_p2p_connection(TestP2PConn())
 
         self.genesis_hash = int(node.getbestblockhash(), 16)
         self.block_heights[self.genesis_hash] = 0
         spendable_outputs = []
 
         # save the current tip so it can be spent by a later block
         def save_spendable_output():
             spendable_outputs.append(self.tip)
 
         # get an output that we previously marked as spendable
         def get_spendable_output():
             return PreviousSpendableOutput(spendable_outputs.pop(0).vtx[0], 0)
 
         # shorthand for functions
         block = self.next_block
 
         # Create a new block
         block(0)
         save_spendable_output()
         default_p2p.send_blocks_and_test([self.tip], node)
 
         # Now we need that block to mature so we can spend the coinbase.
         maturity_blocks = []
         for i in range(99):
             block(5000 + i)
             maturity_blocks.append(self.tip)
             save_spendable_output()
 
         # Get to one block of the May 15, 2018 HF activation
         for i in range(6):
             block(5100 + i)
             maturity_blocks.append(self.tip)
 
         # Send it all to the node at once.
         default_p2p.send_blocks_and_test(maturity_blocks, node)
 
         # collect spendable outputs now to avoid cluttering the code later on
         out = []
         for i in range(100):
             out.append(get_spendable_output())
 
         # Check that compact block also work for big blocks
         # Wait for SENDCMPCT
         def received_sendcmpct():
             return (test_p2p.last_sendcmpct is not None)
         self.wait_until(received_sendcmpct, timeout=30)
 
-        sendcmpct = msg_sendcmpct()
-        sendcmpct.version = 1
-        sendcmpct.announce = True
-        test_p2p.send_and_ping(sendcmpct)
+        test_p2p.send_and_ping(msg_sendcmpct(announce=True, version=1))
 
         # Exchange headers
         def received_getheaders():
             return (test_p2p.last_getheaders is not None)
         self.wait_until(received_getheaders, timeout=30)
 
         # Return the favor
         test_p2p.send_message(test_p2p.last_getheaders)
 
         # Wait for the header list
         def received_headers():
             return (test_p2p.last_headers is not None)
         self.wait_until(received_headers, timeout=30)
 
         # It's like we know about the same headers !
         test_p2p.send_message(test_p2p.last_headers)
 
         # Send a block
         b1 = block(1, spend=out[0], block_size=ONE_MEGABYTE + 1)
         default_p2p.send_blocks_and_test([self.tip], node)
 
         # Checks the node to forward it via compact block
         def received_block():
             return (test_p2p.last_cmpctblock is not None)
         self.wait_until(received_block, timeout=30)
 
         # Was it our block ?
         cmpctblk_header = test_p2p.last_cmpctblock.header_and_shortids.header
         cmpctblk_header.calc_sha256()
         assert cmpctblk_header.sha256 == b1.sha256
 
         # Send a large block with numerous transactions.
         test_p2p.clear_block_data()
         b2 = block(2, spend=out[1], extra_txns=70000,
                    block_size=self.excessive_block_size - 1000)
         default_p2p.send_blocks_and_test([self.tip], node)
 
         # Checks the node forwards it via compact block
         self.wait_until(received_block, timeout=30)
 
         # Was it our block ?
         cmpctblk_header = test_p2p.last_cmpctblock.header_and_shortids.header
         cmpctblk_header.calc_sha256()
         assert cmpctblk_header.sha256 == b2.sha256
 
         # In order to avoid having to resend a ton of transactions, we invalidate
         # b2, which will send all its transactions in the mempool. Note that this
         # assumes reorgs will insert low-fee transactions back into the
         # mempool.
         node.invalidateblock(node.getbestblockhash())
 
         # Let's send a compact block and see if the node accepts it.
         # Let's modify b2 and use it so that we can reuse the mempool.
         tx = b2.vtx[0]
         tx.vout.append(CTxOut(0, CScript([random.randint(0, 256), OP_RETURN])))
         tx.rehash()
         b2.vtx[0] = tx
         b2.hashMerkleRoot = b2.calc_merkle_root()
         b2.solve()
 
         # Now we create the compact block and send it
         comp_block = HeaderAndShortIDs()
         comp_block.initialize_from_block(b2)
         test_p2p.send_and_ping(msg_cmpctblock(comp_block.to_p2p()))
 
         # Check that compact block is received properly
         assert int(node.getbestblockhash(), 16) == b2.sha256
 
 
 if __name__ == '__main__':
     FullBlockTest().main()
diff --git a/test/functional/p2p_compactblocks.py b/test/functional/p2p_compactblocks.py
index bbf764c30..222c7e1fc 100755
--- a/test/functional/p2p_compactblocks.py
+++ b/test/functional/p2p_compactblocks.py
@@ -1,920 +1,907 @@
 #!/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 (
     MSG_BLOCK,
     MSG_CMPCT_BLOCK,
     NODE_NETWORK,
     BlockTransactions,
     BlockTransactionsRequest,
     CBlock,
     CBlockHeader,
     CInv,
     COutPoint,
     CTransaction,
     CTxIn,
     CTxOut,
     FromHex,
     HeaderAndShortIDs,
     P2PHeaderAndShortIDs,
     PrefilledTransaction,
     ToHex,
     calculate_shortid,
     msg_block,
     msg_blocktxn,
     msg_cmpctblock,
     msg_getblocktxn,
     msg_getdata,
     msg_getheaders,
     msg_headers,
     msg_inv,
     msg_sendcmpct,
     msg_sendheaders,
     msg_tx,
 )
 from test_framework.p2p import P2PInterface, p2p_lock
 from test_framework.script import OP_TRUE, CScript
 from test_framework.test_framework import BitcoinTestFramework
 from test_framework.txtools import pad_tx
 from test_framework.util import assert_equal
 
 # 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 == MSG_BLOCK:
                 self.block_announced = True
                 self.announced_blockhashes.add(x.hash)
 
     # Requires caller to hold p2p_lock
     def received_block_announcement(self):
         return self.block_announced
 
     def clear_block_announcement(self):
         with p2p_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)
         self.wait_until(self.received_block_announcement, timeout=30)
         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)
         self.wait_until(received_hash, timeout=timeout)
 
     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)
         self.wait_for_disconnect(timeout)
 
 
 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 _ 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)
         test_node.wait_until(received_sendcmpct, timeout=30)
         with p2p_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 p2p_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)
+        test_node.send_and_ping(msg_sendcmpct(announce=True, version=999))
         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)
+        test_node.send_and_ping(msg_sendcmpct(announce=False,
+                                              version=preferred_version))
         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)
+        test_node.send_and_ping(msg_sendcmpct(announce=True,
+                                              version=preferred_version))
         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)
+        test_node.send_and_ping(msg_sendcmpct(announce=False,
+                                              version=preferred_version - 1))
         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)
+        test_node.send_and_ping(msg_sendcmpct(announce=False,
+                                              version=preferred_version))
         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)
+            old_node.send_and_ping(msg_sendcmpct(announce=True, version=1))
             # 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 _ in range(num_transactions):
             txid = node.sendtoaddress(address, 100000)
             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)
         test_node.wait_until(lambda: "cmpctblock" in test_node.last_message,
                              timeout=30)
 
         # Now fetch and check the compact block
         header_and_shortids = None
         with p2p_lock:
             # 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
         test_node.clear_block_announcement()
         inv = CInv(MSG_CMPCT_BLOCK, block_hash)
         test_node.send_message(msg_getdata([inv]))
 
         test_node.wait_until(lambda: "cmpctblock" in test_node.last_message,
                              timeout=30)
 
         # Now fetch and check the compact block
         header_and_shortids = None
         with p2p_lock:
             # 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)
 
             if announce == "inv":
                 test_node.send_message(
                     msg_inv([CInv(MSG_BLOCK, block.sha256)]))
                 self.wait_until(lambda: "getheaders" in test_node.last_message,
                                 timeout=30)
                 test_node.send_header_for_blocks([block])
             else:
                 test_node.send_header_for_blocks([block])
             test_node.wait_for_getdata([block.sha256], timeout=30)
             assert_equal(test_node.last_message["getdata"].inv[0].type, 4)
 
             # 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 p2p_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 _ 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 p2p_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 p2p_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 p2p_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 p2p_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
         test_node.wait_for_getdata([block.sha256], timeout=10)
         assert test_node.last_message["getdata"].inv[0].type == MSG_BLOCK
 
         # 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)
             test_node.wait_until(lambda: "blocktxn" in test_node.last_message,
                                  timeout=10)
 
             [tx.calc_sha256() for tx in block.vtx]
             with p2p_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 p2p_lock:
             test_node.last_message.pop("block", None)
             test_node.last_message.pop("blocktxn", None)
         test_node.send_and_ping(msg)
         with p2p_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 _ in range(MAX_CMPCTBLOCK_DEPTH + 1):
             test_node.clear_block_announcement()
             new_blocks.append(node.generate(1)[0])
             test_node.wait_until(test_node.received_block_announcement,
                                  timeout=30)
 
         test_node.clear_block_announcement()
         test_node.send_message(msg_getdata(
             [CInv(MSG_CMPCT_BLOCK, int(new_blocks[0], 16))]))
         test_node.wait_until(lambda: "cmpctblock" in test_node.last_message,
                              timeout=30)
 
         test_node.clear_block_announcement()
         node.generate(1)
         test_node.wait_until(test_node.received_block_announcement,
                              timeout=30)
         test_node.clear_block_announcement()
         with p2p_lock:
             test_node.last_message.pop("block", None)
         test_node.send_message(msg_getdata(
             [CInv(MSG_CMPCT_BLOCK, int(new_blocks[0], 16))]))
         test_node.wait_until(lambda: "block" in test_node.last_message,
                              timeout=30)
         with p2p_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 p2p_lock:
             test_node.last_message.pop("blocktxn", None)
         test_node.send_and_ping(msg)
         with p2p_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)
 
         [listener.clear_block_announcement() for listener in listeners]
 
         node.submitblock(ToHex(block))
 
         for listener in listeners:
             listener.wait_until(lambda: "cmpctblock" in listener.last_message,
                                 timeout=30)
         with p2p_lock:
             for listener in listeners:
                 listener.last_message["cmpctblock"].header_and_shortids.header.calc_sha256(
                 )
                 assert_equal(
                     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)
+        peer.send_and_ping(msg_sendcmpct(announce=True, version=version))
 
     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 p2p_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)
         self.sync_blocks()
         self.test_sendcmpct(
             self.nodes[1], self.ex_softfork_node, 1, old_node=self.old_node)
         self.sync_blocks()
 
         self.log.info("\tTesting compactblock construction...")
         self.test_compactblock_construction(self.nodes[0], self.test_node)
         self.sync_blocks()
         self.test_compactblock_construction(
             self.nodes[1], self.ex_softfork_node)
         self.sync_blocks()
 
         self.log.info("\tTesting compactblock requests... ")
         self.test_compactblock_requests(self.nodes[0], self.test_node, 1)
         self.sync_blocks()
         self.test_compactblock_requests(
             self.nodes[1], self.ex_softfork_node, 2)
         self.sync_blocks()
 
         self.log.info("\tTesting getblocktxn requests...")
         self.test_getblocktxn_requests(self.nodes[0], self.test_node, 1)
         self.sync_blocks()
         self.test_getblocktxn_requests(self.nodes[1], self.ex_softfork_node, 2)
         self.sync_blocks()
 
         self.log.info("\tTesting getblocktxn handler...")
         self.test_getblocktxn_handler(self.nodes[0], self.test_node, 1)
         self.sync_blocks()
         self.test_getblocktxn_handler(self.nodes[1], self.ex_softfork_node, 2)
         self.test_getblocktxn_handler(self.nodes[1], self.old_node, 1)
         self.sync_blocks()
 
         self.log.info(
             "\tTesting compactblock requests/announcements not at chain tip...")
         self.test_compactblocks_not_at_tip(self.nodes[0], self.test_node)
         self.sync_blocks()
         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)
         self.sync_blocks()
 
         self.log.info("\tTesting handling of incorrect blocktxn responses...")
         self.test_incorrect_blocktxn_response(self.nodes[0], self.test_node, 1)
         self.sync_blocks()
         self.test_incorrect_blocktxn_response(
             self.nodes[1], self.ex_softfork_node, 2)
         self.sync_blocks()
 
         # 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)
         self.sync_blocks()
 
         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 b6c06de51..f4e85c5cc 100755
--- a/test/functional/test_framework/messages.py
+++ b/test/functional/test_framework/messages.py
@@ -1,2098 +1,2098 @@
 #!/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.
 """
 import copy
 import hashlib
 import random
 import socket
 import struct
 import time
 import unittest
 from codecs import encode
 from enum import IntEnum
 from io import BytesIO
 from typing import List
 
 from test_framework.siphash import siphash256
 from test_framework.util import assert_equal, hex_str_to_bytes
 
 MIN_VERSION_SUPPORTED = 60001
 # past bip-31 for ping/pong
 MY_VERSION = 70014
 MY_SUBVERSION = b"/python-p2p-tester:0.0.3/"
 # from version 70001 onwards, fRelay should be appended to version
 # messages (BIP37)
 MY_RELAY = 1
 
 MAX_LOCATOR_SZ = 101
 MAX_BLOCK_BASE_SIZE = 1000000
 MAX_BLOOM_FILTER_SIZE = 36000
 MAX_BLOOM_HASH_FUNCS = 50
 
 # 1,000,000 XEC in satoshis (legacy BCHA)
 COIN = 100000000
 # 1 XEC in satoshis
 XEC = 100
 MAX_MONEY = 21000000 * COIN
 
 # Maximum length of incoming protocol messages
 MAX_PROTOCOL_MESSAGE_LENGTH = 2 * 1024 * 1024
 MAX_HEADERS_RESULTS = 2000  # Number of headers sent in one getheaders result
 MAX_INV_SIZE = 50000  # Maximum number of entries in an 'inv' protocol message
 
 NODE_NETWORK = (1 << 0)
 NODE_GETUTXO = (1 << 1)
 NODE_BLOOM = (1 << 2)
 # NODE_WITNESS = (1 << 3)
 # NODE_XTHIN = (1 << 4) # removed in v0.22.12
 NODE_COMPACT_FILTERS = (1 << 6)
 NODE_NETWORK_LIMITED = (1 << 10)
 NODE_AVALANCHE = (1 << 24)
 
 MSG_TX = 1
 MSG_BLOCK = 2
 MSG_FILTERED_BLOCK = 3
 MSG_CMPCT_BLOCK = 4
 MSG_AVA_PROOF = 0x1f000001
 MSG_TYPE_MASK = 0xffffffff >> 2
 
 FILTER_TYPE_BASIC = 0
 
 # Serialization/deserialization tools
 
 
 def sha256(s):
     return hashlib.new('sha256', s).digest()
 
 
 def hash256(s):
     return sha256(sha256(s))
 
 
 def ser_compact_size(size):
     r = b""
     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, 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 _ 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
 
 
 # deser_function_name: Allow for an alternate deserialization function on the
 # entries in the vector.
 def deser_vector(f, c, deser_function_name=None):
     nit = deser_compact_size(f)
     r = []
     for _ in range(nit):
         t = c()
         if deser_function_name:
             getattr(t, deser_function_name)(f)
         else:
             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(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 _ in range(nit):
         t = deser_uint256(f)
         r.append(t)
     return r
 
 
 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 _ in range(nit):
         t = deser_string(f)
         r.append(t)
     return r
 
 
 def ser_string_vector(v):
     r = ser_compact_size(len(v))
     for sv in v:
         r += ser_string(sv)
     return r
 
 
 def FromHex(obj, hex_string):
     """Deserialize from a hex string representation (eg from RPC)"""
     obj.deserialize(BytesIO(hex_str_to_bytes(hex_string)))
     return obj
 
 
 def ToHex(obj):
     """Convert a binary-serializable object to hex
     (eg for submission via RPC)"""
     return obj.serialize().hex()
 
 
 # Objects that map to bitcoind objects, which can be serialized/deserialized
 
 class CAddress:
     __slots__ = ("net", "ip", "nServices", "port", "time")
 
     # see https://github.com/bitcoin/bips/blob/master/bip-0155.mediawiki
     NET_IPV4 = 1
 
     ADDRV2_NET_NAME = {
         NET_IPV4: "IPv4"
     }
 
     ADDRV2_ADDRESS_LENGTH = {
         NET_IPV4: 4
     }
 
     def __init__(self):
         self.time = 0
         self.nServices = 1
         self.net = self.NET_IPV4
         self.ip = "0.0.0.0"
         self.port = 0
 
     def deserialize(self, f, *, with_time=True):
         """Deserialize from addrv1 format (pre-BIP155)"""
         if with_time:
             # VERSION messages serialize CAddress objects without time
             self.time = struct.unpack("<I", f.read(4))[0]
         self.nServices = struct.unpack("<Q", f.read(8))[0]
         # We only support IPv4 which means skip 12 bytes and read the next 4 as
         # IPv4 address.
         f.read(12)
         self.net = self.NET_IPV4
         self.ip = socket.inet_ntoa(f.read(4))
         self.port = struct.unpack(">H", f.read(2))[0]
 
     def serialize(self, *, with_time=True):
         """Serialize in addrv1 format (pre-BIP155)"""
         assert self.net == self.NET_IPV4
         r = b""
         if with_time:
             # VERSION messages serialize CAddress objects without time
             r += struct.pack("<I", self.time)
         r += struct.pack("<Q", self.nServices)
         r += b"\x00" * 10 + b"\xff" * 2
         r += socket.inet_aton(self.ip)
         r += struct.pack(">H", self.port)
         return r
 
     def deserialize_v2(self, f):
         """Deserialize from addrv2 format (BIP155)"""
         self.time = struct.unpack("<I", f.read(4))[0]
 
         self.nServices = deser_compact_size(f)
 
         self.net = struct.unpack("B", f.read(1))[0]
         assert self.net == self.NET_IPV4
 
         address_length = deser_compact_size(f)
         assert address_length == self.ADDRV2_ADDRESS_LENGTH[self.net]
 
         self.ip = socket.inet_ntoa(f.read(4))
 
         self.port = struct.unpack(">H", f.read(2))[0]
 
     def serialize_v2(self):
         """Serialize in addrv2 format (BIP155)"""
         assert self.net == self.NET_IPV4
         r = b""
         r += struct.pack("<I", self.time)
         r += ser_compact_size(self.nServices)
         r += struct.pack("B", self.net)
         r += ser_compact_size(self.ADDRV2_ADDRESS_LENGTH[self.net])
         r += socket.inet_aton(self.ip)
         r += struct.pack(">H", self.port)
         return r
 
     def __repr__(self):
         return ("CAddress(nServices=%i net=%s addr=%s port=%i)"
                 % (self.nServices, self.ADDRV2_NET_NAME[self.net], self.ip, self.port))
 
 
 class CInv:
     __slots__ = ("hash", "type")
 
     typemap = {
         0: "Error",
         MSG_TX: "TX",
         MSG_BLOCK: "Block",
         MSG_FILTERED_BLOCK: "filtered Block",
         MSG_CMPCT_BLOCK: "CompactBlock",
         MSG_AVA_PROOF: "avalanche proof",
     }
 
     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)
 
     def __eq__(self, other):
         return isinstance(
             other, CInv) and self.hash == other.hash and self.type == other.type
 
 
 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={}.{:02d} scriptPubKey={})".format(
             self.nValue // XEC, self.nValue % XEC, 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 > MAX_MONEY:
                 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)
 
 
 BLOCK_HEADER_SIZE = len(CBlockHeader().serialize())
 assert_equal(BLOCK_HEADER_SIZE, 80)
 
 
 class CBlock(CBlockHeader):
     __slots__ = ("vtx",)
 
     def __init__(self, header=None):
         super().__init__(header)
         self.vtx = []
 
     def deserialize(self, f):
         super().deserialize(f)
         self.vtx = deser_vector(f, CTransaction)
 
     def serialize(self):
         r = b""
         r += super().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 _ 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))
 
 
 def calculate_shortid(k0, k1, tx_hash):
     """Calculate the BIP 152-compact blocks shortid for a given
     transaction 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=None):
         if prefill_list is None:
             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 _ 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 AvalancheStake:
     def __init__(self, utxo=None, amount=0, height=0,
                  pubkey=b"", is_coinbase=False):
         self.utxo: COutPoint = utxo or COutPoint()
         self.amount: int = amount
         """Amount in satoshis (int64)"""
         self.height: int = height
         """Block height containing this utxo (uint32)"""
         self.pubkey: bytes = pubkey
         """Public key"""
 
         self.is_coinbase: bool = is_coinbase
 
     def deserialize(self, f):
         self.utxo = COutPoint()
         self.utxo.deserialize(f)
         self.amount = struct.unpack("<q", f.read(8))[0]
         height_ser = struct.unpack("<I", f.read(4))[0]
         self.is_coinbase = bool(height_ser & 1)
         self.height = height_ser >> 1
         self.pubkey = deser_string(f)
 
     def serialize(self) -> bytes:
         r = self.utxo.serialize()
         height_ser = self.height << 1 | int(self.is_coinbase)
         r += struct.pack('<q', self.amount)
         r += struct.pack('<I', height_ser)
         r += ser_compact_size(len(self.pubkey))
         r += self.pubkey
         return r
 
     def get_hash(self, proofid) -> bytes:
         """Return the bitcoin hash of the concatenation of proofid
         and the serialized stake."""
         return hash256(proofid + self.serialize())
 
     def __repr__(self):
         return f"AvalancheStake(utxo={self.utxo}, amount={self.amount}," \
                f" height={self.height}, " \
                f"pubkey={self.pubkey.hex()})"
 
 
 class AvalancheSignedStake:
     def __init__(self, stake=None, sig=b""):
         self.stake: AvalancheStake = stake or AvalancheStake()
         self.sig: bytes = sig
         """Signature for this stake, bytes of length 64"""
 
     def deserialize(self, f):
         self.stake = AvalancheStake()
         self.stake.deserialize(f)
         self.sig = f.read(64)
 
     def serialize(self) -> bytes:
         return self.stake.serialize() + self.sig
 
 
 class AvalancheProof:
     __slots__ = (
         "sequence",
         "expiration",
         "master",
         "stakes",
         "limited_proofid",
         "proofid")
 
     def __init__(self, sequence=0, expiration=0,
                  master=b"", signed_stakes=None):
         self.sequence: int = sequence
         self.expiration: int = expiration
         self.master: bytes = master
 
         self.stakes: List[AvalancheSignedStake] = signed_stakes or [
             AvalancheSignedStake()]
 
         self.limited_proofid: int = None
         self.proofid: int = None
         self.compute_proof_id()
 
     def compute_proof_id(self):
         """Compute Bitcoin's 256-bit hash (double SHA-256) of the
         serialized proof data.
         """
         ss = struct.pack("<Qq", self.sequence, self.expiration)
         ss += ser_compact_size(len(self.stakes))
         # Use unsigned stakes
         for s in self.stakes:
             ss += s.stake.serialize()
         h = hash256(ss)
         self.limited_proofid = uint256_from_str(h)
         h += ser_string(self.master)
         h = hash256(h)
         # make it an int, for comparing with Delegation.proofid
         self.proofid = uint256_from_str(h)
 
     def deserialize(self, f):
         self.sequence = struct.unpack("<Q", f.read(8))[0]
         self.expiration = struct.unpack("<q", f.read(8))[0]
         self.master = deser_string(f)
         self.stakes = deser_vector(f, AvalancheSignedStake)
         self.compute_proof_id()
 
     def serialize(self):
         r = b""
         r += struct.pack("<Q", self.sequence)
         r += struct.pack("<q", self.expiration)
         r += ser_string(self.master)
         r += ser_vector(self.stakes)
         return r
 
     def __repr__(self):
         return f"AvalancheProof(sequence={self.sequence}, " \
                f"expiration={self.expiration}, " \
                f"master={self.master.hex()}, " \
                f"stakes={self.stakes})"
 
 
 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 AvalancheVoteError(IntEnum):
     ACCEPTED = 0
     INVALID = 1
     PARKED = 2
     FORK = 3
     UNKNOWN = -1
     MISSING = -2
     PENDING = -3
 
 
 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 AvalancheDelegationLevel:
     __slots__ = ("pubkey", "sig")
 
     def __init__(self, pubkey=b"", sig=b"\0" * 64):
         self.pubkey = pubkey
         self.sig = sig
 
     def deserialize(self, f):
         self.pubkey = deser_string(f)
         self.sig = f.read(64)
 
     def serialize(self):
         r = b""
         r += ser_string(self.pubkey)
         r += self.sig
         return r
 
     def __repr__(self):
         return "AvalancheDelegationLevel(pubkey={}, sig={})".format(
             self.pubkey.hex(), self.sig)
 
 
 class AvalancheDelegation:
     __slots__ = ("limited_proofid", "proof_master", "proofid", "levels")
 
     def __init__(self, limited_proofid=0,
                  proof_master=b"", levels=None):
         self.limited_proofid: int = limited_proofid
         self.proof_master: bytes = proof_master
         self.levels: List[AvalancheDelegationLevel] = levels or []
         self.proofid: int = self.compute_proofid()
 
     def compute_proofid(self) -> int:
         return uint256_from_str(hash256(
             ser_uint256(self.limited_proofid) + ser_string(self.proof_master)))
 
     def deserialize(self, f):
         self.limited_proofid = deser_uint256(f)
         self.proof_master = deser_string(f)
         self.levels = deser_vector(f, AvalancheDelegationLevel)
 
         self.proofid = self.compute_proofid()
 
     def serialize(self):
         r = b""
         r += ser_uint256(self.limited_proofid)
         r += ser_string(self.proof_master)
         r += ser_vector(self.levels)
         return r
 
     def __repr__(self):
         return f"AvalancheDelegation(limitedProofId={self.limited_proofid:064x}, " \
                f"proofMaster={self.proof_master.hex()}, proofid={self.proofid:064x}, " \
                f"levels={self.levels})"
 
     def getid(self):
         h = ser_uint256(self.proofid)
         for level in self.levels:
             h = hash256(h + ser_string(level.pubkey))
         return h
 
 
 class AvalancheHello():
     __slots__ = ("delegation", "sig")
 
     def __init__(self, delegation=AvalancheDelegation(), sig=b"\0" * 64):
         self.delegation = delegation
         self.sig = sig
 
     def deserialize(self, f):
         self.delegation.deserialize(f)
         self.sig = f.read(64)
 
     def serialize(self):
         r = b""
         r += self.delegation.serialize()
         r += self.sig
         return r
 
     def __repr__(self):
         return "AvalancheHello(delegation={}, sig={})".format(
             repr(self.delegation), self.sig)
 
     def get_sighash(self, node):
         b = self.delegation.getid()
         b += struct.pack("<Q", node.remote_nonce)
         b += struct.pack("<Q", node.local_nonce)
         b += struct.pack("<Q", node.remote_extra_entropy)
         b += struct.pack("<Q", node.local_extra_entropy)
         return hash256(b)
 
 
 class CPartialMerkleTree:
     __slots__ = ("nTransactions", "vBits", "vHash")
 
     def __init__(self):
         self.nTransactions = 0
         self.vHash = []
         self.vBits = []
 
     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", "nExtraEntropy")
     msgtype = 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
         self.nExtraEntropy = random.getrandbits(64)
 
     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, with_time=False)
 
         self.addrFrom = CAddress()
         self.addrFrom.deserialize(f, with_time=False)
         self.nNonce = struct.unpack("<Q", f.read(8))[0]
         self.strSubVer = deser_string(f)
 
         self.nStartingHeight = struct.unpack("<i", f.read(4))[0]
 
         self.nRelay = struct.unpack("<b", f.read(1))[0]
 
         self.nExtraEntropy = struct.unpack("<Q", f.read(8))[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(with_time=False)
         r += self.addrFrom.serialize(with_time=False)
         r += struct.pack("<Q", self.nNonce)
         r += ser_string(self.strSubVer)
         r += struct.pack("<i", self.nStartingHeight)
         r += struct.pack("<b", self.nRelay)
         r += struct.pack("<Q", self.nExtraEntropy)
         return r
 
     def __repr__(self):
         return 'msg_version(nVersion={} nServices={} nTime={} addrTo={} addrFrom={} nNonce=0x{:016X} strSubVer={} nStartingHeight={} nRelay={} nExtraEntropy={})'.format(
             self.nVersion, self.nServices, self.nTime,
             repr(self.addrTo), repr(self.addrFrom), self.nNonce,
             self.strSubVer, self.nStartingHeight, self.nRelay, self.nExtraEntropy)
 
 
 class msg_verack:
     __slots__ = ()
     msgtype = 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",)
     msgtype = 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_addrv2:
     __slots__ = ("addrs",)
     msgtype = b"addrv2"
 
     def __init__(self):
         self.addrs = []
 
     def deserialize(self, f):
         self.addrs = deser_vector(f, CAddress, "deserialize_v2")
 
     def serialize(self):
         return ser_vector(self.addrs, "serialize_v2")
 
     def __repr__(self):
         return "msg_addrv2(addrs={})".format(repr(self.addrs))
 
 
 class msg_sendaddrv2:
     __slots__ = ()
     msgtype = b"sendaddrv2"
 
     def __init__(self):
         pass
 
     def deserialize(self, f):
         pass
 
     def serialize(self):
         return b""
 
     def __repr__(self):
         return "msg_sendaddrv2()"
 
 
 class msg_inv:
     __slots__ = ("inv",)
     msgtype = 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",)
     msgtype = 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")
     msgtype = 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",)
     msgtype = 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",)
     msgtype = 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 msgtype, and the data
 class msg_generic:
     __slots__ = ("msgtype", "data")
 
     def __init__(self, msgtype, data=None):
         self.msgtype = msgtype
         self.data = data
 
     def serialize(self):
         return self.data
 
     def __repr__(self):
         return "msg_generic()"
 
 
 class msg_getaddr:
     __slots__ = ()
     msgtype = 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",)
     msgtype = 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",)
     msgtype = 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__ = ()
     msgtype = 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", )
     msgtype = 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__ = ()
     msgtype = 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",)
     msgtype = 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",)
     msgtype = 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_merkleblock:
     __slots__ = ("merkleblock",)
     msgtype = b"merkleblock"
 
     def __init__(self, merkleblock=None):
         if merkleblock is None:
             self.merkleblock = CMerkleBlock()
         else:
             self.merkleblock = merkleblock
 
     def deserialize(self, f):
         self.merkleblock.deserialize(f)
 
     def serialize(self):
         return self.merkleblock.serialize()
 
     def __repr__(self):
         return "msg_merkleblock(merkleblock={})".format(repr(self.merkleblock))
 
 
 class msg_filterload:
     __slots__ = ("data", "nHashFuncs", "nTweak", "nFlags")
     msgtype = b"filterload"
 
     def __init__(self, data=b'00', nHashFuncs=0, nTweak=0, nFlags=0):
         self.data = data
         self.nHashFuncs = nHashFuncs
         self.nTweak = nTweak
         self.nFlags = nFlags
 
     def deserialize(self, f):
         self.data = deser_string(f)
         self.nHashFuncs = struct.unpack("<I", f.read(4))[0]
         self.nTweak = struct.unpack("<I", f.read(4))[0]
         self.nFlags = struct.unpack("<B", f.read(1))[0]
 
     def serialize(self):
         r = b""
         r += ser_string(self.data)
         r += struct.pack("<I", self.nHashFuncs)
         r += struct.pack("<I", self.nTweak)
         r += struct.pack("<B", self.nFlags)
         return r
 
     def __repr__(self):
         return "msg_filterload(data={}, nHashFuncs={}, nTweak={}, nFlags={})".format(
             self.data, self.nHashFuncs, self.nTweak, self.nFlags)
 
 
 class msg_filteradd:
     __slots__ = ("data")
     msgtype = b"filteradd"
 
     def __init__(self, data):
         self.data = data
 
     def deserialize(self, f):
         self.data = deser_string(f)
 
     def serialize(self):
         r = b""
         r += ser_string(self.data)
         return r
 
     def __repr__(self):
         return "msg_filteradd(data={})".format(self.data)
 
 
 class msg_filterclear:
     __slots__ = ()
     msgtype = b"filterclear"
 
     def __init__(self):
         pass
 
     def deserialize(self, f):
         pass
 
     def serialize(self):
         return b""
 
     def __repr__(self):
         return "msg_filterclear()"
 
 
 class msg_feefilter:
     __slots__ = ("feerate",)
     msgtype = 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")
     msgtype = b"sendcmpct"
 
-    def __init__(self):
-        self.announce = False
-        self.version = 1
+    def __init__(self, announce=False, version=1):
+        self.announce = announce
+        self.version = version
 
     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",)
     msgtype = 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",)
     msgtype = 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",)
     msgtype = 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_getcfilters:
     __slots__ = ("filter_type", "start_height", "stop_hash")
     msgtype = b"getcfilters"
 
     def __init__(self, filter_type, start_height, stop_hash):
         self.filter_type = filter_type
         self.start_height = start_height
         self.stop_hash = stop_hash
 
     def deserialize(self, f):
         self.filter_type = struct.unpack("<B", f.read(1))[0]
         self.start_height = struct.unpack("<I", f.read(4))[0]
         self.stop_hash = deser_uint256(f)
 
     def serialize(self):
         r = b""
         r += struct.pack("<B", self.filter_type)
         r += struct.pack("<I", self.start_height)
         r += ser_uint256(self.stop_hash)
         return r
 
     def __repr__(self):
         return "msg_getcfilters(filter_type={:#x}, start_height={}, stop_hash={:x})".format(
             self.filter_type, self.start_height, self.stop_hash)
 
 
 class msg_cfilter:
     __slots__ = ("filter_type", "block_hash", "filter_data")
     msgtype = b"cfilter"
 
     def __init__(self, filter_type=None, block_hash=None, filter_data=None):
         self.filter_type = filter_type
         self.block_hash = block_hash
         self.filter_data = filter_data
 
     def deserialize(self, f):
         self.filter_type = struct.unpack("<B", f.read(1))[0]
         self.block_hash = deser_uint256(f)
         self.filter_data = deser_string(f)
 
     def serialize(self):
         r = b""
         r += struct.pack("<B", self.filter_type)
         r += ser_uint256(self.block_hash)
         r += ser_string(self.filter_data)
         return r
 
     def __repr__(self):
         return "msg_cfilter(filter_type={:#x}, block_hash={:x})".format(
             self.filter_type, self.block_hash)
 
 
 class msg_getcfheaders:
     __slots__ = ("filter_type", "start_height", "stop_hash")
     msgtype = b"getcfheaders"
 
     def __init__(self, filter_type, start_height, stop_hash):
         self.filter_type = filter_type
         self.start_height = start_height
         self.stop_hash = stop_hash
 
     def deserialize(self, f):
         self.filter_type = struct.unpack("<B", f.read(1))[0]
         self.start_height = struct.unpack("<I", f.read(4))[0]
         self.stop_hash = deser_uint256(f)
 
     def serialize(self):
         r = b""
         r += struct.pack("<B", self.filter_type)
         r += struct.pack("<I", self.start_height)
         r += ser_uint256(self.stop_hash)
         return r
 
     def __repr__(self):
         return "msg_getcfheaders(filter_type={:#x}, start_height={}, stop_hash={:x})".format(
             self.filter_type, self.start_height, self.stop_hash)
 
 
 class msg_cfheaders:
     __slots__ = ("filter_type", "stop_hash", "prev_header", "hashes")
     msgtype = b"cfheaders"
 
     def __init__(self, filter_type=None, stop_hash=None,
                  prev_header=None, hashes=None):
         self.filter_type = filter_type
         self.stop_hash = stop_hash
         self.prev_header = prev_header
         self.hashes = hashes
 
     def deserialize(self, f):
         self.filter_type = struct.unpack("<B", f.read(1))[0]
         self.stop_hash = deser_uint256(f)
         self.prev_header = deser_uint256(f)
         self.hashes = deser_uint256_vector(f)
 
     def serialize(self):
         r = b""
         r += struct.pack("<B", self.filter_type)
         r += ser_uint256(self.stop_hash)
         r += ser_uint256(self.prev_header)
         r += ser_uint256_vector(self.hashes)
         return r
 
     def __repr__(self):
         return "msg_cfheaders(filter_type={:#x}, stop_hash={:x})".format(
             self.filter_type, self.stop_hash)
 
 
 class msg_getcfcheckpt:
     __slots__ = ("filter_type", "stop_hash")
     msgtype = b"getcfcheckpt"
 
     def __init__(self, filter_type, stop_hash):
         self.filter_type = filter_type
         self.stop_hash = stop_hash
 
     def deserialize(self, f):
         self.filter_type = struct.unpack("<B", f.read(1))[0]
         self.stop_hash = deser_uint256(f)
 
     def serialize(self):
         r = b""
         r += struct.pack("<B", self.filter_type)
         r += ser_uint256(self.stop_hash)
         return r
 
     def __repr__(self):
         return "msg_getcfcheckpt(filter_type={:#x}, stop_hash={:x})".format(
             self.filter_type, self.stop_hash)
 
 
 class msg_cfcheckpt:
     __slots__ = ("filter_type", "stop_hash", "headers")
     msgtype = b"cfcheckpt"
 
     def __init__(self, filter_type=None, stop_hash=None, headers=None):
         self.filter_type = filter_type
         self.stop_hash = stop_hash
         self.headers = headers
 
     def deserialize(self, f):
         self.filter_type = struct.unpack("<B", f.read(1))[0]
         self.stop_hash = deser_uint256(f)
         self.headers = deser_uint256_vector(f)
 
     def serialize(self):
         r = b""
         r += struct.pack("<B", self.filter_type)
         r += ser_uint256(self.stop_hash)
         r += ser_uint256_vector(self.headers)
         return r
 
     def __repr__(self):
         return "msg_cfcheckpt(filter_type={:#x}, stop_hash={:x})".format(
             self.filter_type, self.stop_hash)
 
 
 class msg_avaproof():
     __slots__ = ("proof",)
     msgtype = b"avaproof"
 
     def __init__(self):
         self.proof = AvalancheProof()
 
     def deserialize(self, f):
         self.proof.deserialize(f)
 
     def serialize(self):
         r = b""
         r += self.proof.serialize()
         return r
 
     def __repr__(self):
         return "msg_avaproof(proof={})".format(repr(self.proof))
 
 
 class msg_avapoll():
     __slots__ = ("poll",)
     msgtype = 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",)
     msgtype = 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",)
     msgtype = 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))
 
 
 class msg_avahello():
     __slots__ = ("hello",)
     msgtype = b"avahello"
 
     def __init__(self):
         self.hello = AvalancheHello()
 
     def deserialize(self, f):
         self.hello.deserialize(f)
 
     def serialize(self):
         r = b""
         r += self.hello.serialize()
         return r
 
     def __repr__(self):
         return "msg_avahello(response={})".format(repr(self.hello))
 
 
 class TestFrameworkMessages(unittest.TestCase):
     def test_serialization_round_trip(self):
         """Verify that messages and serialized objects are unchanged after
         a round-trip of deserialization-serialization.
         """
 
         proof_hex = (
             "2a00000000000000fff053650000000021030b4c866585dd868a9d62348a9cd00"
             "8d6a312937048fff31670e7e920cfc7a74401b7fc19792583e9cb39843fc5e22a"
             "4e3648ab1cb18a70290b341ee8d4f550ae2400000000102700000000000078881"
             "4004104d0de0aaeaefad02b8bdc8a01a1b8b11c696bd3d66a2c5f10780d95b7df"
             "42645cd85228a6fb29940e858e7e55842ae2bd115d1ed7cc0e82d934e929c9764"
             "8cb0ac3052d58da74de7404e84ebe2940ed2b0fe85578d8230788d8387aeaa618"
             "274b0f2edc73679fd398f60e6315258c9ec348df7fcc09340ae1af37d009719b0"
             "665"
         )
 
         avaproof = FromHex(AvalancheProof(), proof_hex)
         self.assertEqual(ToHex(avaproof), proof_hex)
 
         self.assertEqual(
             f"{avaproof.proofid:0{64}x}",
             "cb33d7fac9092089f0d473c13befa012e6ee4d19abf9a42248f731d5e59e74a2"
         )
         self.assertEqual(avaproof.sequence, 42)
         self.assertEqual(avaproof.expiration, 1699999999)
         # The master key is extracted from the key_tests.cpp.
         # Associated privkey:
         #   hex: 12b004fff7f4b69ef8650e767f18f11ede158148b425660723b9f9a66e61f747
         #   WIF: cND2ZvtabDbJ1gucx9GWH6XT9kgTAqfb6cotPt5Q5CyxVDhid2EN
         self.assertEqual(avaproof.master, bytes.fromhex(
             "030b4c866585dd868a9d62348a9cd008d6a312937048fff31670e7e920cfc7a744"
         ))
         self.assertEqual(len(avaproof.stakes), 1)
         self.assertEqual(avaproof.stakes[0].sig, bytes.fromhex(
             "c3052d58da74de7404e84ebe2940ed2b0fe85578d8230788d8387aeaa618274b"
             "0f2edc73679fd398f60e6315258c9ec348df7fcc09340ae1af37d009719b0665"
         ))
         self.assertEqual(f"{avaproof.stakes[0].stake.utxo.hash:x}",
                          "24ae50f5d4e81e340b29708ab11cab48364e2ae2c53f8439cbe983257919fcb7"
                          )
         self.assertEqual(avaproof.stakes[0].stake.utxo.n, 0)
         self.assertEqual(avaproof.stakes[0].stake.amount, 10000)
         self.assertEqual(avaproof.stakes[0].stake.height, 672828)
         self.assertEqual(avaproof.stakes[0].stake.is_coinbase, False)
         self.assertEqual(avaproof.stakes[0].stake.pubkey, bytes.fromhex(
             "04d0de0aaeaefad02b8bdc8a01a1b8b11c696bd3d66a2c5f10780d95b7df42645"
             "cd85228a6fb29940e858e7e55842ae2bd115d1ed7cc0e82d934e929c97648cb0a"
         ))
 
         msg_proof = msg_avaproof()
         msg_proof.proof = avaproof
         self.assertEqual(ToHex(msg_proof), proof_hex)