diff --git a/test/functional/p2p_filter.py b/test/functional/p2p_filter.py
index 698c36db7..7a0efd2f9 100755
--- a/test/functional/p2p_filter.py
+++ b/test/functional/p2p_filter.py
@@ -1,120 +1,130 @@
 #!/usr/bin/env python3
 # Copyright (c) 2020 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 BIP 37
 """
 
 from test_framework.messages import (
     MSG_BLOCK,
     MSG_FILTERED_BLOCK,
     msg_getdata,
     msg_filterload,
     msg_filteradd,
     msg_filterclear,
 )
 from test_framework.mininode import P2PInterface
 from test_framework.test_framework import BitcoinTestFramework
 
 
 class FilterNode(P2PInterface):
     # This is a P2SH watch-only wallet
     watch_script_pubkey = 'a914ffffffffffffffffffffffffffffffffffffffff87'
     # The initial filter (n=10, fp=0.000001) with just the above scriptPubKey
     # added
     watch_filter_init = msg_filterload(
         data=b'@\x00\x08\x00\x80\x00\x00 \x00\xc0\x00 \x04\x00\x08$\x00\x04\x80\x00\x00 \x00\x00\x00\x00\x80\x00\x00@\x00\x02@ \x00',
         nHashFuncs=19,
         nTweak=0,
         nFlags=1,
     )
 
     def on_inv(self, message):
         want = msg_getdata()
         for i in message.inv:
             # inv messages can only contain TX or BLOCK, so translate BLOCK to
             # FILTERED_BLOCK
             if i.type == MSG_BLOCK:
                 i.type = MSG_FILTERED_BLOCK
             want.inv.append(i)
         if len(want.inv):
             self.send_message(want)
 
     def on_merkleblock(self, message):
         self.merkleblock_received = True
 
     def on_tx(self, message):
         self.tx_received = True
 
 
 class FilterTest(BitcoinTestFramework):
     def set_test_params(self):
         self.setup_clean_chain = False
         self.num_nodes = 1
         self.extra_args = [[
             '-peerbloomfilters',
             '-whitelist=noban@127.0.0.1',  # immediate tx relay
         ]]
 
     def skip_test_if_missing_module(self):
         self.skip_if_no_wallet()
 
     def run_test(self):
-        self.log.info('Add filtered P2P connection to the node')
         filter_node = self.nodes[0].add_p2p_connection(FilterNode())
+
+        self.log.info('Check that too large filter is rejected')
+        with self.nodes[0].assert_debug_log(['Misbehaving']):
+            filter_node.send_and_ping(
+                msg_filterload(
+                    data=b'\xaa',
+                    nHashFuncs=51,
+                    nTweak=0,
+                    nFlags=1))
+
+        self.log.info('Add filtered P2P connection to the node')
         filter_node.send_and_ping(filter_node.watch_filter_init)
         filter_address = self.nodes[0].decodescript(
             filter_node.watch_script_pubkey)['addresses'][0]
 
         self.log.info(
             'Check that we receive merkleblock and tx if the filter matches a tx in a block')
         block_hash = self.nodes[0].generatetoaddress(1, filter_address)[0]
         txid = self.nodes[0].getblock(block_hash)['tx'][0]
         filter_node.wait_for_merkleblock(block_hash)
         filter_node.wait_for_tx(txid)
 
         self.log.info(
             'Check that we only receive a merkleblock if the filter does not match a tx in a block')
         filter_node.tx_received = False
         block_hash = self.nodes[0].generatetoaddress(
             1, self.nodes[0].getnewaddress())[0]
         filter_node.wait_for_merkleblock(block_hash)
         assert not filter_node.tx_received
 
         self.log.info(
             'Check that we not receive a tx if the filter does not match a mempool tx')
         filter_node.merkleblock_received = False
         filter_node.tx_received = False
         self.nodes[0].sendtoaddress(self.nodes[0].getnewaddress(), 90)
         filter_node.sync_with_ping()
         filter_node.sync_with_ping()
         assert not filter_node.merkleblock_received
         assert not filter_node.tx_received
 
         self.log.info(
             'Check that we receive a tx in reply to a mempool msg if the filter matches a mempool tx')
         filter_node.merkleblock_received = False
         txid = self.nodes[0].sendtoaddress(filter_address, 90)
         filter_node.wait_for_tx(txid)
         assert not filter_node.merkleblock_received
 
         self.log.info(
             'Check that after deleting filter all txs get relayed again')
         filter_node.send_and_ping(msg_filterclear())
 
         for _ in range(5):
             txid = self.nodes[0].sendtoaddress(
                 self.nodes[0].getnewaddress(), 7)
             filter_node.wait_for_tx(txid)
 
         self.log.info(
             "Check that division-by-zero remote crash bug [CVE-2013-5700] is fixed")
         filter_node.send_and_ping(msg_filterload(data=b'', nHashFuncs=1))
         filter_node.send_and_ping(
             msg_filteradd(
                 data=b'letstrytocrashthisnode'))
 
 
 if __name__ == '__main__':
     FilterTest().main()
diff --git a/test/functional/p2p_invalid_messages.py b/test/functional/p2p_invalid_messages.py
index 38d11813e..45ee14f7a 100755
--- a/test/functional/p2p_invalid_messages.py
+++ b/test/functional/p2p_invalid_messages.py
@@ -1,234 +1,252 @@
 #!/usr/bin/env python3
 # Copyright (c) 2015-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.
 """Test node responses to invalid network messages."""
 import asyncio
 import struct
 
 from test_framework import messages
-from test_framework.mininode import P2PDataStore, NetworkThread
+from test_framework.mininode import (
+    NetworkThread,
+    P2PDataStore,
+    P2PInterface,
+)
 from test_framework.test_framework import BitcoinTestFramework
 
 
 class msg_unrecognized:
     """Nonsensical message. Modeled after similar types in test_framework.messages."""
 
     msgtype = b'badmsg'
 
     def __init__(self, *, str_data):
         self.str_data = str_data.encode() if not isinstance(str_data, bytes) else str_data
 
     def serialize(self):
         return messages.ser_string(self.str_data)
 
     def __repr__(self):
         return "{}(data={})".format(self.msgtype, self.str_data)
 
 
 class InvalidMessagesTest(BitcoinTestFramework):
     def set_test_params(self):
         self.num_nodes = 1
         self.setup_clean_chain = True
 
     def run_test(self):
         """
          . Test msg header
         0. Send a bunch of large (2MB) messages of an unrecognized type. Check to see
            that it isn't an effective DoS against the node.
 
         1. Send an oversized (2MB+) message and check that we're disconnected.
 
         2. Send a few messages with an incorrect data size in the header, ensure the
            messages are ignored.
         """
         self.test_magic_bytes()
         self.test_checksum()
         self.test_size()
         self.test_msgtype()
+        self.test_large_inv()
 
         node = self.nodes[0]
         self.node = node
         node.add_p2p_connection(P2PDataStore())
         conn2 = node.add_p2p_connection(P2PDataStore())
 
         # 2MB, per MAX_PROTOCOL_MESSAGE_LENGTH
         msg_limit = 2 * 1024 * 1024
         # Account for the 4-byte length prefix
         valid_data_limit = msg_limit - 5
 
         #
         # 0.
         #
         # Send as large a message as is valid, ensure we aren't disconnected but
         # also can't exhaust resources.
         #
         msg_at_size = msg_unrecognized(str_data="b" * valid_data_limit)
         assert len(msg_at_size.serialize()) == msg_limit
 
         self.log.info(
             "Sending a bunch of large, junk messages to test memory exhaustion. May take a bit...")
 
         # Run a bunch of times to test for memory exhaustion.
         for _ in range(80):
             node.p2p.send_message(msg_at_size)
 
         # Check that, even though the node is being hammered by nonsense from one
         # connection, it can still service other peers in a timely way.
         for _ in range(20):
             conn2.sync_with_ping(timeout=2)
 
         # Peer 1, despite serving up a bunch of nonsense, should still be
         # connected.
         self.log.info("Waiting for node to drop junk messages.")
         node.p2p.sync_with_ping(timeout=320)
         assert node.p2p.is_connected
 
         #
         # 1.
         #
         # Send an oversized message, ensure we're disconnected.
         #
         msg_over_size = msg_unrecognized(str_data="b" * (valid_data_limit + 1))
         assert len(msg_over_size.serialize()) == (msg_limit + 1)
 
         with node.assert_debug_log(["Oversized header detected"]):
             # An unknown message type (or *any* message type) over
             # MAX_PROTOCOL_MESSAGE_LENGTH should result in a disconnect.
             node.p2p.send_message(msg_over_size)
             node.p2p.wait_for_disconnect(timeout=4)
 
         node.disconnect_p2ps()
         conn = node.add_p2p_connection(P2PDataStore())
         conn.wait_for_verack()
 
         #
         # 2.
         #
         # Send messages with an incorrect data size in the header.
         #
         actual_size = 100
         msg = msg_unrecognized(str_data="b" * actual_size)
 
         # TODO: handle larger-than cases. I haven't been able to pin down what
         # behavior to expect.
         for wrong_size in (2, 77, 78, 79):
             self.log.info(
                 "Sending a message with incorrect size of {}".format(wrong_size))
 
             # Unmodified message should submit okay.
             node.p2p.send_and_ping(msg)
 
             # A message lying about its data size results in a disconnect when the incorrect
             # data size is less than the actual size.
             #
             # TODO: why does behavior change at 78 bytes?
             #
             node.p2p.send_raw_message(
                 self._tweak_msg_data_size(
                     msg, wrong_size))
 
             # For some reason unknown to me, we sometimes have to push additional data to the
             # peer in order for it to realize a disconnect.
             try:
                 node.p2p.send_message(messages.msg_ping(nonce=123123))
             except IOError:
                 pass
 
             node.p2p.wait_for_disconnect(timeout=10)
             node.disconnect_p2ps()
             node.add_p2p_connection(P2PDataStore())
 
         # Node is still up.
         conn = node.add_p2p_connection(P2PDataStore())
 
     def test_magic_bytes(self):
         conn = self.nodes[0].add_p2p_connection(P2PDataStore())
 
         async def swap_magic_bytes():
             # Need to ignore all incoming messages from now, since they come
             # with "invalid" magic bytes
             conn._on_data = lambda: None
             conn.magic_bytes = b'\x00\x11\x22\x32'
 
         # Call .result() to block until the atomic swap is complete, otherwise
         # we might run into races later on
         asyncio.run_coroutine_threadsafe(
             swap_magic_bytes(),
             NetworkThread.network_event_loop).result()
 
         with self.nodes[0].assert_debug_log(['PROCESSMESSAGE: INVALID MESSAGESTART ping']):
             conn.send_message(messages.msg_ping(nonce=0xff))
             conn.wait_for_disconnect(timeout=1)
             self.nodes[0].disconnect_p2ps()
 
     def test_checksum(self):
         conn = self.nodes[0].add_p2p_connection(P2PDataStore())
         with self.nodes[0].assert_debug_log(['CHECKSUM ERROR (badmsg, 2 bytes), expected 78df0a04 was ffffffff']):
             msg = conn.build_message(msg_unrecognized(str_data="d"))
             cut_len = (
                 # magic
                 4 +
                 # msgtype
                 12 +
                 # len
                 4
             )
             # modify checksum
             msg = msg[:cut_len] + b'\xff' * 4 + msg[cut_len + 4:]
             self.nodes[0].p2p.send_raw_message(msg)
             conn.wait_for_disconnect()
             self.nodes[0].disconnect_p2ps()
 
     def test_size(self):
         conn = self.nodes[0].add_p2p_connection(P2PDataStore())
         with self.nodes[0].assert_debug_log(['']):
             msg = conn.build_message(msg_unrecognized(str_data="d"))
             cut_len = (
                 # magic
                 4 +
                 # command
                 12
             )
             # modify len to MAX_SIZE + 1
             msg = msg[:cut_len] + \
                 struct.pack("<I", 0x02000000 + 1) + msg[cut_len + 4:]
             self.nodes[0].p2p.send_raw_message(msg)
             conn.wait_for_disconnect(timeout=1)
             self.nodes[0].disconnect_p2ps()
 
     def test_msgtype(self):
         conn = self.nodes[0].add_p2p_connection(P2PDataStore())
         with self.nodes[0].assert_debug_log(['PROCESSMESSAGE: ERRORS IN HEADER']):
             msg = msg_unrecognized(str_data="d")
             msg.msgtype = b'\xff' * 12
             msg = conn.build_message(msg)
             # Modify msgtype
             msg = msg[:7] + b'\x00' + msg[7 + 1:]
             self.nodes[0].p2p.send_raw_message(msg)
             conn.sync_with_ping(timeout=1)
             self.nodes[0].disconnect_p2ps()
 
+    def test_large_inv(self):
+        conn = self.nodes[0].add_p2p_connection(P2PInterface())
+        with self.nodes[0].assert_debug_log(['Misbehaving', 'peer=4 (0 -> 20): oversized-inv: message inv size() = 50001']):
+            msg = messages.msg_inv([messages.CInv(1, 1)] * 50001)
+            conn.send_and_ping(msg)
+        with self.nodes[0].assert_debug_log(['Misbehaving', 'peer=4 (20 -> 40): too-many-inv: message getdata size() = 50001']):
+            msg = messages.msg_getdata([messages.CInv(1, 1)] * 50001)
+            conn.send_and_ping(msg)
+        with self.nodes[0].assert_debug_log(['Misbehaving', 'peer=4 (40 -> 60): too-many-headers: headers message size = 2001']):
+            msg = messages.msg_headers([messages.CBlockHeader()] * 2001)
+            conn.send_and_ping(msg)
+        self.nodes[0].disconnect_p2ps()
+
     def _tweak_msg_data_size(self, message, wrong_size):
         """
         Return a raw message based on another message but with an incorrect data size in
         the message header.
         """
         raw_msg = self.node.p2p.build_message(message)
 
         bad_size_bytes = struct.pack("<I", wrong_size)
         num_header_bytes_before_size = 4 + 12
 
         # Replace the correct data size in the message with an incorrect one.
         raw_msg_with_wrong_size = (
             raw_msg[:num_header_bytes_before_size] +
             bad_size_bytes +
             raw_msg[(num_header_bytes_before_size + len(bad_size_bytes)):]
         )
         assert len(raw_msg) == len(raw_msg_with_wrong_size)
 
         return raw_msg_with_wrong_size
 
 
 if __name__ == '__main__':
     InvalidMessagesTest().main()
diff --git a/test/functional/p2p_invalid_tx.py b/test/functional/p2p_invalid_tx.py
index b94da2dfc..14405f329 100755
--- a/test/functional/p2p_invalid_tx.py
+++ b/test/functional/p2p_invalid_tx.py
@@ -1,183 +1,215 @@
 #!/usr/bin/env python3
 # Copyright (c) 2015-2017 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 node responses to invalid transactions.
 
 In this test we connect to one node over p2p, and test tx requests.
 """
 
 from test_framework.blocktools import (
     create_block,
     create_coinbase,
 )
 from test_framework.txtools import pad_tx
 from test_framework.messages import (
     COIN,
     COutPoint,
     CTransaction,
     CTxIn,
     CTxOut,
 )
 from test_framework.mininode import P2PDataStore
 from test_framework.test_framework import BitcoinTestFramework
 from test_framework.util import (
     assert_equal,
     wait_until,
 )
 from data import invalid_txs
 
 
 class InvalidTxRequestTest(BitcoinTestFramework):
 
     def set_test_params(self):
         self.num_nodes = 1
         self.extra_args = [
             ["-acceptnonstdtxn=1", ]
         ]
         self.setup_clean_chain = True
 
     def bootstrap_p2p(self, *, num_connections=1):
         """Add a P2P connection to the node.
 
         Helper to connect and wait for version handshake."""
         for _ in range(num_connections):
             self.nodes[0].add_p2p_connection(P2PDataStore())
 
     def reconnect_p2p(self, **kwargs):
         """Tear down and bootstrap the P2P connection to the node.
 
         The node gets disconnected several times in this test. This helper
         method reconnects the p2p and restarts the network thread."""
         self.nodes[0].disconnect_p2ps()
         self.bootstrap_p2p(**kwargs)
 
     def run_test(self):
         node = self.nodes[0]  # convenience reference to the node
 
         self.bootstrap_p2p()  # Add one p2p connection to the node
 
         best_block = self.nodes[0].getbestblockhash()
         tip = int(best_block, 16)
         best_block_time = self.nodes[0].getblock(best_block)['time']
         block_time = best_block_time + 1
 
         self.log.info("Create a new block with an anyone-can-spend coinbase.")
         height = 1
         block = create_block(tip, create_coinbase(height), block_time)
         block.solve()
         # Save the coinbase for later
         block1 = block
         tip = block.sha256
         node.p2p.send_blocks_and_test([block], node, success=True)
 
         self.log.info("Mature the block.")
         self.nodes[0].generatetoaddress(
             100, self.nodes[0].get_deterministic_priv_key().address)
 
         # Iterate through a list of known invalid transaction types, ensuring each is
         # rejected. Some are consensus invalid and some just violate policy.
         for BadTxTemplate in invalid_txs.iter_all_templates():
             self.log.info(
                 "Testing invalid transaction: %s",
                 BadTxTemplate.__name__)
             template = BadTxTemplate(spend_block=block1)
             tx = template.get_tx()
             node.p2p.send_txs_and_test(
                 [tx], node, success=False,
                 expect_disconnect=template.expect_disconnect,
                 reject_reason=template.reject_reason,
             )
 
             if template.expect_disconnect:
                 self.log.info("Reconnecting to peer")
                 self.reconnect_p2p()
 
         # Make two p2p connections to provide the node with orphans
         # * p2ps[0] will send valid orphan txs (one with low fee)
         # * p2ps[1] will send an invalid orphan tx (and is later disconnected for that)
         self.reconnect_p2p(num_connections=2)
 
         self.log.info('Test orphan transaction handling ... ')
         # Create a root transaction that we withold until all dependend transactions
         # are sent out and in the orphan cache
         tx_withhold = CTransaction()
         tx_withhold.vin.append(
             CTxIn(outpoint=COutPoint(block1.vtx[0].sha256, 0)))
         tx_withhold.vout.append(
             CTxOut(nValue=50 * COIN - 12000, scriptPubKey=b'\x51'))
         pad_tx(tx_withhold)
         tx_withhold.calc_sha256()
 
         # Our first orphan tx with some outputs to create further orphan txs
         tx_orphan_1 = CTransaction()
         tx_orphan_1.vin.append(
             CTxIn(outpoint=COutPoint(tx_withhold.sha256, 0)))
-        tx_orphan_1.vout = [CTxOut(nValue=10 * COIN, scriptPubKey=b'\x51')] * 3
+        tx_orphan_1.vout = [
+            CTxOut(
+                nValue=10 * COIN,
+                scriptPubKey=b'\x51')] * 3
         pad_tx(tx_orphan_1)
         tx_orphan_1.calc_sha256()
 
         # A valid transaction with low fee
         tx_orphan_2_no_fee = CTransaction()
         tx_orphan_2_no_fee.vin.append(
             CTxIn(outpoint=COutPoint(tx_orphan_1.sha256, 0)))
         tx_orphan_2_no_fee.vout.append(
             CTxOut(nValue=10 * COIN, scriptPubKey=b'\x51'))
         pad_tx(tx_orphan_2_no_fee)
 
         # A valid transaction with sufficient fee
         tx_orphan_2_valid = CTransaction()
         tx_orphan_2_valid.vin.append(
             CTxIn(outpoint=COutPoint(tx_orphan_1.sha256, 1)))
         tx_orphan_2_valid.vout.append(
             CTxOut(nValue=10 * COIN - 12000, scriptPubKey=b'\x51'))
         tx_orphan_2_valid.calc_sha256()
         pad_tx(tx_orphan_2_valid)
 
         # An invalid transaction with negative fee
         tx_orphan_2_invalid = CTransaction()
         tx_orphan_2_invalid.vin.append(
             CTxIn(outpoint=COutPoint(tx_orphan_1.sha256, 2)))
         tx_orphan_2_invalid.vout.append(
             CTxOut(nValue=11 * COIN, scriptPubKey=b'\x51'))
         pad_tx(tx_orphan_2_invalid)
+        tx_orphan_2_invalid.calc_sha256()
 
         self.log.info('Send the orphans ... ')
         # Send valid orphan txs from p2ps[0]
         node.p2p.send_txs_and_test(
             [tx_orphan_1, tx_orphan_2_no_fee, tx_orphan_2_valid], node, success=False)
         # Send invalid tx from p2ps[1]
         node.p2ps[1].send_txs_and_test(
             [tx_orphan_2_invalid], node, success=False)
 
         # Mempool should be empty
         assert_equal(0, node.getmempoolinfo()['size'])
         # p2ps[1] is still connected
         assert_equal(2, len(node.getpeerinfo()))
 
         self.log.info('Send the withhold tx ... ')
         with node.assert_debug_log(expected_msgs=["bad-txns-in-belowout"]):
             node.p2p.send_txs_and_test([tx_withhold], node, success=True)
 
         # Transactions that should end up in the mempool
         expected_mempool = {
             t.hash
             for t in [
                 tx_withhold,  # The transaction that is the root for all orphans
                 tx_orphan_1,  # The orphan transaction that splits the coins
                 # The valid transaction (with sufficient fee)
                 tx_orphan_2_valid,
             ]
         }
         # Transactions that do not end up in the mempool
         # tx_orphan_no_fee, because it has too low fee (p2ps[0] is not disconnected for relaying that tx)
         # tx_orphan_invaid, because it has negative fee (p2ps[1] is
         # disconnected for relaying that tx)
 
         # p2ps[1] is no longer connected
         wait_until(lambda: 1 == len(node.getpeerinfo()), timeout=12)
         assert_equal(expected_mempool, set(node.getrawmempool()))
 
+        self.log.info('Test orphan pool overflow')
+        orphan_tx_pool = [CTransaction() for _ in range(101)]
+        for i in range(len(orphan_tx_pool)):
+            orphan_tx_pool[i].vin.append(CTxIn(outpoint=COutPoint(i, 333)))
+            orphan_tx_pool[i].vout.append(
+                CTxOut(
+                    nValue=11 * COIN,
+                    scriptPubKey=b'\x51'))
+            pad_tx(orphan_tx_pool[i])
+
+        with node.assert_debug_log(['mapOrphan overflow, removed 1 tx']):
+            node.p2p.send_txs_and_test(orphan_tx_pool, node, success=False)
+
+        rejected_parent = CTransaction()
+        rejected_parent.vin.append(
+            CTxIn(
+                outpoint=COutPoint(
+                    tx_orphan_2_invalid.sha256,
+                    0)))
+        rejected_parent.vout.append(
+            CTxOut(
+                nValue=11 * COIN,
+                scriptPubKey=b'\x51'))
+        pad_tx(rejected_parent)
+        rejected_parent.rehash()
+        with node.assert_debug_log(['not keeping orphan with rejected parents {}'.format(rejected_parent.hash)]):
+            node.p2p.send_txs_and_test([rejected_parent], node, success=False)
+
 
 if __name__ == '__main__':
     InvalidTxRequestTest().main()
diff --git a/test/functional/p2p_leak.py b/test/functional/p2p_leak.py
index 400c8fc7d..209962f75 100755
--- a/test/functional/p2p_leak.py
+++ b/test/functional/p2p_leak.py
@@ -1,197 +1,208 @@
 #!/usr/bin/env python3
 # Copyright (c) 2017-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.
 """Test message sending before handshake completion.
 
 A node should never send anything other than VERSION/VERACK until it's
 received a VERACK.
 
 This test connects to a node and sends it a few messages, trying to entice it
 into sending us something it shouldn't.
 """
 
 import time
 
 from test_framework.messages import (
     msg_getaddr,
     msg_ping,
     msg_verack,
+    msg_version,
 )
 from test_framework.mininode import (
     mininode_lock,
     P2PInterface,
 )
 from test_framework.test_framework import BitcoinTestFramework
 from test_framework.util import (
     assert_equal,
     assert_greater_than_or_equal,
     wait_until,
 )
 
 DISCOURAGEMENT_THRESHOLD = 100
 
 
 class CLazyNode(P2PInterface):
     def __init__(self):
         super().__init__()
         self.unexpected_msg = False
         self.ever_connected = False
 
     def bad_message(self, message):
         self.unexpected_msg = True
         self.log.info(
             "should not have received message: {}".format(message.msgtype))
 
     def on_open(self):
         self.ever_connected = True
 
     def on_version(self, message): self.bad_message(message)
 
     def on_verack(self, message): self.bad_message(message)
 
     def on_inv(self, message): self.bad_message(message)
 
     def on_addr(self, message): self.bad_message(message)
 
     def on_getdata(self, message): self.bad_message(message)
 
     def on_getblocks(self, message): self.bad_message(message)
 
     def on_tx(self, message): self.bad_message(message)
 
     def on_block(self, message): self.bad_message(message)
 
     def on_getaddr(self, message): self.bad_message(message)
 
     def on_headers(self, message): self.bad_message(message)
 
     def on_getheaders(self, message): self.bad_message(message)
 
     def on_ping(self, message): self.bad_message(message)
 
     def on_mempool(self, message): self.bad_message(message)
 
     def on_pong(self, message): self.bad_message(message)
 
     def on_feefilter(self, message): self.bad_message(message)
 
     def on_sendheaders(self, message): self.bad_message(message)
 
     def on_sendcmpct(self, message): self.bad_message(message)
 
     def on_cmpctblock(self, message): self.bad_message(message)
 
     def on_getblocktxn(self, message): self.bad_message(message)
 
     def on_blocktxn(self, message): self.bad_message(message)
 
 # Node that never sends a version. We'll use this to send a bunch of messages
 # anyway, and eventually get disconnected.
 
 
 class CNodeNoVersionMisbehavior(CLazyNode):
     # Send enough veracks without a message to reach the peer discouragement
     # threshold. This should get us disconnected. NOTE: implementation-specific
     # test; update if our discouragement policy for peer misbehavior changes.
     def on_open(self):
         super().on_open()
         for _ in range(DISCOURAGEMENT_THRESHOLD):
             self.send_message(msg_verack())
 
 # Node that never sends a version. This one just sits idle and hopes to receive
 # any message (it shouldn't!)
 
 
 class CNodeNoVersionIdle(CLazyNode):
     def __init__(self):
         super().__init__()
 
 # Node that sends a version but not a verack.
 
 
 class CNodeNoVerackIdle(CLazyNode):
     def __init__(self):
         self.version_received = False
         super().__init__()
 
     def on_verack(self, message): pass
     # When version is received, don't reply with a verack. Instead, see if the
     # node will give us a message that it shouldn't. This is not an exhaustive
     # list!
 
     def on_version(self, message):
         self.version_received = True
         self.send_message(msg_ping())
         self.send_message(msg_getaddr())
 
 
 class P2PVersionStore(P2PInterface):
     version_received = None
 
     def on_version(self, msg):
         super().on_version(msg)
         self.version_received = msg
 
 
 class P2PLeakTest(BitcoinTestFramework):
     def set_test_params(self):
         self.num_nodes = 1
 
     def run_test(self):
         no_version_disconnect_node = self.nodes[0].add_p2p_connection(
             CNodeNoVersionMisbehavior(), send_version=False, wait_for_verack=False)
         no_version_idlenode = self.nodes[0].add_p2p_connection(
             CNodeNoVersionIdle(), send_version=False, wait_for_verack=False)
         no_verack_idlenode = self.nodes[0].add_p2p_connection(
             CNodeNoVerackIdle(), wait_for_verack=False)
 
         # Wait until we got the verack in response to the version. Though, don't wait for the other node to receive the
         # verack, since we never sent one
         no_verack_idlenode.wait_for_verack()
 
         wait_until(
             lambda: no_version_disconnect_node.ever_connected,
             timeout=10,
             lock=mininode_lock)
         wait_until(lambda: no_version_idlenode.ever_connected,
                    timeout=10, lock=mininode_lock)
         wait_until(lambda: no_verack_idlenode.version_received,
                    timeout=10, lock=mininode_lock)
 
         # Mine a block and make sure that it's not sent to the connected nodes
         self.nodes[0].generatetoaddress(
             1, self.nodes[0].get_deterministic_priv_key().address)
 
         # Give the node enough time to possibly leak out a message
         time.sleep(5)
 
         # Expect this node to be disconnected for misbehavior
         assert not no_version_disconnect_node.is_connected
 
         self.nodes[0].disconnect_p2ps()
 
         # Wait until all connections are closed
         wait_until(lambda: len(self.nodes[0].getpeerinfo()) == 0)
 
         # Make sure no unexpected messages came in
         assert not no_version_disconnect_node.unexpected_msg
         assert not no_version_idlenode.unexpected_msg
         assert not no_verack_idlenode.unexpected_msg
 
         self.log.info(
             'Check that the version message does not leak the local address of the node')
         time_begin = int(time.time())
         p2p_version_store = self.nodes[0].add_p2p_connection(P2PVersionStore())
         time_end = time.time()
         ver = p2p_version_store.version_received
         assert_greater_than_or_equal(ver.nTime, time_begin)
         assert_greater_than_or_equal(time_end, 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.nRelay, 1)
 
+        self.log.info('Check that old nodes are disconnected')
+        p2p_old_node = self.nodes[0].add_p2p_connection(
+            P2PInterface(), send_version=False, wait_for_verack=False)
+        old_version_msg = msg_version()
+        old_version_msg.nVersion = 31799
+        wait_until(lambda: p2p_old_node.is_connected)
+        with self.nodes[0].assert_debug_log(['peer=4 using obsolete version 31799; disconnecting']):
+            p2p_old_node.send_message(old_version_msg)
+            p2p_old_node.wait_for_disconnect()
+
 
 if __name__ == '__main__':
     P2PLeakTest().main()
diff --git a/test/functional/p2p_tx_download.py b/test/functional/p2p_tx_download.py
index 3c82edf68..9c6a41feb 100755
--- a/test/functional/p2p_tx_download.py
+++ b/test/functional/p2p_tx_download.py
@@ -1,188 +1,194 @@
 #!/usr/bin/env python3
 # Copyright (c) 2019 The Bitcoin Core developers
 # Distributed under the MIT software license, see the accompanying
 # file COPYING or http://www.opensource.org/licenses/mit-license.php.
 """
 Test transaction download behavior
 """
 
 from test_framework.address import ADDRESS_BCHREG_UNSPENDABLE
 from test_framework.messages import (
     CInv,
     CTransaction,
     FromHex,
     MSG_TX,
     MSG_TYPE_MASK,
     msg_inv,
     msg_notfound,
 )
 from test_framework.mininode import (
     P2PInterface,
     mininode_lock,
 )
 from test_framework.test_framework import BitcoinTestFramework
 from test_framework.util import (
     assert_equal,
     wait_until,
 )
 
 import time
 
 
 class TestP2PConn(P2PInterface):
     def __init__(self):
         super().__init__()
         self.tx_getdata_count = 0
 
     def on_getdata(self, message):
         for i in message.inv:
             if i.type & MSG_TYPE_MASK == MSG_TX:
                 self.tx_getdata_count += 1
 
 
 # Constants from net_processing
 GETDATA_TX_INTERVAL = 60  # seconds
 MAX_GETDATA_RANDOM_DELAY = 2  # seconds
 INBOUND_PEER_TX_DELAY = 2  # seconds
 MAX_GETDATA_IN_FLIGHT = 100
 TX_EXPIRY_INTERVAL = GETDATA_TX_INTERVAL * 10
 
 # Python test constants
 NUM_INBOUND = 10
 MAX_GETDATA_INBOUND_WAIT = GETDATA_TX_INTERVAL + \
     MAX_GETDATA_RANDOM_DELAY + INBOUND_PEER_TX_DELAY
 
 
 class TxDownloadTest(BitcoinTestFramework):
     def set_test_params(self):
         self.setup_clean_chain = False
         self.num_nodes = 2
 
     def test_tx_requests(self):
         self.log.info(
             "Test that we request transactions from all our peers, eventually")
 
         txid = 0xdeadbeef
 
         self.log.info("Announce the txid from each incoming peer to node 0")
         msg = msg_inv([CInv(t=1, h=txid)])
         for p in self.nodes[0].p2ps:
             p.send_and_ping(msg)
 
         outstanding_peer_index = [i for i in range(len(self.nodes[0].p2ps))]
 
         def getdata_found(peer_index):
             p = self.nodes[0].p2ps[peer_index]
             with mininode_lock:
                 return p.last_message.get(
                     "getdata") and p.last_message["getdata"].inv[-1].hash == txid
 
         node_0_mocktime = int(time.time())
         while outstanding_peer_index:
             node_0_mocktime += MAX_GETDATA_INBOUND_WAIT
             self.nodes[0].setmocktime(node_0_mocktime)
             wait_until(lambda: any(getdata_found(i)
                                    for i in outstanding_peer_index))
             for i in outstanding_peer_index:
                 if getdata_found(i):
                     outstanding_peer_index.remove(i)
 
         self.nodes[0].setmocktime(0)
         self.log.info("All outstanding peers received a getdata")
 
     def test_inv_block(self):
         self.log.info("Generate a transaction on node 0")
         tx = self.nodes[0].createrawtransaction(
             inputs=[{
                 # coinbase
                 "txid": self.nodes[0].getblock(self.nodes[0].getblockhash(1))['tx'][0],
                 "vout": 0
             }],
             outputs={ADDRESS_BCHREG_UNSPENDABLE: 50 - 0.00025},
         )
         tx = self.nodes[0].signrawtransactionwithkey(
             hexstring=tx,
             privkeys=[self.nodes[0].get_deterministic_priv_key().key],
         )['hex']
         ctx = FromHex(CTransaction(), tx)
         txid = int(ctx.rehash(), 16)
 
         self.log.info(
             "Announce the transaction to all nodes from all {} incoming peers, but never send it".format(NUM_INBOUND))
         msg = msg_inv([CInv(t=1, h=txid)])
         for p in self.peers:
             p.send_and_ping(msg)
 
         self.log.info("Put the tx in node 0's mempool")
         self.nodes[0].sendrawtransaction(tx)
 
         # Since node 1 is connected outbound to an honest peer (node 0), it
         # should get the tx within a timeout. (Assuming that node 0
         # announced the tx within the timeout)
         # The timeout is the sum of
         # * the worst case until the tx is first requested from an inbound
         #   peer, plus
         # * the first time it is re-requested from the outbound peer, plus
         # * 2 seconds to avoid races
         assert self.nodes[1].getpeerinfo()[0]['inbound'] is False
         timeout = 2 + (MAX_GETDATA_RANDOM_DELAY + INBOUND_PEER_TX_DELAY) + (
             GETDATA_TX_INTERVAL + MAX_GETDATA_RANDOM_DELAY)
         self.log.info(
             "Tx should be received at node 1 after {} seconds".format(timeout))
         self.sync_mempools(timeout=timeout)
 
     def test_in_flight_max(self):
         self.log.info("Test that we don't request more than {} transactions from any peer, every {} minutes".format(
             MAX_GETDATA_IN_FLIGHT, TX_EXPIRY_INTERVAL / 60))
         txids = [i for i in range(MAX_GETDATA_IN_FLIGHT + 2)]
 
         p = self.nodes[0].p2ps[0]
 
         with mininode_lock:
             p.tx_getdata_count = 0
 
         p.send_message(msg_inv([CInv(t=1, h=i) for i in txids]))
         wait_until(lambda: p.tx_getdata_count >=
                    MAX_GETDATA_IN_FLIGHT, lock=mininode_lock)
         with mininode_lock:
             assert_equal(p.tx_getdata_count, MAX_GETDATA_IN_FLIGHT)
 
         self.log.info(
             "Now check that if we send a NOTFOUND for a transaction, we'll get one more request")
         p.send_message(msg_notfound(vec=[CInv(t=1, h=txids[0])]))
         wait_until(
             lambda: p.tx_getdata_count >= MAX_GETDATA_IN_FLIGHT + 1,
             timeout=10,
             lock=mininode_lock)
         with mininode_lock:
             assert_equal(p.tx_getdata_count, MAX_GETDATA_IN_FLIGHT + 1)
 
         WAIT_TIME = TX_EXPIRY_INTERVAL // 2 + TX_EXPIRY_INTERVAL
         self.log.info(
             "if we wait about {} minutes, we should eventually get more requests".format(
                 WAIT_TIME / 60))
         self.nodes[0].setmocktime(int(time.time() + WAIT_TIME))
         wait_until(lambda: p.tx_getdata_count == MAX_GETDATA_IN_FLIGHT + 2)
         self.nodes[0].setmocktime(0)
 
+    def test_spurious_notfound(self):
+        self.log.info('Check that spurious notfound is ignored')
+        self.nodes[0].p2ps[0].send_message(msg_notfound(vec=[CInv(1, 1)]))
+
     def run_test(self):
         # Setup the p2p connections
         self.peers = []
         for node in self.nodes:
             for i in range(NUM_INBOUND):
                 self.peers.append(node.add_p2p_connection(TestP2PConn()))
 
         self.log.info(
             "Nodes are setup with {} incoming connections each".format(NUM_INBOUND))
 
+        self.test_spurious_notfound()
+
         # Test the in-flight max first, because we want no transactions in
         # flight ahead of this test.
         self.test_in_flight_max()
 
         self.test_inv_block()
 
         self.test_tx_requests()
 
 
 if __name__ == '__main__':
     TxDownloadTest().main()