def METHOD_NAME(self):
    self.log.info('Check that the node doesn\'t send unexpected messages before handshake completion')
    # Peer that never sends a version, nor any other messages. It shouldn't receive anything from the node.
    no_version_idle_peer = self.nodes[0].add_p2p_connection(LazyPeer(), send_version=False, wait_for_verack=False)
    # Peer that sends a version but not a verack.
    no_verack_idle_peer = self.nodes[0].add_p2p_connection(NoVerackIdlePeer(), wait_for_verack=False)
    # Pre-wtxidRelay peer that sends a version but not a verack and does not support feature negotiation
    # messages which start at nVersion == 70016
    pre_wtxidrelay_peer = self.nodes[0].add_p2p_connection(NoVerackIdlePeer(), send_version=False, wait_for_verack=False)
    pre_wtxidrelay_peer.send_message(self.create_old_version(70015))
    # Wait until the peer gets the verack in response to the version. Though, don't wait for the node to receive the
    # verack, since the peer never sent one
    no_verack_idle_peer.wait_for_verack()
    pre_wtxidrelay_peer.wait_for_verack()
    no_version_idle_peer.wait_until(lambda: no_version_idle_peer.ever_connected)
    no_verack_idle_peer.wait_until(lambda: no_verack_idle_peer.version_received)
    pre_wtxidrelay_peer.wait_until(lambda: pre_wtxidrelay_peer.version_received)
    # Mine a block and make sure that it's not sent to the connected peers
    self.generate(self.nodes[0], nblocks=1)
    # Give the node enough time to possibly leak out a message
    time.sleep(PEER_TIMEOUT + 2)
    self.log.info("Connect peer to ensure the net thread runs the disconnect logic at least once")
    self.nodes[0].add_p2p_connection(P2PInterface())
    # Make sure only expected messages came in
    assert not no_version_idle_peer.unexpected_msg
    assert not no_version_idle_peer.got_wtxidrelay
    assert not no_version_idle_peer.got_sendaddrv2
    assert not no_verack_idle_peer.unexpected_msg
    assert no_verack_idle_peer.got_wtxidrelay
    assert no_verack_idle_peer.got_sendaddrv2
    assert not pre_wtxidrelay_peer.unexpected_msg
    assert not pre_wtxidrelay_peer.got_wtxidrelay
    assert not pre_wtxidrelay_peer.got_sendaddrv2
    # Expect peers to be disconnected due to timeout
    assert not no_version_idle_peer.is_connected
    assert not no_verack_idle_peer.is_connected
    assert not pre_wtxidrelay_peer.is_connected
    self.log.info('Check that the version message does not leak the local address of the node')
    p2p_version_store = self.nodes[0].add_p2p_connection(P2PVersionStore())
    ver = p2p_version_store.version_received
    # Check that received time is within one hour of now
    assert_greater_than_or_equal(ver.nTime, time.time() - 3600)
    assert_greater_than_or_equal(time.time() + 3600, ver.nTime)
    assert_equal(ver.addrFrom.port, 0)
    assert_equal(ver.addrFrom.ip, '0.0.0.0')
    assert_equal(ver.nStartingHeight, 201)
    assert_equal(ver.relay, 1)
    self.log.info('Check that old peers are disconnected')
    p2p_old_peer = self.nodes[0].add_p2p_connection(P2PInterface(), send_version=False, wait_for_verack=False)
    with self.nodes[0].assert_debug_log(["using obsolete version 31799; disconnecting"]):
        p2p_old_peer.send_message(self.create_old_version(31799))
        p2p_old_peer.wait_for_disconnect()