test/functional/p2p_compactblocks.py - master - githubmirror/bitcoin

test/functional/p2p_compactblocks.py
1 138 строк51 KB
furszy
p2p: reject empty getblocktxn requests
31 июл 2026, 23:08
31 июл 2026, 23:0828641fd
#!/usr/bin/env python3
# Copyright (c) 2016-present The Bitcoin Core developers
# Distributed under the MIT software license, see the accompanying
# file COPYING or http://www.opensource.org/licenses/mit-license.php.
"""Test compact blocks (BIP 152)."""
import random

from test_framework.blocktools import (
    COINBASE_MATURITY,
    NORMAL_GBT_REQUEST_PARAMS,
    add_witness_commitment,
    create_block,
)
from test_framework.messages import (
    BlockTransactions,
    BlockTransactionsRequest,
    CBlock,
    CBlockHeader,
    CInv,
    COutPoint,
    CTransaction,
    CTxIn,
    CTxInWitness,
    CTxOut,
    from_hex,
    HeaderAndShortIDs,
    MSG_BLOCK,
    MSG_CMPCT_BLOCK,
    MSG_WITNESS_FLAG,
    P2PHeaderAndShortIDs,
    PrefilledTransaction,
    calculate_shortid,
    msg_block,
    msg_blocktxn,
    msg_cmpctblock,
    msg_getblocktxn,
    msg_getdata,
    msg_getheaders,
    msg_headers,
    msg_inv,
    msg_no_witness_block,
    msg_no_witness_blocktxn,
    msg_sendcmpct,
    msg_sendheaders,
    msg_tx,
    ser_uint256,
    tx_from_hex,
)
from test_framework.p2p import (
    P2PInterface,
    p2p_lock,
)
from test_framework.script import (
    CScript,
    OP_DROP,
    OP_TRUE,
    OP_RETURN,
)
from test_framework.test_framework import BitcoinTestFramework
from test_framework.test_node import TestNode
from test_framework.util import (
    assert_not_equal,
    assert_equal,
    softfork_active,
)
from test_framework.wallet import MiniWallet


# 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.announced_blockhashes.add(self.last_message["cmpctblock"].header_and_shortids.header.hash_int)

    def on_headers(self, message):
        self.block_announced = True
        for x in self.last_message["headers"].headers:
            self.announced_blockhashes.add(x.hash_int)

    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 clear_getblocktxn(self):
        with p2p_lock:
            self.last_message.pop("getblocktxn", None)

    def get_headers(self, locator, hashstop):
        msg = msg_getheaders()
        msg.locator.vHave = locator
        msg.hashstop = hashstop
        self.send_without_ping(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_without_ping(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_without_ping(message)
        self.wait_for_disconnect(timeout=timeout)

class CompactBlocksTest(BitcoinTestFramework):
    def set_test_params(self):
        self.setup_clean_chain = True
        self.num_nodes = 1
        self.extra_args = [[
            "-acceptnonstdtxn=1",
        ]]
        self.utxos = []

    def getblocktxn_expected(self, peer, blockhash, indices=None):
        with p2p_lock:
            assert "getblocktxn" in peer.last_message
            gbt = peer.last_message["getblocktxn"].block_txn_request

        assert_equal(gbt.blockhash, blockhash)
        if indices is not None:
            assert_equal(gbt.to_absolute(), indices)
        if isinstance(peer, TestNode):
            assert_not_equal(peer.getbestblockhash(), blockhash)

    def build_block_on_tip(self, node):
        block = create_block(tmpl=node.getblocktemplate(NORMAL_GBT_REQUEST_PARAMS))
        block.solve()
        return block

    # Create 12 more anyone-can-spend utxo's for testing.
    def make_utxos(self):
        COUNT = 12
        block = self.build_block_on_tip(self.nodes[0])
        self.segwit_node.send_and_ping(msg_no_witness_block(block))
        assert_equal(self.nodes[0].getbestblockhash(), block.hash_hex)
        self.generate(self.wallet, COINBASE_MATURITY)

        total_value = block.vtx[0].vout[0].nValue
        out_value = total_value // COUNT
        tx = CTransaction()
        tx.vin.append(CTxIn(COutPoint(block.vtx[0].txid_int, 0), b''))
        for _ in range(COUNT):
            tx.vout.append(CTxOut(out_value, CScript([OP_TRUE])))

        block2 = self.build_block_on_tip(self.nodes[0])
        block2.vtx.append(tx)
        block2.hashMerkleRoot = block2.calc_merkle_root()
        block2.solve()
        self.segwit_node.send_and_ping(msg_no_witness_block(block2))
        assert_equal(self.nodes[0].getbestblockhash(), block2.hash_hex)
        self.utxos.extend([[tx.txid_int, i, out_value] for i in range(COUNT)])

    def announce_cmpct_block(self, node, peer, txn_count=5, solicit=False):
        utxo = self.utxos.pop(0)
        block = self.build_block_with_transactions(node, utxo, txn_count)

        cmpct_block = HeaderAndShortIDs()
        cmpct_block.initialize_from_block(block)
        msg = msg_cmpctblock(cmpct_block.to_p2p())
        if solicit:
            peer.send_without_ping(msg_headers([block]))
            peer.wait_for_getdata([block.hash_int], timeout=30)

        peer.clear_getblocktxn()
        peer.send_and_ping(msg)
        self.getblocktxn_expected(peer, block.hash_int)
        return block, cmpct_block

    # Test "sendcmpct" (between peers preferring the same version):
    # - No compact block announcements unless sendcmpct is sent.
    # - If sendcmpct is sent with version = 1, the message is ignored.
    # - If sendcmpct is sent with version > 2, 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.
    def test_sendcmpct(self, test_node):
        node = self.nodes[0]

        # 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 version 2 is received.
            assert_equal(test_node.last_sendcmpct[0].version, 2)
            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(self.generate(node, 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-low version
        test_node.send_and_ping(msg_sendcmpct(announce=True, version=1))
        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 too-high version
        test_node.send_and_ping(msg_sendcmpct(announce=True, version=3))
        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
        test_node.send_and_ping(msg_sendcmpct(announce=False, version=2))
        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
        test_node.send_and_ping(msg_sendcmpct(announce=True, version=2))
        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.
        test_node.send_and_ping(msg_sendcmpct(announce=False, version=1))
        check_announcement_of_new_block(node, test_node, lambda p: "cmpctblock" in p.last_message)

        # Now turn off announcements
        test_node.send_and_ping(msg_sendcmpct(announce=False, version=2))
        check_announcement_of_new_block(node, test_node, lambda p: "cmpctblock" not in p.last_message and "headers" in p.last_message)

    # BIP152 mandates that the announce field of a sendcmpct message is a
    # boolean and MUST have a value of either 1 or 0. Sending any other value
    # should be treated as misbehavior and lead to a disconnect.
    def test_invalid_sendcmpct_announce(self):
        node = self.nodes[0]
        bad_peer = node.add_p2p_connection(TestP2PConn())
        msg = msg_sendcmpct(announce=2, version=2)
        with node.assert_debug_log(['invalid sendcmpct announce field']):
            bad_peer.send_await_disconnect(msg)

    # This test actually causes bitcoind to (reasonably!) disconnect us, so do this last.
    # Note, these are not consensus-invalid blocks, but improperly constructed cmpctblock messages.
    def test_invalid_cmpctblock_message(self):
        # Make a high-bandwidth peer
        hb_peer = self.nodes[0].add_p2p_connection(TestP2PConn())
        self.request_cb_announcements(hb_peer)
        self.make_peer_hb_to_candidate(self.nodes[0], hb_peer)
        self.assert_highbandwidth_states(self.nodes[0], idx=-1, hb_to=True, hb_from=True)

        # Make a low-bandwidth peer
        lb_peer = self.nodes[0].add_p2p_connection(TestP2PConn())
        self.request_cb_announcements(lb_peer)
        self.assert_highbandwidth_states(self.nodes[0], idx=-1, hb_to=False, hb_from=True)

        # Construct an invalid cmpctblock message
        self.generate(self.nodes[0], COINBASE_MATURITY + 1)
        block = self.build_block_on_tip(self.nodes[0])
        cmpct_block = P2PHeaderAndShortIDs()
        cmpct_block.header = CBlockHeader(block)
        cmpct_block.prefilled_txn_length = 1
        too_high_prefill_idx = 1
        prefilled_txn = PrefilledTransaction(too_high_prefill_idx, block.vtx[0])
        cmpct_block.prefilled_txn = [prefilled_txn]

        # Test an unsolicited invalid cmpctblock from an HB peer.
        hb_peer.send_await_disconnect(msg_cmpctblock(cmpct_block))
        assert_equal(int(self.nodes[0].getbestblockhash(), 16), block.hashPrevBlock)

        # Test a solicited invalid cmpctblock from a non-HB peer.
        lb_peer.send_header_for_blocks([block])
        lb_peer.wait_for_getdata([block.hash_int], timeout=30)
        lb_peer.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, test_node):
        node = self.nodes[0]
        # Generate a bunch of transactions.
        self.generate(node, COINBASE_MATURITY + 1)
        num_transactions = 25

        segwit_tx_generated = False
        for _ in range(num_transactions):
            hex_tx = self.wallet.send_self_transfer(from_node=self.nodes[0])['hex']
            tx = tx_from_hex(hex_tx)
            if not tx.wit.is_null():
                segwit_tx_generated = True

        assert segwit_tx_generated  # check that our test is not broken

        # 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)

        # Now mine a block, and look at the resulting compact block.
        test_node.clear_block_announcement()
        block_hash = int(self.generate(node, 1)[0], 16)

        # Store the raw block in our internal format.
        block = from_hex(CBlock(), node.getblock("%064x" % block_hash, False))

        # 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_without_ping(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!
        assert_equal(header_and_shortids.header.hash_int, 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:
            # This checks the non-witness parts of the tx agree
            assert_equal(entry.tx.txid_hex, block.vtx[entry.index].txid_hex)

            # And this checks the witness
            assert_equal(entry.tx.wtxid_hex, block.vtx[entry.index].wtxid_hex)

        # 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].wtxid_int
                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, test_node):
        node = self.nodes[0]
        # 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_without_ping(msg_inv([CInv(MSG_BLOCK, block.hash_int)]))
                test_node.wait_for_getheaders(timeout=30)
                test_node.send_header_for_blocks([block])
            else:
                test_node.send_header_for_blocks([block])
            test_node.wait_for_getdata([block.hash_int], 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].wtxid_int
            comp_block.shortids = [calculate_shortid(k0, k1, coinbase_hash)]
            test_node.clear_getblocktxn()
            test_node.send_and_ping(msg_cmpctblock(comp_block.to_p2p()))
            assert_equal(int(node.getbestblockhash(), 16), block.hashPrevBlock)
            # Expect a getblocktxn message that requests the coinbase.
            self.getblocktxn_expected(test_node, block.hash_int, indices=[0])

            # Send the coinbase, and verify that the tip advances.
            msg = msg_blocktxn()
            msg.block_transactions.blockhash = block.hash_int
            msg.block_transactions.transactions = [block.vtx[0]]
            test_node.send_and_ping(msg)
            assert_equal(node.getbestblockhash(), block.hash_hex)

    # Create a chain of transactions from given utxo, and add to a new block.
    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, OP_DROP] * 15 + [OP_TRUE])))
            utxo = [tx.txid_int, 0, tx.vout[0].nValue]
            block.vtx.append(tx)

        block.hashMerkleRoot = block.calc_merkle_root()
        block.solve()
        return block

    # 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, test_node):
        node = self.nodes[0]

        def test_getblocktxn_response(compact_block, peer, expected_result):
            msg = msg_cmpctblock(compact_block.to_p2p())
            peer.clear_getblocktxn()
            peer.send_and_ping(msg)
            self.getblocktxn_expected(peer, compact_block.header.hash_int, 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 = self.build_block_with_transactions(node, utxo, 5)
        self.utxos.append([block.vtx[-1].txid_int, 0, block.vtx[-1].vout[0].nValue])
        comp_block = HeaderAndShortIDs()
        comp_block.initialize_from_block(block, use_witness=True)

        test_getblocktxn_response(comp_block, test_node, [1, 2, 3, 4, 5])

        msg_bt = msg_no_witness_blocktxn()
        msg_bt = msg_blocktxn()  # serialize with witnesses
        msg_bt.block_transactions = BlockTransactions(block.hash_int, block.vtx[1:])
        test_tip_after_message(node, test_node, msg_bt, block.hash_int)

        utxo = self.utxos.pop(0)
        block = self.build_block_with_transactions(node, utxo, 5)
        self.utxos.append([block.vtx[-1].txid_int, 0, block.vtx[-1].vout[0].nValue])

        # Now try interspersing the prefilled transactions
        comp_block.initialize_from_block(block, prefill_list=[0, 1, 5], use_witness=True)
        test_getblocktxn_response(comp_block, test_node, [2, 3, 4])
        msg_bt.block_transactions = BlockTransactions(block.hash_int, block.vtx[2:5])
        test_tip_after_message(node, test_node, msg_bt, block.hash_int)

        # Now try giving one transaction ahead of time.
        utxo = self.utxos.pop(0)
        block = self.build_block_with_transactions(node, utxo, 5)
        self.utxos.append([block.vtx[-1].txid_int, 0, block.vtx[-1].vout[0].nValue])
        test_node.send_and_ping(msg_tx(block.vtx[1]))
        assert block.vtx[1].txid_hex in node.getrawmempool()

        # Prefill 4 out of the 6 transactions, and verify that only the one
        # that was not in the mempool is requested.
        comp_block.initialize_from_block(block, prefill_list=[0, 2, 3, 4], use_witness=True)
        test_getblocktxn_response(comp_block, test_node, [5])

        msg_bt.block_transactions = BlockTransactions(block.hash_int, [block.vtx[5]])
        test_tip_after_message(node, test_node, msg_bt, block.hash_int)

        # Now provide all transactions to the node before the block is
        # announced and verify reconstruction happens immediately.
        utxo = self.utxos.pop(0)
        block = self.build_block_with_transactions(node, utxo, 10)
        self.utxos.append([block.vtx[-1].txid_int, 0, block.vtx[-1].vout[0].nValue])
        for tx in block.vtx[1:]:
            test_node.send_without_ping(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.txid_hex in mempool

        # Clear out last request.
        test_node.clear_getblocktxn()

        # Send compact block
        comp_block.initialize_from_block(block, prefill_list=[0], use_witness=True)
        test_tip_after_message(node, test_node, msg_cmpctblock(comp_block.to_p2p()), block.hash_int)
        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, test_node):
        node = self.nodes[0]
        utxo = self.utxos.pop(0)

        block = self.build_block_with_transactions(node, utxo, 10)
        self.utxos.append([block.vtx[-1].txid_int, 0, block.vtx[-1].vout[0].nValue])
        # Relay the first 5 transactions from the block in advance
        for tx in block.vtx[1:6]:
            test_node.send_without_ping(msg_tx(tx))
        test_node.sync_with_ping()
        # Make sure all transactions were accepted.
        mempool = node.getrawmempool()
        for tx in block.vtx[1:6]:
            assert tx.txid_hex in mempool

        # Send compact block
        comp_block = HeaderAndShortIDs()
        comp_block.initialize_from_block(block, prefill_list=[0], use_witness=True)
        test_node.clear_getblocktxn()
        test_node.send_and_ping(msg_cmpctblock(comp_block.to_p2p()))
        expected_indices = [6, 7, 8, 9, 10]
        self.getblocktxn_expected(test_node, block.hash_int, 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.hash_int, [block.vtx[5]] + block.vtx[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.hash_int], timeout=10)
        assert test_node.last_message["getdata"].inv[0].type in (MSG_BLOCK, MSG_BLOCK | MSG_WITNESS_FLAG)

        # Deliver the block
        test_node.send_and_ping(msg_block(block))
        assert_equal(node.getbestblockhash(), block.hash_hex)

    # Multiple blocktxn responses will cause a node to get disconnected.
    def test_multiple_blocktxn_response(self, test_node):
        node = self.nodes[0]
        utxo = self.utxos.pop(0)

        block = self.build_block_with_transactions(node, utxo, 2)

        # The attacker sends the block header so that we request it.
        test_node.send_without_ping(msg_headers([block]))
        test_node.wait_for_getdata([block.hash_int], timeout=30)

        # Send compact block
        comp_block = HeaderAndShortIDs()
        comp_block.initialize_from_block(block, prefill_list=[0], use_witness=True)
        test_node.clear_getblocktxn()
        test_node.send_and_ping(msg_cmpctblock(comp_block.to_p2p()))
        self.getblocktxn_expected(test_node, block.hash_int, indices=[1,2])

        # Send a blocktxn that does not succeed in reconstruction, triggering
        # getdata fallback.
        msg = msg_blocktxn()
        msg.block_transactions = BlockTransactions(block.hash_int, [block.vtx[2]] + [block.vtx[1]])
        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.hash_int], timeout=10)
        assert test_node.last_message["getdata"].inv[0].type in (MSG_BLOCK, MSG_BLOCK | MSG_WITNESS_FLAG)

        # Send the same blocktxn and assert the sender gets disconnected.
        with node.assert_debug_log(['previous compact block reconstruction attempt failed']):
            test_node.send_without_ping(msg)
            test_node.wait_for_disconnect()

    def test_getblocktxn_handler(self, test_node):
        node = self.nodes[0]
        # 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 = from_hex(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_without_ping(msg)
            test_node.wait_until(lambda: "blocktxn" in test_node.last_message, timeout=10)

            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)
                    assert_equal(tx.txid_hex, block.vtx[index].txid_hex)
                    # Check that the witness matches
                    assert_equal(tx.wtxid_hex, block.vtx[index].wtxid_hex)
                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:
            assert_equal(test_node.last_message["block"].block.hash_hex, block_hash)
            assert "blocktxn" not in test_node.last_message

        # Request with out-of-bounds tx index results in disconnect
        bad_peer = self.nodes[0].add_p2p_connection(TestP2PConn())
        block_hash = node.getblockhash(chain_height)
        block = from_hex(CBlock(), node.getblock(block_hash, False))
        msg.block_txn_request = BlockTransactionsRequest(int(block_hash, 16), [len(block.vtx)])
        with node.assert_debug_log(['getblocktxn with out-of-bounds tx indices']):
            bad_peer.send_without_ping(msg)
            bad_peer.wait_for_disconnect()

    def test_low_work_compactblocks(self, test_node):
        # A compactblock with insufficient work won't get its header included
        node = self.nodes[0]
        hashPrevBlock = int(node.getblockhash(node.getblockcount() - 150), 16)
        block = self.build_block_on_tip(node)
        block.hashPrevBlock = hashPrevBlock
        block.solve()

        comp_block = HeaderAndShortIDs()
        comp_block.initialize_from_block(block)
        with self.nodes[0].assert_debug_log(['[net] Ignoring low-work compact block from peer 0']):
            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_hex:
                found = True
                break
        assert not found

    def test_compactblocks_not_at_tip(self, test_node):
        node = self.nodes[0]
        # 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(self.generate(node, 1)[0])
            test_node.wait_until(test_node.received_block_announcement, timeout=30)

        test_node.clear_block_announcement()
        test_node.send_without_ping(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()
        self.generate(node, 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_without_ping(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:
            assert_equal(test_node.last_message["block"].block.hash_hex, new_blocks[0])

        # 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_hex:
                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.hash_int, [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, listeners):
        node = self.nodes[0]
        utxo = self.utxos.pop(0)

        block = self.build_block_with_transactions(node, utxo, 10)

        [l.clear_block_announcement() for l in listeners]

        # serialize without witness (this block has no witnesses anyway).
        # TODO: repeat this test with witness tx's to a segwit node.
        node.submitblock(block.serialize().hex())

        for l in listeners:
            l.wait_until(lambda: "cmpctblock" in l.last_message, timeout=30)
        with p2p_lock:
            for l in listeners:
                assert_equal(l.last_message["cmpctblock"].header_and_shortids.header.hash_int, block.hash_int)

    # 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, test_node):
        node = self.nodes[0]
        utxo = self.utxos.pop(0)

        block = self.build_block_with_transactions(node, utxo, 5)
        block.hashMerkleRoot = block.calc_merkle_root()
        # Drop the coinbase witness but include the witness commitment.
        add_witness_commitment(block)
        block.vtx[0].wit.vtxinwit = []
        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=list(range(len(block.vtx))), use_witness=True)
        msg = msg_cmpctblock(comp_block.to_p2p())
        test_node.send_and_ping(msg)

        # Check that the tip didn't advance
        assert_not_equal(node.getbestblockhash(), block.hash_hex)
        test_node.sync_with_ping()

        # Re-establish a proper witness commitment with the coinbase witness, but
        # invalidate the last tx in the block.
        block.vtx[4].vin[0].scriptSig = CScript([OP_RETURN])
        block.hashMerkleRoot = block.calc_merkle_root()
        add_witness_commitment(block)
        block.solve()

        # This will lead to a consensus failure for which we also won't be disconnected but which
        # will be cached.
        comp_block.initialize_from_block(block, prefill_list=list(range(len(block.vtx))), use_witness=True)
        msg = msg_cmpctblock(comp_block.to_p2p())
        test_node.send_and_ping(msg)

        # The tip still didn't advance.
        assert_not_equal(node.getbestblockhash(), block.hash_hex)
        test_node.sync_with_ping()

        # The failure above was cached. Submitting the compact block again will return a cached
        # consensus error (the code path is different) and still not get us disconnected (nor
        # advance the tip).
        test_node.send_and_ping(msg)
        assert_not_equal(node.getbestblockhash(), block.hash_hex)
        test_node.sync_with_ping()

        # Now, announcing a second block building on top of the invalid one will get us disconnected.
        block.hashPrevBlock = block.hash_int
        block.solve()
        comp_block.initialize_from_block(block, prefill_list=list(range(len(block.vtx))), use_witness=True)
        msg = msg_cmpctblock(comp_block.to_p2p())
        test_node.send_await_disconnect(msg)

    def test_empty_getblocktxn_disconnects(self):
        self.log.info("Testing empty getblocktxn disconnects the peer...")
        node = self.nodes[0]
        block_hash = int(node.getbestblockhash(), 16)
        peer = node.add_p2p_connection(P2PInterface())
        msg = msg_getblocktxn()
        msg.block_txn_request = BlockTransactionsRequest(blockhash=block_hash, indexes=[])
        with node.assert_debug_log(['getblocktxn received with no transaction indexes']):
            peer.send_without_ping(msg)
            peer.wait_for_disconnect()

    # peer generates a block and sends it to node, which makes the peer a
    # candidate for high-bandwidth 'to' (up to 3 peers according to BIP 152)
    def make_peer_hb_to_candidate(self, node, peer):
        block = self.build_block_on_tip(node)
        peer.send_and_ping(msg_block(block))

    # Helper for enabling cb announcements
    # Send the sendcmpct request and sync headers
    def request_cb_announcements(self, peer):
        node = self.nodes[0]
        tip = node.getbestblockhash()
        peer.get_headers(locator=[int(tip, 16)], hashstop=0)
        peer.send_and_ping(msg_sendcmpct(announce=True, version=2))

    def test_compactblock_reconstruction_stalling_peer(self, stalling_peer, delivery_peer):
        node = self.nodes[0]

        self.make_peer_hb_to_candidate(node, delivery_peer)
        block, cmpct_block = self.announce_cmpct_block(node, stalling_peer)

        for tx in block.vtx[1:]:
            delivery_peer.send_without_ping(msg_tx(tx))
        delivery_peer.sync_with_ping()
        mempool = node.getrawmempool()
        for tx in block.vtx[1:]:
            assert tx.txid_hex in mempool

        delivery_peer.send_and_ping(msg_cmpctblock(cmpct_block.to_p2p()))
        assert_equal(node.getbestblockhash(), block.hash_hex)

        self.utxos.append([block.vtx[-1].txid_int, 0, block.vtx[-1].vout[0].nValue])

        # Now test that delivering an invalid compact block won't break relay

        block, cmpct_block = self.announce_cmpct_block(node, stalling_peer)
        for tx in block.vtx[1:]:
            delivery_peer.send_without_ping(msg_tx(tx))
        delivery_peer.sync_with_ping()

        cmpct_block.prefilled_txn[0].tx.wit.vtxinwit = [CTxInWitness()]
        cmpct_block.prefilled_txn[0].tx.wit.vtxinwit[0].scriptWitness.stack = [ser_uint256(0)]

        cmpct_block.use_witness = True
        delivery_peer.send_and_ping(msg_cmpctblock(cmpct_block.to_p2p()))
        assert_not_equal(node.getbestblockhash(), block.hash_hex)

        msg = msg_no_witness_blocktxn()
        msg.block_transactions.blockhash = block.hash_int
        msg.block_transactions.transactions = block.vtx[1:]
        stalling_peer.send_and_ping(msg)
        assert_equal(node.getbestblockhash(), block.hash_hex)

    # assert the RPC getpeerinfo boolean fields `bip152_hb_{to, from}`
    # match the given parameters for the peer at idx of a given node
    @staticmethod
    def assert_highbandwidth_states(node, idx, hb_to, hb_from):
        peerinfo = node.getpeerinfo()[idx]
        assert_equal(peerinfo['bip152_hb_to'], hb_to)
        assert_equal(peerinfo['bip152_hb_from'], hb_from)

    def test_highbandwidth_mode_states_via_getpeerinfo(self):
        # create new p2p connection for a fresh state w/o any prior sendcmpct messages sent
        hb_test_node = self.nodes[0].add_p2p_connection(TestP2PConn())

        # Newly created hb_test_node is the last connection.
        hb_test_node_idx = -1

        # initially, neither node has selected the other peer as high-bandwidth yet
        self.assert_highbandwidth_states(self.nodes[0], hb_test_node_idx, hb_to=False, hb_from=False)

        # peer requests high-bandwidth mode by sending sendcmpct(1)
        hb_test_node.send_and_ping(msg_sendcmpct(announce=True, version=2))
        self.assert_highbandwidth_states(self.nodes[0], hb_test_node_idx, hb_to=False, hb_from=True)

        # peer generates a block and sends it to node, which should
        # select the peer as high-bandwidth (up to 3 peers according to BIP 152)
        block = self.build_block_on_tip(self.nodes[0])
        hb_test_node.send_and_ping(msg_block(block))
        self.assert_highbandwidth_states(self.nodes[0], hb_test_node_idx, hb_to=True, hb_from=True)

        # peer requests low-bandwidth mode by sending sendcmpct(0)
        hb_test_node.send_and_ping(msg_sendcmpct(announce=False, version=2))
        self.assert_highbandwidth_states(self.nodes[0], hb_test_node_idx, hb_to=True, hb_from=False)

    def test_compactblock_reconstruction_parallel_reconstruction(self, stalling_peer, delivery_peer, inbound_peer, outbound_peer):
        """ All p2p connections are inbound except outbound_peer. We test that ultimate parallel slot
            can only be taken by an outbound node unless prior attempts were done by an outbound
        """
        node = self.nodes[0]

        for name, peer in [("delivery", delivery_peer), ("inbound", inbound_peer), ("outbound", outbound_peer)]:
            self.log.info(f"Setting {name} as high bandwidth peer")
            self.make_peer_hb_to_candidate(node, peer)
            block, cmpct_block = self.announce_cmpct_block(node, peer, 1)
            msg = msg_blocktxn()
            msg.block_transactions.blockhash = block.hash_int
            msg.block_transactions.transactions = block.vtx[1:]
            peer.send_and_ping(msg)
            assert_equal(node.getbestblockhash(), block.hash_hex)
            peer.clear_getblocktxn()

        # Test the simple parallel download case...
        for num_missing in [1, 5, 20]:
            delivery_peer.clear_getblocktxn()
            inbound_peer.clear_getblocktxn()
            outbound_peer.clear_getblocktxn()

            # Remaining low-bandwidth peer is stalling_peer, who announces first
            assert_equal([peer['bip152_hb_to'] for peer in node.getpeerinfo()], [False, True, True, True])

            block, cmpct_block = self.announce_cmpct_block(node, stalling_peer, num_missing, solicit=True)

            delivery_peer.send_and_ping(msg_cmpctblock(cmpct_block.to_p2p()))
            # The second peer to announce should still get a getblocktxn
            self.getblocktxn_expected(delivery_peer, block.hash_int)

            inbound_peer.send_and_ping(msg_cmpctblock(cmpct_block.to_p2p()))
            with p2p_lock:
                # The third inbound peer to announce should *not* get a getblocktxn
                assert "getblocktxn" not in inbound_peer.last_message
            assert_not_equal(node.getbestblockhash(), block.hash_hex)

            outbound_peer.send_and_ping(msg_cmpctblock(cmpct_block.to_p2p()))
            # The third peer to announce should get a getblocktxn if outbound
            self.getblocktxn_expected(outbound_peer, block.hash_int)

            # Second peer completes the compact block first
            msg = msg_blocktxn()
            msg.block_transactions.blockhash = block.hash_int
            msg.block_transactions.transactions = block.vtx[1:]
            delivery_peer.send_and_ping(msg)
            assert_equal(node.getbestblockhash(), block.hash_hex)

            # Nothing bad should happen if we get a late fill from the first peer...
            stalling_peer.send_and_ping(msg)
            self.utxos.append([block.vtx[-1].txid_int, 0, block.vtx[-1].vout[0].nValue])

    def test_compact_blocks_ignored(self):
        node = self.nodes[0]

        def build_compact_block():
            # generate a compact block to send that will force a GETBLOCKTXN
            utxo = self.utxos.pop(0)
            block = self.build_block_with_transactions(node, utxo, 10)
            cmpct_block = HeaderAndShortIDs()
            cmpct_block.initialize_from_block(block)
            msg = msg_cmpctblock(cmpct_block.to_p2p())
            return block, msg

        # Sends a compact block, uses presence of GETBLOCKTXN as a heuristic
        # for whether or not the node processed the CMPCTBLOCK.
        # Note: since we never fulfill the GETBLOCKTXN, this will never change
        # the HB status of a connection.
        def ignores_compact_block(conn, solicited=False):
            block, msg = build_compact_block()
            conn.clear_getblocktxn()
            if solicited:
                conn.send_without_ping(msg_headers([block]))
                conn.wait_for_getdata([block.hash_int], timeout=30)
            conn.send_and_ping(msg)
            with p2p_lock:
                return "getblocktxn" not in conn.last_message

        # create new p2p connection for a fresh state w/o any prior sendcmpct messages sent
        unsolicited_peer = self.nodes[0].add_p2p_connection(TestP2PConn())
        self.assert_highbandwidth_states(node, idx=-1, hb_to=False, hb_from=False)

        self.log.info("Test that a node ignores unsolicited CMPCTBLOCK messages from peers that have not sent SENDCMPCT.")
        assert ignores_compact_block(unsolicited_peer, solicited=False)

        self.log.info("Test that a node ignores solicited CMPCTBLOCK messages from peers that have not sent SENDCMPCT.")
        assert ignores_compact_block(unsolicited_peer, solicited=True)

        # Unsolicited peer announces CMPCTBLOCK support with SENDCMPCT message,
        # but still non-HB.
        unsolicited_peer.send_and_ping(msg_sendcmpct())
        self.assert_highbandwidth_states(node, idx=-1, hb_to=False, hb_from=False)

        self.log.info("Test that a node ignores unsolicited CMPCTBLOCK messages from non-HB peers.")
        assert ignores_compact_block(unsolicited_peer, solicited=False)
        self.assert_highbandwidth_states(node, idx=-1, hb_to=False, hb_from=False)

        self.log.info("Test that a node does not ignore solicited CMPCTBLOCK messages from non-HB peers.")
        assert not ignores_compact_block(unsolicited_peer, solicited=True)
        self.assert_highbandwidth_states(node, idx=-1, hb_to=False, hb_from=False)

        # The node will ask for transactions from an unsolicited compact block
        # it receives from a high bandwidth peer, we need to use one set up earlier,
        # since all the slots are full.
        self.log.info("Test that a node does not ignore unsolicited CMPCTBLOCK messages from HB peers.")

        hb_peer_idx = -2
        self.assert_highbandwidth_states(node, idx=hb_peer_idx, hb_to=True, hb_from=False)
        hb_peer = self.nodes[0].p2ps[hb_peer_idx]
        assert not ignores_compact_block(hb_peer, solicited=False)

    def run_test(self):
        self.wallet = MiniWallet(self.nodes[0])

        # Setup the p2p connections
        self.segwit_node = self.nodes[0].add_p2p_connection(TestP2PConn())
        self.additional_segwit_node = self.nodes[0].add_p2p_connection(TestP2PConn())
        self.onemore_inbound_node = self.nodes[0].add_p2p_connection(TestP2PConn())
        self.outbound_node = self.nodes[0].add_outbound_p2p_connection(TestP2PConn(), p2p_idx=3, connection_type="outbound-full-relay")

        # We will need UTXOs to construct transactions in later tests.
        self.make_utxos()

        assert softfork_active(self.nodes[0], "segwit")

        self.log.info("Testing SENDCMPCT p2p message... ")
        self.test_sendcmpct(self.segwit_node)
        self.test_sendcmpct(self.additional_segwit_node)
        self.test_sendcmpct(self.onemore_inbound_node)
        self.test_sendcmpct(self.outbound_node)

        self.log.info("Testing compactblock construction...")
        self.test_compactblock_construction(self.segwit_node)

        self.log.info("Testing compactblock requests (segwit node)... ")
        self.test_compactblock_requests(self.segwit_node)

        self.log.info("Testing getblocktxn requests (segwit node)...")
        self.test_getblocktxn_requests(self.segwit_node)

        self.log.info("Testing getblocktxn handler (segwit node should return witnesses)...")
        self.test_getblocktxn_handler(self.segwit_node)

        self.log.info("Testing compactblock requests/announcements not at chain tip...")
        self.test_compactblocks_not_at_tip(self.segwit_node)

        self.log.info("Testing handling of low-work compact blocks...")
        self.test_low_work_compactblocks(self.segwit_node)

        self.log.info("Testing handling of incorrect blocktxn responses...")
        self.test_incorrect_blocktxn_response(self.segwit_node)

        self.log.info("Testing reconstructing compact blocks with a stalling peer...")
        self.test_compactblock_reconstruction_stalling_peer(self.segwit_node, self.additional_segwit_node)

        self.log.info("Testing reconstructing compact blocks from multiple peers...")
        self.test_compactblock_reconstruction_parallel_reconstruction(stalling_peer=self.segwit_node, inbound_peer=self.onemore_inbound_node, delivery_peer=self.additional_segwit_node, outbound_peer=self.outbound_node)

        # Test that if we submitblock to node1, we'll get a compact block
        # announcement to all peers.
        # (Post-segwit activation, blocks won't propagate from node0 to node1
        # automatically, so don't bother testing a block announced to node0.)
        self.log.info("Testing end-to-end block relay...")
        self.request_cb_announcements(self.segwit_node)
        self.request_cb_announcements(self.additional_segwit_node)
        self.test_end_to_end_block_relay([self.segwit_node, self.additional_segwit_node])

        self.log.info("Testing handling of invalid compact blocks...")
        self.test_invalid_tx_in_compactblock(self.segwit_node)
        self.test_empty_getblocktxn_disconnects()

        # The previous test will lead to a disconnection. Reconnect before continuing.
        self.segwit_node = self.nodes[0].add_p2p_connection(TestP2PConn())
        self.segwit_node.send_and_ping(msg_sendcmpct())

        self.log.info("Testing handling of multiple blocktxn responses...")
        self.test_multiple_blocktxn_response(self.segwit_node)

        # The previous test will lead to a disconnection. Reconnect before continuing.
        self.segwit_node = self.nodes[0].add_p2p_connection(TestP2PConn())
        self.segwit_node.send_and_ping(msg_sendcmpct())

        self.log.info("Testing invalid announce field in sendcmpct message...")
        self.test_invalid_sendcmpct_announce()

        self.log.info("Testing invalid index in cmpctblock message...")
        self.test_invalid_cmpctblock_message()

        self.log.info("Testing high-bandwidth mode states via getpeerinfo...")
        self.test_highbandwidth_mode_states_via_getpeerinfo()

        self.log.info("Testing CMPCTBLOCK messages are ignored when expected...")
        self.test_compact_blocks_ignored()


if __name__ == '__main__':
    CompactBlocksTest(__file__).main()